001: /*
002: * SalomeTMF is a Test Management Framework
003: * Copyright (C) 2005 France Telecom R&D
004: *
005: * This library is free software; you can redistribute it and/or
006: * modify it under the terms of the GNU Lesser General Public
007: * License as published by the Free Software Foundation; either
008: * version 2 of the License, or (at your option) any later version.
009: *
010: * This library is distributed in the hope that it will be useful,
011: * but WITHOUT ANY WARRANTY; without even the implied warranty of
012: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
013: * Lesser General Public License for more details.
014: *
015: * You should have received a copy of the GNU Lesser General Public
016: * License along with this library; if not, write to the Free Software
017: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
018: *
019: * @author Fayçal SOUGRATI, Vincent Pautret, Marche Mikael
020: *
021: * Contact: mikael.marche@rd.francetelecom.com
022: */
023:
024: package org.objectweb.salome_tmf.data;
025:
026: import java.util.ArrayList;
027: import java.util.HashSet;
028: import java.util.Hashtable;
029: import java.util.Iterator;
030: import java.util.Set;
031: import java.util.Vector;
032:
033: import org.objectweb.salome_tmf.api.Api;
034: import org.objectweb.salome_tmf.api.ApiConstants;
035: import org.objectweb.salome_tmf.api.Util;
036: import org.objectweb.salome_tmf.api.data.GroupWrapper;
037: import org.objectweb.salome_tmf.api.data.ProjectWrapper;
038: import org.objectweb.salome_tmf.api.data.UserWrapper;
039: import org.objectweb.salome_tmf.api.sql.ISQLGroup;
040: import org.objectweb.salome_tmf.api.sql.ISQLPersonne;
041: import org.objectweb.salome_tmf.api.sql.ISQLProject;
042:
043: /**
044: * Classe qui regroupe les données sur les utilisateurs et sur les groupes pour
045: * l'administration des projets.
046: * @author teaml039
047: * @version : 0.1
048: */
049: public class AdminProjectData {
050: //implements DataConstants
051:
052: static ISQLProject pISQLProject = null;
053: static ISQLPersonne pISQLPersonne = null;
054: static ISQLGroup pISQLGroup = null;
055: /**
056: * Utilisateur courant
057: */
058: private User currentUser;
059:
060: /**
061: * Projet courant
062: */
063: private Project currentProject;
064:
065: /**
066: * Le groupe courant
067: */
068: private Group currentGroup;
069:
070: /**
071: * Ensemble des utilisateurs du projet. Regroupe des éléments de classe
072: * <code>User</code>.
073: */
074: private HashSet userSet = new HashSet();
075:
076: /**
077: * Ensemble des utilisateurs ne faisant pas partie du projet. Regroupe des
078: * éléments de classe <code>User</code>.
079: */
080: private HashSet notInProjectUserSet = new HashSet();
081:
082: /**
083: * Table qui associe aux utilisateurs les groupes. La clé est un objet User
084: * et la value un ensemble de groupes
085: */
086: HashMapForCollections usersMap = new HashMapForCollections();
087:
088: User pAdmin;
089:
090: /**************************************************************************/
091: /** METHODES PUBLIQUES ***/
092: /**************************************************************************/
093:
094: public void setUserAdminVTData(String login) {
095: // TODO
096: }
097:
098: public User getUserAdminVTData() {
099: return pAdmin;
100: }
101:
102: /**************************************************************************/
103: /** METHODES PUBLIQUES ***/
104: /**************************************************************************/
105:
106: /**
107: * Ajout d'un nouvel utilisateur
108: * @param user un utilisateur
109: */
110: public void addUserInModel(User user) {
111: if (user != null) {
112: usersMap.put(user, null);
113: userSet.add(user);
114: boolean in = notInProjectUserSet.remove(user);
115: if (in = false) {
116: System.out
117: .print("nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn");
118: }
119: }
120: } // Fin de la méthode addUser/1
121:
122: /**
123: * Ajoute un utilisateur dans la liste des utilisateurs ne faisant pas
124: * partie du projet
125: * @param user un utilisateur
126: */
127: public void addNotInProjectUserInModel(User user) {
128: notInProjectUserSet.add(user);
129: } // Fin de la méthode addNotInProjectUser/1
130:
131: /**
132: * Ajoute à groupe au projet courant
133: * @param group un groupe
134: */
135: public void addGroupInModel(Group group) {
136: if (group != null)
137: currentProject.addGroupInModel(group);
138: } // Fin de la méthode addGroup/1
139:
140: public void addGroupInDB(Group group) throws Exception {
141: group.setIdBdd(pISQLGroup.insert(currentProject.getIdBdd(),
142: group.getNameFromModel(), group
143: .getDescriptionFromModel(), 0));
144: }
145:
146: public void addGroupInDBAndModel(Group group) throws Exception {
147: addGroupInDB(group);
148: addGroupInModel(group);
149: }
150:
151: /**
152: * Ajoute un utilisateur dans un groupe donné
153: * @param user un utilisateur
154: * @param group un groupe
155: */
156: public void addUserInGroupInModel(User user, Group group) {
157: if (user != null) {
158: usersMap.put(user, group);
159: userSet.add(user);
160: notInProjectUserSet.remove(user);
161: }
162: if (group != null)
163: group.addUserInModel(user);
164: } // Fin de la méthode addUserInGroup/2
165:
166: public void addUserInGroupInDB(User user, Group group)
167: throws Exception {
168: pISQLGroup.insertUser(group.getIdBdd(), user.getIdBdd());
169: } // Fin de la méthode addUserInGroup/2
170:
171: public void addUserInGroupInDBAndModel(User user, Group group)
172: throws Exception {
173: if (user != null && group != null) {
174: if (user.isInBase() && group.isInBase()) {
175: if (!group.containUserInModel(user)) {
176: addUserInGroupInDB(user, group);
177: addUserInGroupInModel(user, group);
178: }
179: } else {
180: throw new Exception("group " + group.getNameFromModel()
181: + " and user " + user.getLoginFromModel()
182: + ", are not in DB");
183: }
184:
185: }
186: } // Fin de la méthode addUserInGroup/2
187:
188: /**
189: * Supprime un utilisateur du projet courant
190: * @param user un utilisateur
191: */
192: public void removeUserFromCurrentProjectInModel(User user) {
193: if (user != null) {
194: HashSet groupSet = (HashSet) usersMap.get(user);
195: for (Iterator iter = groupSet.iterator(); iter.hasNext();) {
196: Group group = (Group) iter.next();
197: group.removeUserInModel(user);
198: }
199: usersMap.remove(user);
200: userSet.remove(user);
201: notInProjectUserSet.add(user);
202: }
203: } // Fin de la méthode removeUserFromCurrentProject/1
204:
205: public void removeUserFromCurrentProjectInDB(User user)
206: throws Exception {
207: user.deleteInProjectInDB(currentProject.getNameFromModel());
208: }
209:
210: public void removeUserFromCurrentProjectInDBAndModel(User user)
211: throws Exception {
212: if (user != null) {
213: removeUserFromCurrentProjectInDB(user);
214: removeUserFromCurrentProjectInModel(user);
215: }
216: } // Fin de la méthode removeUserFromCurrentProject/1
217:
218: /**
219: * Supprime un utilisateur d'un groupe donné
220: * @param user un utilisateur
221: * @param group un groupe
222: */
223: public void removeUserFromGroupInModel(User user, Group group) {
224: HashSet groupSet = (HashSet) usersMap.get(user);
225: groupSet.remove(group);
226: group.removeUserInModel(user);
227: } // Fin de la méthode removeUserFromGroup/2
228:
229: public void removeUserFromGroupInDB(User user, Group group)
230: throws Exception {
231: pISQLGroup.deleteUserInGroup(group.getIdBdd(), user.getIdBdd());
232: }
233:
234: public void removeUserFromGroupInDBAndModel(User user, Group group)
235: throws Exception {
236: if (user != null && group != null) {
237: if (user.isInBase() && group.isInBase()) {
238: removeUserFromGroupInDB(user, group);
239: if (group.containUserInModel(user)) {
240: removeUserFromGroupInModel(user, group);
241: }
242: } else {
243: throw new Exception("group " + group.getNameFromModel()
244: + " and user " + user.getLoginFromModel()
245: + ", are not in DB");
246: }
247:
248: }
249:
250: } //
251:
252: /**
253: * Supprime un groupe du projet courant
254: * @param group un groupe
255: */
256: public void removeGroupInModel(Group group) {
257: ArrayList userSet = group.getUserListFromModel();
258: for (Iterator iter = userSet.iterator(); iter.hasNext();) {
259: HashSet groupSet = (HashSet) usersMap.get(iter.next());
260: groupSet.remove(group);
261: }
262: currentProject.removeGroup(group);
263: } // Fin de la méthode removeGroup/1
264:
265: public void removeGroupInDB(Group group) throws Exception {
266: group.delete();
267: }
268:
269: public void removeGroupInDBAndModel(Group group) throws Exception {
270: removeGroupInDB(group);
271: removeGroupInModel(group);
272: }
273:
274: /**
275: * Retourne le nombre de groupe dans le projet
276: * @return le nombre de groupe dans le projet
277: */
278: public int getGroupCountFromModel() {
279: return currentProject.getGroupListFromModel().size();
280: } // Fin de la méthode getGroupCount/0
281:
282: /**
283: * Retourne le nombre d'utilisateur dans le projet
284: * @return le nombre d'utilisateur dans le projet
285: */
286: public int getUserCountFromModel() {
287: return usersMap.size();
288: } // Fin de la méthode getUserCount/0
289:
290: /**
291: * Retourne le ième groupe
292: * @param i indice du groupe
293: * @return le groupe à l'indice i, <code>null</code> si l'indice passé en
294: * paramètre est supérieur au nombre de groupe
295: */
296: public Group getGroupFromModel(int i) {
297: if (i < currentProject.getGroupListFromModel().size()) {
298: return (Group) currentProject.getGroupListFromModel()
299: .get(i);
300: } else {
301: return null;
302: }
303: } // Fin de la méthode getGroup/1
304:
305: /**
306: * Retourne le groupe dont le nom est passé en paramètre s'il existe,
307: * <code>null</code> sinon
308: * @param name un nom de groupe
309: * @return le groupe dont le nom est passé en paramètre s'il existe,
310: * <code>null</code> sinon
311: */
312: public Group getGroupFromModel(String name) {
313: for (int i = 0; i < currentProject.getGroupListFromModel()
314: .size(); i++) {
315: if (((Group) currentProject.getGroupListFromModel().get(i))
316: .getNameFromModel().equals(name)) {
317: return (Group) currentProject.getGroupListFromModel()
318: .get(i);
319: }
320: }
321: return null;
322: } // Fin de la méthode getGroup/1
323:
324: /**
325: * Retourne le groupe courant
326: * @return le groupe courant
327: */
328: public Group getCurrentGroupFromModel() {
329: return currentGroup;
330: } // Fin de la méthode getCurrentGroup/0
331:
332: /**
333: * Retourne le projet courant
334: * @return le projet courant
335: */
336: public Project getCurrentProjectFromModel() {
337: return currentProject;
338: } // Fin de la méthode getCurrentProject/0
339:
340: /**
341: * Retourne l'utilisateur courant
342: * @return l'utilisateur courant
343: */
344: public User getCurrentUserFromModel() {
345: return currentUser;
346: } // Fin de la méthode getCurrentUser/0
347:
348: /**
349: * Mutateur du groupe courant
350: * @param group un groupe
351: */
352: public void setCurrentGroupInModel(Group group) {
353: //System.out.println("Set current group --------------> " + group);
354: currentGroup = group;
355: } // Fin de la méthode setCurrentGroup/1
356:
357: /**
358: * Mutateur du projet courant
359: * @param project un projet
360: */
361: public void setCurrentProjectInModel(Project project) {
362: currentProject = project;
363: } // Fin de la méthode setCurrentProject/1
364:
365: /**
366: * Mutateur de l'utilisateur courant
367: * @param user un utilisateur
368: */
369: public void setCurrentUserInModel(User user) {
370: currentUser = user;
371: } // Fin de la méthode setCurrentUser/1
372:
373: /**
374: * Retourne l'ensemble des utilisateurs du projet courant
375: * @return l'ensemble des utilisateurs du projet courant
376: */
377: public Set getUsersFromModel() {
378: return usersMap.keySet();
379: } // Fin de la méthode getUsers/0
380:
381: /**
382: * Retourne l'ensemble des utilisateurs d'un groupe donné
383: * @param group un groupe
384: * @return l'ensemble des utilisateurs
385: */
386: public ArrayList getGroupUsersFromModel(Group group) {
387: return group.getUserListFromModel();
388: } // Fin de la méthode getGroupUsers/1
389:
390: /**
391: * Retourne l'ensemble des groupes d'un utilisateur donné
392: * @param user un utilisateur
393: * @return l'ensemble des groupes
394: */
395: public HashSet getUserGroupsFromModel(User user) {
396: return (HashSet) usersMap.get(user);
397: } // Fin de la méthode getUserGroups/1
398:
399: /**
400: * Retourne l'utilisateur dont le login est passé en paramètre. Retourne
401: * <code>null</code> si le login n'est pas celui d'un utilisateur.
402: * @param login le login de l'utilisateur
403: * @return l'objet User correspondant, ou <code>null</code> si le nom n'est
404: * pas celui d'un utilisateur
405: */
406: public User getUserFromModel(String login) {
407: for (Iterator iter = usersMap.keySet().iterator(); iter
408: .hasNext();) {
409: User user = (User) iter.next();
410: if (user.getLoginFromModel().equals(login))
411: return user;
412: }
413: return null;
414: } // Fin de la méthode getUser/1
415:
416: /**
417: * Retourne l'ensemble des utilisateurs non présents dans le projet
418: * @return un ensemble d'utilisateurs
419: */
420: public HashSet getNotInProjectUserSetFromModel() {
421: return notInProjectUserSet;
422: } // Fin de la méthode getNotInProjectUserSet/0
423:
424: /**
425: * Retourne l'ensemble des utilisateurs d'un projet
426: * @return l'ensemble des utilisateurs d'un projet
427: */
428: public HashSet getUsersOfCurrentProjectFromModel() {
429: return userSet;
430: } // Fin de la méthode getUsersOfCurrentProject/0
431:
432: /**
433: * Retourne vrai si le nom passé en paramètre est le nom d'un groupe de
434: * l'utilisateur passé en paramètre.
435: * @param user un utilisateur
436: * @param name un nom de groupe
437: * @return vrai si le nom passé en paramètre est le nom d'un groupe de
438: * l'utilisateur passé en paramètre, faux sinon.
439: */
440: public boolean containsGroupInModel(User user, String name) {
441: HashSet groupSet = getUserGroupsFromModel(user);
442: if (groupSet != null) {
443: for (Iterator iter = groupSet.iterator(); iter.hasNext();) {
444: if (((Group) iter.next()).getNameFromModel().equals(
445: name))
446: return true;
447: }
448: }
449: return false;
450: } // Fin de la méthode containsGroup/2
451:
452: /**
453: * Retourne le groupe correspondant au nom passé en paramètre si ce groupe
454: * existe et qu'il correspond à un groupe de l'utilisateur, <code>null</code>
455: * sinon.
456: * @param user un utilisateur
457: * @param name un nom de groupe
458: * @return le groupe correspondant au nom passé en paramètre si ce groupe
459: * existe et qu'il correspond à un groupe de l'utilisateur, <code>null</code>
460: * sinon.
461: */
462: public Group getGroupFromModel(User user, String name) {
463: HashSet groupSet = getUserGroupsFromModel(user);
464: if (groupSet != null) {
465: for (Iterator iter = groupSet.iterator(); iter.hasNext();) {
466: Group group = (Group) iter.next();
467: if (group.getNameFromModel().equals(name))
468: return group;
469: }
470: }
471: return null;
472: } // Fin de la méthode getGroup/2
473:
474: /**
475: * Méthode pour afficher le contenu du modèle de données
476: * @param title le titre
477: */
478: public void viewDataOfProject(String title) {
479: Util.log("****** " + title + " ******");
480: Util.log("Projet courant : " + currentProject);
481: Util.log("Utilisateur courant : " + currentUser);
482: Util.log("Groupe courant : " + currentGroup);
483: Util.log("Liste utilisateurs : " + userSet);
484: Util.log("Map utilisateurs : " + usersMap);
485: Util.log("-------------------------------");
486: } // Fin de la méthode viewDataOfProject/1
487:
488: /**
489: * Nettoyage du modèle de données
490: */
491: public void clear() {
492: currentProject = null;
493: currentGroup = null;
494: currentUser = null;
495: userSet.clear();
496: usersMap.clear();
497: notInProjectUserSet.clear();
498: } // Fin de la méthode clear/0
499:
500: /**
501: * Initialisation du modèle de données
502: *
503: */
504: public void loadData(String adminLogin, String projectName)
505: throws Exception {
506: Util.log("[AdminProjectData->loadData]");
507: clear();
508: Util.log("[AdminProjectData->loadData] clear");
509: if (pISQLProject == null) {
510: pISQLProject = Api.getISQLObjectFactory().getISQLProject();
511: }
512: if (pISQLPersonne == null) {
513: pISQLPersonne = Api.getISQLObjectFactory()
514: .getISQLPersonne();
515: }
516: if (pISQLGroup == null) {
517: pISQLGroup = Api.getISQLObjectFactory().getISQLGroup();
518: }
519: Util.log("[AdminProjectData->loadData] getISQLObjectFactory");
520: setUserAdminVTData(adminLogin);
521:
522: ProjectWrapper pProjectWrapper = pISQLProject
523: .getProject(projectName);
524:
525: // init du projet courant
526: Project project = new Project(pProjectWrapper);
527: setCurrentProjectInModel(project);
528: UserWrapper pUserWrapper = pISQLPersonne
529: .getUserByLogin(adminLogin);
530: User admin = new User(pUserWrapper);
531: project.setAdministratorInModel(admin);
532:
533: // Initialisation des utilisateurs
534:
535: UserWrapper[] usersAll = pISQLProject.getAllUser();
536: for (int i = 0; i < usersAll.length; i++) {
537: pUserWrapper = usersAll[i];
538: if (!pUserWrapper.getLogin().equals(
539: ApiConstants.ADMIN_SALOME_NAME)) {
540: User user = new User(pUserWrapper);
541: addNotInProjectUserInModel(user);
542: }
543: }
544:
545: UserWrapper[] usersProject = pISQLProject
546: .getUsersOfProject(projectName);
547: for (int i = 0; i < usersProject.length; i++) {
548: pUserWrapper = usersProject[i];
549: User user = new User(pUserWrapper);
550: addUserInModel(user); //then remove user from addNotInProjectUserInModel
551: }
552:
553: //Init des groupes du projet
554: GroupWrapper[] groupsProject = pISQLProject
555: .getProjectGroups(project.getIdBdd());
556: for (int i = 0; i < groupsProject.length; i++) {
557: GroupWrapper pGroupWrapper = groupsProject[i];
558: Group group = new Group(pGroupWrapper);
559: UserWrapper[] usersOfGroup = pISQLProject
560: .getUserOfGroupInProject(projectName, group
561: .getNameFromModel());
562: addGroupInModel(group);
563: for (int j = 0; j < usersOfGroup.length; j++) {
564: pUserWrapper = usersOfGroup[j];
565: User pUser = getUserFromModel(pUserWrapper.getLogin());
566: addUserInGroupInModel(pUser, group);
567: }
568: }
569: Util.log("[AdminProjectData->loadData] done");
570:
571: } // Fin de la méthode initData/0
572:
573: } // Fin de la classe AdminProjectData
|