0001: package salomeTMF_plug.gen_doc_xml;
0002:
0003: import java.io.File;
0004: import java.util.ArrayList;
0005: import java.util.Enumeration;
0006: import java.util.HashMap;
0007: import java.util.Hashtable;
0008: import java.util.Iterator;
0009: import java.util.List;
0010: import java.util.Vector;
0011:
0012: import javax.swing.JDialog;
0013: import javax.swing.JTable;
0014:
0015: import org.dom4j.Document;
0016: import org.dom4j.Element;
0017: import org.java.plugin.Extension;
0018: import org.objectweb.salome_tmf.api.Api;
0019: import org.objectweb.salome_tmf.api.ApiConstants;
0020: import org.objectweb.salome_tmf.api.Util;
0021: import org.objectweb.salome_tmf.api.sql.ISQLProject;
0022: import org.objectweb.salome_tmf.data.Action;
0023: import org.objectweb.salome_tmf.data.AdminVTData;
0024: import org.objectweb.salome_tmf.data.Attachment;
0025: import org.objectweb.salome_tmf.data.AutomaticTest;
0026: import org.objectweb.salome_tmf.data.Campaign;
0027: import org.objectweb.salome_tmf.data.DataSet;
0028: import org.objectweb.salome_tmf.data.Environment;
0029: import org.objectweb.salome_tmf.data.Execution;
0030: import org.objectweb.salome_tmf.data.ExecutionResult;
0031: import org.objectweb.salome_tmf.data.ExecutionTestResult;
0032: import org.objectweb.salome_tmf.data.Family;
0033: import org.objectweb.salome_tmf.data.FileAttachment;
0034: import org.objectweb.salome_tmf.data.ManualExecutionResult;
0035: import org.objectweb.salome_tmf.data.ManualTest;
0036: import org.objectweb.salome_tmf.data.Parameter;
0037: import org.objectweb.salome_tmf.data.Project;
0038: import org.objectweb.salome_tmf.data.Script;
0039: import org.objectweb.salome_tmf.data.Test;
0040: import org.objectweb.salome_tmf.data.TestList;
0041: import org.objectweb.salome_tmf.data.UrlAttachment;
0042: import org.objectweb.salome_tmf.data.User;
0043: import org.objectweb.salome_tmf.data.WithAttachment;
0044: import org.objectweb.salome_tmf.ihm.IHMConstants;
0045: import org.objectweb.salome_tmf.ihm.admin.Administration;
0046: import org.objectweb.salome_tmf.ihm.main.datawrapper.DataModel;
0047: import org.objectweb.salome_tmf.ihm.models.MyTableModel;
0048: import org.objectweb.salome_tmf.ihm.tools.Tools;
0049: import org.objectweb.salome_tmf.plugins.IPlugObject;
0050: import org.objectweb.salome_tmf.plugins.UICompCst;
0051: import org.objectweb.salome_tmf.plugins.core.TestDriver;
0052:
0053: import salomeTMF_plug.gen_doc_xml.languages.Language;
0054:
0055: public class Import implements ApiConstants, IHMConstants {
0056:
0057: private static String fs = System.getProperties().getProperty(
0058: "file.separator");
0059: private Document doc;
0060: private ImportDialog idialog;
0061: private CreateProjectDialog cdialog;
0062:
0063: //Administration adminFrame;
0064:
0065: ArrayList suiteSelectionList;
0066: ArrayList familySelectionList;
0067: ArrayList testSelectionList;
0068:
0069: Project project;
0070:
0071: String dirXml;
0072:
0073: private boolean selectionDesTests;
0074: private boolean importOnlyTests;
0075: private boolean annule = false;
0076: private boolean newProject = false;
0077: private boolean importReq = false;
0078:
0079: ISQLProject pISQLProject;
0080:
0081: AdminVTData pAdminVTData;
0082:
0083: Vector automatedTest2Update;
0084: IPlugObject pIPlugObject;
0085:
0086: ImportReq pImportReq;
0087:
0088: //Object reqRoot;
0089: //boolean reqAreUpdated;
0090:
0091: public Import(JDialog dialog, Document doc, ArrayList familySList,
0092: ArrayList suiteSList, ArrayList testSList,
0093: AdminVTData adminVTData, IPlugObject pIPlugObject) {
0094: super ();
0095: this .doc = doc;
0096: this .pIPlugObject = pIPlugObject;
0097: suiteSelectionList = suiteSList;
0098: familySelectionList = familySList;
0099: testSelectionList = testSList;
0100: pISQLProject = Api.getISQLObjectFactory().getISQLProject();
0101: //pISQLParameter = Api.getISQLObjectFactory().getISQLParameter();
0102: //pISQLEnvironment = Api.getISQLObjectFactory().getISQLEnvironment();
0103: pAdminVTData = adminVTData;
0104: if (dialog instanceof ImportDialog) {
0105: idialog = (ImportDialog) dialog;
0106: } else {
0107: cdialog = (CreateProjectDialog) dialog;
0108: }
0109:
0110: }
0111:
0112: /**
0113: * Supprime les parametres présents dans le projet mais non dans le documents
0114: * @throws Exception
0115: */
0116: boolean suppressionParameter() {
0117: //Suppression des paramètres du projet
0118: Hashtable paramSet = project.getParameterSetFromModel();
0119: Enumeration itParamProjet = paramSet.elements();
0120:
0121: while (itParamProjet.hasMoreElements() && !annule) {
0122: Parameter param = (Parameter) itParamProjet.nextElement();
0123: Iterator itParamXML = doc.selectNodes("//Param").iterator();
0124: boolean appartient = false;
0125: while (itParamXML.hasNext()) {
0126: Element paramElem = (Element) itParamXML.next();
0127: if (paramElem.elementText("Nom").equals(
0128: param.getNameFromModel())) {
0129: appartient = true;
0130: }
0131: }
0132: if (!appartient) {
0133: try {
0134: project.deleteParamInDBndModel(param);
0135: } catch (Exception e) {
0136: Tools.ihmExceptionView(e);
0137: annule = true;
0138: }
0139: }
0140: }
0141: return annule;
0142: }
0143:
0144: /**
0145: * Supprime les attachements de pWithAttachment qui sont présents dans le projet mais pas dans le documents
0146: * @param pDocElem
0147: * @param pWithAttachment
0148: * @return
0149: */
0150: boolean suppressionAttachment(Element pDocElem,
0151: WithAttachment pWithAttachment) {
0152: //suppression des attachements de l'environnement
0153: boolean appartient;
0154: List urlAttachementList = pDocElem
0155: .selectNodes("Attachements/UrlAttachement");
0156: List fileAttachementList = pDocElem
0157: .selectNodes("Attachements/FileAttachement");
0158: HashMap envMap = pWithAttachment.getAttachmentMapFromModel();
0159: ArrayList envMapToRemove = new ArrayList();
0160: Iterator itWithAttachmentMap = envMap.values().iterator();
0161: while (itWithAttachmentMap.hasNext()) {
0162: appartient = false;
0163: Attachment attach = (Attachment) itWithAttachmentMap.next();
0164:
0165: if (attach instanceof UrlAttachment) {
0166: UrlAttachment pUrlAttachment = (UrlAttachment) attach;
0167: Iterator itWithAttachmentUrlAttachXML = urlAttachementList
0168: .iterator();
0169: while (itWithAttachmentUrlAttachXML.hasNext()
0170: && appartient == false) {
0171: Element urlElem = (Element) itWithAttachmentUrlAttachXML
0172: .next();
0173: if (pUrlAttachment.getNameFromModel().equals(
0174: urlElem.attributeValue("url"))) {
0175: appartient = true;
0176: }
0177: }
0178: } else {
0179: FileAttachment pFileAttachment = (FileAttachment) attach;
0180: Iterator itEnvFileAttachXML = fileAttachementList
0181: .iterator();
0182: while (itEnvFileAttachXML.hasNext()
0183: && appartient == false) {
0184: Element fileElem = (Element) itEnvFileAttachXML
0185: .next();
0186: if (pFileAttachment.getNameFromModel().equals(
0187: fileElem.attributeValue("nom"))) {
0188: appartient = true;
0189: }
0190: }
0191: }
0192: if (!appartient) {
0193: envMapToRemove.add(attach);
0194: }
0195:
0196: }
0197: Iterator itMapRm = envMapToRemove.iterator();
0198: while (itMapRm.hasNext()) {
0199: Attachment attach = (Attachment) itMapRm.next();
0200: try {
0201: pWithAttachment.deleteAttachementInDBAndModel(attach);
0202: } catch (Exception e) {
0203: Tools.ihmExceptionView(e);
0204: //annule = true;
0205: }
0206: }
0207: return annule;
0208: }
0209:
0210: /**
0211: * Supprime les environnements qui sont présents dans le projet mais pas dans le documents
0212: * @return
0213: */
0214: boolean suppressionEnvironnement() {
0215: //suppressions des environnements
0216: ArrayList envList = (ArrayList) doc
0217: .selectNodes("//Environnement");
0218: ArrayList envInBDD = project.getEnvironmentListFromModel();
0219: Iterator itEnv = envInBDD.iterator();
0220:
0221: while (itEnv.hasNext() && !annule) {
0222: Environment env = (Environment) itEnv.next();
0223: Iterator itEnvXML = envList.iterator();
0224: Element envElem = null;
0225: boolean appartient = false;
0226: while (itEnvXML.hasNext() && !appartient) {
0227: envElem = (Element) itEnvXML.next();
0228: if (envElem.elementText("Nom").equals(
0229: env.getNameFromModel())) {
0230: appartient = true;
0231: }
0232: }
0233: if (!appartient) {
0234: try {
0235: project.deleteEnvironmentInDBandModel(env);
0236: } catch (Exception e) {
0237: Tools.ihmExceptionView(e);
0238: annule = true;
0239: }
0240: } else {
0241: //suppression paramètres valués dans l'environnement
0242: //int idEnv = env.getIdBdd();
0243: List paramEnvListXML = envElem
0244: .selectNodes("ValeurParams/ValeurParam");
0245: //ArrayList paramsToRemove = new ArrayList();
0246: Hashtable paramEnvList = env
0247: .getParametersHashTableFromModel();
0248: Enumeration enumEnv = paramEnvList.keys();
0249: while (enumEnv.hasMoreElements()) {
0250: appartient = false;
0251: Parameter paramEnv = (Parameter) enumEnv
0252: .nextElement();
0253: Iterator itParamEnvXML = paramEnvListXML.iterator();
0254: while (itParamEnvXML.hasNext()) {
0255: Element paramElem = (Element) itParamEnvXML
0256: .next();
0257: String nomParam = paramElem.elementText("Nom");
0258: if (paramEnv.getNameFromModel()
0259: .equals(nomParam)) {
0260: appartient = true;
0261: }
0262: }
0263: if (!appartient) {
0264: try {
0265: env.deleteDefParamInDBAndModel(paramEnv);
0266: } catch (Exception e) {
0267: Tools.ihmExceptionView(e);
0268: //annule = true;
0269: }
0270: }
0271: }
0272: //suppression du script de l'environnement
0273: Script script = env.getInitScriptFromModel();
0274: if (script != null) {
0275: if (envElem.element("Script") == null) {
0276: try {
0277: env.deleteScriptInDBAndModel();
0278: } catch (Exception e) {
0279: Tools.ihmExceptionView(e);
0280: //annule = true;
0281: }
0282: }
0283: }
0284: //suppression des attachements de l'environnement
0285: suppressionAttachment(envElem, env);
0286: }
0287: }
0288: return annule;
0289: }
0290:
0291: /**
0292: * Méthode qui supprime les actions d'un test manuel
0293: * @param test le test manuel concerné
0294: * @param testElem l'élément du document XML qui correspond au test
0295: */
0296: boolean supprimerActions(Element testElem, ManualTest test) {
0297: ArrayList actionList = test.getActionListFromModel(false);
0298: List actionListXML = testElem
0299: .selectNodes("TestManuel/ActionTest");
0300: ArrayList actionToRemove = new ArrayList();
0301: boolean appartient;
0302: Iterator itAction = actionList.iterator();
0303: while (itAction.hasNext()) {
0304: Action action = (Action) itAction.next();
0305: Element actionElem = null;
0306: appartient = false;
0307: Iterator itActionXML = actionListXML.iterator();
0308: while (itActionXML.hasNext() && !appartient) {
0309: actionElem = (Element) itActionXML.next();
0310: if (actionElem.elementText("Nom").equals(
0311: action.getNameFromModel())) {
0312: appartient = true;
0313: }
0314: }
0315: if (!appartient) {
0316: actionToRemove.add(action);
0317: } else {
0318: //gestion des paramètres des actions
0319: Hashtable actionParam = action
0320: .getParameterHashSetFromModel();
0321: Enumeration itParamAction = actionParam.elements();
0322: ArrayList paramActionToRemove = new ArrayList();
0323: while (itParamAction.hasMoreElements()) {
0324: Parameter param = (Parameter) itParamAction
0325: .nextElement();
0326: appartient = false;
0327: Iterator itParamActionXML = actionElem.selectNodes(
0328: "ParamsT/ParamT").iterator();
0329: while (itParamActionXML.hasNext()) {
0330: Element paramElem = (Element) itParamActionXML
0331: .next();
0332: String nomParam = paramElem.elementText("Nom");
0333: if (param.getNameFromModel().equals(nomParam)) {
0334: appartient = true;
0335: }
0336: }
0337: if (!appartient) {
0338: paramActionToRemove.add(param);
0339: }
0340: }
0341: Iterator itParamActionRm = paramActionToRemove
0342: .iterator();
0343: while (itParamActionRm.hasNext()) {
0344: Parameter param = (Parameter) itParamActionRm
0345: .next();
0346: try {
0347: action.deleteUseParamInDBAndModel(param);
0348: } catch (Exception e) {
0349: Tools.ihmExceptionView(e);
0350: }
0351: }
0352: //gestion des attachements des actions
0353: suppressionAttachment(actionElem, action);
0354: }
0355:
0356: }
0357: Iterator itActionRm = actionToRemove.iterator();
0358: while (itActionRm.hasNext()) {
0359: Action actionRm = (Action) itActionRm.next();
0360: try {
0361: test.deleteActionInDBModel(actionRm);
0362: } catch (Exception e) {
0363: Tools.ihmExceptionView(e);
0364: annule = true;
0365: return annule;
0366: }
0367: }
0368: return annule;
0369: }
0370:
0371: /**
0372: * Supprime les tests qui sont présents dans le projet mais pas dans le documents
0373: * @param suiteElem
0374: * @param suite
0375: * @return
0376: */
0377: boolean suppressionTest(Element suiteElem, TestList suite) {
0378: boolean appartient = false;
0379: ArrayList testList = suite.getTestListFromModel();
0380: ArrayList testToRm = new ArrayList();
0381: Iterator itTest = testList.iterator();
0382: while (itTest.hasNext() && !annule) {
0383: Test test = (Test) itTest.next();
0384: appartient = false;
0385: Element testElem = null;
0386: if (suiteElem != null) {
0387: Iterator itTestXML = suiteElem
0388: .selectNodes("Tests/Test").iterator();
0389: while (itTestXML.hasNext() && !appartient) {
0390: testElem = (Element) itTestXML.next();
0391: if (testElem.elementText("Nom").equals(
0392: test.getNameFromModel())) {
0393: if (isSelectionDesTests()) {
0394: Iterator itTestSelect = testSelectionList
0395: .iterator();
0396: boolean selectionneTest = false;
0397: while (itTestSelect.hasNext()) {
0398: Test testSelect = (Test) itTestSelect
0399: .next();
0400: if (testSelect
0401: .getNameFromModel()
0402: .equals(test.getNameFromModel())
0403: && testSelect
0404: .getTestListFromModel()
0405: .getNameFromModel()
0406: .equals(
0407: test
0408: .getTestListFromModel()
0409: .getNameFromModel())
0410: && testSelect
0411: .getTestListFromModel()
0412: .getFamilyFromModel()
0413: .getNameFromModel()
0414: .equals(
0415: test
0416: .getTestListFromModel()
0417: .getFamilyFromModel()
0418: .getNameFromModel())) {
0419: selectionneTest = true;
0420: }
0421: }
0422: if (selectionneTest) {
0423: appartient = true;
0424: }
0425: } else {
0426: appartient = true;
0427: }
0428: }
0429: }
0430: }
0431: if (!appartient) {
0432: testToRm.add(test);
0433: } else {
0434: //gestion des paramètres
0435: ArrayList paramTestList = test
0436: .getParameterListFromModel();
0437: List paramTestXML = testElem
0438: .selectNodes("ParamsT/ParamT");
0439: ArrayList paramTestToRemove = new ArrayList();
0440: Iterator itParamTest = paramTestList.iterator();
0441: while (itParamTest.hasNext()) {
0442: Parameter param = (Parameter) itParamTest.next();
0443: appartient = false;
0444: Iterator itParamTestXML = paramTestXML.iterator();
0445: while (itParamTestXML.hasNext()) {
0446: Element paramElem = (Element) itParamTestXML
0447: .next();
0448: String nomParam = paramElem.elementText("Nom");
0449: if (param.getNameFromModel().equals(nomParam)) {
0450: appartient = true;
0451: }
0452: }
0453: if (!appartient) {
0454: paramTestToRemove.add(param);
0455: }
0456: }
0457: Iterator itParamRm = paramTestToRemove.iterator();
0458: while (itParamRm.hasNext()) {
0459: Parameter param = (Parameter) itParamRm.next();
0460: try {
0461: test.deleteUseParamInDBAndModel(param);
0462: } catch (Exception e) {
0463: Tools.ihmExceptionView(e);
0464: }
0465: }
0466: //gestion des attachements
0467: suppressionAttachment(testElem, test);
0468:
0469: //si test automatique gestion du script
0470: if (test instanceof AutomaticTest) {
0471: Script script = ((AutomaticTest) test)
0472: .getScriptFromModel();
0473: if (script != null) {
0474: Element scriptElem = (Element) testElem
0475: .selectSingleNode("TestAuto/Script");
0476: if (scriptElem == null
0477: || !scriptElem
0478: .attributeValue("nom")
0479: .equals(
0480: script
0481: .getNameFromModel())) {
0482: try {
0483: ((AutomaticTest) test)
0484: .deleteScriptInDBAndModel();
0485: } catch (Exception e) {
0486: Tools.ihmExceptionView(e);
0487: }
0488: }
0489: }
0490: } else {
0491: if (idialog.isSupprAction()) {
0492: //si test manuel gestion des actions
0493: supprimerActions(testElem, (ManualTest) test);
0494: }
0495: }
0496: }
0497: }
0498: Iterator itTestRm = testToRm.iterator();
0499: while (itTestRm.hasNext() && !annule) {
0500: Test test = (Test) itTestRm.next();
0501: try {
0502: suite.deleteTestInDBAndModel(test);
0503: } catch (Exception e) {
0504: Tools.ihmExceptionView(e);
0505: annule = true;
0506: return annule;
0507: }
0508: }
0509: return annule;
0510: }
0511:
0512: /**
0513: * Supprime les suites qui sont présents dans le projet mais pas dans le documents
0514: * @param famElem
0515: * @param pFamily
0516: * @return
0517: */
0518: boolean suppressionSuite(Element famElem, Family pFamily) {
0519: //gestion des suites
0520: boolean appartient = false;
0521: ArrayList suiteList = pFamily.getSuiteListFromModel();
0522: ArrayList suiteToRemove = new ArrayList();
0523: Element suiteElem = null;
0524: List suiteListXML = famElem.selectNodes("SuiteTests/SuiteTest");
0525: Iterator itSuite = suiteList.iterator();
0526: while (itSuite.hasNext() && !annule) {
0527: TestList suite = (TestList) itSuite.next();
0528: appartient = false;
0529: Iterator itSuiteXML = suiteListXML.iterator();
0530: while (itSuiteXML.hasNext() && !appartient) {
0531: suiteElem = (Element) itSuiteXML.next();
0532: if (suiteElem.elementText("Nom").equals(
0533: suite.getNameFromModel())) {
0534: if (isSelectionDesTests()) {
0535: Iterator itSuiteSelect = suiteSelectionList
0536: .iterator();
0537: boolean selectionneSuite = false;
0538: while (itSuiteSelect.hasNext()) {
0539: TestList suiteSelect = (TestList) itSuiteSelect
0540: .next();
0541: if (suiteSelect.getNameFromModel().equals(
0542: suite.getNameFromModel())
0543: && suiteSelect
0544: .getFamilyFromModel()
0545: .getNameFromModel()
0546: .equals(
0547: suite
0548: .getFamilyFromModel()
0549: .getNameFromModel())) {
0550: selectionneSuite = true;
0551: }
0552: }
0553: if (selectionneSuite) {
0554: appartient = true;
0555: }
0556: } else {
0557: appartient = true;
0558: }
0559: }
0560: }
0561: if (!appartient) {
0562: suiteToRemove.add(suite);
0563: } else {
0564: //gestion de la suppression des attachements de la suite
0565: suppressionAttachment(suiteElem, suite);
0566: //on gère la suppression des tests appartenant à la suite
0567: suppressionTest(suiteElem, suite);
0568: }
0569: }
0570: Iterator itSuiteRm = suiteToRemove.iterator();
0571: while (itSuiteRm.hasNext() && !annule) {
0572: TestList suite = (TestList) itSuiteRm.next();
0573: try {
0574: project.deleteTestListInDBandModel(suite);
0575: } catch (Exception e) {
0576: Tools.ihmExceptionView(e);
0577: annule = true;
0578: return annule;
0579: }
0580: }
0581: return annule;
0582: }
0583:
0584: /**
0585: * Supprime les familles qui sont présents dans le projet mais pas dans le documents
0586: * @return
0587: */
0588: boolean suppressionFamily() {
0589: //suppression des familles
0590: ArrayList familleList = project.getFamilyListFromModel();
0591: ArrayList familleToRemove = new ArrayList();
0592: List familleListXML = doc.selectNodes("//Famille");
0593: Element famElem = null;
0594: Iterator itFamily = familleList.iterator();
0595: while (itFamily.hasNext() && !annule) {
0596: Family family = (Family) itFamily.next();
0597: boolean appartient = false;
0598: Iterator itFamXML = familleListXML.iterator();
0599: while (itFamXML.hasNext() && !appartient) {
0600: famElem = (Element) itFamXML.next();
0601: if (famElem.elementText("Nom").equals(
0602: family.getNameFromModel())) {
0603: if (isSelectionDesTests()) {
0604: Iterator itFamilleSelect = familySelectionList
0605: .iterator();
0606: boolean selectionneFamille = false;
0607: while (itFamilleSelect.hasNext()) {
0608: Family familleSelect = (Family) itFamilleSelect
0609: .next();
0610: if (familleSelect.getNameFromModel()
0611: .equals(family.getNameFromModel())) {
0612: selectionneFamille = true;
0613: }
0614: }
0615: if (selectionneFamille) {
0616: appartient = true;
0617: }
0618: } else {
0619: appartient = true;
0620: }
0621: }
0622: }
0623: if (!appartient) {
0624: familleToRemove.add(family);
0625: } else {
0626: //
0627: suppressionAttachment(famElem, family);
0628: //la famille appartient au document XML, gestion des suites
0629: suppressionSuite(famElem, family);
0630: }
0631: }
0632: Iterator itFamRm = familleToRemove.iterator();
0633: while (itFamRm.hasNext() && !annule) {
0634: Family family = (Family) itFamRm.next();
0635: try {
0636: project.deleteFamilyInDBAndModel(family);
0637: } catch (Exception e) {
0638: Tools.ihmExceptionView(e);
0639: annule = true;
0640: return annule;
0641: }
0642: }
0643: return annule;
0644: }
0645:
0646: /**
0647: * Méthode qui permet de supprimer les éléments qui sont dans le projet mais pas dans le document XML
0648: */
0649: public void gestionDesSuppressionsTests() throws Exception {
0650: //Suppression des paramètres du projet
0651: if (suppressionParameter()) {
0652: throw new Exception("[ImportAlgo->suppressionParameter]");
0653: }
0654:
0655: //suppressions des environnements
0656: if (suppressionEnvironnement()) {
0657: throw new Exception(
0658: "[ImportAlgo->suppressionEnvironnement]");
0659: }
0660:
0661: //suppression des familles
0662: if (suppressionFamily()) {
0663: throw new Exception("[ImportAlgo->suppressionFamily]");
0664: }
0665: }
0666:
0667: /**
0668: * Supprime les jeux de donnees qui sont présents dans le projet mais pas dans le documents
0669: * @param campElem
0670: * @param camp
0671: */
0672: void suppressionDataSet(Element campElem, Campaign camp) {
0673: ArrayList jeuxList = camp.getDataSetListFromModel();
0674: ArrayList jeuxToRemove = new ArrayList();
0675: List jeuxListXML = campElem
0676: .selectNodes("JeuxDonnees/JeuDonnees");
0677: Element jeuElem = null;
0678: Iterator itJeu = jeuxList.iterator();
0679: boolean appartient;
0680: while (itJeu.hasNext()) {
0681: DataSet jeu = (DataSet) itJeu.next();
0682: appartient = false;
0683: Iterator itJeuXML = jeuxListXML.iterator();
0684: while (itJeuXML.hasNext()) {
0685: jeuElem = (Element) itJeuXML.next();
0686: if (jeuElem.elementText("Nom").equals(
0687: jeu.getNameFromModel())) {
0688: appartient = true;
0689: }
0690: }
0691: if (!appartient) {
0692: jeuxToRemove.add(jeu);
0693: }
0694: }
0695: Iterator itJeuRm = jeuxToRemove.iterator();
0696: while (itJeuRm.hasNext()) {
0697: DataSet jeuRm = (DataSet) itJeuRm.next();
0698: try {
0699: camp.deleteDataSetInDBAndModel(jeuRm);
0700: } catch (Exception e) {
0701: Tools.ihmExceptionView(e);
0702: }
0703: }
0704: }
0705:
0706: /**
0707: * Supprime les tests d'une campagne qui sont présents dans le projet mais pas dans le documents
0708: * @param campElem
0709: * @param camp
0710: */
0711: void suppressionTestInCamp(Element campElem, Campaign camp) {
0712: ArrayList testList = camp.getTestListFromModel();
0713: ArrayList testToRemove = new ArrayList();
0714: List testListXML = campElem
0715: .selectNodes("FamillesCamp/FamilleRef/SuiteTestsCamp/SuiteTestRef/TestsCamp/TestRef");
0716: Element testElem = null;
0717: Iterator itTest = testList.iterator();
0718: boolean appartient;
0719: while (itTest.hasNext()) {
0720: Test test = (Test) itTest.next();
0721: String suiteName = test.getTestListFromModel()
0722: .getNameFromModel();
0723: String familyName = test.getTestListFromModel()
0724: .getFamilyFromModel().getNameFromModel();
0725: appartient = false;
0726: Iterator itTestXML = testListXML.iterator();
0727: while (itTestXML.hasNext() && !appartient) {
0728: testElem = (Element) itTestXML.next();
0729: String nomSuite = ((Element) testElem
0730: .selectSingleNode("ancestor::SuiteTestRef[1]"))
0731: .elementText("Nom");
0732: String nomFamille = ((Element) testElem
0733: .selectSingleNode("ancestor::FamilleRef[1]"))
0734: .elementText("Nom");
0735: String nomTest = testElem.elementText("Nom");
0736: if (test.getNameFromModel().equals(nomTest)
0737: && suiteName.equals(nomSuite)
0738: && familyName.equals(nomFamille)) {
0739: appartient = true;
0740: }
0741: }
0742: if (!appartient) {
0743: testToRemove.add(test);
0744: }
0745: }
0746: Iterator itTestRm = testToRemove.iterator();
0747: while (itTestRm.hasNext()) {
0748: Test testRm = (Test) itTestRm.next();
0749: try {
0750: camp.deleteTestFromCampInDBAndModel(testRm, true);
0751: } catch (Exception e) {
0752: Tools.ihmExceptionView(e);
0753: }
0754: }
0755: }
0756:
0757: /**
0758: * Supprime les executions d'une campagne qui sont présents dans le projet mais pas dans le documents
0759: * @param campElem
0760: * @param camp
0761: */
0762: void suppressionExecInCamp(Element campElem, Campaign camp) {
0763: ArrayList execList = camp.getExecutionListFromModel();
0764: ArrayList execToRemove = new ArrayList();
0765: List execListXML = campElem
0766: .selectNodes("ExecCampTests/ExecCampTest");
0767: Element execElem = null;
0768: Iterator itExec = execList.iterator();
0769: boolean appartient;
0770: while (itExec.hasNext() && !annule) {
0771: Execution exec = (Execution) itExec.next();
0772: String execName = exec.getNameFromModel();
0773: appartient = false;
0774: Iterator itExecXML = execListXML.iterator();
0775: while (itExecXML.hasNext() && !appartient) {
0776: execElem = (Element) itExecXML.next();
0777: String nomExec = execElem.elementText("Nom");
0778: if (nomExec.equals(execName)) {
0779: appartient = true;
0780: }
0781: }
0782: if (!appartient) {
0783: execToRemove.add(exec);
0784: } else {
0785: //suppression des résultats d'exécution
0786: ArrayList resExecList = exec
0787: .getExecutionResultListFromModel();
0788: ArrayList resExecToRemove = new ArrayList();
0789: List resExecListXML = execElem
0790: .selectNodes("ResulExecCampTests/ResulExecCampTest");
0791: Element resExecElem = null;
0792: Iterator itResExec = resExecList.iterator();
0793: while (itResExec.hasNext()) {
0794: ExecutionResult resExec = (ExecutionResult) itResExec
0795: .next();
0796: String resExecName = resExec.getNameFromModel();
0797: appartient = false;
0798: Iterator itResExecXML = resExecListXML.iterator();
0799: while (itResExecXML.hasNext() && !appartient) {
0800: resExecElem = (Element) itResExecXML.next();
0801: String nomResExec = resExecElem
0802: .elementText("Nom");
0803: if (nomResExec.equals(resExecName)) {
0804: appartient = true;
0805: }
0806: }
0807: if (!appartient) {
0808: resExecToRemove.add(resExec);
0809: }
0810: }
0811: Iterator itResExecRm = resExecToRemove.iterator();
0812: while (itResExecRm.hasNext()) {
0813: ExecutionResult resExecRm = (ExecutionResult) itResExecRm
0814: .next();
0815: try {
0816: exec
0817: .deleteExecutionResultInDBAndModel(resExecRm);
0818: } catch (Exception e) {
0819: Tools.ihmExceptionView(e);
0820: }
0821: }
0822: }
0823: }
0824: Iterator itExecRm = execToRemove.iterator();
0825: while (itExecRm.hasNext() && !annule) {
0826: Execution execRm = (Execution) itExecRm.next();
0827: try {
0828: camp.deleteExecutionInDBAndModel(execRm);
0829: } catch (Exception e) {
0830: Tools.ihmExceptionView(e);
0831: }
0832: }
0833: }
0834:
0835: /**
0836: * Supprime les campagnes qui sont présents dans le projet mais pas dans le documents
0837: * @throws Exception
0838: */
0839: public void gestionDesSuppressionsCampagnes() throws Exception {
0840: ArrayList campList = project.getCampaignListFromModel();
0841: ArrayList campToRemove = new ArrayList();
0842: List campListXML = doc.selectNodes("//CampagneTest");
0843: Element campElem = null;
0844: Iterator itCamp = campList.iterator();
0845: while (itCamp.hasNext() && !annule) {
0846: Campaign camp = (Campaign) itCamp.next();
0847: boolean appartient = false;
0848: Iterator itCampXML = campListXML.iterator();
0849: while (itCampXML.hasNext() && !appartient) {
0850: campElem = (Element) itCampXML.next();
0851: if (campElem.elementText("Nom").equals(
0852: camp.getNameFromModel())) {
0853: appartient = true;
0854: }
0855: }
0856: if (!appartient) {
0857: campToRemove.add(camp);
0858: } else {
0859: //suppression des jeux de données
0860: suppressionDataSet(campElem, camp);
0861:
0862: //suppression des attachements des campagnes
0863: suppressionAttachment(campElem, camp);
0864:
0865: //suppression Tests
0866: suppressionTestInCamp(campElem, camp);
0867:
0868: //suppression Exécutions -> suppression résultats d'exécution
0869: suppressionExecInCamp(campElem, camp);
0870: }
0871: }
0872: Iterator itCampRm = campToRemove.iterator();
0873: while (itCampRm.hasNext() && !annule) {
0874: Campaign campRm = (Campaign) itCampRm.next();
0875: try {
0876: project.deleteCampaignInDBAndModel(campRm);
0877: } catch (Exception e) {
0878: Tools.ihmExceptionView(e);
0879: throw e;
0880: }
0881: }
0882: }
0883:
0884: /**
0885: * Méthode qui supprime les campagnes lorsque l'utilisateur ne veut importer que les tests
0886: */
0887: public void suppressionsCampagnes() {
0888: ArrayList campList = project.getCampaignListFromModel();
0889: ArrayList campToRemove = new ArrayList();
0890: Iterator itCamp = campList.iterator();
0891: while (itCamp.hasNext() && !annule) {
0892: Campaign camp = (Campaign) itCamp.next();
0893: campToRemove.add(camp);
0894: }
0895: Iterator itCampRm = campToRemove.iterator();
0896: while (itCampRm.hasNext() && !annule) {
0897: Campaign campRm = (Campaign) itCampRm.next();
0898: try {
0899: project.deleteCampaignInDBAndModel(campRm);
0900: } catch (Exception e) {
0901: // TODO
0902: }
0903: }
0904: }
0905:
0906: public void gestionDesSuppressionsProject() {
0907: List projectList = doc.selectNodes("//ProjetVT");
0908: Element projElem = null;
0909: Iterator itProj = projectList.iterator();
0910: while (itProj.hasNext()) {
0911: projElem = (Element) itProj.next();
0912: suppressionAttachment(projElem, project);
0913: }
0914: }
0915:
0916: /************************* UPADATE ***************************************************/
0917:
0918: void updateProjectAttachement() throws Exception {
0919: ArrayList projectList = (ArrayList) doc
0920: .selectNodes("//ProjetVT");
0921: Iterator itProject = projectList.iterator();
0922: while (itProject.hasNext()) {
0923: Element projectElem = (Element) itProject.next();
0924: updateElementAttachement(projectElem, project, false);
0925: }
0926: }
0927:
0928: void updateProjectParameter() throws Exception {
0929: ArrayList paramList = (ArrayList) doc.selectNodes("//Param");
0930: Iterator itParam = paramList.iterator();
0931: while (itParam.hasNext() && !annule) {
0932: Element paramElem = (Element) itParam.next();
0933: String nomParam = paramElem.elementText("Nom");
0934: String descriptionParam = (paramElem
0935: .elementText("Description") == null) ? ""
0936: : paramElem.elementText("Description");
0937: descriptionParam = descriptionParam.replaceAll("\\\\n",
0938: "\n");
0939: Parameter newParamter = new Parameter(nomParam,
0940: descriptionParam);
0941: boolean existe = false;
0942: Parameter par = null;
0943: Enumeration itParam2 = project.getParameterSetFromModel()
0944: .elements();
0945: while (itParam2.hasMoreElements() && !existe) {
0946: par = (Parameter) itParam2.nextElement();
0947: if (par.getNameFromModel().equals(nomParam)) {
0948: existe = true;
0949: }
0950: }
0951: if (!existe) {
0952: //Ajout du nouveau parametre
0953: project.addParameterToDBAndModel(newParamter);
0954: } else {
0955: //Modification du parametre
0956: par.updateDescriptionInDBAndModel(descriptionParam);
0957: }
0958: }
0959: }
0960:
0961: /* String getParentElement(Hashtable docReqById, Integer id_reqParent){
0962:
0963: Element reqElem = (Element)docReqById.get(id_reqParent);
0964: }
0965: */
0966: void updateProjectEnvironment() throws Exception {
0967: //Environnements du projet
0968: Element paramsElem = (Element) doc.selectSingleNode("//Params");
0969: ArrayList envList = (ArrayList) doc
0970: .selectNodes("//Environnement");
0971: ArrayList envInBDD = project.getEnvironmentListFromModel();
0972: Iterator itEnv = envList.iterator();
0973: while (itEnv.hasNext() && !annule) {
0974: Element envElem = (Element) itEnv.next();
0975: String nomEnv = envElem.elementText("Nom");
0976: String descriptionEnv = (envElem.elementText("Description") == null) ? ""
0977: : envElem.elementText("Description");
0978: descriptionEnv = descriptionEnv.replaceAll("\\\\n", "\n");
0979: Iterator itEnvBDD = envInBDD.iterator();
0980: Environment env = null;
0981: boolean existeEnv = false;
0982: while (itEnvBDD.hasNext() && !existeEnv) {
0983: env = (Environment) itEnvBDD.next();
0984: if (env.getNameFromModel().equals(nomEnv)) {
0985: existeEnv = true;
0986: }
0987: }
0988: boolean newEnv = false;
0989: if (!existeEnv) {
0990: env = null;
0991: env = new Environment(nomEnv, descriptionEnv);
0992: project.addEnvironmentInDBAndModel(env);
0993: newEnv = true;
0994: } else {
0995: env.updateInDBAndModel(nomEnv, descriptionEnv);
0996: }
0997: // Valeurs des paramètres
0998: List paramEnvList = envElem
0999: .selectNodes("ValeurParams/ValeurParam");
1000: Iterator itParamEnv = paramEnvList.iterator();
1001: while (itParamEnv.hasNext()) {
1002: Element paramElem = (Element) itParamEnv.next();
1003: String valeurParam = (paramElem
1004: .attributeValue("valeur") != null) ? paramElem
1005: .attributeValue("valeur") : "";
1006: String id_paramDoc = paramElem.attributeValue("ref");
1007: Element paramRootElem = (Element) paramsElem
1008: .selectSingleNode("Param[@id_param = '"
1009: + id_paramDoc + "']");
1010: String nomParam = paramRootElem.elementText("Nom");
1011: //String descriptionParam = (paramRootElem.elementText("Description") == null)?"":paramRootElem.elementText("Description");
1012: boolean existe = false;
1013: Parameter paramEnv = null;
1014: if (env != null && newEnv == false) {
1015: Hashtable paramEnvInBDD = env
1016: .getParametersHashTableFromModel();
1017: Enumeration enumParamEnv = paramEnvInBDD.keys();
1018: while (enumParamEnv.hasMoreElements() && !existe) {
1019: paramEnv = (Parameter) enumParamEnv
1020: .nextElement();
1021: if (nomParam
1022: .equals(paramEnv.getNameFromModel())) {
1023: existe = true;
1024: }
1025: }
1026: }
1027: if (!existe) {
1028: paramEnv = project.getParameterFromModel(nomParam);
1029: if (paramEnv != null) {
1030: env.addParameterValueInDBModel(paramEnv,
1031: valeurParam);
1032: }
1033: } else {
1034: env.addParameterValueInDBModel(paramEnv,
1035: valeurParam);
1036: }
1037: }
1038: //Ajout ou mise à jour du script de l'environnement
1039: if (envElem.element("Script") != null) {
1040: String classpath = envElem.element("Script")
1041: .elementText("Classpath");
1042: String argScript = envElem.element("Script")
1043: .elementText("ArgScript");
1044: String type = envElem.element("Script").attributeValue(
1045: "type");
1046: String dirScript = envElem.element("Script")
1047: .attributeValue("dir");
1048: dirScript = restorePath(dirScript);
1049: File fScript = new File(dirXml + fs + dirScript);
1050:
1051: Script pScritp = new Script(fScript.getName(), "");
1052: pScritp.setTypeInModel(type);
1053: pScritp.setScriptExtensionInModel(classpath);
1054: pScritp.updatePlugArgInModel(argScript);
1055: try {
1056: if (newEnv == true) {
1057: env.addScriptInDBAndModel(pScritp, fScript);
1058: } else {
1059: env.deleteScriptInDBAndModel();
1060: env.addScriptInDBAndModel(pScritp, fScript);
1061: }
1062: } catch (Exception e) {
1063: Tools.ihmExceptionView(e);
1064: }
1065: }
1066: updateElementAttachement(envElem, env, newEnv);
1067: }
1068: }
1069:
1070: void updateElementAttachement(Element envElem,
1071: WithAttachment simpleElement, boolean newElement) {
1072: try {
1073: //URL
1074: List urlAttachementList = envElem
1075: .selectNodes("Attachements/UrlAttachement");
1076: Iterator itEnvUrlAttach = urlAttachementList.iterator();
1077: while (itEnvUrlAttach.hasNext()) {
1078: Element urlElem = (Element) itEnvUrlAttach.next();
1079: String url = urlElem.attributeValue("url");
1080: String description = (urlElem
1081: .elementText("Description") == null) ? ""
1082: : urlElem.elementText("Description");
1083: description = description.replaceAll("\\\\n", "\n");
1084: boolean appartient = false;
1085: Attachment attach = null;
1086: if (newElement == false) {
1087: HashMap envMap = simpleElement
1088: .getAttachmentMapFromModel();
1089: Iterator itEnvAttachs = envMap.values().iterator();
1090: while (itEnvAttachs.hasNext() && !appartient) {
1091: attach = (Attachment) itEnvAttachs.next();
1092: if ((attach instanceof UrlAttachment)
1093: && ((UrlAttachment) attach)
1094: .getNameFromModel().equals(url)) {
1095: appartient = true;
1096: }
1097: }
1098: }
1099: if (!appartient) {
1100: simpleElement
1101: .addAttachementInDBAndModel(new UrlAttachment(
1102: url, description));
1103: } else {
1104: ((UrlAttachment) attach)
1105: .updateDescriptionInDBdAndModel(description);
1106: }
1107: }
1108: //fichiers
1109: List envFileAttachementList = envElem
1110: .selectNodes("Attachements/FileAttachement");
1111: Iterator itEnvFileAttach = envFileAttachementList
1112: .iterator();
1113: while (itEnvFileAttach.hasNext()) {
1114: Element fileElem = (Element) itEnvFileAttach.next();
1115: String dirAtt = fileElem.attributeValue("dir");
1116: String nom = fileElem.attributeValue("nom");
1117: dirAtt = restorePath(dirAtt);
1118: File f = new File(dirXml + fs + dirAtt);
1119: String description = (fileElem
1120: .elementText("Description") == null) ? ""
1121: : fileElem.elementText("Description");
1122: description = description.replaceAll("\\\\n", "\n");
1123: boolean appartient = false;
1124: Attachment attach = null;
1125: if (newElement == false) {
1126: HashMap envMap = simpleElement
1127: .getAttachmentMapFromModel();
1128: Iterator itEnvAttachs = envMap.values().iterator();
1129: while (itEnvAttachs.hasNext() && !appartient) {
1130: attach = (Attachment) itEnvAttachs.next();
1131: if ((attach instanceof FileAttachment)
1132: && ((FileAttachment) attach)
1133: .getNameFromModel().equals(nom)) {
1134: appartient = true;
1135: }
1136: }
1137: }
1138: if (!appartient) {
1139: attach = new FileAttachment(f, description);
1140: simpleElement.addAttachementInDBAndModel(attach);
1141: } else {
1142: ((FileAttachment) attach).updateInDBAndModel(f);
1143: ((FileAttachment) attach)
1144: .updateDescriptionInDBdAndModel(description);
1145: }
1146:
1147: }
1148: } catch (Exception e) {
1149: e.printStackTrace();
1150: if (!idialog.isRecupAttachPb()) {
1151: idialog
1152: .setErrorMessage(idialog.getErrorMessage()
1153: + Language
1154: .getInstance()
1155: .getText(
1156: "Problème_lors_de_la_récupération_des_attachements"));
1157: idialog.setRecupAttachPb(true);
1158: }
1159: idialog.showErrorMessage();
1160: }
1161: }
1162:
1163: /**
1164: * Dans le cas où le test était déjà dans la BD, ajout des paramètres
1165: * @param test le test concerné
1166: * @param testElem élément qui représente le test dans le document XML
1167: * @param id_test identifiant du test qui a été ajouté à la BD
1168: */
1169: public void updateParametresTest(Element testElem, Test test) {
1170: //on ajoute les paramètres que si ils n'existent pas déjà dans la bd
1171: List paramList = testElem.selectNodes("ParamsT/ParamT/Nom");
1172: Iterator itParam = paramList.iterator();
1173: while (itParam.hasNext()) {
1174: String nomParam = ((Element) itParam.next()).getText();
1175: boolean appartient = false;
1176: Parameter param = null;
1177: if (test != null) {
1178: ArrayList paramListBDD = test
1179: .getParameterListFromModel();
1180: Iterator itparam = paramListBDD.iterator();
1181: while (itparam.hasNext() && !appartient) {
1182: param = (Parameter) itparam.next();
1183: if (param.getNameFromModel().equals(nomParam)) {
1184: appartient = true;
1185: }
1186: }
1187: }
1188: try {
1189: if (!appartient) {
1190: param = project.getParameterFromModel(nomParam);
1191: if (param != null) {
1192: test.setUseParamInDBAndModel(param);
1193: } else {
1194: //AIE
1195: }
1196: }
1197: } catch (Exception e) {
1198: Tools.ihmExceptionView(e);
1199: }
1200: }
1201: }
1202:
1203: /**
1204: * Méthode qui vérifie que tous les paramètres d'un test manuel sont bien utilisés, sinon elle les supprime
1205: * @param test le test manuel concerné
1206: */
1207: public void verifUtilisationParams(ManualTest test) {
1208: ArrayList listParams = test.getParameterListFromModel();
1209: ArrayList paramToRemove = new ArrayList();
1210: Iterator itParam = listParams.iterator();
1211: while (itParam.hasNext()) {
1212: Parameter param = (Parameter) itParam.next();
1213: boolean appartient = false;
1214: ArrayList listActions = test.getActionListFromModel(false);
1215: Iterator itAction = listActions.iterator();
1216: while (itAction.hasNext()) {
1217: Action action = (Action) itAction.next();
1218: Hashtable paramActionSet = action
1219: .getParameterHashSetFromModel();
1220: Enumeration itParamAction = paramActionSet.elements();
1221: while (itParamAction.hasMoreElements()) {
1222: Parameter paramAction = (Parameter) itParamAction
1223: .nextElement();
1224: if (param.getNameFromModel().equals(
1225: paramAction.getNameFromModel())) {
1226: appartient = true;
1227: }
1228: }
1229: }
1230: if (!appartient) {
1231: paramToRemove.add(param);
1232: }
1233: }
1234: if (!paramToRemove.isEmpty()) {
1235: Iterator paramRm = paramToRemove.iterator();
1236: while (paramRm.hasNext()) {
1237: Parameter param = (Parameter) paramRm.next();
1238: try {
1239: //test.deleteUseParamFromDB(param);
1240: test.deleteUseParamInDBAndModel(param);
1241: } catch (Exception e) {
1242: /* TODO */
1243: }
1244: }
1245: }
1246: }
1247:
1248: /**
1249: * Dans le cas où le test était déjà dans la BD, ajout ou mise à jour du script
1250: * @param familyName nom de la famille auquelle appartient le test
1251: * @param suiteName nom de la suite auquelle appartient le test
1252: * @param testElem élément qui représente le test dans le document XML
1253: * @param id_test identifiant du test qui a été ajouté à la BD
1254: */
1255: public void updateTestScript(Element testElem, AutomaticTest test) {
1256: Element scriptElem = (Element) testElem
1257: .selectSingleNode("TestAuto/Script");
1258: try {
1259: if (scriptElem != null) {
1260: String classpath = scriptElem.elementText("Classpath");
1261: String argScript = scriptElem.elementText("ArgScript");
1262: String type = scriptElem.attributeValue("type");
1263: String dirScript = scriptElem.attributeValue("dir");
1264: dirScript = restorePath(dirScript);
1265: File fScript = new File(dirXml + fs + dirScript);
1266: //Script fileScript = null;
1267:
1268: Script pScritp = new Script(fScript.getName(), "");
1269: pScritp.setTypeInModel(type);
1270: pScritp.setScriptExtensionInModel(classpath);
1271: pScritp.updatePlugArgInModel(argScript);
1272:
1273: if (test != null) {
1274: if (test.getScriptFromModel() != null) {
1275: test.deleteScriptInDBAndModel();
1276: }
1277:
1278: }
1279: test.addScriptInDBAndModel(pScritp, fScript);
1280:
1281: } else {
1282: if (test.getScriptFromModel() != null) {
1283: test.deleteScriptInDBAndModel();
1284: }
1285: }
1286: } catch (Exception e) {
1287: e.printStackTrace();
1288: idialog
1289: .setErrorMessage(idialog.getErrorMessage()
1290: + Language
1291: .getInstance()
1292: .getText(
1293: "Problème_lors_de_la_suppression_d'un_script"));
1294: idialog.showErrorMessage();
1295: }
1296: }
1297:
1298: /**
1299: * Gérer l'insertion, la mise à jour des tests lors de l'import de données
1300: * @param id_famille identifiant de la famille auquelle appartiennent les tests
1301: * @param suite suite auquel appartiennent les tests
1302: * @param id_suite identifiant de la suite auquelle les tests appartiennent
1303: * @param suiteName, nom de la suite qui contient les test
1304: * @param familyName nom de la famille qui contien les tests
1305: * @param testList liste des tests dans le document
1306: */
1307: public void updateTests(Element suiteElem, Family fam,
1308: TestList suite, boolean newFamily, boolean newSuite) {
1309: //ArrayList testAuto,
1310: ArrayList testList = (ArrayList) suiteElem
1311: .selectNodes(".//Test");
1312: if (testList == null) {
1313: return;
1314: }
1315:
1316: Iterator it = testList.iterator();
1317: while (it.hasNext() && !annule) {
1318: try {
1319: if (!newProject) {
1320: idialog.setConflit(false);
1321: }
1322: Element testElem = (Element) it.next();
1323: String testName = testElem.elementText("Nom");
1324: boolean newTest = false;
1325: boolean selectionneTest = false;
1326: if (isSelectionDesTests()) {
1327: Iterator itTest = testSelectionList.iterator();
1328: while (itTest.hasNext()) {
1329: Test test = (Test) itTest.next();
1330: if (testName.equals(test.getNameFromModel())) {
1331: selectionneTest = true;
1332: }
1333: }
1334: }
1335: if (!isSelectionDesTests() || selectionneTest) {
1336: //Vérification de l'existence ou non du test
1337: boolean appartient = false;
1338: Test test = null;
1339: if (suite != null) {
1340: ArrayList testListBDD = suite
1341: .getTestListFromModel();
1342: Iterator itTest = testListBDD.iterator();
1343: while (itTest.hasNext() && !appartient) {
1344: test = (Test) itTest.next();
1345: if (test.getNameFromModel()
1346: .equals(testName)) {
1347: appartient = true;
1348: }
1349: }
1350: }
1351: //récupération des données dans le document
1352: String loginConceptor = "";
1353: //User pUser;
1354: if (!appartient) {
1355: loginConceptor = getLogin(testElem);
1356: if (loginConceptor == null) {
1357: if (!newProject) {
1358: loginConceptor = DataModel
1359: .getCurrentUser()
1360: .getLoginFromModel();
1361: } else {
1362: loginConceptor = project
1363: .getAdministratorFromModel()
1364: .getLoginFromModel();
1365: }
1366: }
1367: } else {
1368: loginConceptor = test
1369: .getConceptorLoginFromModel();
1370: }
1371: String testDescription = (testElem
1372: .elementText("Description") == null) ? ""
1373: : testElem.elementText("Description");
1374: testDescription = testDescription.replaceAll(
1375: "\\\\n", "\n");
1376: String poids = testElem.attributeValue("poids");
1377: String testType;
1378: String plug_ext;
1379: if (testElem.element("TestAuto") == null) {
1380: testType = "MANUAL";
1381: plug_ext = "";
1382: } else {
1383: testType = "AUTOMATED";
1384: String plug = testElem.element("TestAuto")
1385: .attributeValue("plug_ext");
1386: if (plug != null) {
1387: plug_ext = plug;
1388: } else {
1389: plug_ext = "";
1390: }
1391: }
1392: if (!appartient) {
1393: newTest = true;
1394: if (testType.equals("AUTOMATED")) {
1395: test = new AutomaticTest(testName,
1396: testDescription, plug_ext);
1397: } else {
1398: test = new ManualTest(testName,
1399: testDescription);
1400: }
1401: test.setConceptorLoginInModel(loginConceptor);
1402: suite.addTestInDBAndModel(test);
1403:
1404: //update poids
1405: //majPoids(test.getIdBdd(), poids);
1406: updateElementAttachement(testElem, test,
1407: newTest);
1408:
1409: updateParametresTest(testElem, test);
1410:
1411: if (testType == "AUTOMATED") {
1412: updateTestScript(testElem,
1413: (AutomaticTest) test);
1414: /*int [] tab = {fam.getIdBdd(), suite.getIdBdd(), test.getIdBdd()};
1415: testAuto.add(tab);*/
1416: automatedTest2Update.add(test);
1417: } else {
1418: ajouterActions(testElem, (ManualTest) test);
1419: }
1420: if (pImportReq != null) {
1421: pImportReq.updateReqLink(testElem, test,
1422: idialog.isSupprElement());
1423: }
1424:
1425: } else {
1426: //Vérification de l'existence ou non d'un conflit (i.e: si le test est déja exécuté)
1427: ArrayList campaignList = project
1428: .getCampaignOfTest(test);
1429: if (!campaignList.isEmpty()) {
1430: Iterator itCamp = campaignList.iterator();
1431: while (itCamp.hasNext()
1432: && !idialog.isConflit()) {
1433: Campaign camp = (Campaign) itCamp
1434: .next();
1435: if (!camp.getExecutionListFromModel()
1436: .isEmpty()) {
1437: idialog.setConflit(true);
1438: }
1439: }
1440: }
1441: if (idialog.isConflit()) {
1442: idialog.setExisteModif(detecterModif(fam,
1443: suite, testElem));
1444: }
1445: if (idialog.isConflit()
1446: && idialog.isExisteModif()
1447: && idialog.isCreer_copy()) {
1448: //création d'un nouveau test avec nom précédé de "copy_" lorsqu'il y a un conflit
1449: //Test testExiste = TestPlanData.getTest(familyName, suiteName, "copy_"+testName);
1450: String newName = "copy_" + testName;
1451: Test testExiste = project.getTestFromModel(
1452: fam.getNameFromModel(), suite
1453: .getNameFromModel(),
1454: newName);
1455: if (testExiste != null) {
1456: int num = 1;
1457: while (testExiste != null && num < 101) {
1458: newName = "copy_" + num + testName;
1459: testExiste = project
1460: .getTestFromModel(
1461: fam
1462: .getNameFromModel(),
1463: suite
1464: .getNameFromModel(),
1465: "copy_" + newName);
1466: num++;
1467: }
1468: if (testExiste != null) {
1469: suite
1470: .deleteTestInDBAndModel(testExiste);
1471: }
1472: }
1473:
1474: newTest = true;
1475: if (testType.equals("AUTOMATED")) {
1476: test = new AutomaticTest(newName,
1477: testDescription, plug_ext);
1478: } else {
1479: test = new ManualTest(newName,
1480: testDescription);
1481: }
1482: test.setConceptorLoginInModel(DataModel
1483: .getCurrentUser()
1484: .getLoginFromModel());
1485: suite.addTestInDBAndModel(test);
1486:
1487: //update poids
1488: //majPoids(test.getIdBdd(), poids);
1489: ajouterAttachements(testElem, test);
1490: updateParametresTest(testElem, test);
1491:
1492: if (testType == "AUTOMATED") {
1493: updateTestScript(testElem,
1494: (AutomaticTest) test);
1495: Util
1496: .log("[ImportDialog] Add test auto "
1497: + test);
1498: //int [] tab = {fam.getIdBdd(), suite.getIdBdd(), test.getIdBdd()};
1499: //testAuto.add(tab);
1500: automatedTest2Update.add(test);
1501: } else {
1502: ajouterActions(testElem,
1503: (ManualTest) test);
1504: }
1505: if (pImportReq != null) {
1506: pImportReq.updateReqLink(testElem,
1507: test, idialog.isSupprElement());
1508: }
1509: }
1510: if (!idialog.isConflit()) {
1511: //on effectue toutes les mises à jour nécessaires
1512: test.updateInDBAndModel(testName,
1513: testDescription);
1514: //majPoids(test.getIdBdd(), poids);
1515:
1516: updateElementAttachement(testElem, test,
1517: newTest);
1518:
1519: updateParametresTest(testElem, test);
1520:
1521: if (testType == "AUTOMATED") {
1522: updateTestScript(testElem,
1523: (AutomaticTest) test);
1524: int[] tab = { fam.getIdBdd(),
1525: suite.getIdBdd(),
1526: test.getIdBdd() };
1527: //testAuto.add(tab);
1528: automatedTest2Update.add(test);
1529: } else {
1530: if (idialog.isSupprAction()) {
1531: supprimerActions(testElem,
1532: (ManualTest) test);
1533: verifUtilisationParams((ManualTest) test);
1534: }
1535: updateAction(testElem,
1536: (ManualTest) test, false);
1537: }
1538: if (pImportReq != null) {
1539: pImportReq.updateReqLink(testElem,
1540: test, idialog.isSupprElement());
1541: }
1542: }
1543: if (idialog.isConflit()
1544: && idialog.isExisteModif()
1545: && idialog.isMajPossible()) {
1546: //dans ce cas, il y a conflit et on doit faire la mise à jour des éléments qui sont possibles (Attachements tests et actions, description test, script tests automatiques)
1547: test.updateInModel(testName,
1548: testDescription);
1549: updateElementAttachement(testElem, test,
1550: newTest);
1551: if (testType == "AUTOMATED") {
1552: updateTestScript(testElem,
1553: (AutomaticTest) test);
1554: Util
1555: .log("[ImportDialog] Add test auto "
1556: + test.getIdBdd());
1557: //int [] tab = {fam.getIdBdd(), suite.getIdBdd(), test.getIdBdd()};
1558: //testAuto.add(tab);
1559: automatedTest2Update.add(test);
1560: } else {
1561: if (idialog.isSupprAction()) {
1562: supprimerActions(testElem,
1563: (ManualTest) test);
1564: verifUtilisationParams((ManualTest) test);
1565: }
1566: updateAction(testElem,
1567: (ManualTest) test, true);
1568: }
1569: if (pImportReq != null) {
1570: pImportReq.updateReqLink(testElem,
1571: test, idialog.isSupprElement());
1572: }
1573: }
1574: }
1575: }
1576: } catch (Exception e) {
1577: Tools.ihmExceptionView(e);
1578: }
1579: }
1580: }
1581:
1582: void updateSuite(Element familyElem, Family pFamily,
1583: boolean newFamily) {
1584: ArrayList suiteList = (ArrayList) familyElem
1585: .selectNodes(".//SuiteTest");
1586: if (suiteList != null) {
1587: Iterator it2 = suiteList.iterator();
1588: while (it2.hasNext() && !annule) {
1589: Element suiteElem = (Element) it2.next();
1590: String suiteName = suiteElem.elementText("Nom");
1591: String suiteDescription = (suiteElem
1592: .elementText("Description") == null) ? ""
1593: : suiteElem.elementText("Description");
1594: suiteDescription = suiteDescription.replaceAll("\\\\n",
1595: "\n");
1596: boolean erreur = false;
1597: boolean selectionneSuite = false;
1598: if (isSelectionDesTests()) {
1599: Iterator itSuite = suiteSelectionList.iterator();
1600: while (itSuite.hasNext()) {
1601: TestList suite = (TestList) itSuite.next();
1602: if (suiteName.equals(suite.getNameFromModel())) {
1603: selectionneSuite = true;
1604: }
1605: }
1606: }
1607: boolean newSuite = false;
1608: if (!isSelectionDesTests() || selectionneSuite) {
1609: boolean appartient = false;
1610: TestList suite = null;
1611: if (pFamily != null && newFamily == false) {
1612: ArrayList suiteTestList = pFamily
1613: .getSuiteListFromModel();
1614: Iterator itSuite = suiteTestList.iterator();
1615: while (itSuite.hasNext() && !appartient) {
1616: suite = (TestList) itSuite.next();
1617: if (suite.getNameFromModel().equals(
1618: suiteName)) {
1619: appartient = true;
1620: }
1621: }
1622: }
1623:
1624: try {
1625: if (!appartient) {
1626: suite = new TestList(suiteName,
1627: suiteDescription);
1628: pFamily.addTestListInDBAndModel(suite);
1629: newSuite = true;
1630: } else {
1631: suite.updateInDBAndModel(suiteName,
1632: suiteDescription);
1633: }
1634: //gérer les attachements
1635: updateElementAttachement(suiteElem, suite,
1636: newSuite);
1637:
1638: //les tests
1639: updateTests(suiteElem, pFamily, suite,
1640: newFamily, newSuite);
1641: } catch (Exception e) {
1642: Tools.ihmExceptionView(e);
1643: }
1644: }
1645: }
1646: }
1647: }
1648:
1649: void updateFamily() {
1650: //ArrayList testAuto = new ArrayList();
1651: ArrayList familyList = (ArrayList) doc.selectNodes("//Famille");
1652: ArrayList familleListModel = project.getFamilyListFromModel();
1653: if (familyList != null) {
1654: Iterator it = familyList.iterator();
1655: while (it.hasNext() && !annule) {
1656: Element familyElem = (Element) it.next();
1657: String familyName = familyElem.elementText("Nom");
1658: String familyDescription = (familyElem
1659: .elementText("Description") == null) ? ""
1660: : familyElem.elementText("Description");
1661: familyDescription = familyDescription.replaceAll(
1662: "\\\\n", "\n");
1663: boolean selectionne = false;
1664: if (isSelectionDesTests()) {
1665: Iterator itFamily = familySelectionList.iterator();
1666: while (itFamily.hasNext()) {
1667: Family family = (Family) itFamily.next();
1668: if (familyName
1669: .equals(family.getNameFromModel())) {
1670: selectionne = true;
1671: }
1672: }
1673: }
1674: if (!isSelectionDesTests() || selectionne) {
1675: boolean appartient = false;
1676: Family fam = null;
1677: boolean newFamily = false;
1678: Iterator itFam = familleListModel.iterator();
1679: while (itFam.hasNext() && !appartient) {
1680: fam = (Family) itFam.next();
1681: if (fam.getNameFromModel().equals(familyName)) {
1682: appartient = true;
1683: }
1684: }
1685: try {
1686: if (!appartient) {
1687: fam = new Family(familyName,
1688: familyDescription);
1689:
1690: project.addFamilyInDBAndModel(fam);
1691:
1692: newFamily = true;
1693: } else {
1694: fam
1695: .updateDescriptionInModel(familyDescription);
1696: }
1697:
1698: //updatesuite
1699: updateElementAttachement(familyElem, fam,
1700: newFamily);
1701:
1702: updateSuite(familyElem, fam, newFamily);
1703:
1704: } catch (Exception e) {
1705: Tools.ihmExceptionView(e);
1706: }
1707: }
1708: }
1709: }
1710: }
1711:
1712: /**
1713: * Dans le cas où le test était pas déjà dans la BD, ajout ou mise à jour des actions
1714: * @param test le test qui contient les actions
1715: * @param testElem élément qui représente le test dans le document XML
1716: * @param id_test identifiant du test qui a été ajouté à la BD
1717: * @param justeMAJAttachements si oui, autorise uniquement la mise à jour des attachements des actions
1718: */
1719: public void updateAction(Element testElem, ManualTest test,
1720: boolean justeMAJAttachements) {
1721: if (idialog.isSupprAction() && !idialog.isSupprElement()) {
1722: supprimerActions(testElem, (ManualTest) test);
1723: //vérification que tous les paramètres du test sont toujours utilisés
1724:
1725: }
1726: List actionList = testElem.selectNodes(".//ActionTest");
1727: Iterator itAction = actionList.iterator();
1728: while (itAction.hasNext()) {
1729: Element actionElem = (Element) itAction.next();
1730: String nomAction = actionElem.elementText("Nom");
1731: String description = (actionElem.elementText("Description") == null) ? ""
1732: : actionElem.elementText("Description");
1733: String resulAttendu = (actionElem
1734: .elementText("ResultAttendu") == null) ? ""
1735: : actionElem.elementText("ResultAttendu");
1736: description = description.replaceAll("\\\\n", "\n");
1737: resulAttendu = resulAttendu.replaceAll("\\\\n", "\n");
1738: boolean appartient = false;
1739: Action action = null;
1740: if (test != null) {
1741: ArrayList actionListBDD = ((ManualTest) test)
1742: .getActionListFromModel(false);
1743: Iterator itActionBD = actionListBDD.iterator();
1744: while (itActionBD.hasNext() && !appartient) {
1745: action = (Action) itActionBD.next();
1746: if (action.getNameFromModel().equals(nomAction)) {
1747: appartient = true;
1748: }
1749: }
1750: }
1751: if (!appartient && !justeMAJAttachements) {
1752:
1753: action = new Action(test, nomAction, description);
1754: action.setAwaitedResultInModel(resulAttendu);
1755: try {
1756: test.addActionInDBAndModel(action);
1757: ajouterAttachements(actionElem, action);
1758: ajoutParametresActions(actionElem, action);
1759: } catch (Exception e) {
1760: Tools.ihmExceptionView(e);
1761: }
1762: } else {
1763: if (!justeMAJAttachements) {
1764: try {
1765: action.updateInDBAndModel(nomAction,
1766: description, resulAttendu);
1767: ajoutParametresActions(actionElem, action);
1768: } catch (Exception e) {
1769: Tools.ihmExceptionView(e);
1770: }
1771: }
1772: updateElementAttachement(actionElem, action, false);
1773: }
1774:
1775: }
1776: }
1777:
1778: /**
1779: * Ajout des tests si ils ne sont pas déjà dans la campagne
1780: * @param campElem élément représentant la campagne dans le document XML
1781: * @param campaign campagne du modèle
1782: */
1783: public void updateTestsToCamp(Element campElem, Campaign campaign) {
1784: List familyListXML = campElem
1785: .selectNodes("FamillesCamp/FamilleRef");
1786: Iterator itFam = familyListXML.iterator();
1787: while (itFam.hasNext()) {
1788: Element famElem = (Element) itFam.next();
1789: String nomFamille = famElem.elementText("Nom");
1790: Family family = project.getFamilyFromModel(nomFamille);
1791: List suiteListXML = famElem
1792: .selectNodes("SuiteTestsCamp/SuiteTestRef");
1793: Iterator itSuite = suiteListXML.iterator();
1794: while (itSuite.hasNext()) {
1795: Element suiteElem = (Element) itSuite.next();
1796: String nomSuite = suiteElem.elementText("Nom");
1797: TestList testList = family.getTestListInModel(nomSuite);
1798: List testListXML = suiteElem
1799: .selectNodes("TestsCamp/TestRef");
1800: Iterator itTest = testListXML.iterator();
1801: while (itTest.hasNext()) {
1802: try {
1803: Element testElem = (Element) itTest.next();
1804: String nomTest = testElem.elementText("Nom");
1805: int userID = -1;
1806: String loginAssigned = testElem
1807: .attributeValue("loginAssigned");
1808: if (loginAssigned != null) {
1809: userID = project.containUser(loginAssigned);
1810: }
1811: if (userID == -1) {
1812: if (idialog != null) {
1813: //ConnectionData.getCampTestInsert().addResExecCampUsingID(nom, id_exec, DataModel.getCurrentUser().getLogin(), description, statut, resultat);
1814: userID = DataModel.getCurrentUser()
1815: .getIdBdd();
1816: } else {
1817: //ConnectionData.getCampTestInsert().addResExecCampUsingID(nom, id_exec, cdialog.getNewProject().getAdministrator().getLogin(), description, statut, resultat);
1818: userID = project
1819: .getAdministratorFromModel()
1820: .getIdBdd();
1821: }
1822: }
1823: Test test = testList.getTestFromModel(nomTest);
1824: if (!campaign.getTestListFromModel().contains(
1825: test)) {
1826: campaign.importTestInDBAndModel(test,
1827: userID);
1828: }
1829: } catch (Exception e) {
1830: Tools.ihmExceptionView(e);
1831: }
1832: }
1833: }
1834: }
1835: }
1836:
1837: /**
1838: * Ajout ou mise à jour des jeux de données d'une campagne donnée
1839: * @param campElem
1840: * @param campaign
1841: * @return liste des jeux de données qui ont été modifiés
1842: */
1843: public ArrayList updateJeuxDonnees(Element campElem,
1844: Campaign campaign) {
1845: ArrayList listJeuModif = new ArrayList();
1846: List jeuListXML = campElem
1847: .selectNodes("JeuxDonnees/JeuDonnees");
1848: Iterator itJeu = jeuListXML.iterator();
1849: while (itJeu.hasNext()) {
1850: try {
1851: Element jeuElem = (Element) itJeu.next();
1852: String nomJeu = jeuElem.elementText("Nom");
1853: String description = jeuElem.elementText("Description");
1854: description = description.replaceAll("\\\\n", "\n");
1855: //vérification de l'appartenance ou non du jeu de données à la campagne
1856: boolean appartient = false;
1857: ArrayList dataSetList = campaign
1858: .getDataSetListFromModel();
1859: Iterator itSet = dataSetList.iterator();
1860: DataSet dataSet = null;
1861: while (itSet.hasNext() && !appartient) {
1862: dataSet = (DataSet) itSet.next();
1863: if (dataSet.getNameFromModel().equals(nomJeu)) {
1864: appartient = true;
1865: }
1866: }
1867: boolean different = false;
1868: if (appartient) {
1869: //vérifier que toutes les valeurs des paramètres sont les mêmes sinon créer un "jeu'Bis'", les deux jeux de données ayant le même nom
1870: List paramtestList = jeuElem
1871: .selectNodes("ValeurParams/ValeurParam");
1872: Iterator itParamtestJeu = paramtestList.iterator();
1873: while (itParamtestJeu.hasNext()) {
1874: Element paramElem = (Element) itParamtestJeu
1875: .next();
1876: String valParam = (paramElem
1877: .attributeValue("valeur") != null) ? paramElem
1878: .attributeValue("valeur")
1879: : "";
1880: String nomParam = paramElem.elementText("Nom");
1881: HashMap paramMap = dataSet
1882: .getParametersHashMapFromModel();
1883: if (!paramMap.containsKey(nomParam)) {
1884: different = true;
1885: } else {
1886: String valInJeu = ((String) paramMap
1887: .get(nomParam) != null) ? (String) paramMap
1888: .get(nomParam)
1889: : "";
1890: if (!valInJeu.equals(valParam)) {
1891: different = true;
1892: }
1893: }
1894: }
1895: if (different) {
1896: listJeuModif.add(dataSet.getNameFromModel());
1897: }
1898: }
1899: if (!appartient || different) {
1900: //int id_jeu = 0;
1901: DataSet newDataSet;
1902: if (!appartient) {
1903: newDataSet = new DataSet(nomJeu, description);
1904: campaign.addDataSetInDBAndModel(newDataSet);
1905: } else {
1906: newDataSet = new DataSet(nomJeu + "_Bis",
1907: description);
1908: campaign.addDataSetInDBAndModel(newDataSet);
1909: }
1910: //ajout des paramètres valués du jeu de données
1911: List paramList = jeuElem
1912: .selectNodes("ValeurParams/ValeurParam");
1913: Iterator itParamJeu = paramList.iterator();
1914: while (itParamJeu.hasNext()) {
1915: Element paramElem = (Element) itParamJeu.next();
1916: String valParam = (paramElem
1917: .attributeValue("valeur") != null) ? paramElem
1918: .attributeValue("valeur")
1919: : "";
1920: String nomParam = paramElem.elementText("Nom");
1921: Parameter param = DataModel.getCurrentProject()
1922: .getParameterFromModel(nomParam);
1923: newDataSet.addParamValueToDBAndModel(valParam,
1924: param);
1925: }
1926: }
1927: } catch (Exception e) {
1928: Tools.ihmExceptionView(e);
1929: }
1930: }
1931: return listJeuModif;
1932: }
1933:
1934: /**
1935: * Méthode qui ajoute ou met à jour les exécutions d'une campagne
1936: * @param campElem élément représentant la campagne dans le document XML
1937: * @param campaign campagne du modèle
1938: * @param listJeuModif liste des jeux qui ont été modifiés
1939: */
1940: public void updateExecutions(Element campElem, Campaign campaign,
1941: ArrayList listJeuModif) {
1942: List listExecXML = campElem
1943: .selectNodes("ExecCampTests/ExecCampTest");
1944: Iterator itExec = listExecXML.iterator();
1945: while (itExec.hasNext()) {
1946: Element execElem = (Element) itExec.next();
1947: String nomExec = execElem.elementText("Nom");
1948: String description = (execElem.elementText("Description") != null) ? execElem
1949: .elementText("Description")
1950: : "";
1951: description = description.replaceAll("\\\\n", "\n");
1952: //Vérification de l'appartenance ou non de l'exécution à la campagne
1953: ArrayList execList = campaign.getExecutionListFromModel();
1954: boolean appartient = false;
1955: Execution exec = null;
1956: Iterator itEx = execList.iterator();
1957: while (itEx.hasNext() && !appartient) {
1958: exec = (Execution) itEx.next();
1959: if (exec.getNameFromModel().equals(nomExec)) {
1960: appartient = true;
1961: }
1962: }
1963: boolean different = false;
1964: if (appartient) {
1965: //vérification que c'est vraiment la même exécution avec même jeu de données, même environnement, même scripts même jeu de données
1966: Element jeuElem = execElem.element("JeuDonneesEx");
1967: if (jeuElem != null) {
1968: String nomJeu = jeuElem.elementText("Nom");
1969: if (exec.getDataSetFromModel() == null) {
1970: different = true;
1971: } else if (!exec.getDataSetFromModel()
1972: .getNameFromModel().equals(nomJeu)) {
1973: different = true;
1974: } else if (listJeuModif.contains(nomJeu)) {
1975: different = true;
1976: }
1977: } else if (exec.getDataSetFromModel() != null
1978: && exec.getDataSetFromModel().getIdBdd() != -1) {
1979: different = true;
1980: }
1981: //même environnement
1982: Element envElem = execElem.element("EnvironnementEx");
1983: String nomEnvXML = envElem.elementText("Nom");
1984: if (!nomEnvXML.equals(exec.getEnvironmentFromModel()
1985: .getNameFromModel())) {
1986: different = true;
1987: }
1988: //même scripts
1989: Element scriptPre = (Element) execElem
1990: .selectSingleNode("Script[1]");
1991: if (scriptPre != null) {
1992: String type = scriptPre.attributeValue("type");
1993: String nomScript = scriptPre.attributeValue("nom");
1994: if (type.equals("PRE_SCRIPT")) {
1995: if (exec.getPreScriptFromModel() == null) {
1996: different = true;
1997: } else {
1998: if (!exec.getPreScriptFromModel()
1999: .getNameFromModel().equals(
2000: nomScript)) {
2001: different = true;
2002: }
2003: }
2004: } else {
2005: if (exec.getPostScriptFromModel() == null) {
2006: different = true;
2007: } else {
2008: if (!exec.getPostScriptFromModel()
2009: .getNameFromModel().equals(
2010: nomScript)) {
2011: different = true;
2012: }
2013: }
2014: }
2015: }
2016: Element scriptPost = (Element) execElem
2017: .selectSingleNode("Script[2]");
2018: if (scriptPost != null) {
2019: String nomScript = scriptPost.attributeValue("nom");
2020: if (!exec.getPostScriptFromModel()
2021: .getNameFromModel().equals(nomScript)) {
2022: different = true;
2023: }
2024: }
2025: }
2026:
2027: //Détermination de l'identifiant du jeu de données associé à l'exécution
2028: DataSet pDataSet;
2029: Element jeuElem = execElem.element("JeuDonneesEx");
2030: if (jeuElem != null) {
2031: String nomJeu = jeuElem.elementText("Nom");
2032: pDataSet = campaign.getDataSetFromModel(nomJeu);
2033: } else {
2034: pDataSet = new DataSet(ApiConstants.EMPTY_NAME, "");
2035: }
2036: Element envElem = execElem.element("EnvironnementEx");
2037: String nomEnvXML = envElem.elementText("Nom");
2038: Environment pEnv = project
2039: .getEnvironmentFromModel(nomEnvXML);
2040:
2041: if (!appartient || different) {
2042: Execution pExec;
2043: try {
2044: if (!appartient) {
2045: pExec = new Execution(nomExec, description);
2046: } else {
2047: pExec = new Execution(nomExec + "_Bis",
2048: description);
2049: }
2050: pExec.updateEnvInModel(pEnv);
2051: pExec.updateDatasetInModel(pDataSet);
2052: campaign.addExecutionInDBAndModel(pExec, DataModel
2053: .getCurrentUser());
2054:
2055: //Ajout des scripts
2056: Element scriptPre = (Element) execElem
2057: .selectSingleNode("Script[1]");
2058: if (scriptPre != null) {
2059: ajouterScriptToExec(scriptPre, pExec);
2060: }
2061: Element scriptPost = (Element) execElem
2062: .selectSingleNode("Script[2]");
2063: if (scriptPost != null) {
2064: ajouterScriptToExec(scriptPost, pExec);
2065: }
2066: //ajouter les attachements
2067: ajouterAttachements(execElem, pExec);
2068: //ajouter les résultats d'exécutions
2069:
2070: ajouterResulExec(execElem, pExec);//, campElem.elementText("Nom")
2071: } catch (Exception e) {
2072: Tools.ihmExceptionView(e);
2073: }
2074: } else {
2075: //mise à jour ou ajout des scripts
2076: Element scriptPre = (Element) execElem
2077: .selectSingleNode("Script[1]");
2078: if (scriptPre != null) {
2079: updateScriptToExec(scriptPre, exec);
2080: }
2081: Element scriptPost = (Element) execElem
2082: .selectSingleNode("Script[2]");
2083: if (scriptPost != null) {
2084: updateScriptToExec(scriptPost, exec);
2085: }
2086: //ajout ou mise à jour des attachements de l'exécution
2087: updateElementAttachement(execElem, exec, false);
2088: //ajout ou mise à jour des résultats d'exécutions
2089: updateResulExec(execElem, exec, campaign); //campElem.elementText("Nom")
2090: }
2091: }
2092: }
2093:
2094: /**
2095: * Méthode qui ajoute ou met à jour les résultats d'exécution d'une campagne
2096: * @param execElem élément représentant l'exécution d'une campagne dans le document XML
2097: * @param exec excécution d'une campagne dans le modèle
2098: * @param campName nom de la campagne qui contient l'exécution
2099: */
2100: public void updateResulExec(Element execElem, Execution exec,
2101: Campaign camp) {
2102: List resulExecListXML = execElem
2103: .selectNodes("ResulExecCampTests/ResulExecCampTest");
2104: Iterator itRExec = resulExecListXML.iterator();
2105: while (itRExec.hasNext()) {
2106: try {
2107: Element rexecElem = (Element) itRExec.next();
2108: String nom = rexecElem.elementText("Nom");
2109: String description = (rexecElem
2110: .elementText("Description") != null) ? rexecElem
2111: .elementText("Description")
2112: : "";
2113: String resultat = rexecElem.attributeValue("statut");
2114: description = description.replaceAll("\\\\n", "\n");
2115: Element resExecElem = rexecElem.element("ResulExecs");
2116: String statut = "A_FAIRE";
2117: if (resExecElem != null) {
2118: statut = "FAIT";
2119: }
2120: //vérification de la présence ou non du résultat d'exécution dans le modèle
2121: ArrayList execResList = exec
2122: .getExecutionResultListFromModel();
2123: boolean appartient = false;
2124: ExecutionResult execRes = null;
2125: Iterator itResExec = execResList.iterator();
2126: while (itResExec.hasNext() && !appartient) {
2127: execRes = (ExecutionResult) itResExec.next();
2128: if (execRes.getNameFromModel().equals(nom)) {
2129: appartient = true;
2130: }
2131: }
2132: boolean different = false;
2133: if (appartient) {
2134: //différence au niveau du statue de l'exécution
2135: if (!resultat.equals(execRes
2136: .getExecutionStatusFromModel())) {
2137: different = true;
2138: }
2139: //détection des différences dans les résultats d'exécution de chaque test
2140: if (resExecElem != null && !different) {
2141: List execCasList = resExecElem
2142: .selectNodes("ResulExec");
2143: Iterator itExecCas = execCasList.iterator();
2144: while (itExecCas.hasNext() && !different) {
2145: Element execCasElem = (Element) itExecCas
2146: .next();
2147: String res = execCasElem
2148: .attributeValue("res");
2149: Element refTest = execCasElem
2150: .element("RefTest");
2151: String nomTest = refTest
2152: .elementText("NomTest");
2153: String nomSuite = refTest
2154: .elementText("NomSuite");
2155: String nomFamille = refTest
2156: .elementText("NomFamille");
2157: Test test = project.getTestFromModel(
2158: nomFamille, nomSuite, nomTest);
2159: if (execRes
2160: .getTestResultStatusFromModel(test) == null) {
2161: different = true;
2162: } else if (!execRes
2163: .getTestResultStatusFromModel(test)
2164: .equals(res)) {
2165: different = true;
2166: }
2167: }
2168: }
2169: //détection des différences au niveau des résultats des actions des tests
2170: List resActionList = rexecElem
2171: .selectNodes("ResulActionTests/ResulActionTest");
2172: Iterator itResAction = resActionList.iterator();
2173: while (itResAction.hasNext() && !different) {
2174: Element resAction = (Element) itResAction
2175: .next();
2176: Element refAction = resAction
2177: .element("RefAction");
2178: String nomAction = refAction
2179: .elementText("NomAction");
2180: String nomTest = refAction
2181: .elementText("NomTest");
2182: String nomSuite = refAction
2183: .elementText("NomSuite");
2184: String nomFamille = refAction
2185: .elementText("NomFamille");
2186: Test test = project.getTestFromModel(
2187: nomFamille, nomSuite, nomTest);
2188: Action action = ((ManualTest) test)
2189: .getActionFromModel(nomAction);
2190: String resultatAction = resAction
2191: .attributeValue("res");
2192: ManualExecutionResult pManualExecutionResult = (ManualExecutionResult) execRes
2193: .getExecutionTestResultFromModel(test);
2194: if (resultatAction.equals("NonRenseigne")) {
2195: resultatAction = "";
2196: }
2197: if (pManualExecutionResult
2198: .getActionStatusInModel(action) == null) {
2199: different = true;
2200: } else if (!pManualExecutionResult
2201: .getActionStatusInModel(action).equals(
2202: resultatAction)) {
2203: different = true;
2204: }
2205: }
2206: }
2207: if (!appartient || different) {
2208: //int id_exec_res = 0;
2209: ExecutionResult pExecutionResult;
2210: if (!appartient) {
2211: pExecutionResult = new ExecutionResult(nom,
2212: description, exec);
2213: } else {
2214: pExecutionResult = new ExecutionResult(nom
2215: + "_Bis", description, exec);
2216: }
2217:
2218: pExecutionResult
2219: .setExecutionStatusInModel(resultat);
2220: exec.addExecutionResultInDBAndModel(
2221: pExecutionResult, DataModel
2222: .getCurrentUser());
2223: ajouterAttachements(rexecElem, pExecutionResult);
2224:
2225: if (resExecElem != null) {
2226: List execCasList = resExecElem
2227: .selectNodes("ResulExec");
2228: Iterator itExecCas = execCasList.iterator();
2229: while (itExecCas.hasNext()) {
2230: Element execCasElem = (Element) itExecCas
2231: .next();
2232: String res = execCasElem
2233: .attributeValue("res");
2234: Element refTest = execCasElem
2235: .element("RefTest");
2236: String nomTest = refTest
2237: .elementText("NomTest");
2238: String nomSuite = refTest
2239: .elementText("NomSuite");
2240: String nomFamille = refTest
2241: .elementText("NomFamille");
2242: Test test = project.getTestFromModel(
2243: nomFamille, nomSuite, nomTest);
2244:
2245: ExecutionTestResult pExecutionTestResult = pExecutionResult
2246: .addTestResultStatusInModel(test,
2247: res);
2248: pExecutionResult
2249: .addExecTestResultInDB(test);
2250: ajouterAttachements(execCasElem,
2251: pExecutionTestResult);
2252: }
2253: }
2254: List resActionList = rexecElem
2255: .selectNodes("ResulActionTests/ResulActionTest");
2256: Iterator itResAction = resActionList.iterator();
2257: while (itResAction.hasNext()) {
2258: Element resAction = (Element) itResAction
2259: .next();
2260: Element refAction = resAction
2261: .element("RefAction");
2262: String nomAction = refAction
2263: .elementText("NomAction");
2264: String nomTest = refAction
2265: .elementText("NomTest");
2266: String nomSuite = refAction
2267: .elementText("NomSuite");
2268: String nomFamille = refAction
2269: .elementText("NomFamille");
2270: Test test = project.getTestFromModel(
2271: nomFamille, nomSuite, nomTest);
2272: Action action = ((ManualTest) test)
2273: .getActionFromModel(nomAction);
2274: ManualExecutionResult pManualExecutionResult = (ManualExecutionResult) pExecutionResult
2275: .getExecutionTestResultFromModel(test);
2276: if (!pManualExecutionResult.isInBase()) {
2277: pExecutionResult
2278: .addExecTestResultInDB((ManualTest) test);
2279: }
2280: String resultatAction = resAction
2281: .attributeValue("res");
2282: if (resultatAction.equals("NonRenseigne")) {
2283: resultatAction = "";
2284: }
2285: String descAction = (resAction
2286: .elementText("Description") == null) ? ""
2287: : resAction.elementText("Description");
2288: String resulAttendu = (resAction
2289: .elementText("ResultAttendu") == null) ? ""
2290: : resAction
2291: .elementText("ResultAttendu");
2292: String effectiveAttendu = (resAction
2293: .elementText("ResulEffectif") == null) ? ""
2294: : resAction
2295: .elementText("ResulEffectif");
2296: descAction = descAction.replaceAll("\\\\n",
2297: "\n");
2298: resulAttendu = resulAttendu.replaceAll("\\\\n",
2299: "\n");
2300: effectiveAttendu = effectiveAttendu.replaceAll(
2301: "\\\\n", "\n");
2302:
2303: pManualExecutionResult
2304: .addStatusForActionInModel(action,
2305: resultatAction);
2306: pManualExecutionResult
2307: .addEffectivResultInModel(action,
2308: effectiveAttendu);
2309: pManualExecutionResult
2310: .addDescriptionResultInModel(action,
2311: descAction);
2312: pManualExecutionResult.addAwaitedResultInModel(
2313: action, resulAttendu);
2314: //pManualExecutionResult.addActionResultInDB(action);
2315: pExecutionResult.addExecActionResultInDB(test,
2316: action);
2317: }
2318: } else {
2319: //int id_exec_res = execRes.getIdBDD();
2320: updateElementAttachement(rexecElem, execRes, false);
2321: if (resExecElem != null) {
2322: List execCasList = resExecElem
2323: .selectNodes("ResulExec");
2324: Iterator itExecCas = execCasList.iterator();
2325: while (itExecCas.hasNext()) {
2326: Element execCasElem = (Element) itExecCas
2327: .next();
2328: Element refTest = execCasElem
2329: .element("RefTest");
2330: String nomTest = refTest
2331: .elementText("NomTest");
2332: String nomSuite = refTest
2333: .elementText("NomSuite");
2334: String nomFamille = refTest
2335: .elementText("NomFamille");
2336: Test test = project.getTestFromModel(
2337: nomFamille, nomSuite, nomTest);
2338: ExecutionTestResult pExecutionTestResult = execRes
2339: .getExecutionTestResultFromModel(test);
2340: updateElementAttachement(execCasElem,
2341: pExecutionTestResult, false);
2342: }
2343: }
2344: List resActionList = rexecElem
2345: .selectNodes("ResulActionTests/ResulActionTest");
2346: Iterator itResAction = resActionList.iterator();
2347: while (itResAction.hasNext()) {
2348: Element resAction = (Element) itResAction
2349: .next();
2350: Element refAction = resAction
2351: .element("RefAction");
2352: String nomAction = refAction
2353: .elementText("NomAction");
2354: String nomTest = refAction
2355: .elementText("NomTest");
2356: String nomSuite = refAction
2357: .elementText("NomSuite");
2358: String nomFamille = refAction
2359: .elementText("NomFamille");
2360: Test test = project.getTestFromModel(
2361: nomFamille, nomSuite, nomTest);
2362: Action action = ((ManualTest) test)
2363: .getActionFromModel(nomAction);
2364: ManualExecutionResult pManualExecutionResult = (ManualExecutionResult) execRes
2365: .getExecutionTestResultFromModel(test);
2366:
2367: String resultatAction = resAction
2368: .attributeValue("res");
2369: if (resultatAction.equals("NonRenseigne")) {
2370: resultatAction = "";
2371: }
2372: String effectiveResult = (resAction
2373: .elementText("ResulEffectif") == null) ? ""
2374: : resAction
2375: .elementText("ResulEffectif");
2376:
2377: pManualExecutionResult
2378: .addEffectivResultInModel(action,
2379: effectiveResult);
2380: pManualExecutionResult
2381: .addStatusForActionInModel(action,
2382: resultatAction);
2383: pManualExecutionResult
2384: .updateActionEffectiveResInDB(action);
2385: }
2386: }
2387: } catch (Exception e) {
2388: Tools.ihmExceptionView(e);
2389: }
2390: }
2391: }
2392:
2393: /**
2394: * Méthode qui ajoute ou met à jour un script d'une exécution
2395: * @param script élément script du document XML
2396: * @param id_exec identifiant de l'exécution
2397: */
2398: public void updateScriptToExec(Element script, Execution exec) {
2399: String classpath = script.elementText("Classpath");
2400: String argScript = script.elementText("ArgScript");
2401: String type = script.attributeValue("type");
2402: String dirScript = script.attributeValue("dir");
2403: dirScript = restorePath(dirScript);
2404: File fScript = new File(dirXml + fs + dirScript);
2405:
2406: Script pScritp = new Script(fScript.getName(), "");
2407: pScritp.setTypeInModel(type);
2408: pScritp.setScriptExtensionInModel(classpath);
2409: pScritp.updatePlugArgInModel(argScript);
2410:
2411: if ((type.equals("PRE_SCRIPT") && exec.getPreScriptFromModel() == null)
2412: || (type.equals("POST_SCRIPT") && exec
2413: .getPostScriptFromModel() == null)) {
2414: try {
2415: exec.addScriptInDBAndModel(pScritp, fScript);
2416: } catch (Exception e) {
2417: Tools.ihmExceptionView(e);
2418: }
2419: } else {
2420: if (type.equals("PRE_SCRIPT")) {
2421: try {
2422: Script scriptInit = exec.getPreScriptFromModel();
2423: if (scriptInit != null) {
2424: scriptInit.updateInDB(fScript);
2425: scriptInit.updatePlugArgInDBAndModel(argScript);
2426: }
2427: } catch (Exception fe) {
2428: fe.printStackTrace();
2429: if (!idialog.isMajAttachPb()) {
2430: idialog
2431: .setErrorMessage(idialog
2432: .getErrorMessage()
2433: + Language
2434: .getInstance()
2435: .getText(
2436: "Problème_lors_de_la_mise_à_jour_des_attachements"));
2437: idialog.showErrorMessage();
2438: idialog.setMajAttachPb(true);
2439: }
2440: }
2441: } else {
2442: Script scriptPost = exec.getPostScriptFromModel();
2443: try {
2444: if (scriptPost != null) {
2445: scriptPost.updateInDB(fScript);
2446: scriptPost.updatePlugArgInDBAndModel(argScript);
2447: }
2448: } catch (Exception fe) {
2449: fe.printStackTrace();
2450: if (!idialog.isMajAttachPb()) {
2451: idialog
2452: .setErrorMessage(idialog
2453: .getErrorMessage()
2454: + Language
2455: .getInstance()
2456: .getText(
2457: "Problème_lors_de_la_mise_à_jour_des_attachements"));
2458: idialog.showErrorMessage();
2459: idialog.setMajAttachPb(true);
2460: }
2461: }
2462: }
2463: }
2464: }
2465:
2466: /***********************************************************************************************************************/
2467:
2468: /**
2469: * Gestion de l'insertion ou la mise à jour des campagnes du projet Salomé courant en fonction du document XML
2470: */
2471: public void gestionDesCampagnes() {
2472: ArrayList campList = project.getCampaignListFromModel();
2473: List campListXML = doc.selectNodes("//CampagneTest");
2474: Iterator itCampXML = campListXML.iterator();
2475: while (itCampXML.hasNext() && !annule) {
2476: try {
2477: Element campElem = (Element) itCampXML.next();
2478: boolean appartient = false;
2479: Campaign campaign = null;
2480: Iterator itCamp = campList.iterator();
2481: while (itCamp.hasNext() && !appartient) {
2482: campaign = (Campaign) itCamp.next();
2483: if (campElem.elementText("Nom").equals(
2484: campaign.getNameFromModel())) {
2485: appartient = true;
2486: }
2487: Util.log("[gestionDesCampagnes] compare "
2488: + campaign.getNameFromModel() + " avec "
2489: + campElem.elementText("Nom")
2490: + " result = " + appartient);
2491:
2492: }
2493: String loginConceptor = "";
2494: if (!appartient) {
2495: if (!newProject) {
2496: loginConceptor = DataModel.getCurrentUser()
2497: .getLoginFromModel();
2498: } else {
2499: loginConceptor = project
2500: .getAdministratorFromModel()
2501: .getLoginFromModel();
2502: }
2503: } else {
2504: loginConceptor = campaign.getConceptorFroModel();
2505: }
2506: String campName = campElem.elementText("Nom");
2507: String campDescription = (campElem
2508: .elementText("Description") == null) ? ""
2509: : campElem.elementText("Description");
2510: campDescription = campDescription.replaceAll("\\\\n",
2511: "\n");
2512: if (!appartient) {
2513: /*
2514: int nbTestCamp = ConnectionData.getCampTestSelect().getNumberOfCampaign();
2515: nbTestCamp++;
2516: ConnectionData.getCampTestInsert().addCampaign(campName, campDescription, loginConceptor, nbTestCamp);
2517: int id_camp = ConnectionData.getCampTestSelect().getCampaignId(campName);
2518: */
2519:
2520: Campaign camp = new Campaign(campName,
2521: campDescription);
2522: project.addCampaignInDBandModel(camp);
2523:
2524: //ajout des attachements
2525: ajouterAttachements(campElem, camp);
2526: //ajout des jeux de données
2527: ajouterJeuxDonnees(campElem, camp);
2528: //ajout des tests associées à la campagne
2529: ajoutTestsToCamp(campElem, camp);
2530: //ajout des exécutions
2531: ajouterExecutions(campElem, camp);
2532:
2533: } else {
2534: //détection conflit
2535: //i.e. campagne avec des exécutions qui contient de nouveaux tests
2536: boolean conflit = detecterConflitCamp(campaign,
2537: campElem);
2538: if (conflit && idialog.isCreer_copy()) {
2539: int numCopy = 0;
2540: String newName = "copy_" + campName;
2541: Campaign campExiste = project
2542: .getCampaignFromModel("copy_"
2543: + campName);
2544: while (campExiste != null && numCopy < 100) {
2545: newName = "copy" + numCopy + "_" + campName;
2546: campExiste = project
2547: .getCampaignFromModel("copy_"
2548: + newName);
2549: numCopy++;
2550: }
2551:
2552: if (campExiste != null) {
2553: //ConnectionData.getCampTestDelete().deleteCampaignUsingID(campExiste.getIdBdd());
2554: project
2555: .deleteCampaignInDBAndModel(campExiste);
2556: }
2557:
2558: Campaign newCamp = new Campaign(newName,
2559: campDescription);
2560: project.addCampaignInDBandModel(newCamp);
2561:
2562: //ajout des attachements
2563: ajouterAttachements(campElem, newCamp);
2564: //ajout des jeux de données
2565: ajouterJeuxDonnees(campElem, newCamp);
2566: //ajout des tests associées à la campagne
2567: ajoutTestsToCamp(campElem, newCamp);
2568: //ajout des exécutions
2569: ajouterExecutions(campElem, newCamp);
2570: }
2571: if (!conflit) {
2572: //on effectue toutes les mises à jour nécessaires de la BD en fonction du fichier XML
2573: //ConnectionData.getCampTestUpdate().updateCampaignUsingID(campaign.getIdBdd(), campElem.elementText("Nom"), campDescription);
2574: campaign.updateInDBAndModel(campElem
2575: .elementText("Nom"), campDescription);
2576: //mise à jour des attachements
2577: updateElementAttachement(campElem, campaign,
2578: false);
2579: //ajout et mise à jour des jeux de données
2580: ArrayList listJeuModif = updateJeuxDonnees(
2581: campElem, campaign);
2582: //ajout ou mise à jour des tests associées à la campagne
2583: updateTestsToCamp(campElem, campaign);
2584: //ajout ou mise à jour des exécutions
2585: updateExecutions(campElem, campaign,
2586: listJeuModif);
2587: }
2588: if (conflit && idialog.isMajPossible()) {
2589: //dans ce cas, il y a conflit et on doit faire la mise à jour des éléments qui sont possibles
2590: updateElementAttachement(campElem, campaign,
2591: false);
2592: }
2593:
2594: }
2595: } catch (Exception e) {
2596: Tools.ihmExceptionView(e);
2597: }
2598: }
2599: }
2600:
2601: void updatePlugin() {
2602: //gestion des drivers des scripts des tests automatiques
2603: Iterator itTestAuto = automatedTest2Update.iterator();
2604: while (itTestAuto.hasNext()) {
2605: AutomaticTest test = (AutomaticTest) itTestAuto.next();
2606: try {
2607: if (newProject) {
2608:
2609: } else {
2610:
2611: }
2612: TestDriver driver = ((AutomaticTest) test)
2613: .ActivateExtention((Extension) pIPlugObject
2614: .getAssociatedExtension(test
2615: .getExtensionFromModel()),
2616: pIPlugObject.getUrlBase(), pIPlugObject
2617: .getPluginManager());
2618:
2619: //TestDriver driver = ((AutomaticTest)test).ActivateExtention((Extension)SalomeTMF.associatedExtension.get(test.getExtensionFromModel()), SalomeTMF.urlSalome, SalomeTMF.jpf);
2620: if (test.getScriptFromModel() != null && driver != null) {
2621: File file = null;
2622:
2623: file = ((AutomaticTest) test).getTestScriptFromDB();
2624:
2625: if (file != null) {
2626: driver.updateTestScriptFromImport(file
2627: .getAbsolutePath(),
2628: (AutomaticTest) test);
2629: }
2630: }
2631: } catch (Exception e) {
2632: e.printStackTrace();
2633: idialog
2634: .setErrorMessage(idialog.getErrorMessage()
2635: + Language
2636: .getInstance()
2637: .getText(
2638: "Problème_lors_de_la_mise_à_jour_des_drivers_des_scripts"));
2639: idialog.showErrorMessage();
2640: }
2641: }
2642: }
2643:
2644: /********************************* Ajout ************************************************/
2645:
2646: /**
2647: * Dans le cas où le test n'était pas déjà dans la BD, ajout des actions
2648: * @param testElem élément qui représente le test dans le document XML
2649: * @param id_test identifiant du test qui a été ajouté à la BD
2650: */
2651: public void ajouterActions(Element testElem, ManualTest test)
2652: throws Exception {
2653: List actionList = testElem.selectNodes(".//ActionTest");
2654: Iterator itAction = actionList.iterator();
2655: //int actionOrder = 0;
2656: while (itAction.hasNext()) {
2657: Element actionElem = (Element) itAction.next();
2658: String nomAction = actionElem.elementText("Nom");
2659: String description = (actionElem.elementText("Description") == null) ? ""
2660: : actionElem.elementText("Description");
2661: String resulAttendu = (actionElem
2662: .elementText("ResultAttendu") == null) ? ""
2663: : actionElem.elementText("ResultAttendu");
2664: description = description.replaceAll("\\\\n", "\n");
2665: resulAttendu = resulAttendu.replaceAll("\\\\n", "\n");
2666:
2667: Action newAction = new Action(test, nomAction, description);
2668: newAction.setAwaitedResultInModel(resulAttendu);
2669: test.addActionInDBAndModel(newAction);
2670:
2671: ajouterAttachements(actionElem, newAction);
2672: ajoutParametresActions(actionElem, newAction);
2673: }
2674: }
2675:
2676: /**
2677: * Dans le cas où attachableElement n'était pas déjà dans la BD, ajout des attachements
2678: * @param elem : élément qui représente le WithAttachment dans le document XML
2679: * @param attachableElement
2680: */
2681: public void ajouterAttachements(Element elem,
2682: WithAttachment attachableElement) {
2683:
2684: List urlAttachementList = elem
2685: .selectNodes("Attachements/UrlAttachement");
2686: Iterator itUrlAttach = urlAttachementList.iterator();
2687: while (itUrlAttach.hasNext()) {
2688: Element urlElem = (Element) itUrlAttach.next();
2689: String url = urlElem.attributeValue("url");
2690: String description = (urlElem.elementText("Description") == null) ? ""
2691: : urlElem.elementText("Description");
2692: description = description.replaceAll("\\\\n", "\n");
2693: UrlAttachment pUrlAttachment = new UrlAttachment(url,
2694: description);
2695: try {
2696: attachableElement
2697: .addAttachementInDBAndModel(pUrlAttachment);
2698: } catch (Exception e1) {
2699: Tools.ihmExceptionView(e1);
2700: }
2701: }
2702: List testFileAttachementList = elem
2703: .selectNodes("Attachements/FileAttachement");
2704: Iterator itFileAttach = testFileAttachementList.iterator();
2705: while (itFileAttach.hasNext()) {
2706: Element fileElem = (Element) itFileAttach.next();
2707: String dirAtt = fileElem.attributeValue("dir");
2708: dirAtt = restorePath(dirAtt);
2709: File f = new File(dirXml + fs + dirAtt);
2710: String description = (fileElem.elementText("Description") == null) ? ""
2711: : fileElem.elementText("Description");
2712: description = description.replaceAll("\\\\n", "\n");
2713: FileAttachment pFileAttachment = new FileAttachment(f,
2714: description);
2715: try {
2716: attachableElement
2717: .addAttachementInDBAndModel(pFileAttachment);
2718: } catch (Exception e2) {
2719: Tools.ihmExceptionView(e2);
2720: }
2721: }
2722: }
2723:
2724: /**
2725: * Si l'action existait dans la BD, ajout ou mise à jour des paramètres
2726: * @param pAction identifiant de l'action
2727: * @param actionElem élément action du document comportant les données
2728: */
2729: public void ajoutParametresActions(Element actionElem,
2730: Action pAction) throws Exception {
2731: List paramActionList = actionElem
2732: .selectNodes("ParamsT/ParamT/Nom");
2733: Iterator itParamAction = paramActionList.iterator();
2734: while (itParamAction.hasNext()) {
2735: String nomParamImport = ((Element) itParamAction.next())
2736: .getText();
2737: boolean appartient = false;
2738: if (pAction.getParameterFromModel(nomParamImport) != null) {
2739: appartient = true;
2740: }
2741: if (!appartient) {
2742: Parameter param;
2743: Test pTest = pAction.getTest();
2744: param = pTest.getUsedParameterFromModel(nomParamImport);
2745: if (param != null) {
2746: pAction.setUseParamInDBAndModel(param);
2747: } else {
2748: param = project
2749: .getParameterFromModel(nomParamImport);
2750: if (param != null) {
2751: pTest.setUseParamInDBAndModel(param);
2752: pAction.setUseParamInDBAndModel(param);
2753: } else {
2754: //AIE
2755: }
2756: }
2757: } else {
2758: //Le parametre est déja utilisé (rien a faire)
2759: }
2760: }
2761: }
2762:
2763: /**
2764: * Si la campagne n'existait pas déjà dans la BD, ajout des jeux de données
2765: * @param campElem élément représentant la campagne dans le document XML
2766: * @param id_camp identifiant de la campagne ajoutée dans la base de données
2767: */
2768: public void ajouterJeuxDonnees(Element campElem, Campaign pCamp)
2769: throws Exception {
2770: List jeuListXML = campElem
2771: .selectNodes("JeuxDonnees/JeuDonnees");
2772: Iterator itJeu = jeuListXML.iterator();
2773: while (itJeu.hasNext()) {
2774: Element jeuElem = (Element) itJeu.next();
2775: String nomJeu = jeuElem.elementText("Nom");
2776: String description = jeuElem.elementText("Description");
2777: if (description == null) {
2778: description = "";
2779: } else {
2780: description = description.replaceAll("\\\\n", "\n");
2781: }
2782: DataSet pDataSet = new DataSet(nomJeu, description);
2783: pCamp.addDataSetInDBAndModel(pDataSet);
2784:
2785: //ajout du jeu de données au modèle
2786: //ajout des paramètres valués du jeu de données
2787: List paramList = jeuElem
2788: .selectNodes("ValeurParams/ValeurParam");
2789: Iterator itParamJeu = paramList.iterator();
2790: while (itParamJeu.hasNext()) {
2791: Element paramElem = (Element) itParamJeu.next();
2792: String valParam = (paramElem.attributeValue("valeur") != null) ? paramElem
2793: .attributeValue("valeur")
2794: : "";
2795: String nomParam = paramElem.elementText("Nom");
2796:
2797: Parameter param = project
2798: .getParameterFromModel(nomParam);
2799: pDataSet.addParamValueToDBAndModel(valParam, param);
2800: }
2801: }
2802: }
2803:
2804: public void ajoutTestsToCamp(Element campElem, Campaign pCamp)
2805: throws Exception {
2806: List familyListXML = campElem
2807: .selectNodes("FamillesCamp/FamilleRef");
2808: Iterator itFam = familyListXML.iterator();
2809: while (itFam.hasNext()) {
2810: Element famElem = (Element) itFam.next();
2811: String nomFamille = famElem.elementText("Nom");
2812: Family family = project.getFamilyFromModel(nomFamille);
2813: List suiteListXML = famElem
2814: .selectNodes("SuiteTestsCamp/SuiteTestRef");
2815: Iterator itSuite = suiteListXML.iterator();
2816: while (itSuite.hasNext()) {
2817: Element suiteElem = (Element) itSuite.next();
2818: String nomSuite = suiteElem.elementText("Nom");
2819: TestList testList = family.getTestListInModel(nomSuite);
2820: List testListXML = suiteElem
2821: .selectNodes("TestsCamp/TestRef");
2822: Iterator itTest = testListXML.iterator();
2823: while (itTest.hasNext()) {
2824: Element testElem = (Element) itTest.next();
2825: String nomTest = testElem.elementText("Nom");
2826: int userID = -1;
2827: String loginAssigned = testElem
2828: .attributeValue("loginAssigned");
2829: if (loginAssigned != null) {
2830: userID = project.containUser(loginAssigned);
2831: }
2832: if (userID == -1) {
2833: if (idialog != null) {
2834: //ConnectionData.getCampTestInsert().addResExecCampUsingID(nom, id_exec, DataModel.getCurrentUser().getLogin(), description, statut, resultat);
2835: userID = DataModel.getCurrentUser()
2836: .getIdBdd();
2837: } else {
2838: //ConnectionData.getCampTestInsert().addResExecCampUsingID(nom, id_exec, cdialog.getNewProject().getAdministrator().getLogin(), description, statut, resultat);
2839: userID = project
2840: .getAdministratorFromModel()
2841: .getIdBdd();
2842: }
2843: }
2844: Test pTest = testList.getTestFromModel(nomTest);
2845: pCamp.importTestInDBAndModel(pTest, userID);
2846: }
2847: }
2848: }
2849: }
2850:
2851: /**
2852: * Méthode qui ajoute les exécutions aux campagnes qui n'était pas au préalable dans la BD
2853: * @param campElem élément représentant la campagne dans le document XML
2854: * @param id_camp identifiant de la campagne dans la BD
2855: */
2856: public void ajouterExecutions(Element campElem, Campaign pCamp) {
2857: List listExecXML = campElem
2858: .selectNodes("ExecCampTests/ExecCampTest");
2859: Iterator itExec = listExecXML.iterator();
2860: while (itExec.hasNext()) {
2861: Element execElem = (Element) itExec.next();
2862: String nomExec = execElem.elementText("Nom");
2863: String description = (execElem.elementText("Description") != null) ? execElem
2864: .elementText("Description")
2865: : "";
2866: description = description.replaceAll("\\\\n", "\n");
2867: Execution pExecution = new Execution(nomExec, description);
2868:
2869: Element jeuElem = execElem.element("JeuDonneesEx");
2870: DataSet pDataSet = null;
2871: if (jeuElem != null) {
2872: String nomJeu = jeuElem.elementText("Nom");
2873: //id_jeu = ConnectionData.getCampTestSelect().getDataSetId(nomJeu, campName);
2874: pDataSet = pCamp.getDataSetFromModel(nomJeu);
2875: } else {
2876: pDataSet = new DataSet(ApiConstants.EMPTY_NAME, "");
2877: }
2878: pExecution.updateDatasetInModel(pDataSet);
2879:
2880: Element envElem = execElem.element("EnvironnementEx");
2881: String nomEnvXML = envElem.elementText("Nom");
2882:
2883: Environment pEnvironement = project
2884: .getEnvironmentFromModel(nomEnvXML);
2885: pExecution.updateEnvInModel(pEnvironement);
2886:
2887: User pUser = null;
2888: if (idialog != null) {
2889: pUser = DataModel.getCurrentUser();
2890: } else {
2891: pUser = project.getAdministratorFromModel();
2892: }
2893: try {
2894: pCamp.addExecutionInDBAndModel(pExecution, pUser);
2895:
2896: //Ajout des scripts
2897: Element scriptPre = (Element) execElem
2898: .selectSingleNode("Script[1]");
2899: if (scriptPre != null) {
2900: ajouterScriptToExec(scriptPre, pExecution);
2901: }
2902: Element scriptPost = (Element) execElem
2903: .selectSingleNode("Script[2]");
2904: if (scriptPost != null) {
2905: ajouterScriptToExec(scriptPost, pExecution);
2906: }
2907:
2908: //ajouter les attachements
2909: ajouterAttachements(execElem, pExecution);
2910:
2911: //ajouter les résultats d'exécutions
2912: ajouterResulExec(execElem, pExecution);
2913: } catch (Exception e) {
2914: Tools.ihmExceptionView(e);
2915: }
2916:
2917: }
2918: }
2919:
2920: /**
2921: * Méthode qui ajoute un script à une exécution
2922: * @param script élément script du document XML
2923: * @param id_exec identifiant de l'exécution
2924: */
2925: public void ajouterScriptToExec(Element script, Execution pExecution) {
2926: String classpath = script.elementText("Classpath");
2927: String argScript = script.elementText("ArgScript");
2928: String type = script.attributeValue("type");
2929: String dirScript = script.attributeValue("dir");
2930: dirScript = restorePath(dirScript);
2931: File fScript = new File(dirXml + fs + dirScript);
2932:
2933: Script pScritp = new Script(fScript.getName(), "");
2934: pScritp.setTypeInModel(type);
2935: pScritp.setScriptExtensionInModel(classpath);
2936: pScritp.updatePlugArgInModel(argScript);
2937: try {
2938: pExecution.addScriptInDBAndModel(pScritp, fScript);
2939: } catch (Exception e) {
2940: Tools.ihmExceptionView(e);
2941: }
2942: }
2943:
2944: /**
2945: * Méthode qui rajoute les résultats d'exécution à une campagne
2946: * @param execElem élément représentant l'exécution d'une campagne dans le document XML
2947: * @param id_exec identifiant de l'exécution dans la BD
2948: * @param campName nom de la campagne qui contient l'exécution
2949: */
2950: public void ajouterResulExec(Element execElem, Execution pExecution)
2951: throws Exception {
2952: List resulExecListXML = execElem
2953: .selectNodes("ResulExecCampTests/ResulExecCampTest");
2954: Iterator itRExec = resulExecListXML.iterator();
2955: while (itRExec.hasNext()) {
2956: Element rexecElem = (Element) itRExec.next();
2957: String nom = rexecElem.elementText("Nom");
2958: String description = (rexecElem.elementText("Description") != null) ? rexecElem
2959: .elementText("Description")
2960: : "";
2961: description = description.replaceAll("\\\\n", "\n");
2962: String resultat = rexecElem.attributeValue("statut");
2963: Element resExecElem = rexecElem.element("ResulExecs");
2964: String statut = "A_FAIRE";
2965: if (resExecElem != null) {
2966: statut = "FAIT";
2967: }
2968: User pUser = null;
2969: if (idialog != null) {
2970: //ConnectionData.getCampTestInsert().addResExecCampUsingID(nom, id_exec, DataModel.getCurrentUser().getLogin(), description, statut, resultat);
2971: pUser = DataModel.getCurrentUser();
2972: } else {
2973: //ConnectionData.getCampTestInsert().addResExecCampUsingID(nom, id_exec, cdialog.getNewProject().getAdministrator().getLogin(), description, statut, resultat);
2974: pUser = project.getAdministratorFromModel();
2975: }
2976: ExecutionResult pExecutionResult = new ExecutionResult(nom,
2977: description, pExecution);
2978: pExecutionResult.setExecutionStatusInModel(resultat);
2979: //pExecutionResult.addInDB(pExecution, pUser);
2980: pExecution.addExecutionResultInDBAndModel(pExecutionResult,
2981: pUser);
2982:
2983: ajouterAttachements(rexecElem, pExecutionResult);
2984: if (resExecElem != null) {
2985: List execCasList = resExecElem.selectNodes("ResulExec");
2986: Iterator itExecCas = execCasList.iterator();
2987: while (itExecCas.hasNext()) {
2988: Element execCasElem = (Element) itExecCas.next();
2989: String res = execCasElem.attributeValue("res");
2990: Element refTest = execCasElem.element("RefTest");
2991: String nomTest = refTest.elementText("NomTest");
2992: String nomSuite = refTest.elementText("NomSuite");
2993: String nomFamille = refTest
2994: .elementText("NomFamille");
2995:
2996: Test pTest = project.getTestFromModel(nomFamille,
2997: nomSuite, nomTest);
2998: ExecutionTestResult pExecutionTestResult = pExecutionResult
2999: .initTestResultStatusInModel(pTest, res, 0,
3000: pExecution.getCampagneFromModel());
3001: if (!pExecutionTestResult.isInBase()) {
3002: pExecutionResult.addExecTestResultInDB(pTest);
3003: }
3004: ajouterAttachements(execCasElem,
3005: pExecutionTestResult);
3006:
3007: }
3008: }
3009:
3010: List resActionList = rexecElem
3011: .selectNodes("ResulActionTests/ResulActionTest");
3012: Iterator itResAction = resActionList.iterator();
3013: while (itResAction.hasNext()) {
3014: Element resAction = (Element) itResAction.next();
3015: Element refAction = resAction.element("RefAction");
3016: String nomAction = refAction.elementText("NomAction");
3017: String nomTest = refAction.elementText("NomTest");
3018: String nomSuite = refAction.elementText("NomSuite");
3019: String nomFamille = refAction.elementText("NomFamille");
3020:
3021: Test pTest = project.getTestFromModel(nomFamille,
3022: nomSuite, nomTest);
3023: Action pAction = ((ManualTest) pTest)
3024: .getActionFromModel(nomAction);
3025: ManualExecutionResult pManualExecutionResult = (ManualExecutionResult) pExecutionResult
3026: .getExecutionTestResultFromModel(pTest);
3027: if (!pManualExecutionResult.isInBase()) {
3028: pExecutionResult
3029: .addExecTestResultInDB((ManualTest) pTest);
3030: }
3031: String resultatAction = resAction.attributeValue("res");
3032: if (resultatAction.equals("NonRenseigne")) {
3033: resultatAction = "";
3034: }
3035: String descAction = (resAction
3036: .elementText("Description") == null) ? ""
3037: : resAction.elementText("Description");
3038: String resulAttendu = (resAction
3039: .elementText("ResultAttendu") == null) ? ""
3040: : resAction.elementText("ResultAttendu");
3041: String effectiveAttendu = (resAction
3042: .elementText("ResulEffectif") == null) ? ""
3043: : resAction.elementText("ResulEffectif");
3044:
3045: descAction = descAction.replaceAll("\\\\n", "\n");
3046: resulAttendu = resulAttendu.replaceAll("\\\\n", "\n");
3047: effectiveAttendu = effectiveAttendu.replaceAll("\\\\n",
3048: "\n");
3049:
3050: //ConnectionData.getCampTestInsert().addResExecActionUsingID(id_exec_res, id_test, id_action, resultatAction, descAction, resulAttendu);
3051:
3052: pManualExecutionResult.addStatusForActionInModel(
3053: pAction, resultatAction);
3054: pManualExecutionResult.addEffectivResultInModel(
3055: pAction, effectiveAttendu);
3056: pManualExecutionResult.addDescriptionResultInModel(
3057: pAction, descAction);
3058: pManualExecutionResult.addAwaitedResultInModel(pAction,
3059: resulAttendu);
3060: pExecutionResult
3061: .addExecActionResultInDB(pTest, pAction);
3062: //pManualExecutionResult.addActionResultInDB(pAction);
3063:
3064: }
3065: }
3066: }
3067:
3068: /****************************************************************************************/
3069:
3070: /**
3071: * Si le test appartient à une campagne dont une exécution a déjà été lancée
3072: * on cherche à savoir si le test du projet possède des différences avec le test présent dans le fichier XML,
3073: * ces différences générant un conflit
3074: * @param familyName nom de la famille auquelle appartient le test
3075: * @param suiteName nom de la suite auquelle appartient le test
3076: * @param testElem élément test du document XML
3077: * @return true si réel conflit, false sinon
3078: */
3079: public boolean detecterModif(Family pFamily, TestList suite,
3080: Element testElem) {
3081: //on vérifie que tous les paramètres qui sont dans le document d'import sont dans le projet
3082: boolean existeModif = false;
3083: String testName = testElem.elementText("Nom");
3084: //Test test = TestPlanData.getTest(familyName, suiteName, testName);
3085: Test test = project.getTestFromModel(
3086: pFamily.getNameFromModel(), suite.getNameFromModel(),
3087: testName);
3088: List paramsImport = testElem.selectNodes("ParamsT/ParamT/Nom");
3089: ArrayList paramsProjet = test.getParameterListFromModel();
3090: Iterator itImport = paramsImport.iterator();
3091: while (itImport.hasNext() && !existeModif) {
3092: String nomParamImport = ((Element) itImport.next())
3093: .getText();
3094: boolean appartient = false;
3095: Iterator itParamProjet = paramsProjet.iterator();
3096: while (itParamProjet.hasNext()) {
3097: Parameter param = (Parameter) itParamProjet.next();
3098: if (param.getNameFromModel().equals(nomParamImport)) {
3099: appartient = true;
3100: }
3101: }
3102: if (!appartient) {
3103: existeModif = true;
3104: }
3105: }
3106: if (!existeModif) {
3107: //on vérifie que tous les paramètres qui sont dans le projet sont bien dans le document d'import
3108: Iterator itProj = paramsProjet.iterator();
3109: while (itProj.hasNext() && !existeModif) {
3110: Parameter param = (Parameter) itProj.next();
3111: boolean appartient = false;
3112: Iterator itDonnees = paramsImport.iterator();
3113: while (itDonnees.hasNext()) {
3114: String nomParam = ((Element) itDonnees.next())
3115: .getText();
3116: if (nomParam.equals(param.getNameFromModel())) {
3117: appartient = true;
3118: }
3119: }
3120: if (!appartient) {
3121: existeModif = true;
3122: }
3123: }
3124: }
3125: //Vérification des actions si paramètres ok
3126: if (!existeModif && (test instanceof ManualTest)) {
3127: //détection de modifications dans les actions
3128: ManualTest testManuel = (ManualTest) test;
3129: List actionList = testElem.selectNodes(".//ActionTest");
3130: Iterator itAction = actionList.iterator();
3131: while (itAction.hasNext() && !existeModif) {
3132: Element actionElem = (Element) itAction.next();
3133: String nomAction = actionElem.elementText("Nom");
3134: String descriptionAction = (actionElem
3135: .elementText("Description") == null) ? ""
3136: : actionElem.elementText("Description");
3137: String resulAttendu = (actionElem
3138: .elementText("ResultAttendu") == null) ? ""
3139: : actionElem.elementText("ResultAttendu");
3140: descriptionAction = descriptionAction.replaceAll(
3141: "\\\\n", "\n");
3142: resulAttendu = resulAttendu.replaceAll("\\\\n", "\n");
3143:
3144: Action pAction = testManuel
3145: .getActionFromModel(nomAction);
3146: if (pAction == null) {
3147: existeModif = true;
3148: } else {
3149: if (!pAction.getDescriptionFromModel().trim()
3150: .equals(descriptionAction)
3151: || !pAction.getAwaitedResultFromModel()
3152: .trim().equals(resulAttendu)) {
3153: existeModif = true;
3154: }
3155: if (!existeModif) {
3156: existeModif = verifParamsAction(actionElem,
3157: pAction);
3158: }
3159: }
3160: }
3161: if (!existeModif) {
3162:
3163: //vérifier que toutes les actions qui sont dans le projet sont dans le fichier XML
3164: ArrayList actionsProjet = testManuel
3165: .getActionListFromModel(false);
3166: Iterator itProj = actionsProjet.iterator();
3167: while (itProj.hasNext() && !existeModif) {
3168: Action action = (Action) itProj.next();
3169: boolean appartient = false;
3170: Iterator itDonnees = actionList.iterator();
3171: while (itDonnees.hasNext()) {
3172: Element actionElem = (Element) itDonnees.next();
3173: String nomAction = actionElem
3174: .elementText("Nom");
3175: if (action.getNameFromModel().equals(nomAction)) {
3176: appartient = true;
3177: }
3178: }
3179: if (!appartient) {
3180: existeModif = true;
3181: }
3182: }
3183: }
3184: }
3185: return existeModif;
3186: }
3187:
3188: /**
3189: * Méthode qui détecte si il existe un conflit pour la mise à jour des campagnes
3190: * @param campaign la campgne concernée
3191: * @param campElem l'élément campagne du document XML
3192: * @return
3193: */
3194: public boolean detecterConflitCamp(Campaign campaign,
3195: Element campElem) {
3196: boolean conflit = false;
3197: boolean contientResulExec = false;
3198: ArrayList listExec = campaign.getExecutionListFromModel();
3199: Iterator itListExec = listExec.iterator();
3200: while (itListExec.hasNext()) {
3201: Execution exec = (Execution) itListExec.next();
3202: if (!exec.getExecutionResultListFromModel().isEmpty()) {
3203: contientResulExec = true;
3204: }
3205: }
3206: if (contientResulExec) {
3207: List testListXML = campElem
3208: .selectNodes("FamillesCamp/FamilleRef/SuiteTestsCamp/SuiteTestRef/TestsCamp/TestRef");
3209: Iterator itTestXML = testListXML.iterator();
3210: ArrayList testList = campaign.getTestListFromModel();
3211: if (testListXML.size() != testList.size()) {
3212: conflit = true;
3213: } else {
3214: while (itTestXML.hasNext() && !conflit) {
3215: Element testRef = (Element) itTestXML.next();
3216: String nomTest = testRef.elementText("Nom");
3217: String nomSuite = ((Element) testRef
3218: .selectSingleNode("ancestor::SuiteTestRef[1]"))
3219: .elementText("Nom");
3220: String nomFamille = ((Element) testRef
3221: .selectSingleNode("ancestor::FamilleRef[1]"))
3222: .elementText("Nom");
3223: boolean appartient = false;
3224: //ArrayList testList = campaign.getTestListFromModel();
3225: Iterator itTestList = testList.iterator();
3226: while (itTestList.hasNext() && !appartient) {
3227: Test test = (Test) itTestList.next();
3228: String suiteName = test.getTestListFromModel()
3229: .getNameFromModel();
3230: String familyName = test.getTestListFromModel()
3231: .getFamilyFromModel()
3232: .getNameFromModel();
3233: //if (test.getNameFromModel().equals(nomTest) && suiteName.equals(suiteRootElem.elementText("Nom")) && familyName.equals(famRootElem.elementText("Nom"))){
3234: if (test.getNameFromModel().equals(nomTest)
3235: && suiteName.equals(nomSuite)
3236: && familyName.equals(nomFamille)) {
3237: appartient = true;
3238: }
3239: }
3240: if (!appartient) {
3241: conflit = true;
3242: }
3243: }
3244: }
3245:
3246: }
3247: return conflit;
3248: }
3249:
3250: /**
3251: * Méthode qui évalue si il y a une différence entre les paramètres d'une action dans le document XML
3252: * et ceux de cette même action dans le projet Salomé
3253: * @param actionElem élément du document DOM4J contenant l'action
3254: * @param action action dans le modèle de SaloméTMF
3255: * @return
3256: */
3257: public boolean verifParamsAction(Element actionElem, Action action) {
3258: boolean existeModif = false;
3259: List paramsImport = actionElem
3260: .selectNodes("ParamsT/ParamT/Nom");
3261: Hashtable paramsProjet = action.getParameterHashSetFromModel();
3262: Iterator itImport = paramsImport.iterator();
3263: //on vérifie que tous les paramètres qui sont dans le document d'import sont bien dans le projet
3264: while (itImport.hasNext() && !existeModif) {
3265: String nomParamImport = ((Element) itImport.next())
3266: .getText();
3267: if (action.getParameterFromModel(nomParamImport) == null) {
3268: existeModif = true;
3269: }
3270: }
3271: if (!existeModif) {
3272: //on vérifie que tous les paramètres qui sont dans le projet sont bien dans le document d'import
3273: Enumeration itProj = paramsProjet.elements();
3274: while (itProj.hasMoreElements() && !existeModif) {
3275: Parameter param = (Parameter) itProj.nextElement();
3276: boolean appartient = false;
3277: Iterator itDonnees = paramsImport.iterator();
3278: while (itDonnees.hasNext()) {
3279: String nomParam = ((Element) itDonnees.next())
3280: .getText();
3281: if (nomParam.equals(param.getNameFromModel())) {
3282: appartient = true;
3283: }
3284: }
3285: if (!appartient) {
3286: existeModif = true;
3287: }
3288: }
3289: }
3290: return existeModif;
3291: }
3292:
3293: /****************************************************************************************/
3294:
3295: void coreImport() {
3296: try {
3297: automatedTest2Update = new Vector();
3298:
3299: updateProjectAttachement();
3300:
3301: //Paramètres du projet
3302: updateProjectParameter();
3303:
3304: //Environnement du projet
3305: updateProjectEnvironment();
3306:
3307: if (pImportReq != null && importReq) {
3308: pImportReq.updateProjectRequirement(doc);
3309: }
3310:
3311: //Abre de test
3312: updateFamily();
3313:
3314: if (!isImportOnlyTests() && !annule) {
3315: gestionDesCampagnes();
3316: //DataModel.reloadFromBase();
3317: }
3318: updatePlugin();
3319:
3320: } catch (Exception e) {
3321: Tools.ihmExceptionView(e);
3322: annule = true;
3323: return;
3324: }
3325: }
3326:
3327: public void importInProject() {
3328: project = DataModel.getCurrentProject(); //Add for V2
3329: DataModel.reloadFromBase(false);
3330:
3331: try {
3332: if (idialog.isSupprElement() && !annule) {
3333: gestionDesSuppressionsProject();
3334: gestionDesSuppressionsTests();
3335: gestionDesSuppressionsCampagnes();
3336: if (pImportReq != null && importReq) {
3337: pImportReq.gestionDesSuppressionsRequirements(doc);
3338: }
3339: if (isImportOnlyTests()) {
3340: //suppressionsCampagnes();
3341: }
3342: }
3343:
3344: } catch (Exception e) {
3345: Tools.ihmExceptionView(e);
3346: annule = true;
3347: return;
3348: }
3349: coreImport();
3350:
3351: if (importReq && pImportReq != null) {
3352: pImportReq.reloadReq();
3353: }
3354: DataModel.reloadFromBase(true);
3355: }
3356:
3357: public void importInNewProject() {
3358: //créer le nouveau projet avec son administrateur
3359: //System.out.println("début import in new Project");
3360: newProject = true;
3361: ArrayList data = new ArrayList();
3362: project = cdialog.getNewProject();
3363: if (project != null && !annule) {
3364: if (Api.isConnected()) {
3365: //int transNumber = -1;
3366: try {
3367: project.addInDB();
3368: project.setUserInModel(project
3369: .getAdministratorFromModel());
3370:
3371: data.add(Tools.createAppletImageIcon(
3372: PATH_TO_PROJECT_ICON, ""));
3373: data.add(project.getNameFromModel().trim());
3374: data.add(project.getAdministratorFromModel()
3375: .getLoginFromModel());
3376: data.add(project.getCreationDateFromModel()
3377: .toString());
3378: data.add(project.getDescriptionFromModel());
3379: JTable projectTable = (JTable) Administration
3380: .getUIComponent(UICompCst.ADMIN_PROJECT_MANAGEMENT_TABLE);
3381: ((MyTableModel) projectTable.getModel())
3382: .addRow(data);
3383: project.setUserInModel(project
3384: .getAdministratorFromModel());
3385: pAdminVTData.addProjectInModel(project);
3386: pAdminVTData.addAdminToProjectInModel(project
3387: .getAdministratorFromModel(), project);
3388: //ProjectTableCellRenderer.setColor(new Color(204,255,204));
3389: projectTable.getColumnModel().getColumn(0)
3390: .setMaxWidth(18);
3391: //deleteProjectButton.setEnabled(true);
3392: } catch (Exception exception) {
3393: //Api.forceRollBackTrans(transNumber);
3394: cdialog
3395: .setErrorMessage(cdialog.getErrorMessage()
3396: + Language
3397: .getInstance()
3398: .getText(
3399: "Problème_lors_de_la_création_du_nouveau_projet"));
3400: cdialog.showErrorMessage();
3401: setAnnule(true);
3402: }
3403: }
3404:
3405: }
3406:
3407: if (!annule) {
3408: coreImport();
3409: /*try {
3410: importProject();
3411: importTest();
3412: if (!isImportOnlyTests()){
3413: importCampaign();
3414: }
3415: } catch (Exception e){
3416: Tools.ihmExceptionView(e);
3417: }*/
3418: }
3419: }
3420:
3421: String getLogin(Element pElem) {
3422: String login = pElem.element("Concepteur").elementText("Login");
3423: if (project.containUser(login) != -1) {
3424: return login;
3425: } else {
3426: return null;
3427: }
3428: }
3429:
3430: /****************************************************************************************/
3431: /**
3432: * @return Returns the doc.
3433: */
3434: public Document getDoc() {
3435: return doc;
3436: }
3437:
3438: /**
3439: * @param doc The doc to set.
3440: */
3441: public void setDoc(Document doc) {
3442: this .doc = doc;
3443: }
3444:
3445: // /**
3446: // * @return Returns the adminFrame.
3447: // */
3448: // public Administration getAdminFrame() {
3449: // return adminFrame;
3450: // }
3451: // /**
3452: // * @param adminFrame The adminFrame to set.
3453: // */
3454: // public void setAdminFrame(Administration adminFrame) {
3455: // this.adminFrame = adminFrame;
3456: // }
3457: /**
3458: * @return Returns the dirXml.
3459: */
3460: public String getDirXml() {
3461: return dirXml;
3462: }
3463:
3464: /**
3465: * @param dirXml The dirXml to set.
3466: */
3467: public void setDirXml(String dirXml) {
3468: this .dirXml = dirXml;
3469: }
3470:
3471: /**
3472: * @return Returns the selectionDesTests.
3473: */
3474: public boolean isSelectionDesTests() {
3475: return selectionDesTests;
3476: }
3477:
3478: /**
3479: * @param selectionDesTests The selectionDesTests to set.
3480: */
3481: public void setSelectionDesTests(boolean selectionDesTests) {
3482: this .selectionDesTests = selectionDesTests;
3483: }
3484:
3485: /**
3486: * @return Returns the importOnlyTests.
3487: */
3488: public boolean isImportOnlyTests() {
3489: return importOnlyTests;
3490: }
3491:
3492: /**
3493: * @param importOnlyTests The importOnlyTests to set.
3494: */
3495: public void setImportOnlyTests(boolean importOnlyTests) {
3496: this .importOnlyTests = importOnlyTests;
3497: }
3498:
3499: public void setImportRequirement(boolean importReq) {
3500: this .importReq = importReq;
3501:
3502: if (importReq == true) {
3503: try {
3504: pImportReq = new ImportReq(this .pIPlugObject, this );
3505: } catch (Exception e) {
3506: importReq = false;
3507: pImportReq = null;
3508: }
3509: }
3510: }
3511:
3512: /**
3513: * @return Returns the annule.
3514: */
3515: public boolean isAnnule() {
3516: return annule;
3517: }
3518:
3519: /**
3520: * @param annule The annule to set.
3521: */
3522: public void setAnnule(boolean annule) {
3523: this .annule = annule;
3524: }
3525:
3526: String restorePath(String path) {
3527: if (fs.equals("\\")) {
3528: //Unix2Windows
3529: return path.replace('/', '\\');
3530: } else {
3531: return path.replace('\\', '/');
3532: }
3533: }
3534: }
|