001: package org.objectweb.salome_tmf.data;
002:
003: import java.util.ArrayList;
004:
005: import org.objectweb.salome_tmf.api.ApiConstants;
006: import org.objectweb.salome_tmf.ihm.tools.Tools;
007:
008: public class TestPlanData implements ApiConstants {
009:
010: /**
011: * Liste des familles
012: */
013: static private ArrayList familyList = new ArrayList();;
014:
015: /**
016: * Famille par défaut
017: */
018: //static private Family defaultFamily = null;
019: /***********************************************************************************************************/
020: static void clearData() {
021: familyList.clear();
022: /*if (defaultFamily == null) {
023: defaultFamily = new Family();
024: defaultFamily.setName(DEFAULT_FAMILY_NAME);
025: }*/
026:
027: }
028:
029: /***********************************************************************************/
030:
031: /**
032: * Retourne la liste ordonnée des tests d'une suite
033: * @param list une suite
034: * @return liste ordonnée de la suite passée en paramètre
035: */
036: public static ArrayList getAllTest(TestList list) {
037: return list.getTestList();
038: } // Fin de la méthode getAllTest/1
039:
040: /**
041: * Retourne la liste ordonnée des objets "suites de tests"
042: * @return la liste ordonnée de tous les objets "suites de tests"
043: */
044: public static ArrayList getAllTestList(Family family) {
045: return family.getTestListList();
046: } // Fin de la méthode getAllTestList/1
047:
048: /**
049: * Retourne la liste ordonnée des familles
050: */
051: public static ArrayList getFamilyList() {
052: return familyList;
053: } // Fin de la méthode getFamilySet/0
054:
055: /**
056: * @return
057: */
058: /*public static Family getDefaultFamily() {
059: return defaultFamily;
060: }*/
061:
062: /**
063: * @param family
064: */
065: /*public static void setDefaultFamily(Family family) {
066: defaultFamily = family;
067: }*/
068:
069: /**
070: * Retourne la famille dont le nom est passé en paramètre
071: * @param familyName un nom
072: * @return Retourne la famille dont le nom est passé en paramètre, <code>null</code>
073: * si le nom n'est pas celui d'une famille
074: */
075: public static Family getFamily(String familyName) {
076: for (int i = 0; i < familyList.size(); i++) {
077: if (((Family) familyList.get(i)).getName().equals(
078: familyName)) {
079: return (Family) familyList.get(i);
080: }
081: }
082: return null;
083: } // Fin de la méthode getFamily/1
084:
085: /**
086: * Retourne la famille dont le nom est passé en paramètre
087: * @param int id l'id d'une famille
088: * @return Retourne la famille dont le nom est passé en paramètre, <code>null</code>
089: * si le nom n'est pas celui d'une famille
090: */
091: public static Family getFamily(int id) {
092: for (int i = 0; i < familyList.size(); i++) {
093: if (((Family) familyList.get(i)).getIdBdd() == id) {
094: return (Family) familyList.get(i);
095: }
096: }
097: return null;
098: } // Fin de la méthode getFamily/1
099:
100: /**
101: * Retourne la suite de tests dont le nom est passé en paramètre
102: * @param familyName un nom de famille
103: * @param testListName un nom
104: * @return Retourne la suite de tests dont le nom est passé en paramètre, <code>null</code>
105: * si le nom n'est pas celui d'une suite de tests
106: */
107: public static TestList getTestList(String familyName,
108: String testListName) {
109: for (int i = 0; i < familyList.size(); i++) {
110: if (((Family) familyList.get(i)).getName().equals(
111: familyName)) {
112: ArrayList list = ((Family) familyList.get(i))
113: .getTestListList();
114: for (int j = 0; j < list.size(); j++) {
115: if (((TestList) list.get(j)).getName().equals(
116: testListName)) {
117: return (TestList) list.get(j);
118: }
119:
120: }
121: }
122: }
123: return null;
124: } // Fin de la méthode getTestList/2
125:
126: /**
127: * Retourne le test dont le nom est passé en paramètre
128: * @param familyName un nom de famille
129: * @param testListName un nom de suite
130: * @param un nom de test
131: * @return Retourne le test dont le nom est passé en paramètre, <code>null</code>
132: * si le nom n'est pas celui d'un test
133: */
134: public static Test getTest(String familyName, String testListName,
135: String testName) {
136: for (int i = 0; i < familyList.size(); i++) {
137: if (((Family) familyList.get(i)).getName().equals(
138: familyName)) {
139: ArrayList list = ((Family) familyList.get(i))
140: .getTestListList();
141: for (int j = 0; j < list.size(); j++) {
142: if (((TestList) list.get(j)).getName().equals(
143: testListName)) {
144: ArrayList tests = ((TestList) list.get(j))
145: .getTestList();
146: for (int k = 0; k < tests.size(); k++) {
147: if (((Test) tests.get(k)).getName().equals(
148: testName)) {
149: return (Test) tests.get(k);
150: }
151: }
152: }
153:
154: }
155: }
156: }
157: return null;
158: } // Fin de la méthode getTest/3
159:
160: public static ArrayList getTestOfParameter(String paramName) {
161: ArrayList result = new ArrayList();
162: for (int i = 0; i < familyList.size(); i++) {
163: ArrayList testListArrayList = ((Family) familyList.get(i))
164: .getTestListList();
165: for (int j = 0; j < testListArrayList.size(); j++) {
166: ArrayList testArrayList = ((TestList) testListArrayList
167: .get(j)).getTestList();
168: for (int k = 0; k < testArrayList.size(); k++) {
169: if (((Test) testArrayList.get(k))
170: .getParameter(paramName) != null) {
171: result.add(testArrayList.get(k));
172: }
173: }
174: }
175: }
176: return result;
177: }
178:
179: /**************** Operations d'ajout dans le modele de données **********************************/
180: /*
181: * Ajoute une famille
182: * @param familyName le nom de la famille
183: */
184: static void addFamilyInModel(Family family) {
185: familyList.add(family);
186: } // Fin de la méthode addFamily/1
187:
188: public static void addFamilyInBddAndModel(Family family)
189: throws Exception {
190: //Bdd
191: family.add2DB(getFamilyList().size());
192:
193: //Model
194: addFamilyInModel(family);
195: } // Fin de la méthode addFamily/1
196:
197: /**
198: * Ajoute une suite de tests dans une famille existante
199: * @param list
200: * @param family
201: */
202: static void addTestListInFamilyInModel(TestList list, Family family) {
203: list.setFamily(family);
204: family.addTestList(list);
205: } // Fin de la méthode addNewTestListInOldFamily/2
206:
207: // Return True if IHM need refresh
208: public static boolean addTestListInFamilyInModelAndBDD(
209: TestList pList, Family pFamily) throws Exception {
210: boolean refresh = false;
211: //BDD
212: if (pFamily == null) {
213: throw new Exception();
214: }
215: if (pFamily.getIdBdd() == -1) {
216: throw new Exception();
217: }
218: pList.setFamily(pFamily);
219: refresh = pList.add2DB();
220:
221: addTestListInFamilyInModel(pList, pFamily);
222: return refresh;
223: }
224:
225: static void addTestInListInModel(Test test, TestList list) {
226: list.addTest(test);
227: test.setTestList(list);
228: } // Fin de la méthode addTestInOldList/2
229:
230: public static boolean addTestInListInBddAndModel(Test pTest,
231: TestList list) throws Exception {
232: boolean res;
233: //BDD
234: //pTest.setTestList(list);
235: //res = pTest.add2DB();
236: res = pTest.addInBddAndModel(list);
237: //Model
238: //addTestInListInModel(pTest, list );
239: return res;
240: } // Fin de la méthode addTestInOldList/2
241:
242: /**************** Operations de suppression dans données **********************************/
243:
244: /**
245: * Supprime un test
246: * @param test un test
247: */
248: static void deleteTestInModel(Test pTest) {
249: TestList pList = pTest.getTestList();
250: ArrayList campaignList = CampaignData.getCampaignOfTest(pTest);
251:
252: deleteTestFromListFromModel(pTest, pList);
253:
254: /* Delete From Campain */
255: for (int i = 0; i < campaignList.size(); i++) {
256: CampaignData.deleteTestFromCampaignInModel(pTest,
257: (Campaign) campaignList.get(i));
258: }
259: //TestList pTestList = pTest.getTestList();
260: //pTestList.removeTest(pTest);
261:
262: } // Fin de la méthode deleteTest/1
263:
264: public static void deleteTestInBDDandModel(Test pTest)
265: throws Exception {
266: // BDD
267: //pTest.deleteFromDB(true);
268: pTest.deleteInBddAndModel(true);
269: // Model
270: deleteTestInModel(pTest);
271: } // Fin de la méthode deleteTest/1
272:
273: /**
274: * Supprime un test d'une suite de tests
275: * @param test un test
276: * @param list une suite de tests
277: */
278: static void deleteTestFromListFromModel(Test test, TestList list) {
279: list.removeTest(test);
280: /* Refresh Test order */
281: for (int i = 0; i < list.getTestList().size(); i++) {
282: ((Test) (list.getTestList().get(i))).setOrder(i);
283: }
284: } // Fin de la méthode deleteTestFromList/2
285:
286: /**
287: * Supprime une suite de tests
288: * @param list une suite de tests
289: */
290: static void deleteTestListInModel(TestList pList) {
291: ArrayList campaignList = CampaignData
292: .getCampaignOfTestList(pList);
293:
294: pList.getFamily().removeTestList(pList);
295:
296: for (int i = 0; i < campaignList.size(); i++) {
297: CampaignData.deleteTestListFromCampaignInModel(pList,
298: (Campaign) campaignList.get(i));
299: }
300:
301: } // Fin de la méthode deleteTestList/1
302:
303: public static void deleteTestListInBDDandModel(TestList pList)
304: throws Exception {
305: //BDD
306: //pList.deleteFromDB(true);
307: pList.deleteInBddAndModel(true);
308: //Model
309: deleteTestListInModel(pList);
310: }
311:
312: /**
313: * Supprime une famille du model en mettant à jour le model
314: * Suppression dans les campagnes
315: * @param family une famille
316: */
317: static void deleteFamilyInModel(Family pFamily) {
318: ArrayList campaignList = CampaignData
319: .getCampaignOfFamily(pFamily);
320: familyList.remove(pFamily);
321:
322: for (int i = 0; i < campaignList.size(); i++) {
323: CampaignData.deleteFamilyFromCampaignFromModel(pFamily,
324: (Campaign) campaignList.get(i));
325: }
326:
327: } // Fin de la méthode deleteFamily/1
328:
329: public static void deleteFamilyInBDDandModel(Family pFamily)
330: throws Exception {
331: // BDD
332: pFamily.deleteFromDB(true);
333: //Model
334: deleteFamilyInModel(pFamily);
335: } // Fin de la méthode deleteFamily/1
336:
337: /**********************************************************************************************************/
338:
339: /**
340: * Méthode qui rend vrai si la suite passée en paramètre
341: * possède un test dont le nom est passé en paramètre, faux sinon.
342: * @param testListName le nom d'une suite
343: * @param testName le nom d'un test
344: * @return vrai si la suite dont le nom est passée en paramètre
345: * possède un test dont le nom est passé en paramètre, faux sinon.
346: */
347: public static boolean containsTest(TestList testList,
348: String testName) {
349: for (int i = 0; i < testList.getTestList().size(); i++) {
350: Test test = (Test) testList.getTestList().get(i);
351: if (test.getName().equals(testName)) {
352: return true;
353: }
354: }
355: return false;
356: } // Fin de la méthode containsTest/2
357:
358: /**
359: * Rend vrai si la famille passée en paramètre contient une suite de tests
360: * dont le nom est passé en paramètre, faux sinon.
361: * @param family une famille
362: * @param testListName une suite de tests
363: * @return Rend vrai si la famille passée en paramètre contient une suite de tests
364: * dont le nom est passé en paramètre, faux sinon.
365: */
366: public static boolean containsTestList(Family family,
367: String testListName) {
368: for (int i = 0; i < family.getTestListList().size(); i++) {
369: if (((TestList) family.getTestListList().get(i)).getName()
370: .equals(testListName)) {
371: System.out.println("containsTestList --> true");
372: return true;
373: }
374: }
375: System.out.println("containsTestList --> false");
376: return false;
377: } // Fin de la méthode containsTestList/2
378:
379: /**
380: * Rend vrai si le nom passé en paramètre correspond au nom d'une famille
381: * @param familyName le nom d'une famille
382: * @return Rend vrai si le nom passé en paramètre correspond au nom d'une
383: * famille, faux sinon.
384: */
385: public static boolean containsFamily(String familyName) {
386: for (int i = 0; i < familyList.size(); i++) {
387: if (((Family) familyList.get(i)).getName().equals(
388: familyName)) {
389: return true;
390: }
391: }
392: return false;
393: } // Fin de la méthode containsFamily/1
394: }
|