0001: /*
0002: * SalomeTMF is a test Management Framework
0003: * Copyright (C) 2007 EDF / France Telecom R&D
0004: *
0005: * This library is free software; you can redistribute it and/or
0006: * modify it under the terms of the GNU Lesser General Public
0007: * License as published by the Free Software Foundation; either
0008: * version 2 of the License, or (at your option) any later version.
0009: *
0010: * This library is distributed in the hope that it will be useful,
0011: * but WITHOUT ANY WARRANTY; without even the implied warranty of
0012: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0013: * Lesser General Public License for more details.
0014: *
0015: * You should have received a copy of the GNU Lesser General Public
0016: * License along with this library; if not, write to the Free Software
0017: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0018: *
0019: * @author Jérémie DEFAYE
0020: *
0021: * Contact: mikael.marche@rd.francetelecom.com
0022: */
0023:
0024: package salomeTMF_plug.pluginxlsxml.Import;
0025:
0026: import java.io.FileInputStream;
0027: import java.io.FileOutputStream;
0028: import java.io.FileWriter;
0029: import java.io.IOException;
0030: import java.io.File;
0031:
0032: import java.net.MalformedURLException;
0033: import java.net.URL;
0034:
0035: import javax.swing.JOptionPane;
0036:
0037: import java.nio.channels.FileChannel;
0038:
0039: import java.text.DateFormat;
0040:
0041: import java.util.ArrayList;
0042: import java.util.Date;
0043: import java.util.StringTokenizer;
0044:
0045: import jxl.Cell;
0046: import jxl.CellType;
0047: import jxl.FormulaCell;
0048: import jxl.Workbook;
0049: import jxl.biff.formula.FormulaException;
0050: import jxl.read.biff.BiffException;
0051: import jxl.Sheet;
0052:
0053: import org.dom4j.DocumentHelper;
0054: import org.dom4j.Element;
0055: import org.dom4j.Document;
0056: import org.dom4j.io.OutputFormat;
0057: import org.dom4j.io.XMLWriter;
0058: import org.objectweb.salome_tmf.plugins.IPlugObject;
0059:
0060: import salomeTMF_plug.pluginxlsxml.Commun.PopUpFormalismeExcel;
0061: import salomeTMF_plug.pluginxlsxml.Commun.TestPresencePlugin;
0062: import salomeTMF_plug.pluginxlsxml.language.Language;
0063:
0064: /**
0065: * Read a Spreadsheet having requirements and test cases, and transform them in
0066: * XML to be imported by Doc XML in SaloméTMF
0067: *
0068: * @author Jérémie DEFAYE
0069: * @version 1.0
0070: * @deprecated no
0071: */
0072: public class FromExcelToXml {
0073:
0074: private ArrayList<String> actionID = new ArrayList<String>();
0075: private ArrayList<String> campagneID = new ArrayList<String>();
0076: private ArrayList<String> environnementID = new ArrayList<String>();
0077: private ArrayList<String> exigenceID = new ArrayList<String>();
0078: private ArrayList<String> jeuDeDonneesID = new ArrayList<String>();
0079: private ArrayList<String> listeExigencesCampagnes = new ArrayList<String>();
0080: private ArrayList<String> listeFamille = new ArrayList<String>();
0081: private ArrayList<String> listeParametre = new ArrayList<String>();
0082: private ArrayList<String> listePourCampagne = new ArrayList<String>();
0083: private ArrayList<String> listeTestsPourCampagne = new ArrayList<String>();
0084: private ArrayList<String> valeurLienHypertexte = new ArrayList<String>();
0085: private ArrayList<String> valeurPieceJointe = new ArrayList<String>();
0086: private ArrayList<String> vecteurBrancheID = new ArrayList<String>();
0087: private ArrayList<String> familleIDSuiteID = new ArrayList<String>();
0088: private ArrayList<String> numeroActionDesTests = new ArrayList<String>();
0089:
0090: private boolean isErreurFormalismeExcel = false;
0091: private boolean isErreurImportFichier;
0092: private boolean isErreurTraitementImport = false;
0093: private boolean isPresenceColonneActionARealiser = false;
0094: private boolean isPresenceColonneActionAttendue = false;
0095: private boolean isPresenceColonneActionExecuteeExecutionCamp;
0096: private boolean isPresenceColonneActionObtenueExecutionCamp;
0097: private boolean isPresenceColonneBranche = false;
0098: private boolean isPresenceColonneBrancheTests = false;
0099: private boolean isPresenceColonneCasDeTestCampagne;
0100: private boolean isPresenceColonneCasDeTests = false;
0101: private boolean isPresenceColonneCasDeTestsExecutionCamp;
0102: private boolean isPresenceColonneCategorie = false;
0103: private boolean isPresenceColonneComplexite = false;
0104: private boolean isPresenceColonneDescription = false;
0105: private boolean isPresenceColonneDescriptionCampagne;
0106: private boolean isPresenceColonneDescriptionEnvironnement = false;
0107: private boolean isPresenceColonneDescriptionJeuDeDonneesCampagne;
0108: private boolean isPresenceColonneDescriptionParametre = false;
0109: private boolean isPresenceColonneDescriptionTest = false;
0110: private boolean isPresenceColonneEmplacementTestAutomatique;
0111: private boolean isPresenceColonneEtat = false;
0112: private boolean isPresenceColonneExigence = false;
0113: private boolean isPresenceColonneExigenceTests = false;
0114: private boolean isPresenceColonneFamilleDeTests;
0115: private boolean isPresenceColonneFamilleDeTestsExecutionCamp;
0116: private boolean isPresenceColonneFamilleTestCampagne;
0117: private boolean isPresenceColonneJeuDeDonneesCampagne;
0118: private boolean isPresenceColonneJeuDeDonneesExecutionCamp;
0119: private boolean isPresenceColonneLienHypertexte = false;
0120: private boolean isPresenceColonneLienHypertexteCampagne;
0121: private boolean isPresenceColonneLienHypertexteEnvironnement;
0122: private boolean isPresenceColonneLienHypertexteExecutionCamp;
0123: private boolean isPresenceColonneNomCampagne;
0124: private boolean isPresenceColonneNomCampagneExecutionCamp;
0125: private boolean isPresenceColonneNomEnvironnement = false;
0126: private boolean isPresenceColonneNomEnvironnementExecutionCamp;
0127: private boolean isPresenceColonneNomExecutionExecutionCamp;
0128: private boolean isPresenceColonneNomParametre = false;
0129: private boolean isPresenceColonneNomParametreEnvironnement = false;
0130: private boolean isPresenceColonneNomResultatExecutionExecutionCamp;
0131: private boolean isPresenceColonneNumeroExecutionCamp;
0132: private boolean isPresenceColonneNumeroTests = false;
0133: private boolean isPresenceColonneOrigine = false;
0134: private boolean isPresenceColonnePieceJointe = false;
0135: private boolean isPresenceColonnePieceJointeCampagne;
0136: private boolean isPresenceColonnePieceJointeEnvironnement;
0137: private boolean isPresenceColonnePieceJointeExecutionCamp;
0138: private boolean isPresenceColonnePriorite = false;
0139: private boolean isPresenceColonneReference = false;
0140: private boolean isPresenceColonneResultatExecutionExecutionCamp;
0141: private boolean isPresenceColonneResultatTestExecuteExecutionCamp;
0142: private boolean isPresenceColonneSuiteDeTests = false;
0143: private boolean isPresenceColonneSuiteDeTestsExecutionCamp;
0144: private boolean isPresenceColonneSuiteTestCampagne;
0145: private boolean isPresenceColonneTestLienHypertexte = false;
0146: private boolean isPresenceColonneTestPieceJointe = false;
0147: private boolean isPresenceColonneTestLienHypertexteAction = false;
0148: private boolean isPresenceColonneTestPieceJointeAction = false;
0149: private boolean isPresenceColonneTypeTestAutomatique;
0150: private boolean isPresenceColonneValeurParametreEnvironnement;
0151: private boolean isPresenceColonneVerifWay = false;
0152: private boolean isPresenceColonneVersion = false;
0153: private boolean presenceFeuilleCampagne = false;
0154: private boolean presenceFeuilleEnvironnements = false;
0155: private boolean presenceFeuilleExecutionCamp = false;
0156: private boolean presenceFeuilleExigence = false;
0157: private boolean presenceFeuilleParametres = false;
0158: private boolean presenceFeuilleTest = false;
0159:
0160: private Cell celluleLu;
0161:
0162: private Document documentXml;
0163:
0164: private Element actionTest;
0165: private Element CampagneTest;
0166: private Element ExecCampTest;
0167: private Element Environnements;
0168: private Element famille;
0169: private Element familles;
0170: private Element familyRequirement;
0171: private Element LinkRequirement;
0172: private Element projetVT;
0173: private Element requirements;
0174: private Element ResulActionTests;
0175: private Element ResulExecCampTest;
0176: private Element ResulExecs;
0177: private Element test;
0178: private Element TestAuto;
0179: private Element testManuel;
0180: private Element tests;
0181: private Element params;
0182:
0183: private File fichierDeSortieXML;
0184:
0185: private int debutCampagne;
0186: private int debutEnvironnement;
0187: private int debutExecutionCamp;
0188: private int debutExecutionCampagne;
0189: private int debutNomResultatExecutionCamp;
0190: private int debutResultatExecutionCampagne;
0191: private int debutTestExecutionCampagne;
0192: private int hauteurCampagne;
0193: private int hauteurEnvironnement;
0194: private int hauteurExecutionCamp;
0195: private int hauteurExecutionCampagne;
0196: private int hauteurNomResultatExecutionCamp;
0197: private int hauteurResultatExecutionCampagne;
0198: private int hauteurTestExecutionCampagne;
0199: private int indiceActionTest = 5;
0200: private int indiceCampagne = 6;
0201: private int indiceEnvironnement = 9;
0202: private int indiceExecCampagne = 7;
0203: private int indiceExecutionCamp = 10;
0204: private int indiceFamilleTest = 2;
0205: private int indiceJeuDeDonnees = 9;
0206: private int indiceParametre = 8;
0207: private int indiceRequirement = 1;
0208: private int indiceRequirementExigenceEnCours = 1;
0209: private int indiceResultatExecution = 11;
0210: private int indiceSuiteTest = 3;
0211: private int indiceTestTest = 4;
0212: private int ligneDebutTableauCampagne = 0;
0213: private int ligneDebutTableauEnvironnement = 0;
0214: private int ligneDebutTableauExecutionCamp;
0215: private int ligneDebutTableauParametre = 0;
0216: private int ligneDebutTableauRequirement = 0;
0217: private int ligneDebutTableauTest = 0;
0218: private int nombreColonneTableau = 0;
0219: private int nombreColonneTableauCampagne;
0220: private int nombreColonneTableauEnvironnements;
0221: private int nombreColonneTableauExecutionCamp;
0222: private int nombreColonneTableauParametres = 0;
0223: private int nombreColonneTableauTests = 0;
0224: private int nombreLigneTableau = 0;
0225: private int nombreLigneTableauCampagne;
0226: private int nombreLigneTableauEnvironnements;
0227: private int nombreLigneTableauExecutionCamp;
0228: private int nombreLigneTableauParametres = 0;
0229: private int nombreLigneTableauTests = 0;
0230: private int numeroColonneActionARealiser;
0231: private int numeroColonneActionAttendue;
0232: private int numeroColonneActionExecuteeExecutionCamp;
0233: private int numeroColonneActionObtenueExecutionCamp;
0234: private int numeroColonneCasDeTestCampagne;
0235: private int numeroColonneCasDeTests;
0236: private int numeroColonneCasDeTestsExecutionCamp;
0237: private int numeroColonneCategorie;
0238: private int numeroColonneComplexite;
0239: private int numeroColonneDescription;
0240: private int numeroColonneDescriptionCampagne;
0241: private int numeroColonneDescriptionEnvironnement;
0242: private int numeroColonneDescriptionJeuDeDonneesCampagne;
0243: private int numeroColonneDescriptionParametre;
0244: private int numeroColonneDescriptionTest;
0245: private int numeroColonneEmplacementTestAutomatique;
0246: private int numeroColonneEtat;
0247: private int numeroColonneExigence;
0248: private int numeroColonneExigenceTests;
0249: private int numeroColonneFamilleDeTests;
0250: private int numeroColonneFamilleDeTestsExecutionCamp;
0251: private int numeroColonneFamilleTestCampagne;
0252: private int numeroColonneJeuDeDonneesCampagne;
0253: private int numeroColonneJeuDeDonneesExecutionCamp;
0254: private int numeroColonneLienHypertexte;
0255: private int numeroColonneLienHypertexteCampagne;
0256: private int numeroColonneLienHypertexteEnvironnement;
0257: private int numeroColonneLienHypertexteExecutionCamp;
0258: private int numeroColonneNomCampagne;
0259: private int numeroColonneNomCampagneExecutionCamp;
0260: private int numeroColonneNomEnvironnement;
0261: private int numeroColonneNomEnvironnementExecutionCamp;
0262: private int numeroColonneNomExecutionExecutionCamp;
0263: private int numeroColonneNomParametre;
0264: private int numeroColonneNomParametreEnvironnement;
0265: private int numeroColonneNomResultatExecutionExecutionCamp;
0266: private int numeroColonneNumeroExecutionCamp;
0267: private int numeroColonneNumeroTests;
0268: private int numeroColonneOrigine;
0269: private int numeroColonnePieceJointe;
0270: private int numeroColonnePieceJointeCampagne;
0271: private int numeroColonnePieceJointeEnvironnement;
0272: private int numeroColonnePieceJointeExecutionCamp;
0273: private int numeroColonnePriorite;
0274: private int numeroColonneReference;
0275: private int numeroColonneResultatExecutionExecutionCamp;
0276: private int numeroColonneResultatTestExecuteExecutionCamp;
0277: private int numeroColonneSuiteDeTests;
0278: private int numeroColonneSuiteDeTestsExecutionCamp;
0279: private int numeroColonneSuiteTestCampagne;
0280: private int numeroColonneTestLienHypertexte;
0281: private int numeroColonneTestPieceJointe;
0282: private int numeroColonneTestLienHypertexteAction;
0283: private int numeroColonneTestPieceJointeAction;
0284: private int numeroColonneTypeTestAutomatique;
0285: private int numeroColonneValeurParametreEnvironnement;
0286: private int numeroColonneVerifWay;
0287: private int numeroColonneVersion;
0288:
0289: private IPlugObject pIPlugObject;
0290:
0291: private Sheet campagneSheet;
0292: private Sheet enviroSheet;
0293: private Sheet execCampSheet;
0294: private Sheet paramSheet;
0295: private Sheet requirementSheet;
0296: private Sheet testSheet;
0297:
0298: private String exigenceAEcrire = "";
0299: private String exigenceLu;
0300: private String exigenceLuTest;
0301: private String exigenceNonTrouvePourTest = "";
0302: private String familleEnCours;
0303: private String familleEnCoursTests;
0304: private String famillePrecedente = Language.getInstance().getText(
0305: "Pas_De_Famille");
0306: private String fichiersNonImportes = "";
0307: private String fs = System.getProperties().getProperty(
0308: "file.separator");
0309: private String IDAction;
0310: private String IDCampagne;
0311: private String IDParametreEnvironnement;
0312: private String IDTest;
0313: private String indiceRequirementFamilleEnCours;
0314: private String listeCampagneNonTrouve = "";
0315: private String nomFichierXML;
0316: private String nomParametreEnvironnement = "";
0317: private String numeroColonneBranche = null;
0318: private String numeroColonneBrancheTests = null;
0319: private String ResultatExecution;
0320: private String Sortie;
0321: private String suitePrecedente;
0322: private String valeurActionARealiser;
0323: private String valeurActionAttendue;
0324: private String valeurCasDeTests;
0325: private String valeurCategorie;
0326: private String valeurComplexite;
0327: private String valeurDescription;
0328: private String valeurDescriptionTest;
0329: private String valeurEmplacementTestAutomatique;
0330: private String valeurEtat;
0331: private String valeurFamilleDeTests;
0332: private String valeurNomCampagne;
0333: private String valeurNomCasDeTestExecutionCampagne;
0334: private String valeurNomEnvironnement;
0335: private String valeurNomExecutionCampagne;
0336: private String valeurNomFamilleTestExecutionCampagne;
0337: private String valeurNomSuiteTestExecutionCampagne;
0338: private String valeurNumeroExecuteExecutionCampagne;
0339: private String valeurNumeroTests;
0340: private String valeurOrigine;
0341: private String valeurParametreEnvironnement;
0342: private String valeurPriorite;
0343: private String valeurReference;
0344: private String valeurResultatTestExecuteExecutionCampagne;
0345: private String valeurSuiteDeTests;
0346: private String valeurTypeTestAutomatique;
0347: private String valeurVerifWay;
0348: private String valeurVersion;
0349: private String xmlDir;
0350:
0351: private Workbook workbook;
0352:
0353: /**
0354: * Read a Spreadsheet having requirements ans test cases, and transform them
0355: * in XML to be imported by Doc XML in SaloméTMF
0356: * @param selectionImportParametre parametre case à cocher
0357: * @param selectionImportEnvironnement parametre case à cocher
0358: * @param selectionExecutionCampagnes parametre case à cocher
0359: * @param selectionImportExigence parametre case à cocher
0360: * @param selectionImportTest parametre case à cocher
0361: * @param creationCampagne parametre case à cocher
0362: * @param fichierExcel Name of the spreadsheet file
0363: * @throws java.lang.Exception Language Exception
0364: */
0365: public FromExcelToXml(String fichierExcel,
0366: boolean selectionImportExigence,
0367: boolean selectionImportTest,
0368: boolean selectionImportParametre,
0369: boolean selectionImportEnvironnement,
0370: String creationCampagne, boolean selectionExecutionCampagnes)
0371: throws Exception {
0372:
0373: openXLSFile(fichierExcel);
0374: if (isErreurFormalismeExcel == false) {
0375: nomFichierXML = createXmlFile(fichierExcel);
0376: writeXmlHeading();
0377:
0378: if (selectionImportExigence == true
0379: && !isErreurTraitementImport) {
0380: testColumnsPresenceRequirement();
0381: }
0382:
0383: if (selectionImportTest == true
0384: && !isErreurTraitementImport) {
0385: testColumnsPresenceTests();
0386: }
0387:
0388: if (selectionImportParametre == true
0389: && !isErreurTraitementImport) {
0390: testColumnsPresenceParametre();
0391: }
0392:
0393: if (selectionImportEnvironnement == true
0394: && !isErreurTraitementImport) {
0395: testColumnsPresenceEnvironnement();
0396: }
0397:
0398: if (creationCampagne == Language.getInstance().getText(
0399: "Importer_Campagnes")
0400: && !isErreurTraitementImport) {
0401: testColumnsPresenceCampagnes();
0402: }
0403: if (selectionExecutionCampagnes == true
0404: && !isErreurTraitementImport) {
0405: testColumnsPresenceExecutionCampagnes();
0406: }
0407:
0408: if (selectionImportExigence == true
0409: && !isErreurTraitementImport) {
0410: readXlsTableRequirement();
0411: }
0412:
0413: if (selectionImportTest == true
0414: && !isErreurTraitementImport) {
0415: readXlsTableTest(selectionImportExigence);
0416: }
0417:
0418: if (selectionImportParametre == true
0419: && !isErreurTraitementImport) {
0420: readXlsTableParametre();
0421: }
0422:
0423: if (selectionImportEnvironnement == true
0424: && !isErreurTraitementImport) {
0425: readXlsTableEnvironnement(selectionImportParametre);
0426: }
0427:
0428: if ((creationCampagne != Language.getInstance().getText(
0429: "Pas_De_Campagne"))
0430: && (creationCampagne != Language.getInstance()
0431: .getText("Importer_Campagnes"))
0432: && !isErreurTraitementImport) {
0433: creeCampagnes(creationCampagne,
0434: selectionImportEnvironnement);
0435: } else if (creationCampagne == Language.getInstance()
0436: .getText("Importer_Campagnes")
0437: && !isErreurTraitementImport) {
0438: readXlsTableCampagnes(selectionImportExigence,
0439: selectionExecutionCampagnes);
0440:
0441: }
0442:
0443: closeXmlAndXlsFiles();
0444: }
0445:
0446: }
0447:
0448: /**
0449: * Lit les executions des campagnes
0450: * @param debutExecutionCampagne Début ligne
0451: * @param hauteurExecutionCampagne nombre de lignes à lire
0452: */
0453: public void litLesExecutions(int debutExecutionCampagne,
0454: int hauteurExecutionCampagne) {
0455: for (int i = debutExecutionCampagne; i < debutExecutionCampagne
0456: + hauteurExecutionCampagne; i++) {
0457: celluleLu = execCampSheet.getCell(
0458: numeroColonneNomResultatExecutionExecutionCamp, i);
0459: valeurNomExecutionCampagne = celluleLu.getContents();
0460: if (valeurNomExecutionCampagne.length() > 0) {
0461: Element ResulExecCampTests = ExecCampTest
0462: .addElement("ResulExecCampTests");
0463: if (isPresenceColonneResultatExecutionExecutionCamp) {
0464: celluleLu = execCampSheet
0465: .getCell(
0466: numeroColonneResultatExecutionExecutionCamp,
0467: i);
0468: ResultatExecution = celluleLu.getContents();
0469: } else {
0470: ResultatExecution = Language.getInstance().getText(
0471: "INCOMPLETE");
0472: }
0473: celluleLu = execCampSheet.getCell(
0474: numeroColonneResultatExecutionExecutionCamp, i);
0475: if (isPresenceColonneNomResultatExecutionExecutionCamp) {
0476: ResulExecCampTest = ResulExecCampTests.addElement(
0477: "ResulExecCampTest").addAttribute(
0478: "id_exec_res",
0479: "ResExecCamp__" + indiceResultatExecution)
0480: .addAttribute("statut", ResultatExecution);
0481: Element Testeur = ResulExecCampTest.addElement(
0482: "Testeur").addText(
0483: Language.getInstance().getText(
0484: "pluginxlsxml"));
0485: Element NomResulExecCampTests = ResulExecCampTest
0486: .addElement("Nom").addText(
0487: valeurNomExecutionCampagne);
0488: // Génération de la date
0489: DateFormat dateFormat = DateFormat
0490: .getDateInstance(DateFormat.MONTH_FIELD);
0491: Element dateCrea = ResulExecCampTest.addElement(
0492: "Date_crea").addText(
0493: dateFormat.format(new Date()));
0494: DateFormat dateFormat2 = DateFormat
0495: .getTimeInstance(DateFormat.MEDIUM);
0496: Element heureCrea = ResulExecCampTest.addElement(
0497: "Heure_crea").addText(
0498: dateFormat2.format(new Date()));
0499: ResulExecs = ResulExecCampTest
0500: .addElement("ResulExecs");
0501:
0502: hauteurResultatExecutionCampagne = 1;
0503: debutResultatExecutionCampagne = i;
0504:
0505: celluleLu = execCampSheet
0506: .getCell(
0507: numeroColonneNomResultatExecutionExecutionCamp,
0508: i
0509: + hauteurResultatExecutionCampagne);
0510:
0511: while ((celluleLu.getContents().length() == 0)
0512: && (hauteurResultatExecutionCampagne
0513: + debutResultatExecutionCampagne < nombreLigneTableauExecutionCamp - 1)) {
0514: hauteurResultatExecutionCampagne++;
0515: celluleLu = execCampSheet
0516: .getCell(
0517: numeroColonneNomResultatExecutionExecutionCamp,
0518: i
0519: + hauteurResultatExecutionCampagne);
0520: }
0521:
0522: if ((debutResultatExecutionCampagne == nombreLigneTableauExecutionCamp - 1)
0523: && (execCampSheet
0524: .getCell(
0525: numeroColonneNomResultatExecutionExecutionCamp,
0526: nombreLigneTableauExecutionCamp - 1)
0527: .getContents().length() != 0)) {
0528: hauteurResultatExecutionCampagne++;
0529: }
0530: if ((debutResultatExecutionCampagne
0531: + hauteurResultatExecutionCampagne == nombreLigneTableauExecutionCamp - 1)
0532: && (execCampSheet
0533: .getCell(
0534: numeroColonneNomResultatExecutionExecutionCamp,
0535: nombreLigneTableauExecutionCamp - 1)
0536: .getContents().length() == 0)) {
0537: hauteurResultatExecutionCampagne++;
0538: }
0539:
0540: litLesResultatExecutionsTests(
0541: debutResultatExecutionCampagne,
0542: hauteurResultatExecutionCampagne);
0543: }
0544: }
0545:
0546: indiceResultatExecution++;
0547: }
0548: }
0549:
0550: /**
0551: * Lit les résultats d'executions des campagnes
0552: * @param debutResultatExecutionCampagne Début ligne
0553: * @param hauteurResultatExecutionCampagne nombre de lignes à lire
0554: */
0555: public void litLesResultatExecutionsTests(
0556: int debutResultatExecutionCampagne,
0557: int hauteurResultatExecutionCampagne) {
0558: for (int i = debutResultatExecutionCampagne; i < debutResultatExecutionCampagne
0559: + hauteurResultatExecutionCampagne; i++) {
0560: celluleLu = execCampSheet.getCell(
0561: numeroColonneFamilleDeTestsExecutionCamp, i);
0562: valeurNomFamilleTestExecutionCampagne = celluleLu
0563: .getContents();
0564: celluleLu = execCampSheet.getCell(
0565: numeroColonneSuiteDeTestsExecutionCamp, i);
0566: valeurNomSuiteTestExecutionCampagne = celluleLu
0567: .getContents();
0568: celluleLu = execCampSheet.getCell(
0569: numeroColonneCasDeTestsExecutionCamp, i);
0570: valeurNomCasDeTestExecutionCampagne = celluleLu
0571: .getContents();
0572: if (isPresenceColonneResultatTestExecuteExecutionCamp) {
0573: celluleLu = execCampSheet.getCell(
0574: numeroColonneResultatTestExecuteExecutionCamp,
0575: i);
0576: valeurResultatTestExecuteExecutionCampagne = celluleLu
0577: .getContents();
0578: } else {
0579: valeurResultatTestExecuteExecutionCampagne = Language
0580: .getInstance().getText("INCOMPLETE");
0581: }
0582:
0583: if (valeurNomCasDeTestExecutionCampagne.length() > 0) {
0584: boolean IDTestTrouve = false;
0585: for (int j = 0; j < listeTestsPourCampagne.size(); j = j + 8) {
0586: if ((listeTestsPourCampagne.get(j)
0587: .equals(valeurNomFamilleTestExecutionCampagne))
0588: && (listeTestsPourCampagne.get(j + 2)
0589: .equals(valeurNomSuiteTestExecutionCampagne))
0590: && (listeTestsPourCampagne.get(j + 4)
0591: .equals(valeurNomCasDeTestExecutionCampagne))
0592: && (IDTestTrouve == false)) {
0593: IDTestTrouve = true;
0594: IDTest = listeTestsPourCampagne.get(j + 5);
0595: }
0596: }
0597: if (IDTestTrouve) {
0598: Element ResulExec = ResulExecs.addElement(
0599: "ResulExec").addAttribute("refTest",
0600: "Test_" + IDTest).addAttribute("res",
0601: valeurResultatTestExecuteExecutionCampagne);
0602: Element RefTest = ResulExec.addElement("RefTest");
0603: if (isPresenceColonneCasDeTestsExecutionCamp) {
0604: Element NomTest = RefTest
0605: .addElement("NomTest")
0606: .addText(
0607: valeurNomCasDeTestExecutionCampagne);
0608: }
0609: if (isPresenceColonneSuiteDeTestsExecutionCamp) {
0610: Element NomSuite = RefTest.addElement(
0611: "NomSuite").addText(
0612: valeurNomSuiteTestExecutionCampagne);
0613: }
0614: if (isPresenceColonneFamilleDeTestsExecutionCamp) {
0615: Element NomFamille = RefTest.addElement(
0616: "NomFamille").addText(
0617: valeurNomFamilleTestExecutionCampagne);
0618: }
0619: ResulActionTests = ResulExecCampTest
0620: .addElement("ResulActionTests");
0621:
0622: //A completer
0623: if (valeurNomCasDeTestExecutionCampagne.length() > 0) {
0624: hauteurTestExecutionCampagne = 1;
0625: debutTestExecutionCampagne = i;
0626: if ((hauteurTestExecutionCampagne
0627: + debutTestExecutionCampagne < nombreLigneTableauExecutionCamp - 1)) {
0628: celluleLu = execCampSheet
0629: .getCell(
0630: numeroColonneCasDeTestsExecutionCamp,
0631: i
0632: + hauteurTestExecutionCampagne);
0633: while ((celluleLu.getContents().length() == 0)
0634: && (hauteurTestExecutionCampagne
0635: + debutTestExecutionCampagne < nombreLigneTableauExecutionCamp - 1)) {
0636: hauteurTestExecutionCampagne++;
0637: celluleLu = execCampSheet
0638: .getCell(
0639: numeroColonneCasDeTestsExecutionCamp,
0640: i
0641: + hauteurTestExecutionCampagne);
0642: }
0643:
0644: if ((debutTestExecutionCampagne == nombreLigneTableauExecutionCamp - 1)
0645: && (execCampSheet
0646: .getCell(
0647: numeroColonneCasDeTestsExecutionCamp,
0648: nombreLigneTableauExecutionCamp - 1)
0649: .getContents().length() != 0)) {
0650: hauteurTestExecutionCampagne++;
0651: }
0652: if ((debutTestExecutionCampagne
0653: + hauteurTestExecutionCampagne == nombreLigneTableauExecutionCamp - 1)
0654: && (execCampSheet
0655: .getCell(
0656: numeroColonneCasDeTestsExecutionCamp,
0657: nombreLigneTableauExecutionCamp - 1)
0658: .getContents().length() == 0)) {
0659: hauteurTestExecutionCampagne++;
0660: }
0661: }
0662:
0663: litLesActionsExecutionsTests(
0664: debutTestExecutionCampagne,
0665: hauteurTestExecutionCampagne);
0666:
0667: }
0668: }
0669: }
0670: }
0671: }
0672:
0673: private void litLesActionsExecutionsTests(
0674: int debutTestExecutionCampagne,
0675: int hauteurTestExecutionCampagne) {
0676: for (int i = debutTestExecutionCampagne; i < debutTestExecutionCampagne
0677: + hauteurTestExecutionCampagne; i++) {
0678: celluleLu = execCampSheet.getCell(
0679: numeroColonneNumeroExecutionCamp, i);
0680:
0681: valeurNumeroExecuteExecutionCampagne = celluleLu
0682: .getContents();
0683: boolean IDActionTrouve = false;
0684: for (int j = 0; j < actionID.size(); j = j + 5) {
0685: if ((actionID.get(j).equals(IDTest))
0686: && (actionID.get(j + 1)
0687: .equals(valeurNumeroExecuteExecutionCampagne))
0688: && (IDActionTrouve == false)) {
0689: IDActionTrouve = true;
0690: IDAction = actionID.get(j + 2);
0691: valeurActionARealiser = actionID.get(j + 3);
0692: valeurActionAttendue = actionID.get(j + 4);
0693: }
0694: }
0695: celluleLu = execCampSheet.getCell(
0696: numeroColonneActionExecuteeExecutionCamp, i);
0697:
0698: Element ResulActionTest = ResulActionTests.addElement(
0699: "ResulActionTest").addAttribute("refAction",
0700: "Action_" + IDAction).addAttribute("res",
0701: celluleLu.getContents());
0702: Element RefAction = ResulActionTest.addElement("RefAction");
0703: Element NomAction = RefAction.addElement("NomAction")
0704: .addText(valeurNumeroExecuteExecutionCampagne);
0705: Element NomTest = RefAction.addElement("NomTest").addText(
0706: valeurNomCasDeTestExecutionCampagne);
0707: Element NomSuite = RefAction.addElement("NomSuite")
0708: .addText(valeurNomSuiteTestExecutionCampagne);
0709: Element NomFamille = RefAction.addElement("NomFamille")
0710: .addText(valeurNomFamilleTestExecutionCampagne);
0711: Element Description = ResulActionTest.addElement(
0712: "Description").addText(valeurActionARealiser);
0713: Element ResultAttendu = ResulActionTest.addElement(
0714: "ResultAttendu").addText(valeurActionAttendue);
0715:
0716: celluleLu = execCampSheet.getCell(
0717: numeroColonneActionObtenueExecutionCamp, i);
0718: if (celluleLu.getContents().length() > 0) {
0719: Element ResulEffectif = ResulActionTest.addElement(
0720: "ResulEffectif").addText(
0721: celluleLu.getContents());
0722: }
0723:
0724: }
0725: }
0726:
0727: /**
0728: * Lit la feuille executions des campagnes
0729: * @param valeurNomCampagne Nom de la campagne
0730: */
0731: public void readXlsTableExecutionCampagnes(String valeurNomCampagne) {
0732: for (int i = ligneDebutTableauExecutionCamp + 1; i < nombreLigneTableauExecutionCamp; i++) {
0733: celluleLu = execCampSheet.getCell(
0734: numeroColonneNomCampagneExecutionCamp, i);
0735: if (celluleLu.getContents().length() > 0
0736: && valeurNomCampagne
0737: .equals(celluleLu.getContents())) {
0738: // lit le nom de la campagne
0739: /* boolean campagneTrouve =false;
0740: for (int j=0; j <campagneID.size();j=j+2){
0741: if (celluleLu.getContents().equals(campagneID.get(j))){
0742: campagneTrouve=true;
0743: valeurNomCampagne = celluleLu.getContents();
0744: IDCampagne = campagneID.get(j+1);
0745: }
0746: }*/
0747:
0748: /* if(campagneTrouve){
0749: Element CampagneTest = CampagneTests.addElement("CampagneTest")
0750: .addAttribute("id_camp", "Camp_" + IDCampagne);*/
0751: Element ExecCampTests = CampagneTest
0752: .addElement("ExecCampTests");
0753: ExecCampTest = ExecCampTests.addElement("ExecCampTest")
0754: .addAttribute("id_exec_camp",
0755: "ExecCamp_" + indiceExecutionCamp);
0756:
0757: celluleLu = execCampSheet.getCell(
0758: numeroColonneNomExecutionExecutionCamp, i);
0759: Element NomExecCamp = ExecCampTest.addElement("Nom")
0760: .addText(celluleLu.getContents());
0761: celluleLu = execCampSheet.getCell(
0762: numeroColonneNomEnvironnementExecutionCamp, i);
0763: for (int k = 0; k < environnementID.size(); k = k + 2) {
0764: if (celluleLu.getContents().equals(
0765: environnementID.get(k))) {
0766: Element EnvironnementEx = ExecCampTest
0767: .addElement("EnvironnementEx")
0768: .addAttribute(
0769: "ref",
0770: "Env_"
0771: + environnementID
0772: .get(k + 1));
0773: Element NomEnvironnementEx = EnvironnementEx
0774: .addElement("Nom").addText(
0775: celluleLu.getContents());
0776: }
0777: }
0778: celluleLu = execCampSheet.getCell(
0779: numeroColonneJeuDeDonneesExecutionCamp, i);
0780: for (int k = 0; k < jeuDeDonneesID.size(); k = k + 2) {
0781: if (celluleLu.getContents().equals(
0782: jeuDeDonneesID.get(k))) {
0783: Element JeuDonneesEx = ExecCampTest.addElement(
0784: "JeuDonneesEx").addAttribute("ref",
0785: "Jeu_" + jeuDeDonneesID.get(k + 1));
0786: Element NomJeuDonneesEx = JeuDonneesEx
0787: .addElement("Nom").addText(
0788: celluleLu.getContents());
0789:
0790: }
0791: }
0792:
0793: litPJetURL(
0794: ExecCampTest,
0795: execCampSheet,
0796: i,
0797: isPresenceColonneLienHypertexteExecutionCamp,
0798: numeroColonneLienHypertexteExecutionCamp,
0799: isPresenceColonnePieceJointeExecutionCamp,
0800: numeroColonnePieceJointeExecutionCamp,
0801: Language.getInstance().getText("Campagnes")
0802: + fs
0803: + IDCampagne
0804: + fs
0805: + execCampSheet
0806: .getCell(
0807: numeroColonneNomCampagneExecutionCamp,
0808: i).getContents());
0809: if (valeurNomCampagne.length() > 0) {
0810: hauteurExecutionCampagne = 1;
0811: debutExecutionCampagne = i;
0812:
0813: celluleLu = execCampSheet.getCell(
0814: numeroColonneNomCampagneExecutionCamp, i
0815: + hauteurExecutionCampagne);
0816: while ((celluleLu.getContents().length() == 0)
0817: && (hauteurExecutionCampagne
0818: + debutExecutionCampagne < nombreLigneTableauExecutionCamp - 1)) {
0819: hauteurExecutionCampagne++;
0820: celluleLu = execCampSheet.getCell(
0821: numeroColonneNomCampagneExecutionCamp,
0822: i + hauteurExecutionCampagne);
0823:
0824: }
0825:
0826: if ((debutExecutionCampagne == nombreLigneTableauExecutionCamp - 1)
0827: && (execCampSheet
0828: .getCell(
0829: numeroColonneNomCampagneExecutionCamp,
0830: nombreLigneTableauExecutionCamp - 1)
0831: .getContents().length() != 0)) {
0832: hauteurExecutionCampagne++;
0833: }
0834: if ((debutExecutionCampagne
0835: + hauteurExecutionCampagne == nombreLigneTableauExecutionCamp - 1)
0836: && (execCampSheet
0837: .getCell(
0838: numeroColonneNomCampagneExecutionCamp,
0839: nombreLigneTableauExecutionCamp - 1)
0840: .getContents().length() == 0)) {
0841: hauteurExecutionCampagne++;
0842: }
0843: litLesExecutions(debutExecutionCampagne,
0844: hauteurExecutionCampagne);
0845:
0846: }
0847:
0848: /* }else{
0849: listeCampagneNonTrouve = listeCampagneNonTrouve + celluleLu.getContents() + "\n";
0850: } */
0851: indiceExecutionCamp++;
0852:
0853: }
0854: }
0855:
0856: }
0857:
0858: /**
0859: * Function that Verify the presence of Execution campaigns columns in the Execution campaign spreadsheet
0860: */
0861: public void testColumnsPresenceExecutionCampagnes() {
0862:
0863: StringTokenizer st;
0864: // Recupère ligne debut tableau
0865: boolean ExecutionCampagneTrouve = false;
0866: for (int i = 0; i < nombreColonneTableauExecutionCamp; i++) {
0867: for (int j = 0; j < nombreLigneTableauExecutionCamp; j++) {
0868: celluleLu = execCampSheet.getCell(i, j);
0869: st = new StringTokenizer(Language.getInstance()
0870: .getText("nom_Campagne_Liste").toLowerCase(),
0871: ",");
0872: while (st.hasMoreTokens()
0873: && ExecutionCampagneTrouve == false) {
0874: if (celluleLu.getContents().trim().toLowerCase()
0875: .equals(st.nextToken().toString())) {
0876: ligneDebutTableauExecutionCamp = celluleLu
0877: .getRow();
0878: ExecutionCampagneTrouve = true;
0879: }
0880: }
0881:
0882: }
0883: }
0884:
0885: // test présence des differents colonnes
0886: for (int i = 0; i < nombreColonneTableauExecutionCamp; i++) {
0887: celluleLu = execCampSheet.getCell(i,
0888: ligneDebutTableauExecutionCamp);
0889:
0890: // test présence nom Campagne
0891: st = new StringTokenizer(Language.getInstance().getText(
0892: "nom_Campagne_Liste").toLowerCase(), ",");
0893: while (st.hasMoreTokens()
0894: && isPresenceColonneNomCampagneExecutionCamp == false) {
0895: if (celluleLu.getContents().trim().toLowerCase()
0896: .equals(st.nextToken().toString())) {
0897: isPresenceColonneNomCampagneExecutionCamp = true;
0898: numeroColonneNomCampagneExecutionCamp = i;
0899: }
0900: }
0901: //test présence nom de l'execution
0902: st = new StringTokenizer(Language.getInstance().getText(
0903: "nom_Execution_Liste").toLowerCase(), ",");
0904: while (st.hasMoreTokens()
0905: && isPresenceColonneNomExecutionExecutionCamp == false) {
0906: if (celluleLu.getContents().trim().toLowerCase()
0907: .equals(st.nextToken().toString())) {
0908: isPresenceColonneNomExecutionExecutionCamp = true;
0909: numeroColonneNomExecutionExecutionCamp = i;
0910: }
0911: }
0912: //test présence nom de l'environnement
0913: st = new StringTokenizer(Language.getInstance().getText(
0914: "nom_Environnements_Liste").toLowerCase(), ",");
0915: while (st.hasMoreTokens()
0916: && isPresenceColonneNomEnvironnementExecutionCamp == false) {
0917: if (celluleLu.getContents().trim().toLowerCase()
0918: .equals(st.nextToken().toString())) {
0919: isPresenceColonneNomEnvironnementExecutionCamp = true;
0920: numeroColonneNomEnvironnementExecutionCamp = i;
0921: }
0922: }
0923:
0924: //test présence Jeu de donnees
0925: st = new StringTokenizer(Language.getInstance().getText(
0926: "jeu_de_donnees_Campagne_Liste").toLowerCase(), ",");
0927: while (st.hasMoreTokens()
0928: && isPresenceColonneJeuDeDonneesExecutionCamp == false) {
0929: if (celluleLu.getContents().trim().toLowerCase()
0930: .equals(st.nextToken().toString())) {
0931: isPresenceColonneJeuDeDonneesExecutionCamp = true;
0932: numeroColonneJeuDeDonneesExecutionCamp = i;
0933: }
0934: }
0935:
0936: // test présence des colonnes Lien Hypertexte
0937: st = new StringTokenizer(Language.getInstance().getText(
0938: "Lien_Hypertexte_Liste").toLowerCase(), ",");
0939: while (st.hasMoreTokens()
0940: && isPresenceColonneLienHypertexteExecutionCamp == false) {
0941: if (celluleLu.getContents().trim().toLowerCase()
0942: .equals(st.nextToken().toString())) {
0943: isPresenceColonneLienHypertexteExecutionCamp = true;
0944: numeroColonneLienHypertexteExecutionCamp = i;
0945: }
0946: }
0947:
0948: // test présence des colonnes Piece Jointe
0949: st = new StringTokenizer(Language.getInstance().getText(
0950: "Piece_Jointe_Liste").toLowerCase(), ",");
0951: while (st.hasMoreTokens()
0952: && isPresenceColonnePieceJointeExecutionCamp == false) {
0953: if (celluleLu.getContents().trim().toLowerCase()
0954: .equals(st.nextToken().toString())) {
0955: isPresenceColonnePieceJointeExecutionCamp = true;
0956: numeroColonnePieceJointeExecutionCamp = i;
0957: }
0958: }
0959:
0960: // test présence des colonnes NOM DU RÉSULTAT DE L'EXÉCUTION
0961: st = new StringTokenizer(Language.getInstance().getText(
0962: "Nom_du_resultat_de_lexecution_Liste")
0963: .toLowerCase(), ",");
0964: while (st.hasMoreTokens()
0965: && isPresenceColonneNomResultatExecutionExecutionCamp == false) {
0966: if (celluleLu.getContents().trim().toLowerCase()
0967: .equals(st.nextToken().toString())) {
0968: isPresenceColonneNomResultatExecutionExecutionCamp = true;
0969: numeroColonneNomResultatExecutionExecutionCamp = i;
0970: }
0971: }
0972: // test présence des colonnes RÉSULTAT EXÉCUTION
0973: st = new StringTokenizer(Language.getInstance().getText(
0974: "Resultat_de_lexecution_Liste").toLowerCase(), ",");
0975: while (st.hasMoreTokens()
0976: && isPresenceColonneResultatExecutionExecutionCamp == false) {
0977: if (celluleLu.getContents().trim().toLowerCase()
0978: .equals(st.nextToken().toString())) {
0979: isPresenceColonneResultatExecutionExecutionCamp = true;
0980: numeroColonneResultatExecutionExecutionCamp = i;
0981: }
0982: }
0983: // test présence des Famille de tests
0984: st = new StringTokenizer(Language.getInstance().getText(
0985: "famille_de_tests_Liste").toLowerCase(), ",");
0986: while (st.hasMoreTokens()
0987: && isPresenceColonneFamilleDeTestsExecutionCamp == false) {
0988: if (celluleLu.getContents().trim().toLowerCase()
0989: .equals(st.nextToken().toString())) {
0990: isPresenceColonneFamilleDeTestsExecutionCamp = true;
0991: numeroColonneFamilleDeTestsExecutionCamp = i;
0992: }
0993: }
0994:
0995: //test présence des Suite de tests
0996: st = new StringTokenizer(Language.getInstance().getText(
0997: "suite_de_tests_Liste").toLowerCase(), ",");
0998: while (st.hasMoreTokens()
0999: && isPresenceColonneSuiteDeTestsExecutionCamp == false) {
1000: if (celluleLu.getContents().trim().toLowerCase()
1001: .equals(st.nextToken().toString())) {
1002: isPresenceColonneSuiteDeTestsExecutionCamp = true;
1003: numeroColonneSuiteDeTestsExecutionCamp = i;
1004: }
1005: }
1006:
1007: // test présence des colonnes Cas de tests
1008: st = new StringTokenizer(Language.getInstance().getText(
1009: "cas_de_tests_Liste").toLowerCase(), ",");
1010: while (st.hasMoreTokens()
1011: && isPresenceColonneCasDeTestsExecutionCamp == false) {
1012: if (celluleLu.getContents().trim().toLowerCase()
1013: .equals(st.nextToken().toString())) {
1014: isPresenceColonneCasDeTestsExecutionCamp = true;
1015: numeroColonneCasDeTestsExecutionCamp = i;
1016: }
1017: }
1018: // test présence des colonnes RÉSULTAT DU TEST EXÉCUTÉ
1019: st = new StringTokenizer(Language.getInstance().getText(
1020: "Resultat_test_execute_Liste").toLowerCase(), ",");
1021: while (st.hasMoreTokens()
1022: && isPresenceColonneResultatTestExecuteExecutionCamp == false) {
1023: if (celluleLu.getContents().trim().toLowerCase()
1024: .equals(st.nextToken().toString())) {
1025: isPresenceColonneResultatTestExecuteExecutionCamp = true;
1026: numeroColonneResultatTestExecuteExecutionCamp = i;
1027: }
1028: }
1029: // test présence des colonnes numéro
1030: st = new StringTokenizer(Language.getInstance().getText(
1031: "numero_Liste").toLowerCase(), ",");
1032: while (st.hasMoreTokens()
1033: && isPresenceColonneNumeroExecutionCamp == false) {
1034: if (celluleLu.getContents().trim().toLowerCase()
1035: .equals(st.nextToken().toString())) {
1036: isPresenceColonneNumeroExecutionCamp = true;
1037: numeroColonneNumeroExecutionCamp = i;
1038: }
1039: }
1040: // test présence des colonnes ACTION EXÉCUTÉE
1041: st = new StringTokenizer(Language.getInstance().getText(
1042: "action_executee_Liste").toLowerCase(), ",");
1043: while (st.hasMoreTokens()
1044: && isPresenceColonneActionExecuteeExecutionCamp == false) {
1045: if (celluleLu.getContents().trim().toLowerCase()
1046: .equals(st.nextToken().toString())) {
1047: isPresenceColonneActionExecuteeExecutionCamp = true;
1048: numeroColonneActionExecuteeExecutionCamp = i;
1049: }
1050: }
1051: // test présence des colonnes ACTION OBTENUE
1052: st = new StringTokenizer(Language.getInstance().getText(
1053: "action_obtenue_Liste").toLowerCase(), ",");
1054: while (st.hasMoreTokens()
1055: && isPresenceColonneActionObtenueExecutionCamp == false) {
1056: if (celluleLu.getContents().trim().toLowerCase()
1057: .equals(st.nextToken().toString())) {
1058: isPresenceColonneActionObtenueExecutionCamp = true;
1059: numeroColonneActionObtenueExecutionCamp = i;
1060: }
1061: }
1062:
1063: }
1064: if ((isPresenceColonneNomCampagneExecutionCamp == false)
1065: || (isPresenceColonneNomExecutionExecutionCamp == false)
1066: || (isPresenceColonneNomEnvironnementExecutionCamp == false)
1067: || (isPresenceColonneJeuDeDonneesExecutionCamp == false)) {
1068: isErreurTraitementImport = true;
1069: closeXmlAndXlsFiles();
1070: JOptionPane.showMessageDialog(null, Language.getInstance()
1071: .getText("Stop_No_Campaign_Name_Column"), Language
1072: .getInstance().getText("Erreur_!"),
1073: JOptionPane.ERROR_MESSAGE);
1074: PopUpFormalismeExcel p = new PopUpFormalismeExcel(
1075: pIPlugObject);
1076:
1077: }
1078:
1079: }
1080:
1081: /**
1082: * read url and files for all spreadsheets
1083: * @param ElementAAttachements Element XML
1084: * @param feuilleExcel Feuille Excel
1085: * @param ligneALire ligne à lire
1086: * @param presenceColonneLienHypertexte presence Colonne Lien Hypertexte
1087: * @param numeroColonneLienHypertexte numéro Colonne Lien Hypertexte
1088: * @param presenceColonnePieceJointe presence colonne Piece Jointe
1089: * @param numeroColonnePieceJointe numéro colonne Piece Jointe
1090: * @param repertoirePieceJointe Répertoire de stockage des Piece Jointe
1091: */
1092: public void litPJetURL(Element ElementAAttachements,
1093: Sheet feuilleExcel, int ligneALire,
1094: boolean presenceColonneLienHypertexte,
1095: int numeroColonneLienHypertexte,
1096: boolean presenceColonnePieceJointe,
1097: int numeroColonnePieceJointe, String repertoirePieceJointe) {
1098: // lit Lien Hypertexte
1099: if (presenceColonneLienHypertexte == true) {
1100: celluleLu = feuilleExcel.getCell(
1101: numeroColonneLienHypertexte, ligneALire);
1102: if (celluleLu.getType() == CellType.NUMBER_FORMULA
1103: || celluleLu.getType() == CellType.STRING_FORMULA
1104: || celluleLu.getType() == CellType.BOOLEAN_FORMULA
1105: || celluleLu.getType() == CellType.DATE_FORMULA
1106: || celluleLu.getType() == CellType.FORMULA_ERROR) {
1107: FormulaCell nfc = (FormulaCell) celluleLu;
1108: StringBuffer sb = new StringBuffer();
1109: try {
1110: StringTokenizer st = new StringTokenizer(nfc
1111: .getFormula(), "\"");
1112: st.nextToken();
1113: valeurLienHypertexte.add(st.nextToken());
1114: } catch (FormulaException e) {
1115: JOptionPane.showMessageDialog(null, Language
1116: .getInstance().getText("malformed_formula")
1117: + sb.toString() + ": " + e.getMessage(),
1118: Language.getInstance().getText("Erreur_!"),
1119: JOptionPane.ERROR_MESSAGE);
1120: }
1121: } else {
1122: StringTokenizer st = new StringTokenizer(celluleLu
1123: .getContents(), "\n");
1124: while (st.hasMoreTokens()) {
1125: valeurLienHypertexte.add(st.nextToken());
1126: }
1127: }
1128: if (!valeurLienHypertexte.isEmpty()) {
1129: for (int z = 0; z < valeurLienHypertexte.size(); z++) {
1130: try {
1131: URL url = new URL(valeurLienHypertexte.get(z)
1132: .toString());
1133: } catch (MalformedURLException mue) {
1134: JOptionPane.showMessageDialog(null, Language
1135: .getInstance().getText("malformed_URL")
1136: + valeurLienHypertexte.get(z)
1137: .toString(), Language
1138: .getInstance().getText("Erreur_!"),
1139: JOptionPane.ERROR_MESSAGE);
1140: valeurLienHypertexte.remove(z);
1141: }
1142: }
1143:
1144: } else {
1145: valeurLienHypertexte.clear();
1146: }
1147: }
1148:
1149: // lit Piece Jointe
1150: if (presenceColonnePieceJointe == true) {
1151: celluleLu = feuilleExcel.getCell(numeroColonnePieceJointe,
1152: ligneALire);
1153: if (celluleLu.getType() == CellType.NUMBER_FORMULA
1154: || celluleLu.getType() == CellType.STRING_FORMULA
1155: || celluleLu.getType() == CellType.BOOLEAN_FORMULA
1156: || celluleLu.getType() == CellType.DATE_FORMULA
1157: || celluleLu.getType() == CellType.FORMULA_ERROR) {
1158: FormulaCell nfc = (FormulaCell) celluleLu;
1159: StringBuffer sb = new StringBuffer();
1160:
1161: try {
1162: StringTokenizer st = new StringTokenizer(nfc
1163: .getFormula(), "\"");
1164: st.nextToken();
1165: String RecupereCheminRelatif;
1166: try {
1167: RecupereCheminRelatif = copyFileAttachements(st
1168: .nextToken().replaceFirst("file:///",
1169: ""), repertoirePieceJointe,
1170: null);
1171: valeurPieceJointe.add(RecupereCheminRelatif);
1172: valeurPieceJointe.remove(null);
1173: } catch (Exception e) {
1174: // TODO Auto-generated catch block
1175: e.printStackTrace();
1176: }
1177: } catch (FormulaException e) {
1178: JOptionPane.showMessageDialog(null, Language
1179: .getInstance().getText("malformed_formula")
1180: + sb.toString() + ": " + e.getMessage(),
1181: Language.getInstance().getText("Erreur_!"),
1182: JOptionPane.ERROR_MESSAGE);
1183: }
1184: } else {
1185: StringTokenizer st = new StringTokenizer(celluleLu
1186: .getContents(), "\n");
1187: while (st.hasMoreTokens()) {
1188: String RecupereCheminRelatif;
1189: try {
1190: RecupereCheminRelatif = copyFileAttachements(st
1191: .nextToken(), repertoirePieceJointe,
1192: null);
1193: valeurPieceJointe.add(RecupereCheminRelatif);
1194: valeurPieceJointe.remove(null);
1195: } catch (Exception e) {
1196: // TODO Auto-generated catch block
1197: e.printStackTrace();
1198: }
1199: }
1200: }
1201:
1202: if (valeurPieceJointe.isEmpty()) {
1203: valeurPieceJointe.clear();
1204: }
1205: }
1206: //Ecrit Lien hypertexte si présent et piece jointe si present
1207: if ((!valeurLienHypertexte.isEmpty())
1208: || (!valeurPieceJointe.isEmpty())) {
1209: Element Attachement = ElementAAttachements
1210: .addElement("Attachements");
1211: for (int z = 0; z < valeurLienHypertexte.size(); z++) {
1212: Element UrlAttachement = Attachement.addElement(
1213: "UrlAttachement").addAttribute("url",
1214: valeurLienHypertexte.get(z).toString());
1215: }
1216: for (int z = 0; z < valeurPieceJointe.size(); z++) {
1217: if (!valeurPieceJointe.get(z).toString().equals(null)) {
1218: Element FileAttachement = Attachement
1219: .addElement("FileAttachement")
1220: .addAttribute(
1221: "nom",
1222: valeurPieceJointe
1223: .get(z)
1224: .toString()
1225: .substring(
1226: valeurPieceJointe
1227: .get(z)
1228: .toString()
1229: .lastIndexOf(
1230: fs) + 1))
1231: .addAttribute("dir",
1232: valeurPieceJointe.get(z).toString());
1233: }
1234: }
1235: valeurLienHypertexte.clear();
1236: valeurPieceJointe.clear();
1237: }
1238: }
1239:
1240: /**
1241: * Read all the spreadsheet for the campaigns
1242: * @param selectionImportExigence selection Import Exigence
1243: * @param selectionExecutionCampagnes selection Execution Campagnes
1244: * @throws java.lang.Exception Exception
1245: */
1246: public void readXlsTableCampagnes(boolean selectionImportExigence,
1247: boolean selectionExecutionCampagnes) throws Exception {
1248: // Gestion des CampagnesTests
1249: Element CampagneTests = projetVT.addElement("CampagneTests");
1250:
1251: for (int i = ligneDebutTableauCampagne + 1; i < nombreLigneTableauCampagne; i++) {
1252: celluleLu = campagneSheet.getCell(numeroColonneNomCampagne,
1253: i);
1254: if (celluleLu.getContents().length() > 0) {
1255: // lit le nom de la campagne
1256: CampagneTest = CampagneTests.addElement("CampagneTest")
1257: .addAttribute("id_camp",
1258: "Camp_" + indiceCampagne);
1259: Element Concepteur = CampagneTest
1260: .addElement("Concepteur");
1261: Element NomConcepteur = Concepteur.addElement("Nom")
1262: .addText(
1263: Language.getInstance().getText(
1264: "pluginxlsxml"));
1265: // Génération de la date
1266: DateFormat dateFormat = DateFormat
1267: .getDateInstance(DateFormat.MONTH_FIELD);
1268: Element dateCrea = CampagneTest.addElement("Date_crea")
1269: .addText(dateFormat.format(new Date()));
1270:
1271: celluleLu = campagneSheet.getCell(
1272: numeroColonneNomCampagne, i);
1273:
1274: valeurNomCampagne = celluleLu.getContents();
1275: Element Campagne = CampagneTest.addElement("Nom")
1276: .addText(valeurNomCampagne);
1277: campagneID.add(valeurNomCampagne);
1278: campagneID.add(Integer.toString(indiceCampagne));
1279:
1280: //Lit la description de la campagne
1281: if (isPresenceColonneDescriptionCampagne) {
1282: celluleLu = campagneSheet.getCell(
1283: numeroColonneDescriptionCampagne, i);
1284: Element descriptionCampagne = CampagneTest
1285: .addElement("Description").addText(
1286: celluleLu.getContents());
1287: }
1288:
1289: litPJetURL(CampagneTest, campagneSheet, i,
1290: isPresenceColonneLienHypertexteCampagne,
1291: numeroColonneLienHypertexteCampagne,
1292: isPresenceColonnePieceJointeCampagne,
1293: numeroColonnePieceJointeCampagne, Language
1294: .getInstance().getText("Campagne")
1295: + fs + indiceCampagne);
1296:
1297: if (valeurNomCampagne.length() > 0) {
1298: hauteurCampagne = 0;
1299: debutCampagne = i;
1300:
1301: celluleLu = campagneSheet.getCell(
1302: numeroColonneNomCampagne, i
1303: + hauteurCampagne);
1304:
1305: while (((celluleLu.getContents().equals(
1306: valeurNomCampagne) || celluleLu
1307: .getContents().length() == 0))
1308: && (hauteurCampagne + debutCampagne < nombreLigneTableauCampagne - 1)) {
1309: hauteurCampagne++;
1310: celluleLu = campagneSheet.getCell(
1311: numeroColonneNomCampagne, i
1312: + hauteurCampagne);
1313:
1314: }
1315:
1316: if ((debutCampagne == nombreLigneTableauCampagne - 1)
1317: && (campagneSheet.getCell(
1318: numeroColonneNomCampagne,
1319: nombreLigneTableauCampagne - 1)
1320: .getContents().length() != 0)) {
1321: hauteurCampagne++;
1322: }
1323: if ((debutCampagne + hauteurCampagne == nombreLigneTableauCampagne - 1)
1324: && (campagneSheet.getCell(
1325: numeroColonneNomCampagne,
1326: nombreLigneTableauCampagne - 1)
1327: .getContents().length() == 0)) {
1328: hauteurCampagne++;
1329: }
1330:
1331: for (int boucle = debutCampagne; boucle < debutCampagne
1332: + hauteurCampagne; boucle++) {
1333: if (isPresenceColonneJeuDeDonneesCampagne) {
1334: celluleLu = campagneSheet.getCell(
1335: numeroColonneJeuDeDonneesCampagne,
1336: boucle);
1337: if (celluleLu.getContents().length() > 0) {
1338: Element JeuxDonnees = CampagneTest
1339: .addElement("JeuxDonnees");
1340: Element JeuDonnees = JeuxDonnees
1341: .addElement("JeuDonnees")
1342: .addAttribute(
1343: "id_jeu",
1344: "Jeu_"
1345: + indiceJeuDeDonnees);
1346: Element NomJeuDonnees = JeuDonnees
1347: .addElement("Nom")
1348: .addText(
1349: celluleLu.getContents());
1350: jeuDeDonneesID.add(celluleLu
1351: .getContents());
1352: jeuDeDonneesID.add(Integer
1353: .toString(indiceJeuDeDonnees));
1354: indiceJeuDeDonnees++;
1355: if (isPresenceColonneDescriptionJeuDeDonneesCampagne) {
1356: celluleLu = campagneSheet
1357: .getCell(
1358: numeroColonneDescriptionJeuDeDonneesCampagne,
1359: boucle);
1360: if (celluleLu.getContents()
1361: .length() > 0) {
1362: Element DescriptionJeuDonnees = JeuDonnees
1363: .addElement(
1364: "Description")
1365: .addText(
1366: celluleLu
1367: .getContents());
1368: }
1369: }
1370:
1371: }
1372: }
1373: }
1374:
1375: if (selectionImportExigence) {
1376: LinkRequirement = CampagneTest
1377: .addElement("LinkRequirement");
1378: // Partie lien Exigence
1379: for (int boucle = debutCampagne; boucle < debutCampagne
1380: + hauteurCampagne; boucle++) {
1381: if (isPresenceColonneFamilleTestCampagne
1382: && isPresenceColonneSuiteTestCampagne
1383: && isPresenceColonneCasDeTestCampagne) {
1384: celluleLu = campagneSheet.getCell(
1385: numeroColonneCasDeTestCampagne,
1386: boucle);
1387: if (celluleLu.getContents().length() > 0) {
1388: for (int j = 0; j < listeTestsPourCampagne
1389: .size(); j = j + 8) {
1390: if (listeTestsPourCampagne
1391: .get(j)
1392: .equals(
1393: campagneSheet
1394: .getCell(
1395: numeroColonneFamilleTestCampagne,
1396: boucle)
1397: .getContents())
1398: && listeTestsPourCampagne
1399: .get(j + 2)
1400: .equals(
1401: campagneSheet
1402: .getCell(
1403: numeroColonneSuiteTestCampagne,
1404: boucle)
1405: .getContents())
1406: && listeTestsPourCampagne
1407: .get(j + 4)
1408: .equals(
1409: campagneSheet
1410: .getCell(
1411: numeroColonneCasDeTestCampagne,
1412: boucle)
1413: .getContents())) {
1414: if ((listeTestsPourCampagne
1415: .get(j + 6) != null)) {
1416: Element RequirementRef = LinkRequirement
1417: .addElement(
1418: "RequirementRef")
1419: .addAttribute(
1420: "ref",
1421: "Req_"
1422: + listeTestsPourCampagne
1423: .get(j + 7));
1424: Element nomRequirementRef = RequirementRef
1425: .addElement(
1426: "Nom")
1427: .addText(
1428: listeTestsPourCampagne
1429: .get(j + 6));
1430: }
1431: }
1432: }
1433: }
1434: }
1435: }
1436: }
1437:
1438: // Partie Famille
1439: Element FamillesCamp = CampagneTest
1440: .addElement("FamillesCamp");
1441: for (int boucle = debutCampagne; boucle < debutCampagne
1442: + hauteurCampagne; boucle++) {
1443: if (isPresenceColonneFamilleTestCampagne
1444: && isPresenceColonneSuiteTestCampagne
1445: && isPresenceColonneCasDeTestCampagne) {
1446: celluleLu = campagneSheet.getCell(
1447: numeroColonneCasDeTestCampagne,
1448: boucle);
1449: if (celluleLu.getContents().length() > 0) {
1450: boolean testTrouve = false;
1451: for (int j = 0; j < listeTestsPourCampagne
1452: .size(); j = j + 8) {
1453: if (listeTestsPourCampagne
1454: .get(j)
1455: .equals(
1456: campagneSheet
1457: .getCell(
1458: numeroColonneFamilleTestCampagne,
1459: boucle)
1460: .getContents())
1461: && listeTestsPourCampagne
1462: .get(j + 2)
1463: .equals(
1464: campagneSheet
1465: .getCell(
1466: numeroColonneSuiteTestCampagne,
1467: boucle)
1468: .getContents())
1469: && listeTestsPourCampagne
1470: .get(j + 4)
1471: .equals(
1472: campagneSheet
1473: .getCell(
1474: numeroColonneCasDeTestCampagne,
1475: boucle)
1476: .getContents())
1477: && !testTrouve) {
1478: Element FamilleRef = FamillesCamp
1479: .addElement(
1480: "FamilleRef")
1481: .addAttribute(
1482: "ref",
1483: "Fam_"
1484: + listeTestsPourCampagne
1485: .get(j + 1));
1486: Element NomFamilleRef = FamilleRef
1487: .addElement("Nom")
1488: .addText(
1489: listeTestsPourCampagne
1490: .get(j));
1491: Element SuiteTestsCamp = FamilleRef
1492: .addElement("SuiteTestsCamp");
1493: Element SuiteTestRef = SuiteTestsCamp
1494: .addElement(
1495: "SuiteTestRef")
1496: .addAttribute(
1497: "ref",
1498: "SuiteTest_"
1499: + listeTestsPourCampagne
1500: .get(j + 3));
1501: Element NomSuiteTestRef = SuiteTestRef
1502: .addElement("Nom")
1503: .addText(
1504: listeTestsPourCampagne
1505: .get(j + 2));
1506: Element TestsCamp = SuiteTestRef
1507: .addElement("TestsCamp");
1508: Element TestRef = TestsCamp
1509: .addElement("TestRef")
1510: .addAttribute(
1511: "ref",
1512: "Test_"
1513: + listeTestsPourCampagne
1514: .get(j + 5))
1515: .addAttribute(
1516: "loginAssigned",
1517: Language
1518: .getInstance()
1519: .getText(
1520: "pluginxlsxml"));
1521: Element NomTestRef = TestRef
1522: .addElement("Nom")
1523: .addText(
1524: listeTestsPourCampagne
1525: .get(j + 4));
1526: testTrouve = true;
1527: }
1528: }
1529: }
1530: }
1531: }
1532:
1533: }
1534: if (selectionExecutionCampagnes == true
1535: && !isErreurTraitementImport) {
1536: readXlsTableExecutionCampagnes(valeurNomCampagne);
1537: }
1538: indiceCampagne++;
1539: }
1540: }
1541:
1542: }
1543:
1544: /**
1545: * Function that Verify the presence of parameters columns in the paremeter spreadsheet
1546: */
1547: public void testColumnsPresenceCampagnes() {
1548:
1549: StringTokenizer st;
1550: // Recupère ligne debut tableau
1551: boolean CampagnesTrouve = false;
1552: for (int i = 0; i < nombreColonneTableauCampagne; i++) {
1553: for (int j = 0; j < nombreLigneTableauCampagne; j++) {
1554: celluleLu = campagneSheet.getCell(i, j);
1555: st = new StringTokenizer(Language.getInstance()
1556: .getText("nom_Campagne_Liste").toLowerCase(),
1557: ",");
1558: while (st.hasMoreTokens() && CampagnesTrouve == false) {
1559: if (celluleLu.getContents().trim().toLowerCase()
1560: .equals(st.nextToken().toString())) {
1561: ligneDebutTableauCampagne = celluleLu.getRow();
1562: CampagnesTrouve = true;
1563: }
1564: }
1565:
1566: }
1567: }
1568:
1569: // test présence des differents colonnes
1570: for (int i = 0; i < nombreColonneTableauCampagne; i++) {
1571: celluleLu = campagneSheet.getCell(i,
1572: ligneDebutTableauCampagne);
1573:
1574: // test présence nom Campagne
1575: st = new StringTokenizer(Language.getInstance().getText(
1576: "nom_Campagne_Liste").toLowerCase(), ",");
1577: while (st.hasMoreTokens()
1578: && isPresenceColonneNomCampagne == false) {
1579: if (celluleLu.getContents().trim().toLowerCase()
1580: .equals(st.nextToken().toString())) {
1581: isPresenceColonneNomCampagne = true;
1582: numeroColonneNomCampagne = i;
1583: }
1584: }
1585: //test présence description Campagne
1586: st = new StringTokenizer(Language.getInstance().getText(
1587: "description_Campagne_Liste").toLowerCase(), ",");
1588: while (st.hasMoreTokens()
1589: && isPresenceColonneDescriptionCampagne == false) {
1590: if (celluleLu.getContents().trim().toLowerCase()
1591: .equals(st.nextToken().toString())) {
1592: isPresenceColonneDescriptionCampagne = true;
1593: numeroColonneDescriptionCampagne = i;
1594: }
1595: }
1596: //test présence Jeu de donnees Campagne
1597: st = new StringTokenizer(Language.getInstance().getText(
1598: "jeu_de_donnees_Campagne_Liste").toLowerCase(), ",");
1599: while (st.hasMoreTokens()
1600: && isPresenceColonneJeuDeDonneesCampagne == false) {
1601: if (celluleLu.getContents().trim().toLowerCase()
1602: .equals(st.nextToken().toString())) {
1603: isPresenceColonneJeuDeDonneesCampagne = true;
1604: numeroColonneJeuDeDonneesCampagne = i;
1605: }
1606: }
1607: //test présence Description du Jeu de donnees Campagne
1608: st = new StringTokenizer(Language.getInstance().getText(
1609: "description_jeu_de_donnees_Campagne_Liste")
1610: .toLowerCase(), ",");
1611: while (st.hasMoreTokens()
1612: && isPresenceColonneDescriptionJeuDeDonneesCampagne == false) {
1613: if (celluleLu.getContents().trim().toLowerCase()
1614: .equals(st.nextToken().toString())) {
1615: isPresenceColonneDescriptionJeuDeDonneesCampagne = true;
1616: numeroColonneDescriptionJeuDeDonneesCampagne = i;
1617: }
1618: }
1619: //test présence Famille de tests Campagne
1620: st = new StringTokenizer(Language.getInstance().getText(
1621: "famille_de_tests_Liste").toLowerCase(), ",");
1622: while (st.hasMoreTokens()
1623: && isPresenceColonneFamilleTestCampagne == false) {
1624: if (celluleLu.getContents().trim().toLowerCase()
1625: .equals(st.nextToken().toString())) {
1626: isPresenceColonneFamilleTestCampagne = true;
1627: numeroColonneFamilleTestCampagne = i;
1628: }
1629: }
1630: //test présence suite de tests Campagne
1631: st = new StringTokenizer(Language.getInstance().getText(
1632: "suite_de_tests_Liste").toLowerCase(), ",");
1633: while (st.hasMoreTokens()
1634: && isPresenceColonneSuiteTestCampagne == false) {
1635: if (celluleLu.getContents().trim().toLowerCase()
1636: .equals(st.nextToken().toString())) {
1637: isPresenceColonneSuiteTestCampagne = true;
1638: numeroColonneSuiteTestCampagne = i;
1639: }
1640: }
1641: //test présence cas de tests Campagne
1642: st = new StringTokenizer(Language.getInstance().getText(
1643: "cas_de_tests_Liste").toLowerCase(), ",");
1644: while (st.hasMoreTokens()
1645: && isPresenceColonneCasDeTestCampagne == false) {
1646: if (celluleLu.getContents().trim().toLowerCase()
1647: .equals(st.nextToken().toString())) {
1648: isPresenceColonneCasDeTestCampagne = true;
1649: numeroColonneCasDeTestCampagne = i;
1650: }
1651: }
1652: // test présence des colonnes Lien Hypertexte
1653: st = new StringTokenizer(Language.getInstance().getText(
1654: "Lien_Hypertexte_Liste").toLowerCase(), ",");
1655: while (st.hasMoreTokens()
1656: && isPresenceColonneLienHypertexteCampagne == false) {
1657: if (celluleLu.getContents().trim().toLowerCase()
1658: .equals(st.nextToken().toString())) {
1659: isPresenceColonneLienHypertexteCampagne = true;
1660: numeroColonneLienHypertexteCampagne = i;
1661: }
1662: }
1663:
1664: // test présence des colonnes Piece Jointe
1665: st = new StringTokenizer(Language.getInstance().getText(
1666: "Piece_Jointe_Liste").toLowerCase(), ",");
1667: while (st.hasMoreTokens()
1668: && isPresenceColonnePieceJointeCampagne == false) {
1669: if (celluleLu.getContents().trim().toLowerCase()
1670: .equals(st.nextToken().toString())) {
1671: isPresenceColonnePieceJointeCampagne = true;
1672: numeroColonnePieceJointeCampagne = i;
1673: }
1674: }
1675: }
1676: if ((isPresenceColonneNomCampagne == false)) {
1677: isErreurTraitementImport = true;
1678: closeXmlAndXlsFiles();
1679: JOptionPane.showMessageDialog(null, Language.getInstance()
1680: .getText("Stop_No_Campaign_Name_Column"), Language
1681: .getInstance().getText("Erreur_!"),
1682: JOptionPane.ERROR_MESSAGE);
1683: PopUpFormalismeExcel p = new PopUpFormalismeExcel(
1684: pIPlugObject);
1685:
1686: }
1687:
1688: }
1689:
1690: /**
1691: * Read all the spreadsheet for the environments
1692: *
1693: * @throws java.lang.Exception
1694: * Null pointer exception
1695: */
1696: public void readXlsTableEnvironnement(
1697: boolean selectionImportParametre) throws Exception {
1698: if (!selectionImportParametre) {
1699: params = projetVT.addElement("Params");
1700: }
1701: // Gestion des Environnements
1702: Environnements = projetVT.addElement("Environnements");
1703:
1704: for (int i = ligneDebutTableauEnvironnement + 1; i < nombreLigneTableauEnvironnements; i++) {
1705: celluleLu = enviroSheet.getCell(
1706: numeroColonneNomEnvironnement, i);
1707: if (celluleLu.getContents().length() > 0) {
1708: // lit le nom de l'environnement
1709: Element Environnement = Environnements.addElement(
1710: "Environnement").addAttribute("idEnv",
1711: "Env_" + indiceEnvironnement);
1712: celluleLu = enviroSheet.getCell(
1713: numeroColonneNomEnvironnement, i);
1714: valeurNomEnvironnement = celluleLu.getContents();
1715: Element nomEnvironnement = Environnement.addElement(
1716: "Nom").addText(valeurNomEnvironnement);
1717: environnementID.add(valeurNomEnvironnement);
1718: environnementID.add(Integer
1719: .toString(indiceEnvironnement));
1720:
1721: //Lit la description de l'environnement
1722: if (isPresenceColonneDescriptionEnvironnement) {
1723: celluleLu = enviroSheet.getCell(
1724: numeroColonneDescriptionEnvironnement, i);
1725: Element descriptionParam = Environnement
1726: .addElement("Description").addText(
1727: celluleLu.getContents());
1728: }
1729: Element ValeurParams = Environnement
1730: .addElement("ValeurParams");
1731: litPJetURL(Environnement, enviroSheet, i,
1732: isPresenceColonneLienHypertexteEnvironnement,
1733: numeroColonneLienHypertexteEnvironnement,
1734: isPresenceColonnePieceJointeEnvironnement,
1735: numeroColonnePieceJointeEnvironnement, Language
1736: .getInstance()
1737: .getText("Environnements")
1738: + fs + indiceEnvironnement);
1739:
1740: if (valeurNomEnvironnement.length() > 0) {
1741: hauteurEnvironnement = 0;
1742: debutEnvironnement = i;
1743:
1744: celluleLu = enviroSheet.getCell(
1745: numeroColonneNomEnvironnement, i
1746: + hauteurEnvironnement);
1747:
1748: while (((celluleLu.getContents().equals(
1749: valeurNomEnvironnement) || celluleLu
1750: .getContents().length() == 0))
1751: && (hauteurEnvironnement
1752: + debutEnvironnement < nombreLigneTableauEnvironnements - 1)) {
1753: hauteurEnvironnement++;
1754: celluleLu = enviroSheet.getCell(
1755: numeroColonneNomEnvironnement, i
1756: + hauteurEnvironnement);
1757:
1758: }
1759:
1760: if ((debutEnvironnement == nombreLigneTableauEnvironnements - 1)
1761: && (enviroSheet
1762: .getCell(
1763: numeroColonneNomEnvironnement,
1764: nombreLigneTableauEnvironnements - 1)
1765: .getContents().length() != 0)) {
1766: hauteurEnvironnement++;
1767: }
1768: if ((debutEnvironnement + hauteurEnvironnement == nombreLigneTableauEnvironnements - 1)
1769: && (enviroSheet
1770: .getCell(
1771: numeroColonneNomEnvironnement,
1772: nombreLigneTableauEnvironnements - 1)
1773: .getContents().length() == 0)) {
1774: hauteurEnvironnement++;
1775: }
1776: for (int boucle = debutEnvironnement; boucle < debutEnvironnement
1777: + hauteurEnvironnement; boucle++) {
1778: if (isPresenceColonneNomParametreEnvironnement) {
1779: celluleLu = enviroSheet
1780: .getCell(
1781: numeroColonneNomParametreEnvironnement,
1782: boucle);
1783: if (celluleLu.getContents().length() > 0) {
1784: if (listeParametre.contains(celluleLu
1785: .getContents())) {
1786: nomParametreEnvironnement = celluleLu
1787: .getContents();
1788: IDParametreEnvironnement = listeParametre
1789: .get(listeParametre
1790: .indexOf(celluleLu
1791: .getContents()) + 1);
1792: } else {
1793: //Rajoute le parametre
1794: Element param = params.addElement(
1795: "Param").addAttribute(
1796: "id_param",
1797: "Param_" + indiceParametre);
1798: Element nomParam = param
1799: .addElement("Nom")
1800: .addText(
1801: celluleLu
1802: .getContents());
1803: listeParametre.add(celluleLu
1804: .getContents());
1805: listeParametre.add(Integer
1806: .toString(indiceParametre));
1807: nomParametreEnvironnement = celluleLu
1808: .getContents();
1809: IDParametreEnvironnement = Integer
1810: .toString(indiceParametre);
1811: indiceParametre++;
1812: }
1813:
1814: if (isPresenceColonneValeurParametreEnvironnement) {
1815: celluleLu = enviroSheet
1816: .getCell(
1817: numeroColonneValeurParametreEnvironnement,
1818: boucle);
1819: valeurParametreEnvironnement = celluleLu
1820: .getContents();
1821: Element ValeurParam = ValeurParams
1822: .addElement("ValeurParam")
1823: .addAttribute(
1824: "ref",
1825: "Param_"
1826: + IDParametreEnvironnement)
1827: .addAttribute("valeur",
1828: valeurParametreEnvironnement);
1829: Element Nom = ValeurParam
1830: .addElement("Nom")
1831: .addText(
1832: nomParametreEnvironnement);
1833: } else {
1834: valeurParametreEnvironnement = "";
1835: }
1836:
1837: }
1838: }
1839: }
1840: }
1841: indiceEnvironnement++;
1842: }
1843: }
1844: }
1845:
1846: /**
1847: * Function that Verify the presence of environments columns in the enviroment spreadsheet
1848: */
1849: public void testColumnsPresenceEnvironnement() {
1850:
1851: StringTokenizer st;
1852: // Recupère ligne debut tableau
1853: boolean EnvironnementTrouve = false;
1854: for (int i = 0; i < nombreColonneTableauEnvironnements; i++) {
1855: for (int j = 0; j < nombreLigneTableauEnvironnements; j++) {
1856: celluleLu = enviroSheet.getCell(i, j);
1857: st = new StringTokenizer(Language.getInstance()
1858: .getText("nom_Environnements_Liste")
1859: .toLowerCase(), ",");
1860: while (st.hasMoreTokens()
1861: && EnvironnementTrouve == false) {
1862: if (celluleLu.getContents().trim().toLowerCase()
1863: .equals(st.nextToken().toString())) {
1864: ligneDebutTableauEnvironnement = celluleLu
1865: .getRow();
1866: EnvironnementTrouve = true;
1867: }
1868: }
1869: }
1870: }
1871:
1872: // test présence des differents colonnes
1873: for (int i = 0; i < nombreColonneTableauEnvironnements; i++) {
1874: celluleLu = enviroSheet.getCell(i,
1875: ligneDebutTableauEnvironnement);
1876:
1877: // test présence nom Environnements
1878: st = new StringTokenizer(Language.getInstance().getText(
1879: "nom_Environnements_Liste").toLowerCase(), ",");
1880: while (st.hasMoreTokens()
1881: && isPresenceColonneNomEnvironnement == false) {
1882: if (celluleLu.getContents().trim().toLowerCase()
1883: .equals(st.nextToken().toString())) {
1884: isPresenceColonneNomEnvironnement = true;
1885: numeroColonneNomEnvironnement = i;
1886: }
1887: }
1888: //test présence description Environnements
1889: st = new StringTokenizer(Language.getInstance().getText(
1890: "description_Environnement_Liste").toLowerCase(),
1891: ",");
1892: while (st.hasMoreTokens()
1893: && isPresenceColonneDescriptionEnvironnement == false) {
1894: if (celluleLu.getContents().trim().toLowerCase()
1895: .equals(st.nextToken().toString())) {
1896: isPresenceColonneDescriptionEnvironnement = true;
1897: numeroColonneDescriptionEnvironnement = i;
1898: }
1899: }
1900: // test présence nom parametre
1901: st = new StringTokenizer(Language.getInstance().getText(
1902: "nom_Parametres_Liste").toLowerCase(), ",");
1903: while (st.hasMoreTokens()
1904: && isPresenceColonneNomParametreEnvironnement == false) {
1905: if (celluleLu.getContents().trim().toLowerCase()
1906: .equals(st.nextToken().toString())) {
1907: isPresenceColonneNomParametreEnvironnement = true;
1908: numeroColonneNomParametreEnvironnement = i;
1909: }
1910: }
1911: // test présence Valeur parametre
1912: st = new StringTokenizer(Language.getInstance().getText(
1913: "valeur_Parametres_Liste").toLowerCase(), ",");
1914: while (st.hasMoreTokens()
1915: && isPresenceColonneValeurParametreEnvironnement == false) {
1916: if (celluleLu.getContents().trim().toLowerCase()
1917: .equals(st.nextToken().toString())) {
1918: isPresenceColonneValeurParametreEnvironnement = true;
1919: numeroColonneValeurParametreEnvironnement = i;
1920: }
1921: }
1922: // test présence des colonnes Lien Hypertexte
1923: st = new StringTokenizer(Language.getInstance().getText(
1924: "Lien_Hypertexte_Liste").toLowerCase(), ",");
1925: while (st.hasMoreTokens()
1926: && isPresenceColonneLienHypertexteEnvironnement == false) {
1927: if (celluleLu.getContents().trim().toLowerCase()
1928: .equals(st.nextToken().toString())) {
1929: isPresenceColonneLienHypertexteEnvironnement = true;
1930: numeroColonneLienHypertexteEnvironnement = i;
1931: }
1932: }
1933:
1934: // test présence des colonnes Piece Jointe
1935: st = new StringTokenizer(Language.getInstance().getText(
1936: "Piece_Jointe_Liste").toLowerCase(), ",");
1937: while (st.hasMoreTokens()
1938: && isPresenceColonnePieceJointeEnvironnement == false) {
1939: if (celluleLu.getContents().trim().toLowerCase()
1940: .equals(st.nextToken().toString())) {
1941: isPresenceColonnePieceJointeEnvironnement = true;
1942: numeroColonnePieceJointeEnvironnement = i;
1943: }
1944: }
1945: }
1946:
1947: if (isPresenceColonneNomEnvironnement == false) {
1948: isErreurTraitementImport = true;
1949: closeXmlAndXlsFiles();
1950: JOptionPane.showMessageDialog(null, Language.getInstance()
1951: .getText("Stop_No_Environnement_Name_Column"),
1952: Language.getInstance().getText("Erreur_!"),
1953: JOptionPane.ERROR_MESSAGE);
1954: PopUpFormalismeExcel p = new PopUpFormalismeExcel(
1955: pIPlugObject);
1956:
1957: }
1958:
1959: }
1960:
1961: /**
1962: * Read all the spreadsheet for the parameters
1963: *
1964: * @throws java.lang.Exception
1965: * Null pointer exception
1966: */
1967: public void readXlsTableParametre() throws Exception {
1968:
1969: // Gestion des parametres
1970: params = projetVT.addElement("Params");
1971:
1972: for (int i = ligneDebutTableauParametre + 1; i < nombreLigneTableauParametres; i++) {
1973: // lit le parametre
1974: celluleLu = paramSheet
1975: .getCell(numeroColonneNomParametre, i);
1976: if (celluleLu.getContents().length() > 0) {
1977: Element param = params.addElement("Param")
1978: .addAttribute("id_param",
1979: "Param_" + indiceParametre);
1980: Element nomParam = param.addElement("Nom").addText(
1981: celluleLu.getContents());
1982: listeParametre.add(celluleLu.getContents());
1983: listeParametre.add(Integer.toString(indiceParametre));
1984: if (isPresenceColonneDescriptionParametre) {
1985: celluleLu = paramSheet.getCell(
1986: numeroColonneDescriptionParametre, i);
1987: Element descriptionParam = param.addElement(
1988: "Description").addText(
1989: celluleLu.getContents());
1990: }
1991: indiceParametre++;
1992: }
1993: }
1994: }
1995:
1996: /**
1997: * Function that Verify the presence of parameters columns in the paremeter spreadsheet
1998: */
1999: public void testColumnsPresenceParametre() {
2000:
2001: StringTokenizer st;
2002: // Recupère ligne debut tableau
2003: boolean parametreTrouve = false;
2004: for (int i = 0; i < nombreColonneTableauParametres; i++) {
2005: for (int j = 0; j < nombreLigneTableauParametres; j++) {
2006: celluleLu = paramSheet.getCell(i, j);
2007: st = new StringTokenizer(Language.getInstance()
2008: .getText("nom_Parametres_Liste").toLowerCase(),
2009: ",");
2010: while (st.hasMoreTokens() && parametreTrouve == false) {
2011: if (celluleLu.getContents().trim().toLowerCase()
2012: .equals(st.nextToken().toString())) {
2013: ligneDebutTableauParametre = celluleLu.getRow();
2014: parametreTrouve = true;
2015: }
2016: }
2017:
2018: }
2019: }
2020:
2021: // test présence des differents colonnes
2022: for (int i = 0; i < nombreColonneTableauParametres; i++) {
2023: celluleLu = paramSheet.getCell(i,
2024: ligneDebutTableauParametre);
2025:
2026: // test présence nom parametre
2027: st = new StringTokenizer(Language.getInstance().getText(
2028: "nom_Parametres_Liste").toLowerCase(), ",");
2029: while (st.hasMoreTokens()
2030: && isPresenceColonneNomParametre == false) {
2031: if (celluleLu.getContents().trim().toLowerCase()
2032: .equals(st.nextToken().toString())) {
2033: isPresenceColonneNomParametre = true;
2034: numeroColonneNomParametre = i;
2035: }
2036: }
2037: //test présence description parametre
2038: st = new StringTokenizer(Language.getInstance().getText(
2039: "description_Parametres_Liste").toLowerCase(), ",");
2040: while (st.hasMoreTokens()
2041: && isPresenceColonneDescriptionParametre == false) {
2042: if (celluleLu.getContents().trim().toLowerCase()
2043: .equals(st.nextToken().toString())) {
2044: isPresenceColonneDescriptionParametre = true;
2045: numeroColonneDescriptionParametre = i;
2046: }
2047: }
2048:
2049: }
2050:
2051: if ((isPresenceColonneNomParametre == false)) {
2052: isErreurTraitementImport = true;
2053: closeXmlAndXlsFiles();
2054: JOptionPane.showMessageDialog(null, Language.getInstance()
2055: .getText("Stop_No_Parameter_Name_Column"), Language
2056: .getInstance().getText("Erreur_!"),
2057: JOptionPane.ERROR_MESSAGE);
2058: PopUpFormalismeExcel p = new PopUpFormalismeExcel(
2059: pIPlugObject);
2060:
2061: }
2062:
2063: }
2064:
2065: /**
2066: * Fonction that generate campaigns
2067: *
2068: * @param creationCampagne
2069: * type of camapaign to create
2070: */
2071: void creeCampagnes(String creationCampagne,
2072: boolean selectionImportEnvironnement) {
2073: // Generation d'un environnement vide
2074: if (!selectionImportEnvironnement) {
2075: Environnements = projetVT.addElement("Environnements");
2076:
2077: Element environnement = Environnements.addElement(
2078: "Environnement").addAttribute("idEnv", "Env_0");
2079: Element nomEnvironnement = environnement.addElement("Nom")
2080: .addText(
2081: Language.getInstance().getText(
2082: "environnement_reel"));
2083: environnement = Environnements.addElement("Environnement")
2084: .addAttribute("idEnv", "Env_1");
2085: nomEnvironnement = environnement.addElement("Nom").addText(
2086: Language.getInstance().getText(
2087: "environnement_simule"));
2088: }
2089:
2090: if (creationCampagne == Language.getInstance().getText(
2091: "Campagne_Par_Projet")) {
2092: creeCampagne(Language.getInstance().getText("Projet"),
2093: listeTestsPourCampagne,
2094: selectionImportEnvironnement);
2095: }
2096:
2097: if (creationCampagne == Language.getInstance().getText(
2098: "Campagne_Par_Famille")) {
2099: listeFamille = new ArrayList();
2100: for (int i = 0; i < listeTestsPourCampagne.size(); i += 8) {
2101: if (!listeFamille.contains(listeTestsPourCampagne
2102: .get(i))) {
2103: listeFamille.add(listeTestsPourCampagne.get(i));
2104: }
2105: }
2106: for (int i = 0; i < listeFamille.size(); i++) {
2107: listePourCampagne.clear();
2108: for (int j = 0; j < listeTestsPourCampagne.size(); j += 8) {
2109: if (listeTestsPourCampagne.get(j) == listeFamille
2110: .get(i)) {
2111: for (int k = 0; k < 8; k++) {
2112: listePourCampagne
2113: .add(listeTestsPourCampagne.get(j
2114: + k));
2115: }
2116: }
2117: }
2118: creeCampagne(listeFamille.get(i).toString(),
2119: listePourCampagne, selectionImportEnvironnement);
2120: }
2121: }
2122:
2123: if (creationCampagne == Language.getInstance().getText(
2124: "Campagne_Par_Exigence")) {
2125: for (int i = 0; i < listeTestsPourCampagne.size(); i += 8) {
2126: if (listeTestsPourCampagne.get(i + 6) != null) {
2127: if (!listeFamille.contains(listeTestsPourCampagne
2128: .get(i + 6))) {
2129: listeFamille.add(listeTestsPourCampagne
2130: .get(i + 6));
2131: }
2132: }
2133: }
2134: for (int i = 0; i < listeFamille.size(); i++) {
2135: System.out.println("i : " + i + " listeFamille :"
2136: + listeFamille.get(i));
2137: listePourCampagne.clear();
2138: for (int j = 0; j < listeTestsPourCampagne.size(); j += 8) {
2139: if (listeTestsPourCampagne.get(j + 6) == listeFamille
2140: .get(i)) {
2141: for (int k = 0; k < 8; k++) {
2142: listePourCampagne
2143: .add(listeTestsPourCampagne.get(j
2144: + k));
2145: }
2146: }
2147: }
2148:
2149: creeCampagne(listeFamille.get(i).toString(),
2150: listePourCampagne, selectionImportEnvironnement);
2151: }
2152: }
2153: }
2154:
2155: /**
2156: * Fonction that generate acampaign
2157: *
2158: * @param nomCampagne
2159: * name of campaign to create
2160: * @param vectorElementsofCampaign
2161: * vector containing all elements to create a campaign
2162: */
2163: void creeCampagne(String nomCampagne,
2164: ArrayList vectorElementsofCampaign,
2165: boolean selectionImportEnvironnement) {
2166: Element CampagneTests = projetVT.addElement("CampagneTests");
2167: CampagneTest = CampagneTests.addElement("CampagneTest")
2168: .addAttribute("id_camp", "Camp_" + indiceCampagne);
2169: Element Concepteur = CampagneTest.addElement("Concepteur");
2170: Element NomConcepteur = Concepteur.addElement("Nom").addText(
2171: Language.getInstance().getText("pluginxlsxml"));
2172: Element nomXMLCampagne = CampagneTest.addElement("Nom")
2173: .addText(
2174: Language.getInstance().getText("Campagne")
2175: + " " + nomCampagne);
2176: // Génération de la date
2177: DateFormat dateFormat = DateFormat
2178: .getDateInstance(DateFormat.MONTH_FIELD);
2179: Element dateCrea = CampagneTest.addElement("Date_crea")
2180: .addText(dateFormat.format(new Date()));
2181: if (TestPresencePlugin.testDeLaPresenceDuPluginRequirement()) {
2182: listeExigencesCampagnes.clear();
2183: Element LinkRequirement = CampagneTest
2184: .addElement("LinkRequirement");
2185: for (int i = 0; i < vectorElementsofCampaign.size(); i = i + 8) {
2186: if ((!listeExigencesCampagnes
2187: .contains(vectorElementsofCampaign.get(i + 6)))) {
2188: if (vectorElementsofCampaign.get(i + 6) != null) {
2189: Element RequirementRef = LinkRequirement
2190: .addElement("RequirementRef")
2191: .addAttribute(
2192: "ref",
2193: "Req_"
2194: + vectorElementsofCampaign
2195: .get(i + 7));
2196: Element nomRequirementRef = RequirementRef
2197: .addElement("Nom").addText(
2198: vectorElementsofCampaign.get(
2199: i + 6).toString());
2200: listeExigencesCampagnes
2201: .add((String) vectorElementsofCampaign
2202: .get(i + 6));
2203: }
2204:
2205: }
2206: }
2207: }
2208: String famillePrecedente = null;
2209: String suitePrecedente = null;
2210: Element SuiteTestsCamp = null;
2211: Element TestsCamp = null;
2212: Element FamillesCamp = CampagneTest.addElement("FamillesCamp");
2213: for (int i = 0; i < vectorElementsofCampaign.size(); i += 8) {
2214: if (!vectorElementsofCampaign.get(i).equals(
2215: famillePrecedente)) {
2216: Element FamilleRef = FamillesCamp.addElement(
2217: "FamilleRef").addAttribute(
2218: "ref",
2219: "Fam_"
2220: + vectorElementsofCampaign.get(i + 1)
2221: .toString());
2222: Element nomFamilleRef = FamilleRef
2223: .addElement("Nom")
2224: .addText(
2225: removeSpecialCharacters(vectorElementsofCampaign
2226: .get(i).toString()));
2227: SuiteTestsCamp = FamilleRef
2228: .addElement("SuiteTestsCamp");
2229: famillePrecedente = vectorElementsofCampaign.get(i)
2230: .toString();
2231: suitePrecedente = null;
2232: }
2233: if (!vectorElementsofCampaign.get(i + 2).equals(
2234: suitePrecedente)) {
2235: Element SuiteTestRef = SuiteTestsCamp.addElement(
2236: "SuiteTestRef").addAttribute(
2237: "ref",
2238: "SuiteTest_"
2239: + vectorElementsofCampaign.get(i + 3)
2240: .toString());
2241: Element nomSuiteTestRef = SuiteTestRef
2242: .addElement("Nom").addText(
2243: vectorElementsofCampaign.get(i + 2)
2244: .toString());
2245: TestsCamp = SuiteTestRef.addElement("TestsCamp");
2246: suitePrecedente = vectorElementsofCampaign.get(i + 2)
2247: .toString();
2248: }
2249: Element TestRef = TestsCamp.addElement("TestRef")
2250: .addAttribute(
2251: "ref",
2252: "Test_"
2253: + vectorElementsofCampaign.get(
2254: i + 5).toString())
2255: .addAttribute(
2256: "loginAssigned",
2257: Language.getInstance().getText(
2258: "pluginxlsxml"));
2259: Element nomTestRef = TestRef.addElement("Nom").addText(
2260: removeSpecialCharacters(vectorElementsofCampaign
2261: .get(i + 4).toString()));
2262: }
2263:
2264: indiceExecCampagne++;
2265: Element ExecCampTests = CampagneTest
2266: .addElement("ExecCampTests");
2267: Element ExecCampTest = ExecCampTests.addElement("ExecCampTest")
2268: .addAttribute("id_exec_camp",
2269: "ExecCamp_" + indiceExecCampagne);
2270: if (!selectionImportEnvironnement) {
2271: Element nomExecCampTest = ExecCampTest.addElement("Nom")
2272: .addText(
2273: Language.getInstance().getText(
2274: "Premiere_Execution"));
2275: Element EnvironnementEx = ExecCampTest.addElement(
2276: "EnvironnementEx").addAttribute("ref", "Env_1");
2277: Element nomEnvironnementEx = EnvironnementEx.addElement(
2278: "Nom").addText(
2279: Language.getInstance().getText(
2280: "environnement_simule"));
2281: } else {
2282: for (int i = 0; i < environnementID.size(); i = i + 2) {
2283: Element nomExecCampTest = ExecCampTest
2284: .addElement("Nom").addText(
2285: Language.getInstance().getText(
2286: "Execution_sur")
2287: + environnementID.get(i));
2288: Element EnvironnementEx = ExecCampTest.addElement(
2289: "EnvironnementEx").addAttribute("ref",
2290: "Env_" + environnementID.get(i + 1));
2291: Element nomEnvironnementEx = EnvironnementEx
2292: .addElement("Nom").addText(
2293: environnementID.get(i));
2294: }
2295:
2296: }
2297:
2298: }
2299:
2300: /**
2301: * Function that write a test in the XML File
2302: * @param lignePourLirePJetURL lignePourLirePJetURL
2303: */
2304: public void writeTest(int lignePourLirePJetURL) {
2305: if (valeurCasDeTests.length() != 0) {
2306: // Ecrit entete
2307: indiceTestTest++;
2308: test = tests.addElement("Test").addAttribute("id_test",
2309: "Test_" + indiceTestTest);
2310: Element Concepteur = test.addElement("Concepteur");
2311: Element NomConcepteur = Concepteur.addElement("Nom")
2312: .addText(
2313: Language.getInstance().getText(
2314: "pluginxlsxml"));
2315: Element LoginConcepteur = Concepteur.addElement("Login")
2316: .addText(
2317: Language.getInstance().getText(
2318: "pluginxlsxml"));
2319: if (listeTestsPourCampagne.contains(valeurCasDeTests)) {
2320: int i = 0;
2321: while (listeTestsPourCampagne
2322: .contains(valeurCasDeTests)) {
2323:
2324: if (i == 0) {
2325: valeurCasDeTests = valeurCasDeTests
2326: + Language.getInstance().getText("_")
2327: + Integer.toString(i);
2328: } else {
2329: valeurCasDeTests = valeurCasDeTests.substring(
2330: 0, valeurCasDeTests
2331: .lastIndexOf(Language
2332: .getInstance().getText(
2333: "_")))
2334: + Language.getInstance().getText("_")
2335: + Integer.toString(i);
2336: }
2337:
2338: }
2339: }
2340: Element NomTest = test.addElement("Nom").addText(
2341: removeSpecialCharacters(valeurCasDeTests));
2342: // Génération de la date
2343: DateFormat dateFormat = DateFormat
2344: .getDateInstance(DateFormat.MONTH_FIELD);
2345: Element dateCrea = test.addElement("Date_crea").addText(
2346: dateFormat.format(new Date()));
2347: Element DescriptionTest = test.addElement("Description")
2348: .addText(valeurDescriptionTest);
2349:
2350: Element Executed = test.addElement("Executed").addText(
2351: "false");
2352:
2353: litPJetURL(test, testSheet, lignePourLirePJetURL,
2354: isPresenceColonneTestLienHypertexte,
2355: numeroColonneTestLienHypertexte,
2356: isPresenceColonneTestPieceJointe,
2357: numeroColonneTestPieceJointe, famillePrecedente
2358: + fs
2359: + Language.getInstance().getText(
2360: "Suite_Par_Defaut") + fs + "RT_"
2361: + exigenceLuTest
2362: + Language.getInstance().getText("_")
2363: + valeurCasDeTests);
2364:
2365: LinkRequirement = test.addElement("LinkRequirement");
2366: }
2367: }
2368:
2369: /**
2370: * Write automatic tests
2371: */
2372: public void writeActionTestAuto() {
2373: if ((valeurTypeTestAutomatique.toLowerCase().equals(
2374: Language.getInstance().getText("Beanshell")
2375: .toLowerCase()) && TestPresencePlugin
2376: .testDeLaPresenceDuPluginBeanShell())
2377: || (valeurTypeTestAutomatique.toLowerCase().equals(
2378: Language.getInstance().getText("simpleJunit")
2379: .toLowerCase()) && TestPresencePlugin
2380: .testDeLaPresenceDuPluginSimpleJunit())
2381: || (valeurTypeTestAutomatique.toLowerCase().equals(
2382: Language.getInstance().getText(
2383: "abbotScriptRunner").toLowerCase()) && TestPresencePlugin
2384: .testDeLaPresenceDuPluginAbbotScriptRunner())) {
2385:
2386: TestAuto = test.addElement("TestAuto").addAttribute(
2387: "plug_ext",
2388: valeurTypeTestAutomatique + ".TestDriver");
2389: if (valeurEmplacementTestAutomatique != null) {
2390: Element Script = TestAuto
2391: .addElement("Script")
2392: .addAttribute("type", "TEST_SCRIPT")
2393: .addAttribute(
2394: "nom",
2395: valeurEmplacementTestAutomatique
2396: .substring(valeurEmplacementTestAutomatique
2397: .lastIndexOf(fs) + 1))
2398: .addAttribute("dir",
2399: valeurEmplacementTestAutomatique);
2400: Element Classpath = Script.addElement("Classpath")
2401: .addText(
2402: valeurTypeTestAutomatique
2403: + ".TestDriver");
2404: }
2405: } else {
2406: isErreurTraitementImport = true;
2407: JOptionPane.showMessageDialog(null, Language.getInstance()
2408: .getText("install_Plugin")
2409: + valeurTypeTestAutomatique.toLowerCase(), Language
2410: .getInstance().getText("Erreur_!"),
2411: JOptionPane.ERROR_MESSAGE);
2412:
2413: }
2414: }
2415:
2416: /**
2417: * Write one action for a test
2418: */
2419: public void writeActionTestManuel() {
2420: if ((valeurNumeroTests.length() != 0)
2421: && ((valeurActionARealiser.length() != 0) || (valeurActionAttendue
2422: .length() != 0))) {
2423: testManuel = test.addElement("TestManuel");
2424: actionTest = testManuel.addElement("ActionTest")
2425: .addAttribute("id_action",
2426: "Action_" + indiceActionTest);
2427: Element NomActionTest = actionTest
2428: .addElement("Nom")
2429: .addText(removeSpecialCharacters(valeurNumeroTests));
2430: Element DescriptionActionTest = actionTest.addElement(
2431: "Description").addText(
2432: removeSpecialCharacters(valeurActionARealiser));
2433: Element ResultAttenduActionTest = actionTest.addElement(
2434: "ResultAttendu").addText(
2435: removeSpecialCharacters(valeurActionAttendue));
2436: actionID.add(Integer.toString(indiceTestTest));
2437: actionID.add(removeSpecialCharacters(valeurNumeroTests));
2438: actionID.add(Integer.toString(indiceActionTest));
2439: actionID
2440: .add(removeSpecialCharacters(valeurActionARealiser));
2441: actionID.add(removeSpecialCharacters(valeurActionAttendue));
2442: indiceActionTest++;
2443: }
2444:
2445: }
2446:
2447: /**
2448: * Write a requirement linked to a test
2449: */
2450: public void writeRequirementLinkToTest() {
2451:
2452: if (exigenceID.contains(familleEnCoursTests
2453: + Language.getInstance().getText("_")
2454: + removeSpecialCharacters(exigenceLuTest))) {
2455: int temp = exigenceID.indexOf(familleEnCoursTests
2456: + Language.getInstance().getText("_")
2457: + removeSpecialCharacters(exigenceLuTest)) + 1;
2458:
2459: Element RequirementRef = LinkRequirement.addElement(
2460: "RequirementRef").addAttribute("ref",
2461: "Req_" + exigenceID.get(temp));
2462: Element NomRequirementRef = RequirementRef
2463: .addElement("Nom").addText(
2464: removeSpecialCharacters(exigenceLuTest));
2465: } else {
2466: exigenceNonTrouvePourTest = exigenceNonTrouvePourTest
2467: + exigenceLuTest + "\n";
2468: }
2469: }
2470:
2471: /**
2472: * Function that write a family test in the XML File
2473: */
2474: public void writeFamilyTest() {
2475:
2476: if (!familleIDSuiteID.contains(valeurFamilleDeTests)) {
2477: indiceFamilleTest++;
2478: famille = familles.addElement("Famille").addAttribute(
2479: "id_famille", "Fam_" + indiceFamilleTest);
2480: Element NomFamilleTest = famille.addElement("Nom").addText(
2481: removeSpecialCharacters(valeurFamilleDeTests));
2482: } else {
2483: famille = familles
2484: .addElement("Famille")
2485: .addAttribute(
2486: "id_famille",
2487: "Fam_"
2488: + familleIDSuiteID
2489: .get(familleIDSuiteID
2490: .indexOf(valeurFamilleDeTests) + 1));
2491: Element NomFamilleTest = famille.addElement("Nom").addText(
2492: removeSpecialCharacters(valeurFamilleDeTests));
2493: }
2494:
2495: }
2496:
2497: /**
2498: * write suite test
2499: */
2500: public void writeSuiteTest() {
2501: boolean familleSuiteExisteDeja = false;
2502: for (int i = 0; i < familleIDSuiteID.size(); i = i + 4) {
2503: if (familleIDSuiteID.get(i).equals(valeurFamilleDeTests)
2504: && familleIDSuiteID.get(i + 2).equals(
2505: valeurSuiteDeTests)) {
2506: familleSuiteExisteDeja = true;
2507: Element SuiteTests = famille.addElement("SuiteTests");
2508: Element SuiteTest = SuiteTests.addElement("SuiteTest")
2509: .addAttribute(
2510: "id_suite",
2511: "SuiteTest_"
2512: + familleIDSuiteID.get(i + 3));
2513: Element NomTest = SuiteTest.addElement("Nom").addText(
2514: removeSpecialCharacters(valeurSuiteDeTests));
2515: Element DescriptionTest = SuiteTest
2516: .addElement("Description");
2517: tests = SuiteTest.addElement("Tests");
2518: }
2519: }
2520:
2521: if (familleSuiteExisteDeja == false) {
2522: Element SuiteTests = famille.addElement("SuiteTests");
2523: Element SuiteTest = SuiteTests.addElement("SuiteTest")
2524: .addAttribute("id_suite",
2525: "SuiteTest_" + indiceSuiteTest);
2526: Element NomTest = SuiteTest.addElement("Nom").addText(
2527: removeSpecialCharacters(valeurSuiteDeTests));
2528: Element DescriptionTest = SuiteTest
2529: .addElement("Description");
2530: tests = SuiteTest.addElement("Tests");
2531: familleIDSuiteID.add(valeurFamilleDeTests);
2532: familleIDSuiteID.add(Integer.toString(indiceFamilleTest));
2533: familleIDSuiteID.add(valeurSuiteDeTests);
2534: familleIDSuiteID.add(Integer.toString(indiceSuiteTest));
2535: indiceSuiteTest++;
2536: }
2537:
2538: }
2539:
2540: /**
2541: * read a family for a test
2542: *
2543: * @param i
2544: * numbre of line read
2545: */
2546: public void readFamilyTest(int i) {
2547: // lit Famille
2548: boolean changementFamille = false;
2549: celluleLu = testSheet.getCell(numeroColonneFamilleDeTests, i);
2550: valeurFamilleDeTests = celluleLu.getContents();
2551: if (valeurFamilleDeTests != famillePrecedente) {
2552: if (valeurFamilleDeTests.length() == 0
2553: || isPresenceColonneFamilleDeTests == false) {
2554: valeurFamilleDeTests = Language.getInstance().getText(
2555: "Famille_par_defaut");
2556: }
2557: famillePrecedente = valeurFamilleDeTests;
2558: changementFamille = true;
2559: writeFamilyTest();
2560: }
2561:
2562: //lit suite
2563: celluleLu = testSheet.getCell(numeroColonneSuiteDeTests, i);
2564: valeurSuiteDeTests = celluleLu.getContents();
2565: if (valeurSuiteDeTests.length() == 0
2566: || isPresenceColonneSuiteDeTests == false) {
2567: valeurSuiteDeTests = Language.getInstance().getText(
2568: "Suite_Par_Defaut");
2569: }
2570: if (!valeurSuiteDeTests.equals(suitePrecedente)
2571: || changementFamille) {
2572: writeSuiteTest();
2573: suitePrecedente = valeurSuiteDeTests;
2574: }
2575:
2576: }
2577:
2578: /**
2579: * Read all requirements linked to a test
2580: *
2581: * @param debutCasDeTest
2582: * integer
2583: * @param hauteurCasDeTest
2584: * integer
2585: */
2586:
2587: public void readRequirementTest(int debutCasDeTest,
2588: int hauteurCasDeTest) {
2589: // lit Famille
2590: boolean nouveauTest = true;
2591: for (int v = debutCasDeTest; v < debutCasDeTest
2592: + hauteurCasDeTest; v++) {
2593: if (testSheet.getCell(numeroColonneExigenceTests, v)
2594: .getContents().length() != 0) {
2595: if (isPresenceColonneBrancheTests == false) {
2596: familleEnCoursTests = Language.getInstance()
2597: .getText("Famille_par_defaut");
2598: } else {
2599: StringTokenizer st = new StringTokenizer(
2600: numeroColonneBrancheTests, Language
2601: .getInstance().getText("_"));
2602: familleEnCoursTests = "";
2603: while (st.hasMoreTokens()) {
2604: celluleLu = testSheet.getCell(Integer
2605: .parseInt(st.nextToken()), v);
2606: if (celluleLu.getContents().length() != 0) {
2607: if (familleEnCoursTests == "") {
2608: familleEnCoursTests = celluleLu
2609: .getContents();
2610: } else {
2611: familleEnCoursTests = familleEnCoursTests
2612: + Language.getInstance()
2613: .getText("_")
2614: + celluleLu.getContents();
2615: }
2616: }
2617: }
2618: }
2619: }
2620: celluleLu = testSheet
2621: .getCell(numeroColonneExigenceTests, v);
2622: exigenceLuTest = celluleLu.getContents();
2623: while (exigenceLuTest.startsWith(Language.getInstance()
2624: .getText("_"))) {
2625: exigenceLuTest = exigenceLuTest.substring(1);
2626: }
2627:
2628: if (exigenceLuTest.length() > 0) {
2629: if (nouveauTest
2630: || (!exigenceAEcrire.equals(familleEnCoursTests
2631: + Language.getInstance().getText("_")
2632: + exigenceLuTest))) {
2633: writeRequirementLinkToTest();
2634: exigenceAEcrire = familleEnCoursTests
2635: + Language.getInstance().getText("_")
2636: + exigenceLuTest;
2637: nouveauTest = false;
2638: }
2639: }
2640:
2641: // if ((!exigenceAEcrire.equals(familleEnCoursTests + Language.getInstance().getText("_") + exigenceLuTest)) && (exigenceLuTest.length()>0)) {
2642: // writeRequirementLinkToTest();
2643: // exigenceAEcrire = familleEnCoursTests + Language.getInstance().getText("_") + exigenceLuTest;
2644: // }
2645:
2646: // creation d'un vecteur
2647: // Famille-NumeroFamille-Suite-NumeroSuite-CasTest-NumeroCasTest-ExigenceVide-NumeroExigenceVide
2648:
2649: if (listeTestsPourCampagne.size() > 0) {
2650: if ((!listeTestsPourCampagne.get(
2651: listeTestsPourCampagne.size() - 8).equals(
2652: valeurFamilleDeTests))
2653: || (!listeTestsPourCampagne.get(
2654: listeTestsPourCampagne.size() - 6)
2655: .equals(valeurSuiteDeTests))
2656: || (!listeTestsPourCampagne.get(
2657: listeTestsPourCampagne.size() - 4)
2658: .equals(valeurCasDeTests))) {
2659: // creation d'un vecteur
2660: // Famille-NumeroFamille-Suite-NumeroSuite-CasTest-NumeroCasTest-ExigenceVide-NumeroExigenceVide
2661: listeTestsPourCampagne.add(valeurFamilleDeTests);
2662: listeTestsPourCampagne.add(Integer
2663: .toString(indiceFamilleTest));
2664: listeTestsPourCampagne.add(valeurSuiteDeTests);
2665: listeTestsPourCampagne.add(Integer
2666: .toString(indiceSuiteTest));
2667: listeTestsPourCampagne.add(valeurCasDeTests);
2668: listeTestsPourCampagne.add(Integer
2669: .toString(indiceTestTest));
2670: if (exigenceID
2671: .indexOf(removeSpecialCharacters(familleEnCoursTests
2672: + Language.getInstance().getText(
2673: "_") + exigenceLuTest)) > 0) {
2674: listeTestsPourCampagne.add(exigenceLuTest);
2675: listeTestsPourCampagne
2676: .add(exigenceID
2677: .get(exigenceID
2678: .indexOf(removeSpecialCharacters(familleEnCoursTests
2679: + Language
2680: .getInstance()
2681: .getText(
2682: "_")
2683: + exigenceLuTest)) + 1));
2684:
2685: } else {
2686: listeTestsPourCampagne.add(null);
2687: listeTestsPourCampagne.add(null);
2688: }
2689:
2690: }
2691: } else {
2692: listeTestsPourCampagne.add(valeurFamilleDeTests);
2693: listeTestsPourCampagne.add(Integer
2694: .toString(indiceFamilleTest));
2695: listeTestsPourCampagne.add(valeurSuiteDeTests);
2696: listeTestsPourCampagne.add(Integer
2697: .toString(indiceSuiteTest));
2698: listeTestsPourCampagne.add(valeurCasDeTests);
2699: listeTestsPourCampagne.add(Integer
2700: .toString(indiceTestTest));
2701: if (exigenceID.indexOf(familleEnCoursTests
2702: + Language.getInstance().getText("_")
2703: + exigenceLuTest) > 0) {
2704: listeTestsPourCampagne.add(exigenceLuTest);
2705: listeTestsPourCampagne
2706: .add(exigenceID.get(exigenceID
2707: .indexOf(familleEnCoursTests
2708: + Language.getInstance()
2709: .getText("_")
2710: + exigenceLuTest) + 1));
2711:
2712: } else {
2713: listeTestsPourCampagne.add(null);
2714: listeTestsPourCampagne.add(null);
2715: }
2716:
2717: }
2718:
2719: }
2720: }
2721:
2722: /**
2723: * Read all the spreadsheet for the test
2724: * @param selectionImportExigence selectionImportExigence
2725: * @throws java.lang.Exception Exception
2726: */
2727: public void readXlsTableTest(boolean selectionImportExigence)
2728: throws Exception {
2729: int hauteurCasDeTest = 0;
2730: int debutCasDeTest = 0;
2731:
2732: // Gestion des tests
2733: familles = projetVT.addElement("Familles");
2734:
2735: famillePrecedente = Language.getInstance().getText(
2736: "Pas_De_Famille");
2737: suitePrecedente = Language.getInstance().getText(
2738: "Pas_De_Famille");
2739:
2740: // fonction qui ne marche pas si le tableau n'est pas trié par Famille
2741:
2742: exigenceLuTest = "";
2743: for (int i = ligneDebutTableauTest + 1; i < nombreLigneTableauTests; i++) {
2744: // lit Cas de tests
2745: if (isPresenceColonneCasDeTests == true) {
2746: celluleLu = testSheet.getCell(numeroColonneCasDeTests,
2747: i);
2748: valeurCasDeTests = celluleLu.getContents();
2749:
2750: } else {
2751: valeurCasDeTests = "";
2752: }
2753: if (isPresenceColonneDescriptionTest == true) {
2754: celluleLu = testSheet.getCell(
2755: numeroColonneDescriptionTest, i);
2756: valeurDescriptionTest = celluleLu.getContents();
2757: } else {
2758: valeurDescriptionTest = "";
2759: }
2760:
2761: if (valeurCasDeTests.length() > 0) {
2762: readFamilyTest(i);
2763: hauteurCasDeTest = 0;
2764: debutCasDeTest = i;
2765:
2766: celluleLu = testSheet.getCell(numeroColonneCasDeTests,
2767: i + hauteurCasDeTest);
2768:
2769: while (((celluleLu.getContents().equals(
2770: valeurCasDeTests) || celluleLu.getContents()
2771: .length() == 0))
2772: && (hauteurCasDeTest + debutCasDeTest < nombreLigneTableauTests - 1)) {
2773: hauteurCasDeTest++;
2774: celluleLu = testSheet.getCell(
2775: numeroColonneCasDeTests, i
2776: + hauteurCasDeTest);
2777: }
2778:
2779: if ((debutCasDeTest == nombreLigneTableauTests - 1)
2780: && (testSheet.getCell(numeroColonneCasDeTests,
2781: nombreLigneTableauTests - 1)
2782: .getContents().length() != 0)) {
2783: hauteurCasDeTest++;
2784: }
2785: if ((debutCasDeTest + hauteurCasDeTest == nombreLigneTableauTests - 1)
2786: && (testSheet.getCell(numeroColonneCasDeTests,
2787: nombreLigneTableauTests - 1)
2788: .getContents().length() == 0)) {
2789: hauteurCasDeTest++;
2790: }
2791: writeTestCase(debutCasDeTest, hauteurCasDeTest);
2792: if (isPresenceColonneExigenceTests == true
2793: && selectionImportExigence) {
2794: readRequirementTest(debutCasDeTest,
2795: hauteurCasDeTest);
2796: } else {
2797: // creation d'un vecteur
2798: // Famille-NumeroFamille-Suite-NumeroSuite-CasTest-NumeroCasTest-ExigenceVide-NumeroExigenceVide
2799: listeTestsPourCampagne.add(valeurFamilleDeTests);
2800: listeTestsPourCampagne.add(Integer
2801: .toString(indiceFamilleTest));
2802: listeTestsPourCampagne.add(valeurSuiteDeTests);
2803: listeTestsPourCampagne.add(Integer
2804: .toString(indiceSuiteTest));
2805: listeTestsPourCampagne.add(valeurCasDeTests);
2806: listeTestsPourCampagne.add(Integer
2807: .toString(indiceTestTest));
2808: listeTestsPourCampagne.add(null);
2809: listeTestsPourCampagne.add(null);
2810: }
2811:
2812: }
2813:
2814: }
2815:
2816: }
2817:
2818: /**
2819: * Write a coplete test case
2820: *
2821: * @param debutCasDeTest
2822: * Integer
2823: * @param hauteurCasDeTest
2824: * Integer
2825: */
2826: public void writeTestCase(int debutCasDeTest, int hauteurCasDeTest) {
2827: writeTest(debutCasDeTest);
2828: numeroActionDesTests.clear();
2829: for (int boucle = debutCasDeTest; boucle < debutCasDeTest
2830: + hauteurCasDeTest; boucle++) {
2831: //lit type test automatique
2832: if (isPresenceColonneTypeTestAutomatique == true) {
2833: celluleLu = testSheet.getCell(
2834: numeroColonneTypeTestAutomatique, boucle);
2835: valeurTypeTestAutomatique = celluleLu.getContents();
2836: } else {
2837: valeurTypeTestAutomatique = "";
2838: }
2839: //lit Emplacement test automatique
2840: if (isPresenceColonneEmplacementTestAutomatique == true) {
2841: String repertoirePieceJointe = famillePrecedente + fs
2842: + suitePrecedente + fs + valeurCasDeTests + fs
2843: + Language.getInstance().getText("Script");
2844: celluleLu = testSheet
2845: .getCell(
2846: numeroColonneEmplacementTestAutomatique,
2847: boucle);
2848: if (celluleLu.getType() == CellType.NUMBER_FORMULA
2849: || celluleLu.getType() == CellType.STRING_FORMULA
2850: || celluleLu.getType() == CellType.BOOLEAN_FORMULA
2851: || celluleLu.getType() == CellType.DATE_FORMULA
2852: || celluleLu.getType() == CellType.FORMULA_ERROR) {
2853: FormulaCell nfc = (FormulaCell) celluleLu;
2854: StringBuffer sb = new StringBuffer();
2855:
2856: try {
2857: StringTokenizer st = new StringTokenizer(nfc
2858: .getFormula(), "\"");
2859: st.nextToken();
2860: String RecupereCheminRelatif;
2861: try {
2862: RecupereCheminRelatif = copyFileAttachements(
2863: st.nextToken().replaceFirst(
2864: "file:///", ""),
2865: repertoirePieceJointe, null);
2866: valeurEmplacementTestAutomatique = RecupereCheminRelatif;
2867: } catch (Exception e) {
2868: // TODO Auto-generated catch block
2869: e.printStackTrace();
2870: }
2871: } catch (FormulaException e) {
2872: JOptionPane.showMessageDialog(null,
2873: Language.getInstance().getText(
2874: "malformed_formula")
2875: + sb.toString()
2876: + ": "
2877: + e.getMessage(), Language
2878: .getInstance().getText(
2879: "Erreur_!"),
2880: JOptionPane.ERROR_MESSAGE);
2881: }
2882: } else {
2883: StringTokenizer st = new StringTokenizer(celluleLu
2884: .getContents(), "\n");
2885: while (st.hasMoreTokens()) {
2886: String RecupereCheminRelatif;
2887: try {
2888: RecupereCheminRelatif = copyFileAttachements(
2889: st.nextToken(),
2890: repertoirePieceJointe, null);
2891: valeurEmplacementTestAutomatique = RecupereCheminRelatif;
2892: } catch (Exception e) {
2893: // TODO Auto-generated catch block
2894: e.printStackTrace();
2895: }
2896: }
2897: }
2898: } else {
2899: valeurEmplacementTestAutomatique = "";
2900: }
2901: // lit NméroAction
2902: if (isPresenceColonneNumeroTests == true) {
2903: celluleLu = testSheet.getCell(numeroColonneNumeroTests,
2904: boucle);
2905: valeurNumeroTests = celluleLu.getContents();
2906: if (valeurNumeroTests.length() == 0) {
2907: int i = 1;
2908: while (numeroActionDesTests.contains(Integer
2909: .toString(boucle - debutCasDeTest + i))) {
2910: i++;
2911: }
2912: valeurNumeroTests = Integer.toString(boucle
2913: - debutCasDeTest + i);
2914: numeroActionDesTests.add(valeurNumeroTests);
2915: } else {
2916: if (numeroActionDesTests
2917: .contains(valeurNumeroTests)) {
2918: int i = 1;
2919: while (numeroActionDesTests.contains(Integer
2920: .toString(boucle - debutCasDeTest + i))) {
2921: i++;
2922: }
2923: valeurNumeroTests = Integer.toString(boucle
2924: - debutCasDeTest + i);
2925: numeroActionDesTests.add(valeurNumeroTests);
2926: }
2927: }
2928:
2929: } else {
2930: valeurNumeroTests = Integer.toString(boucle
2931: - debutCasDeTest + 1);
2932: }
2933: // lit Action a réaliser
2934: if (isPresenceColonneActionARealiser == true) {
2935: celluleLu = testSheet.getCell(
2936: numeroColonneActionARealiser, boucle);
2937: valeurActionARealiser = celluleLu.getContents();
2938: } else {
2939: valeurActionARealiser = "";
2940: }
2941: // lit Action attendue
2942: if (isPresenceColonneActionAttendue == true) {
2943: celluleLu = testSheet.getCell(
2944: numeroColonneActionAttendue, boucle);
2945: valeurActionAttendue = celluleLu.getContents();
2946: } else {
2947: valeurActionAttendue = "";
2948: }
2949: if (valeurTypeTestAutomatique.length() > 0) {
2950: writeActionTestAuto();
2951: }
2952:
2953: writeActionTestManuel();
2954:
2955: litPJetURL(actionTest, testSheet, boucle,
2956: isPresenceColonneTestLienHypertexteAction,
2957: numeroColonneTestLienHypertexteAction,
2958: isPresenceColonneTestPieceJointeAction,
2959: numeroColonneTestPieceJointeAction,
2960: famillePrecedente + fs + suitePrecedente + fs
2961: + valeurCasDeTests + fs + valeurNumeroTests);
2962:
2963: }
2964: }
2965:
2966: /**
2967: * Function that Verify the presence of test columns in the test spreadsheet
2968: */
2969: public void testColumnsPresenceTests() {
2970: StringTokenizer st;
2971: // Recupère ligne debut tableau
2972: boolean casDeTestTrouve = false;
2973: for (int i = 0; i < nombreColonneTableauTests; i++) {
2974: for (int j = 0; j < nombreLigneTableauTests; j++) {
2975: celluleLu = testSheet.getCell(i, j);
2976: st = new StringTokenizer(Language.getInstance()
2977: .getText("cas_de_tests_Liste").toLowerCase(),
2978: ",");
2979: while (st.hasMoreTokens() && casDeTestTrouve == false) {
2980: if (celluleLu.getContents().trim().toLowerCase()
2981: .equals(st.nextToken().toString())) {
2982: ligneDebutTableauTest = celluleLu.getRow();
2983: casDeTestTrouve = true;
2984: }
2985: }
2986:
2987: }
2988: }
2989:
2990: // test présence des differents colonnes
2991: for (int i = 0; i < nombreColonneTableauTests; i++) {
2992: celluleLu = testSheet.getCell(i, ligneDebutTableauTest);
2993:
2994: // test présence des Famille de tests
2995: st = new StringTokenizer(Language.getInstance().getText(
2996: "famille_de_tests_Liste").toLowerCase(), ",");
2997: while (st.hasMoreTokens()
2998: && isPresenceColonneFamilleDeTests == false) {
2999: if (celluleLu.getContents().trim().toLowerCase()
3000: .equals(st.nextToken().toString())) {
3001: isPresenceColonneFamilleDeTests = true;
3002: numeroColonneFamilleDeTests = i;
3003: }
3004: }
3005:
3006: //test présence des Suite de tests
3007: st = new StringTokenizer(Language.getInstance().getText(
3008: "suite_de_tests_Liste").toLowerCase(), ",");
3009: while (st.hasMoreTokens()
3010: && isPresenceColonneSuiteDeTests == false) {
3011: if (celluleLu.getContents().trim().toLowerCase()
3012: .equals(st.nextToken().toString())) {
3013: isPresenceColonneSuiteDeTests = true;
3014: numeroColonneSuiteDeTests = i;
3015: }
3016: }
3017:
3018: // test présence des colonnes Cas de tests
3019: st = new StringTokenizer(Language.getInstance().getText(
3020: "cas_de_tests_Liste").toLowerCase(), ",");
3021: while (st.hasMoreTokens()
3022: && isPresenceColonneCasDeTests == false) {
3023: if (celluleLu.getContents().trim().toLowerCase()
3024: .equals(st.nextToken().toString())) {
3025: isPresenceColonneCasDeTests = true;
3026: numeroColonneCasDeTests = i;
3027: }
3028: }
3029:
3030: // test présence des colonnes numéro
3031: st = new StringTokenizer(Language.getInstance().getText(
3032: "numero_Liste").toLowerCase(), ",");
3033: while (st.hasMoreTokens()
3034: && isPresenceColonneNumeroTests == false) {
3035: if (celluleLu.getContents().trim().toLowerCase()
3036: .equals(st.nextToken().toString())) {
3037: isPresenceColonneNumeroTests = true;
3038: numeroColonneNumeroTests = i;
3039: }
3040: }
3041:
3042: // test présence des colonnes Action a réaliser
3043: st = new StringTokenizer(Language.getInstance().getText(
3044: "Action_A_Realiser_Liste").toLowerCase(), ",");
3045: while (st.hasMoreTokens()
3046: && isPresenceColonneActionARealiser == false) {
3047: if (celluleLu.getContents().trim().toLowerCase()
3048: .equals(st.nextToken().toString())) {
3049: isPresenceColonneActionARealiser = true;
3050: numeroColonneActionARealiser = i;
3051: }
3052: }
3053: // test présence des colonnes Action attendue
3054: st = new StringTokenizer(Language.getInstance().getText(
3055: "Action_Attendue_Liste").toLowerCase(), ",");
3056: while (st.hasMoreTokens()
3057: && isPresenceColonneActionAttendue == false) {
3058: if (celluleLu.getContents().trim().toLowerCase()
3059: .equals(st.nextToken().toString())) {
3060: isPresenceColonneActionAttendue = true;
3061: numeroColonneActionAttendue = i;
3062: }
3063: }
3064: // test présence des colonnes Description
3065: st = new StringTokenizer(Language.getInstance().getText(
3066: "Description_Liste").toLowerCase(), ",");
3067: while (st.hasMoreTokens()
3068: && isPresenceColonneDescriptionTest == false) {
3069: if (celluleLu.getContents().trim().toLowerCase()
3070: .equals(st.nextToken().toString())) {
3071: isPresenceColonneDescriptionTest = true;
3072: numeroColonneDescriptionTest = i;
3073: }
3074: }
3075:
3076: // test présence des colonnes Lien Hypertexte
3077: st = new StringTokenizer(Language.getInstance().getText(
3078: "Lien_Hypertexte_Liste").toLowerCase(), ",");
3079: while (st.hasMoreTokens()
3080: && isPresenceColonneTestLienHypertexte == false) {
3081: if (celluleLu.getContents().trim().toLowerCase()
3082: .equals(st.nextToken().toString())) {
3083: isPresenceColonneTestLienHypertexte = true;
3084: numeroColonneTestLienHypertexte = i;
3085: }
3086: }
3087:
3088: // test présence des colonnes Piece Jointe
3089: st = new StringTokenizer(Language.getInstance().getText(
3090: "Piece_Jointe_Liste").toLowerCase(), ",");
3091: while (st.hasMoreTokens()
3092: && isPresenceColonneTestPieceJointe == false) {
3093: if (celluleLu.getContents().trim().toLowerCase()
3094: .equals(st.nextToken().toString())) {
3095: isPresenceColonneTestPieceJointe = true;
3096: numeroColonneTestPieceJointe = i;
3097: }
3098: }
3099:
3100: // test présence des colonnes Lien Hypertexte Action
3101: st = new StringTokenizer(Language.getInstance().getText(
3102: "Lien_Hypertexte_Action_Liste").toLowerCase(), ",");
3103: while (st.hasMoreTokens()
3104: && isPresenceColonneTestLienHypertexteAction == false) {
3105: if (celluleLu.getContents().trim().toLowerCase()
3106: .equals(st.nextToken().toString())) {
3107: isPresenceColonneTestLienHypertexteAction = true;
3108: numeroColonneTestLienHypertexteAction = i;
3109: }
3110: }
3111:
3112: // test présence des colonnes Piece Jointe Action
3113: st = new StringTokenizer(Language.getInstance().getText(
3114: "Piece_Jointe_Action_Liste").toLowerCase(), ",");
3115: while (st.hasMoreTokens()
3116: && isPresenceColonneTestPieceJointeAction == false) {
3117: if (celluleLu.getContents().trim().toLowerCase()
3118: .equals(st.nextToken().toString())) {
3119: isPresenceColonneTestPieceJointeAction = true;
3120: numeroColonneTestPieceJointeAction = i;
3121: }
3122: }
3123:
3124: // test présence des colonnes Type Test automatique
3125: st = new StringTokenizer(Language.getInstance().getText(
3126: "Type_Test_Automatique_Liste").toLowerCase(), ",");
3127: while (st.hasMoreTokens()
3128: && isPresenceColonneTypeTestAutomatique == false) {
3129: if (celluleLu.getContents().trim().toLowerCase()
3130: .equals(st.nextToken().toString())) {
3131: isPresenceColonneTypeTestAutomatique = true;
3132: numeroColonneTypeTestAutomatique = i;
3133: }
3134: }
3135:
3136: // test présence des colonnes emplacement Test automatique
3137: st = new StringTokenizer(
3138: Language.getInstance().getText(
3139: "Emplacement_Test_Automatique_Liste")
3140: .toLowerCase(), ",");
3141: while (st.hasMoreTokens()
3142: && isPresenceColonneEmplacementTestAutomatique == false) {
3143: if (celluleLu.getContents().trim().toLowerCase()
3144: .equals(st.nextToken().toString())) {
3145: isPresenceColonneEmplacementTestAutomatique = true;
3146: numeroColonneEmplacementTestAutomatique = i;
3147: }
3148: }
3149: }
3150:
3151: // test de présence des colonnes Famille et Exigence
3152: for (int i = 0; i < nombreColonneTableauTests; i++) {
3153: celluleLu = testSheet.getCell(i, ligneDebutTableauTest);
3154: st = new StringTokenizer(Language.getInstance().getText(
3155: "Exigence_Liste").toLowerCase(), ",");
3156: while (st.hasMoreTokens()
3157: && isPresenceColonneExigenceTests == false) {
3158: if (celluleLu.getContents().trim().toLowerCase()
3159: .equals(st.nextToken().toString())) {
3160: isPresenceColonneExigenceTests = true;
3161: numeroColonneExigenceTests = i;
3162: }
3163: }
3164:
3165: st = new StringTokenizer(Language.getInstance().getText(
3166: "Theme_Liste").toLowerCase(), ",");
3167: while (st.hasMoreTokens()) {
3168: if (celluleLu.getContents().trim().toLowerCase()
3169: .equals(st.nextToken().toString())) {
3170: isPresenceColonneBrancheTests = true;
3171: if (numeroColonneBrancheTests == null) {
3172: numeroColonneBrancheTests = Integer.toString(i);
3173: } else {
3174: numeroColonneBrancheTests = numeroColonneBrancheTests
3175: + Language.getInstance().getText("_")
3176: + Integer.toString(i);
3177: }
3178:
3179: }
3180: }
3181:
3182: }
3183:
3184: if ((isPresenceColonneCasDeTests == false)
3185: || (isPresenceColonneActionARealiser == false)
3186: || (isPresenceColonneActionAttendue == false)) {
3187: isErreurTraitementImport = true;
3188: closeXmlAndXlsFiles();
3189: JOptionPane.showMessageDialog(null, Language.getInstance()
3190: .getText("Stop_No_TestCase_Or_Action"), Language
3191: .getInstance().getText("Erreur_!"),
3192: JOptionPane.ERROR_MESSAGE);
3193: PopUpFormalismeExcel p = new PopUpFormalismeExcel(
3194: pIPlugObject);
3195:
3196: }
3197:
3198: }
3199:
3200: /**
3201: * Function that write a family Requirement in the XML File
3202: */
3203: public void writeFamilyRequirement() {
3204: String parent = "0";
3205: String enfant = "0";
3206: String idExigences = "0";
3207: Element familyRequirementName;
3208:
3209: if (vecteurBrancheID.contains(familleEnCours)) {
3210: idExigences = vecteurBrancheID.get(vecteurBrancheID
3211: .indexOf(familleEnCours) + 1);
3212: }
3213:
3214: StringTokenizer stfamille = new StringTokenizer(
3215: removeSpecialCharacters(familleEnCours), "_");
3216: StringTokenizer stId = new StringTokenizer(idExigences, "_");
3217:
3218: enfant = stId.nextToken();
3219: familyRequirement = requirements
3220: .addElement("RequirementFamily").addAttribute("id_req",
3221: "Req_" + enfant).addAttribute("id_req_parent",
3222: "Req_" + parent);
3223: familyRequirementName = familyRequirement.addElement("Nom")
3224: .addText(stfamille.nextToken());
3225:
3226: while (stfamille.hasMoreTokens()) {
3227: parent = enfant;
3228: enfant = stId.nextToken();
3229: familyRequirement = requirements.addElement(
3230: "RequirementFamily").addAttribute("id_req",
3231: "Req_" + enfant).addAttribute("id_req_parent",
3232: "Req_" + parent);
3233: familyRequirementName = familyRequirement.addElement("Nom")
3234: .addText(stfamille.nextToken());
3235: }
3236:
3237: indiceRequirementFamilleEnCours = enfant;
3238: }
3239:
3240: /**
3241: * Function that write a Requirement in the XML File
3242: * @param lignePourLirePJetURL lignePourLirePJetURL
3243: * @param familleExiste boolean
3244: */
3245: public void writeRequirement(boolean familleExiste,
3246: int lignePourLirePJetURL) {
3247: Element Requirement;
3248: if (familleExiste) {
3249: Requirement = familyRequirement
3250: .addElement("Requirement")
3251: .addAttribute("priority", valeurPriorite)
3252: .addAttribute("category", valeurCategorie)
3253: .addAttribute("complexity", valeurComplexite)
3254: .addAttribute("state", valeurEtat)
3255: .addAttribute("origine", valeurOrigine)
3256: .addAttribute("version", valeurVersion)
3257: .addAttribute("reference", valeurReference)
3258: .addAttribute("verifway", valeurVerifWay)
3259: .addAttribute(
3260: "id_req",
3261: "Req_"
3262: + Integer
3263: .toString(indiceRequirement))
3264: .addAttribute("id_req_parent",
3265: "Req_" + indiceRequirementFamilleEnCours);
3266: } else {
3267: Requirement = requirements
3268: .addElement("Requirement")
3269: .addAttribute("priority", valeurPriorite)
3270: .addAttribute("category", valeurCategorie)
3271: .addAttribute("complexity", valeurComplexite)
3272: .addAttribute("state", valeurEtat)
3273: .addAttribute("origine", valeurOrigine)
3274: .addAttribute("version", valeurVersion)
3275: .addAttribute("reference", valeurReference)
3276: .addAttribute("verifway", valeurVerifWay)
3277: .addAttribute(
3278: "id_req",
3279: "Req_"
3280: + Integer
3281: .toString(indiceRequirement))
3282: .addAttribute("id_req_parent", "Req_0");
3283: }
3284: // enleve possibilité 2 underscore qui se suivent :
3285: exigenceLu = exigenceLu.replaceAll(Language.getInstance()
3286: .getText("_")
3287: + Language.getInstance().getText("_"), Language
3288: .getInstance().getText("_"));
3289:
3290: Element RequirementName = Requirement.addElement("Nom")
3291: .addText(removeSpecialCharacters(exigenceLu));
3292: Element RequirementDescription = Requirement.addElement(
3293: "Description").addText(valeurDescription);
3294:
3295: exigenceID.add(familleEnCours
3296: + Language.getInstance().getText("_")
3297: + removeSpecialCharacters(exigenceLu));
3298: exigenceID.add(String.valueOf(indiceRequirement));
3299: indiceRequirement++;
3300:
3301: litPJetURL(Requirement, requirementSheet, lignePourLirePJetURL,
3302: isPresenceColonneLienHypertexte,
3303: numeroColonneLienHypertexte,
3304: isPresenceColonnePieceJointe, numeroColonnePieceJointe,
3305: "Requirements");
3306:
3307: indiceRequirementExigenceEnCours++;
3308: }
3309:
3310: /**
3311: * Function that read each cells of the requirement spreadsheet
3312: *
3313: * @throws java.lang.Exception
3314: * Language Exception
3315: */
3316: public void readXlsTableRequirement() throws Exception {
3317: // Gestion des exigences
3318: requirements = projetVT.addElement("Requirements")
3319: .addAttribute("id_req", "Req_0");
3320: for (int i = ligneDebutTableauRequirement + 1; i < nombreLigneTableau; i++) {
3321: // lit Famille
3322: if (isPresenceColonneBranche == false) {
3323: familleEnCours = Language.getInstance().getText(
3324: "Famille_par_defaut");
3325: } else {
3326: StringTokenizer st = new StringTokenizer(
3327: numeroColonneBranche, Language.getInstance()
3328: .getText("_"));
3329: familleEnCours = null;
3330: while (st.hasMoreTokens()) {
3331: celluleLu = requirementSheet.getCell(Integer
3332: .parseInt(st.nextToken()), i);
3333: if (familleEnCours == null) {
3334: familleEnCours = celluleLu.getContents();
3335: if (familleEnCours.length() != 0) {
3336: if (!vecteurBrancheID
3337: .contains(familleEnCours)) {
3338: vecteurBrancheID.add(familleEnCours);
3339: vecteurBrancheID.add(Integer
3340: .toString(indiceRequirement));
3341: indiceRequirement++;
3342: }
3343: }
3344:
3345: } else {
3346: if (celluleLu.getContents().length() != 0) {
3347: if (!vecteurBrancheID
3348: .contains(familleEnCours
3349: + Language.getInstance()
3350: .getText("_")
3351: + celluleLu.getContents())) {
3352: int j = vecteurBrancheID
3353: .indexOf(familleEnCours);
3354: familleEnCours = familleEnCours
3355: + Language.getInstance()
3356: .getText("_")
3357: + celluleLu.getContents();
3358: vecteurBrancheID.add(familleEnCours);
3359: vecteurBrancheID
3360: .add(vecteurBrancheID
3361: .get(j + 1)
3362: + Language
3363: .getInstance()
3364: .getText("_")
3365: + Integer
3366: .toString(indiceRequirement));
3367: indiceRequirement++;
3368: } else {
3369: familleEnCours = familleEnCours
3370: + Language.getInstance()
3371: .getText("_")
3372: + celluleLu.getContents();
3373:
3374: }
3375:
3376: }
3377:
3378: }
3379:
3380: }
3381: }
3382: if ((!familleEnCours.equals(famillePrecedente))
3383: && (familleEnCours.length() > 0)
3384: && isPresenceColonneBranche) {
3385: writeFamilyRequirement();
3386: famillePrecedente = familleEnCours;
3387: }
3388:
3389: // Lit Exigence
3390: celluleLu = requirementSheet.getCell(numeroColonneExigence,
3391: i);
3392: exigenceLu = celluleLu.getContents();
3393:
3394: while (exigenceLu.startsWith(Language.getInstance()
3395: .getText("_"))) {
3396: exigenceLu = exigenceLu.substring(1);
3397: }
3398: // lit Priorité
3399: if (isPresenceColonnePriorite == true) {
3400: boolean setValeurPriorite = false;
3401: celluleLu = requirementSheet.getCell(
3402: numeroColonnePriorite, i);
3403: if (celluleLu.getContents().length() != 0) {
3404: valeurPriorite = celluleLu.getContents().toString();
3405: valeurPriorite = valeurPriorite.trim();
3406: } else {
3407: valeurPriorite = "10";
3408: }
3409: // si champ priorité est sous format texte
3410: if ((valeurPriorite.equals("1"))
3411: || (valeurPriorite.equalsIgnoreCase(Language
3412: .getInstance().getText("Bas")))
3413: || (valeurPriorite.equalsIgnoreCase(Language
3414: .getInstance().getText("Basse")))) {
3415: valeurPriorite = "1";
3416: setValeurPriorite = true;
3417: } else if ((valeurPriorite.equals("10"))
3418: || (valeurPriorite.equalsIgnoreCase(Language
3419: .getInstance().getText("Moyen")))
3420: || (valeurPriorite.equalsIgnoreCase(Language
3421: .getInstance().getText("Moyenne")))) {
3422: valeurPriorite = "10";
3423: setValeurPriorite = true;
3424: } else if ((valeurPriorite.equals("100"))
3425: || (valeurPriorite.equalsIgnoreCase(Language
3426: .getInstance().getText("Haut")))
3427: || (valeurPriorite.equalsIgnoreCase(Language
3428: .getInstance().getText("Haute")))) {
3429: valeurPriorite = "100";
3430: setValeurPriorite = true;
3431: } else if ((valeurPriorite.equals("1000"))
3432: || (valeurPriorite.equalsIgnoreCase(Language
3433: .getInstance().getText("Essentiel")))
3434: || (valeurPriorite.equalsIgnoreCase(Language
3435: .getInstance().getText("Essentielle")))) {
3436: valeurPriorite = "1000";
3437: setValeurPriorite = true;
3438: }
3439: if (setValeurPriorite == false) {
3440: valeurPriorite = "10";
3441: }
3442:
3443: } else {
3444: valeurPriorite = "10";
3445: }
3446:
3447: // lit Version
3448: if (isPresenceColonneVersion == true) {
3449: celluleLu = requirementSheet.getCell(
3450: numeroColonneVersion, i);
3451: valeurVersion = celluleLu.getContents();
3452: } else {
3453: valeurVersion = "1";
3454: }
3455: // lit Origine
3456: if (isPresenceColonneOrigine == true) {
3457: celluleLu = requirementSheet.getCell(
3458: numeroColonneOrigine, i);
3459: valeurOrigine = celluleLu.getContents();
3460: } else {
3461: valeurOrigine = "MOE";
3462: }
3463: // lit VerifWay
3464: if (isPresenceColonneVerifWay == true) {
3465: celluleLu = requirementSheet.getCell(
3466: numeroColonneVerifWay, i);
3467: valeurVerifWay = celluleLu.getContents();
3468: } else {
3469: valeurVerifWay = "";
3470: }
3471: // lit Reference
3472: if (isPresenceColonneReference == true) {
3473: celluleLu = requirementSheet.getCell(
3474: numeroColonneReference, i);
3475: valeurReference = celluleLu.getContents();
3476: } else {
3477: valeurReference = "";
3478: }
3479: // lit Description
3480: if (isPresenceColonneDescription == true) {
3481: celluleLu = requirementSheet.getCell(
3482: numeroColonneDescription, i);
3483: valeurDescription = celluleLu.getContents();
3484: } else {
3485: valeurDescription = "";
3486: }
3487:
3488: // lit Catégorie
3489: if (isPresenceColonneCategorie == true) {
3490: celluleLu = requirementSheet.getCell(
3491: numeroColonneCategorie, i);
3492: valeurCategorie = celluleLu.getContents();
3493: if ((valeurCategorie.equals("0"))
3494: || (valeurCategorie.equalsIgnoreCase(Language
3495: .getInstance().getText("Fonctionnel")))
3496: || (valeurCategorie
3497: .equalsIgnoreCase(Language
3498: .getInstance().getText(
3499: "Fonctionnelle")))) {
3500: valeurCategorie = "0";
3501: } else if ((valeurCategorie.equals("1"))
3502: || (valeurCategorie.equalsIgnoreCase(Language
3503: .getInstance().getText(
3504: "Interoperabilite")))
3505: || (valeurCategorie.equalsIgnoreCase(Language
3506: .getInstance().getText(
3507: "Interoperabilitee")))) {
3508: valeurCategorie = "1";
3509: } else if ((valeurCategorie.equals("2"))
3510: || valeurCategorie.equalsIgnoreCase(Language
3511: .getInstance().getText("Charge"))) {
3512: valeurCategorie = "2";
3513: } else if ((valeurCategorie.equals("3"))
3514: || (valeurCategorie.equalsIgnoreCase(Language
3515: .getInstance().getText("Performance")))) {
3516: valeurCategorie = "3";
3517: } else if ((valeurCategorie.equals("4"))
3518: || (valeurCategorie
3519: .equalsIgnoreCase(Language
3520: .getInstance().getText(
3521: "Disponibilite")))
3522: || (valeurCategorie.equalsIgnoreCase(Language
3523: .getInstance()
3524: .getText("Disponibilitee")))) {
3525: valeurCategorie = "4";
3526: } else if ((valeurCategorie.equals("5"))
3527: || (valeurCategorie.equalsIgnoreCase(Language
3528: .getInstance().getText("Securite")))
3529: || (valeurCategorie.equalsIgnoreCase(Language
3530: .getInstance().getText("Securitee")))) {
3531: valeurCategorie = "5";
3532: } else if ((valeurCategorie.equals("6"))
3533: || (valeurCategorie.equalsIgnoreCase(Language
3534: .getInstance()
3535: .getText("Exploitabilite")))
3536: || (valeurCategorie.equalsIgnoreCase(Language
3537: .getInstance().getText(
3538: "Exploitabilitee")))) {
3539: valeurCategorie = "6";
3540: }
3541: } else {
3542: valeurCategorie = "7";
3543: }
3544: // lit complexite
3545: if (isPresenceColonneComplexite == true) {
3546: celluleLu = requirementSheet.getCell(
3547: numeroColonneComplexite, i);
3548: valeurComplexite = celluleLu.getContents();
3549: if ((valeurComplexite.equals("1000"))
3550: || (valeurComplexite.equalsIgnoreCase(Language
3551: .getInstance().getText("C0")))) {
3552: valeurComplexite = "1000";
3553: } else if ((valeurComplexite.equals("100"))
3554: || (valeurComplexite.equalsIgnoreCase(Language
3555: .getInstance().getText("C1")))) {
3556: valeurComplexite = "100";
3557: } else if ((valeurComplexite.equals("10"))
3558: || (valeurComplexite.equalsIgnoreCase(Language
3559: .getInstance().getText("C2")))) {
3560: valeurComplexite = "10";
3561: } else if ((valeurComplexite.equals("1"))
3562: || (valeurComplexite.equalsIgnoreCase(Language
3563: .getInstance().getText("C3")))) {
3564: valeurComplexite = "1";
3565: }
3566: } else {
3567: valeurComplexite = "1";
3568: }
3569:
3570: // lit Etat
3571: if (isPresenceColonneEtat == true) {
3572: celluleLu = requirementSheet.getCell(numeroColonneEtat,
3573: i);
3574: valeurEtat = celluleLu.getContents();
3575: if ((valeurEtat.equals("0"))
3576: || (valeurEtat.equalsIgnoreCase(Language
3577: .getInstance().getText("A_Analyser")))) {
3578: valeurEtat = "0";
3579: } else if ((valeurEtat.equals("1"))
3580: || (valeurEtat.equalsIgnoreCase(Language
3581: .getInstance().getText("Analysee")))) {
3582: valeurEtat = "1";
3583: } else if ((valeurEtat.equals("2"))
3584: || (valeurEtat.equalsIgnoreCase(Language
3585: .getInstance().getText("Approuvee")))) {
3586: valeurEtat = "2";
3587: } else if ((valeurEtat.equals("3"))
3588: || (valeurEtat.equalsIgnoreCase(Language
3589: .getInstance().getText("Verifiee")))) {
3590: valeurEtat = "3";
3591: } else if ((valeurEtat.equals("4"))
3592: || (valeurEtat.equalsIgnoreCase(Language
3593: .getInstance().getText("Finalisee")))) {
3594: valeurEtat = "4";
3595: } else if ((valeurEtat.equals("5"))
3596: || (valeurEtat.equalsIgnoreCase(Language
3597: .getInstance().getText("Reportee")))) {
3598: valeurEtat = "5";
3599: } else if ((valeurEtat.equals("6"))
3600: || (valeurEtat.equalsIgnoreCase(Language
3601: .getInstance().getText("Abandonnee")))) {
3602: valeurEtat = "6";
3603: }
3604: } else {
3605: valeurEtat = "0";
3606: }
3607:
3608: boolean ExigenceAttacheFamille;
3609: if (familleEnCours.length() > 0 && isPresenceColonneBranche) {
3610: ExigenceAttacheFamille = true;
3611: writeRequirement(ExigenceAttacheFamille, i);
3612: } else {
3613: ExigenceAttacheFamille = false;
3614: writeRequirement(ExigenceAttacheFamille, i);
3615: }
3616: }
3617: }
3618:
3619: /**
3620: * Function that verify the presence of requirement columns in the
3621: * requirement spreadsheet
3622: */
3623: public void testColumnsPresenceRequirement() {
3624: StringTokenizer st;
3625:
3626: // Recupère ligne debut tableau
3627: boolean exigenceTrouve = false;
3628: for (int i = 0; i < nombreColonneTableau; i++) {
3629: for (int j = 0; j < nombreLigneTableau; j++) {
3630: celluleLu = requirementSheet.getCell(i, j);
3631: st = new StringTokenizer(Language.getInstance()
3632: .getText("Exigence_Liste").toLowerCase(), ",");
3633: while (st.hasMoreTokens() && exigenceTrouve == false) {
3634: if (celluleLu.getContents().trim().toLowerCase()
3635: .equals(st.nextToken().toString())) {
3636: ligneDebutTableauRequirement = celluleLu
3637: .getRow();
3638: exigenceTrouve = true;
3639: }
3640: }
3641: }
3642: }
3643:
3644: // test présences des colonnes version,priorité et Description
3645: for (int i = 0; i < nombreColonneTableau; i++) {
3646: celluleLu = requirementSheet.getCell(i,
3647: ligneDebutTableauRequirement);
3648: // test présences des colonnes priorité
3649: st = new StringTokenizer(Language.getInstance().getText(
3650: "Priorite_Liste").toLowerCase(), ",");
3651: while (st.hasMoreTokens()
3652: && isPresenceColonnePriorite == false) {
3653: if (celluleLu.getContents().trim().toLowerCase()
3654: .equals(st.nextToken().toString())) {
3655: isPresenceColonnePriorite = true;
3656: numeroColonnePriorite = i;
3657: }
3658: }
3659: // test présences des colonnes version
3660: st = new StringTokenizer(Language.getInstance().getText(
3661: "Version_Liste").toLowerCase(), ",");
3662: while (st.hasMoreTokens()
3663: && isPresenceColonneVersion == false) {
3664: if (celluleLu.getContents().trim().toLowerCase()
3665: .equals(st.nextToken().toString())) {
3666: isPresenceColonneVersion = true;
3667: numeroColonneVersion = i;
3668: }
3669: }
3670:
3671: // test présences des colonnes Description
3672: st = new StringTokenizer(Language.getInstance().getText(
3673: "Description_Liste").toLowerCase(), ",");
3674: while (st.hasMoreTokens()
3675: && isPresenceColonneDescription == false) {
3676: if (celluleLu.getContents().trim().toLowerCase()
3677: .equals(st.nextToken().toString())) {
3678: isPresenceColonneDescription = true;
3679: numeroColonneDescription = i;
3680: }
3681: }
3682:
3683: // test présences des colonnes Lien Hypertexte
3684: st = new StringTokenizer(Language.getInstance().getText(
3685: "Lien_Hypertexte_Liste").toLowerCase(), ",");
3686: while (st.hasMoreTokens()
3687: && isPresenceColonneLienHypertexte == false) {
3688: if (celluleLu.getContents().trim().toLowerCase()
3689: .equals(st.nextToken().toString())) {
3690: isPresenceColonneLienHypertexte = true;
3691: numeroColonneLienHypertexte = i;
3692: }
3693: }
3694:
3695: // test présences des colonnes Piece Jointe
3696: st = new StringTokenizer(Language.getInstance().getText(
3697: "Piece_Jointe_Liste").toLowerCase(), ",");
3698: while (st.hasMoreTokens()
3699: && isPresenceColonnePieceJointe == false) {
3700: if (celluleLu.getContents().trim().toLowerCase()
3701: .equals(st.nextToken().toString())) {
3702: isPresenceColonnePieceJointe = true;
3703: numeroColonnePieceJointe = i;
3704: }
3705: }
3706:
3707: // test présences des colonnes Catégorie
3708: st = new StringTokenizer(Language.getInstance().getText(
3709: "Categorie_Liste").toLowerCase(), ",");
3710: while (st.hasMoreTokens()
3711: && isPresenceColonneCategorie == false) {
3712: if (celluleLu.getContents().trim().toLowerCase()
3713: .equals(st.nextToken().toString())) {
3714: isPresenceColonneCategorie = true;
3715: numeroColonneCategorie = i;
3716: }
3717: }
3718:
3719: // test présences des colonnes Complexite
3720: st = new StringTokenizer(Language.getInstance().getText(
3721: "Complexite_Liste").toLowerCase(), ",");
3722: while (st.hasMoreTokens()
3723: && isPresenceColonneComplexite == false) {
3724: if (celluleLu.getContents().trim().toLowerCase()
3725: .equals(st.nextToken().toString())) {
3726: isPresenceColonneComplexite = true;
3727: numeroColonneComplexite = i;
3728: }
3729: }
3730:
3731: // test présences des colonnes Etat
3732: st = new StringTokenizer(Language.getInstance().getText(
3733: "Etat_Liste").toLowerCase(), ",");
3734: while (st.hasMoreTokens() && isPresenceColonneEtat == false) {
3735: if (celluleLu.getContents().trim().toLowerCase()
3736: .equals(st.nextToken().toString())) {
3737: isPresenceColonneEtat = true;
3738: numeroColonneEtat = i;
3739: }
3740: }
3741:
3742: // test présences des colonnes Origine
3743: st = new StringTokenizer(Language.getInstance().getText(
3744: "Origine_Liste").toLowerCase(), ",");
3745: while (st.hasMoreTokens()
3746: && isPresenceColonneOrigine == false) {
3747: if (celluleLu.getContents().trim().toLowerCase()
3748: .equals(st.nextToken().toString())) {
3749: isPresenceColonneOrigine = true;
3750: numeroColonneOrigine = i;
3751: }
3752: }
3753:
3754: // test présences des colonnes VerifWay
3755: st = new StringTokenizer(Language.getInstance().getText(
3756: "VerifWay_Liste").toLowerCase(), ",");
3757: while (st.hasMoreTokens()
3758: && isPresenceColonneVerifWay == false) {
3759: if (celluleLu.getContents().trim().toLowerCase()
3760: .equals(st.nextToken().toString())) {
3761: isPresenceColonneVerifWay = true;
3762: numeroColonneVerifWay = i;
3763: }
3764: }
3765: // test présences des colonnes Refecence
3766: st = new StringTokenizer(Language.getInstance().getText(
3767: "Reference_Liste").toLowerCase(), ",");
3768: while (st.hasMoreTokens()
3769: && isPresenceColonneReference == false) {
3770: if (celluleLu.getContents().trim().toLowerCase()
3771: .equals(st.nextToken().toString())) {
3772: isPresenceColonneReference = true;
3773: numeroColonneReference = i;
3774: }
3775: }
3776:
3777: }
3778:
3779: // test de présence des colonnes Famille et Exigence
3780: for (int i = 0; i < nombreColonneTableau; i++) {
3781: celluleLu = requirementSheet.getCell(i,
3782: ligneDebutTableauRequirement);
3783: st = new StringTokenizer(Language.getInstance().getText(
3784: "Exigence_Liste").toLowerCase(), ",");
3785: while (st.hasMoreTokens()
3786: && isPresenceColonneExigence == false) {
3787: if (celluleLu.getContents().trim().toLowerCase()
3788: .equals(st.nextToken().toString())) {
3789: isPresenceColonneExigence = true;
3790: numeroColonneExigence = i;
3791: }
3792: }
3793:
3794: st = new StringTokenizer(Language.getInstance().getText(
3795: "Theme_Liste").toLowerCase(), ",");
3796: while (st.hasMoreTokens()) {
3797: if (celluleLu.getContents().trim().toLowerCase()
3798: .equals(st.nextToken().toString())) {
3799: isPresenceColonneBranche = true;
3800: if (numeroColonneBranche == null) {
3801: numeroColonneBranche = Integer.toString(i);
3802: } else {
3803: numeroColonneBranche = numeroColonneBranche
3804: + Language.getInstance().getText("_")
3805: + Integer.toString(i);
3806: }
3807:
3808: }
3809: }
3810:
3811: }
3812:
3813: if ((isPresenceColonneExigence == false)) {
3814: PopUpFormalismeExcel aide = new PopUpFormalismeExcel(null);
3815: closeXmlAndXlsFiles();
3816: JOptionPane.showMessageDialog(null, Language.getInstance()
3817: .getText("Stop_No_Requirement_Column_Or_Family"),
3818: Language.getInstance().getText("Erreur_!"),
3819: JOptionPane.ERROR_MESSAGE);
3820: isErreurTraitementImport = true;
3821: }
3822:
3823: }
3824:
3825: /**
3826: * Function that write the XML Heading (common to every XML files)
3827: */
3828: public void writeXmlHeading() {
3829: // Création du document XML
3830: documentXml = DocumentHelper.createDocument();
3831:
3832: // Gestion de l'entete XML commune
3833: Element root = documentXml.addElement("SalomeDynamique");
3834: projetVT = root.addElement("ProjetVT");
3835: Element nomProjet = projetVT.addElement("Nom").addText(
3836: "pluginxlsxml");
3837:
3838: // Génération de la date
3839: DateFormat dateFormat = DateFormat
3840: .getDateInstance(DateFormat.MONTH_FIELD);
3841: Element dateCrea = projetVT.addElement("Date_crea").addText(
3842: dateFormat.format(new Date()));
3843: Element groupesDePersonnes = projetVT.addElement(
3844: "GroupesDePersonnes").addText("");
3845: Element groupeDePersonnes = groupesDePersonnes.addElement(
3846: "GroupeDePersonnes").addText("");
3847: Element nomGroupe = groupeDePersonnes.addElement("Nom")
3848: .addText("OutilExcelXml");
3849: Element descriptionGroupe = groupeDePersonnes.addElement(
3850: "Description").addText(
3851: "Groupe de transfert des exigences");
3852:
3853: }
3854:
3855: /**
3856: * Function that create the XML file from the name typed in the swing
3857: * component
3858: *
3859: * @param nomFichierXml
3860: * Name of the XML file
3861: * @return the real name of the created XML File
3862: */
3863: public String createXmlFile(String nomFichierXml) {
3864:
3865: // Crée nom Fichier XML a partir nom Excel
3866: nomFichierXml = nomFichierXml.substring(0, nomFichierXml
3867: .lastIndexOf(".xls"))
3868: + ".xml";
3869:
3870: // Tente de créer le fichier XML
3871: fichierDeSortieXML = new File(nomFichierXml);
3872: int i = 0;
3873: while (fichierDeSortieXML.exists()) {
3874:
3875: if (i == 0) {
3876: System.out.println(Language.getInstance().getText(
3877: "FileName_Already_Exists"));
3878:
3879: nomFichierXml = nomFichierXml.substring(0,
3880: nomFichierXml.lastIndexOf("."))
3881: + Language.getInstance().getText("_")
3882: + Integer.toString(i) + ".xml";
3883:
3884: } else {
3885: nomFichierXml = nomFichierXml.substring(0,
3886: nomFichierXml.lastIndexOf(Language
3887: .getInstance().getText("_")))
3888: + Language.getInstance().getText("_")
3889: + Integer.toString(i) + ".xml";
3890:
3891: }
3892:
3893: fichierDeSortieXML = new File(nomFichierXml);
3894: i++;
3895: }
3896: System.out.println(Language.getInstance().getText(
3897: "Fichier_Sortie_XML")
3898: + fichierDeSortieXML.toString());
3899: try {
3900: fichierDeSortieXML.createNewFile();
3901: } catch (IOException ex) {
3902: System.out.println(Language.getInstance().getText(
3903: "Erreur_Fichier_Sortie_XML_:")
3904: + fichierDeSortieXML.toString());
3905: ex.printStackTrace();
3906: }
3907: return fichierDeSortieXML.toString();
3908: }
3909:
3910: /**
3911: * Function testing the presence of the XLS file and open it
3912: *
3913: * @param FichierExcel
3914: * Name of the XLS File
3915: *
3916: */
3917: public void openXLSFile(String FichierExcel) {
3918:
3919: // Récupère le fichier excel et tente de l'ouvrir, sinon, erreur
3920: try {
3921: // recupère fichier Excel
3922: workbook = Workbook.getWorkbook(new File(FichierExcel));
3923: } catch (IOException e) {
3924: System.out.println(Language.getInstance().getText(
3925: "Erreur_Fichier_Excel_Existe_Pas_:")
3926: + FichierExcel);
3927: } catch (BiffException e) {
3928: e.printStackTrace();
3929: }
3930:
3931: // recupere le nombre de feuilles du classeur
3932: String[] nombreFeuilles = workbook.getSheetNames();
3933: for (int i = 0; i < nombreFeuilles.length; i++) {
3934: // Récupére la feuille Exigence
3935: StringTokenizer st = new StringTokenizer(Language
3936: .getInstance().getText("Exigence_Liste")
3937: .toLowerCase(), ",");
3938: while (st.hasMoreTokens()) {
3939: if (nombreFeuilles[i].toLowerCase().equals(
3940: st.nextToken().toString())) {
3941: // Récupére la feuille Exigence
3942: requirementSheet = workbook
3943: .getSheet(nombreFeuilles[i]);
3944: // Récupère les dimensions du tableau
3945: nombreColonneTableau = requirementSheet
3946: .getColumns();
3947: nombreLigneTableau = requirementSheet.getRows();
3948: presenceFeuilleExigence = true;
3949: }
3950: }
3951: st = new StringTokenizer(Language.getInstance().getText(
3952: "cas_de_tests_Liste").toLowerCase(), ",");
3953: while (st.hasMoreTokens()) {
3954: if (nombreFeuilles[i].toLowerCase().equals(
3955: st.nextToken().toString())) {
3956: // Récupére la feuille tests
3957: testSheet = workbook.getSheet(nombreFeuilles[i]);
3958: // Récupère les dimensions du tableau
3959: nombreColonneTableauTests = testSheet.getColumns();
3960: nombreLigneTableauTests = testSheet.getRows();
3961: presenceFeuilleTest = true;
3962: }
3963: }
3964: st = new StringTokenizer(Language.getInstance().getText(
3965: "nom_Parametres_Liste").toLowerCase(), ",");
3966: while (st.hasMoreTokens()) {
3967: if (nombreFeuilles[i].toLowerCase().equals(
3968: st.nextToken().toString())) {
3969: // Récupére la feuille tests
3970: paramSheet = workbook.getSheet(nombreFeuilles[i]);
3971: // Récupère les dimensions du tableau
3972: nombreColonneTableauParametres = paramSheet
3973: .getColumns();
3974: nombreLigneTableauParametres = paramSheet.getRows();
3975: presenceFeuilleParametres = true;
3976: }
3977: }
3978: st = new StringTokenizer(Language.getInstance().getText(
3979: "nom_Environnements_Liste").toLowerCase(), ",");
3980: while (st.hasMoreTokens()) {
3981: if (nombreFeuilles[i].toLowerCase().equals(
3982: st.nextToken().toString())) {
3983: // Récupére la feuille tests
3984: enviroSheet = workbook.getSheet(nombreFeuilles[i]);
3985: // Récupère les dimensions du tableau
3986: nombreColonneTableauEnvironnements = enviroSheet
3987: .getColumns();
3988: nombreLigneTableauEnvironnements = enviroSheet
3989: .getRows();
3990: presenceFeuilleEnvironnements = true;
3991:
3992: }
3993: }
3994: st = new StringTokenizer(Language.getInstance().getText(
3995: "nom_Campagne_Liste").toLowerCase(), ",");
3996: while (st.hasMoreTokens()) {
3997: if (nombreFeuilles[i].toLowerCase().equals(
3998: st.nextToken().toString())) {
3999: // Récupére la feuille tests
4000: campagneSheet = workbook
4001: .getSheet(nombreFeuilles[i]);
4002: // Récupère les dimensions du tableau
4003: nombreColonneTableauCampagne = campagneSheet
4004: .getColumns();
4005: nombreLigneTableauCampagne = campagneSheet
4006: .getRows();
4007: presenceFeuilleCampagne = true;
4008:
4009: }
4010: }
4011: st = new StringTokenizer(Language.getInstance().getText(
4012: "nom_Execution_Campagne_Liste").toLowerCase(), ",");
4013: while (st.hasMoreTokens()) {
4014: if (nombreFeuilles[i].toLowerCase().equals(
4015: st.nextToken().toString())) {
4016: // Récupére la feuille tests
4017: execCampSheet = workbook
4018: .getSheet(nombreFeuilles[i]);
4019: // Récupère les dimensions du tableau
4020: nombreColonneTableauExecutionCamp = execCampSheet
4021: .getColumns();
4022: nombreLigneTableauExecutionCamp = execCampSheet
4023: .getRows();
4024: presenceFeuilleExecutionCamp = true;
4025:
4026: }
4027: }
4028: }
4029:
4030: try {
4031: if (presenceFeuilleExigence) {
4032: celluleLu = requirementSheet.getCell(0, 0);
4033: }
4034: if (presenceFeuilleTest) {
4035: celluleLu = testSheet.getCell(0, 0);
4036: }
4037: if (presenceFeuilleParametres) {
4038: celluleLu = paramSheet.getCell(0, 0);
4039: }
4040: if (presenceFeuilleEnvironnements) {
4041: celluleLu = enviroSheet.getCell(0, 0);
4042: }
4043: if (presenceFeuilleCampagne) {
4044: celluleLu = campagneSheet.getCell(0, 0);
4045: }
4046: } catch (NullPointerException e) {
4047:
4048: PopUpFormalismeExcel aide = new PopUpFormalismeExcel(null);
4049: isErreurFormalismeExcel = true;
4050: workbook.close();
4051:
4052: }
4053:
4054: }
4055:
4056: /**
4057: * Function that close the XLS and the XML file This function tries to
4058: * delete empties spreadsheet's columns
4059: */
4060: public void closeXmlAndXlsFiles() {
4061: XMLWriter writer;
4062: try {
4063: // Pretty print the document to System.out
4064: OutputFormat format = OutputFormat.createPrettyPrint();
4065: format.setEncoding("ISO-8859-1");
4066: writer = new XMLWriter(new FileWriter(nomFichierXML),
4067: format);
4068: writer.write(documentXml);
4069: writer.close();
4070: } catch (IOException ex) {
4071: ex.printStackTrace();
4072: }
4073: // Finished - close the workbook and free up memory
4074: workbook.close();
4075: }
4076:
4077: /**
4078: * Function that only return the name of the files that had not been
4079: * imported
4080: *
4081: * @return Name of files
4082: */
4083: public String getFichiersNonImportes() {
4084: return fichiersNonImportes;
4085: }
4086:
4087: /**
4088: * Function that only return the npath of the xlm created by this function
4089: *
4090: * @return path
4091: */
4092: public String getXmlDir() {
4093: return xmlDir;
4094: }
4095:
4096: /**
4097: * Function that only return true if there has been an error during import
4098: *
4099: * @return path
4100: */
4101: public boolean getIsErreurTraitementImport() {
4102: return isErreurTraitementImport;
4103: }
4104:
4105: /**
4106: * Function that only return the name of the XML File
4107: *
4108: * @return Name of the XML File
4109: */
4110: public String getXMLFileName() {
4111: return nomFichierXML;
4112: }
4113:
4114: /**
4115: * Function that only return the list of requirements that don't exist
4116: *
4117: * @return list of requirements that don't exist
4118: */
4119: public String getExigenceNonTrouvePourTest() {
4120: return exigenceNonTrouvePourTest;
4121: }
4122:
4123: /**
4124: * listeCampagneNonTrouve
4125: * @return listeCampagneNonTrouve
4126: */
4127: public String getListeCampagneNonTrouve() {
4128: return listeCampagneNonTrouve;
4129: }
4130:
4131: /**
4132: * Function that return if the transformation in a XML File was OK
4133: *
4134: * @return boolean
4135: */
4136: public boolean getErreurImportFichier() {
4137: return isErreurImportFichier;
4138: }
4139:
4140: /**
4141: * Function that verify if attachements are accessible and copy them into a
4142: * same directory tree
4143: *
4144: * @param listePJ
4145: * File
4146: * @param type
4147: * Requirement or test
4148: * @param exigenceLu
4149: * Requirement linket to file
4150: * @throws java.lang.Exception
4151: * Language Exception
4152: * @return New file diectory tree
4153: */
4154: public String copyFileAttachements(String listePJ, String type,
4155: String exigenceLu) throws Exception {
4156: xmlDir = nomFichierXML.substring(0, nomFichierXML
4157: .lastIndexOf(fs));
4158: Sortie = Language.getInstance().getText("Attachements") + fs
4159: + type;
4160:
4161: if (exigenceLu != null) {
4162: Sortie = Sortie + fs + exigenceLu;
4163: }
4164:
4165: listePJ = restorePath(listePJ);
4166: xmlDir = restorePath(xmlDir);
4167: Sortie = restorePath(Sortie);
4168:
4169: File f1 = new File(listePJ);
4170: File f2 = new File(xmlDir + fs + Sortie);
4171: File f3 = new File(f2.toString() + fs
4172: + listePJ.substring(listePJ.lastIndexOf(fs) + 1));
4173:
4174: if (!f1.exists()) {
4175: if (isErreurImportFichier = false) {
4176: fichiersNonImportes = f1.toString() + "\n";
4177: } else {
4178: fichiersNonImportes = fichiersNonImportes
4179: + f1.toString() + "\n";
4180: }
4181: isErreurImportFichier = true;
4182: return null;
4183:
4184: } else {
4185:
4186: FileChannel in = null; // canal d'entrée
4187: FileChannel out = null; // canal de sortie
4188:
4189: try {
4190: f2.mkdirs();
4191: // Init
4192: in = new FileInputStream(f1.toString()).getChannel();
4193: out = new FileOutputStream(f3.toString()).getChannel();
4194: // Copie depuis le in vers le out
4195: in.transferTo(0, in.size(), out);
4196: } catch (Exception e) {
4197: e.printStackTrace(); // n'importe quelle exception
4198: } finally { // finalement on ferme
4199: if (in != null) {
4200: try {
4201: in.close();
4202: } catch (IOException e) {
4203: }
4204: }
4205: if (out != null) {
4206: try {
4207: out.close();
4208: } catch (IOException e) {
4209: }
4210: }
4211: }
4212: return Sortie + fs
4213: + listePJ.substring(listePJ.lastIndexOf(fs) + 1);
4214: }
4215:
4216: }
4217:
4218: /**
4219: * Modify a string to pass spécial characters like quote
4220: *
4221: * @param chaineAModifier
4222: * A string for argument
4223: * @return A string
4224: */
4225: public String removeSpecialCharacters(String chaineAModifier) {
4226: chaineAModifier = chaineAModifier.replaceAll("’", "'");
4227: chaineAModifier = chaineAModifier.replaceAll("–", "-");
4228: return chaineAModifier;
4229: }
4230:
4231: String restorePath(String path) throws Exception {
4232: if (fs.equals("\\")) {
4233: // Unix2Windows
4234: return path.replace('/', '\\');
4235: } else {
4236: return path.replace('\\', '/');
4237: }
4238: }
4239:
4240: }
|