Source Code Cross Referenced for Import.java in  » Test-Coverage » salome-tmf » salomeTMF_plug » gen_doc_xml » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » Test Coverage » salome tmf » salomeTMF_plug.gen_doc_xml 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


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