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