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.Enumeration;
028: import java.util.HashSet;
029: import java.util.Hashtable;
030: import java.util.Vector;
031:
032: import org.objectweb.salome_tmf.api.Api;
033: import org.objectweb.salome_tmf.api.ApiConstants;
034: import org.objectweb.salome_tmf.api.data.ProjectWrapper;
035: import org.objectweb.salome_tmf.api.data.UserWrapper;
036: import org.objectweb.salome_tmf.api.sql.ISQLPersonne;
037: import org.objectweb.salome_tmf.api.sql.ISQLProject;
038:
039: public class AdminVTData {
040:
041: static ISQLProject pISQLProject = null;
042: static ISQLPersonne pISQLPersonne = null;
043: /**
044: * Liste de tous les projets. Regroupe des élements de classe <code>Project</code>
045: */
046: ArrayList projectList;
047:
048: /**
049: * Liste de tous les utilisateurs. Regroupe des éléments de classe <code>User</code>
050: */
051: ArrayList userList;
052:
053: /**
054: * Table contenant les administrateurs des projet. Pour chaque projet (la clé)
055: * on associe un hashSet contenant les logins des admins (<code>String</code>)
056: * du projet;
057: */
058: protected Hashtable projectAdmin;
059:
060: User pAdmin;
061:
062: /**************************************************************************/
063: /** METHODES PUBLIQUES ***/
064: /**************************************************************************/
065:
066: public void setUserAdminVTData(String login) throws Exception {
067: pAdmin = new User(pISQLPersonne.getUserByLogin(login));
068: }
069:
070: public User getUserAdminVTData() {
071: return pAdmin;
072: }
073:
074: /**
075: * Ajoute un projet
076: * @param project un projet
077: */
078: public void addProjectInModel(Project project) {
079: if (project != null) {
080: projectList.add(project);
081: addAdminToProjectInModel(project
082: .getAdministratorFromModel(), project);
083: }
084:
085: } // Fin de la méthode addProject/1
086:
087: public void addProjectInDB(Project project) throws Exception {
088: if (project != null) {
089: project.addInDB();
090: }
091: } // Fin de la méthode addProject/1
092:
093: public void addProjectInDB(Project project, Project copy,
094: boolean suite, boolean campagne, boolean users,
095: boolean groupe) throws Exception {
096: if (project != null) {
097: project.addInDB(copy, suite, campagne, users, groupe);
098: }
099: } // Fin de la méthode addProject/1
100:
101: public void addProjectInDBAndModel(Project project)
102: throws Exception {
103: addProjectInDB(project);
104: addProjectInModel(project);
105: } // Fin de la méthode addProject/1
106:
107: public void addProjectInDBAndModelByCopy(Project project,
108: Project copy, boolean suite, boolean campagne,
109: boolean users, boolean groupe) throws Exception {
110: addProjectInDB(project, copy, suite, campagne, users, groupe);
111: addProjectInModel(project);
112: } // Fin de la méthode addProject/1
113:
114: /**
115: * Permet de récupérer le projet associé au nom passé en paramètre
116: * @param name le nom du projet
117: * @return un projet si le nom passé en paramètre est un nom de projet,
118: * <code>null</code> sinon.
119: */
120: public Project getProjectFromModel(String name) {
121: for (int i = 0; i < projectList.size(); i++) {
122: if (((Project) projectList.get(i)).getNameFromModel()
123: .equals(name)) {
124: return (Project) projectList.get(i);
125: }
126: }
127: return null;
128: } // Fin de la méthode getProject/1
129:
130: void deleteProjectInDB(Project pProject) throws Exception {
131: pProject.deleteInDB();
132: }
133:
134: /**
135: * Supprime un projet
136: * @param project le projet à supprimer
137: */
138: public void deleteProjectInModel(Project project) {
139: projectList.remove(project);
140: projectAdmin.remove(project);
141: } // Fin de la méthode removeProject/1
142:
143: public void deleteProjectInDBAndModel(Project project)
144: throws Exception {
145: deleteProjectInDB(project);
146: deleteProjectInModel(project);
147: } // Fin de la méthode removeProject/1
148:
149: /**
150: * Supprime un projet
151: * @param name le nom du projet à supprimer
152: */
153: /*public void deleteProjectInModel(String name) {
154: Project project = getProjectFromModel(name);
155: if (project != null) {
156: removeProjectInModel(project);
157: }
158: } // Fin de la méthode removeProject/1
159: */
160: /**
161: * Retourne le nombre de projets dans SalomeTMF
162: * @return le nombre de projets dans SalomeTMF
163: */
164: public int getProjectCountFromModel() {
165: return projectList.size();
166: } // Fin de la méthode getProjectCount/0
167:
168: /**
169: * Retourne la liste de tous les utilisateurs déclarés dans SalomeTMF
170: * @return la liste de tous les utilisateurs déclarés dans SalomeTMF
171: */
172: public ArrayList getAllUsersFromModel() {
173: return userList;
174: } // Fin de la méthode getAllUsers
175:
176: /**
177: * Retourne le nombre d'utilisateurs déclarés dans SalomeTMF
178: * @return le nombre d'utilisateurs déclarés dans SalomeTMF
179: */
180: public int getAllUsersCountFromModel() {
181: return userList.size();
182: } // Fin de la méthode getAllUsersCount/0
183:
184: /**
185: * Ajoute un nouvel utilisateur
186: * @param user un utilisateur
187: */
188: public void addUserInModel(User user) {
189: userList.add(user);
190: } // Fin de la méthode addUser/1
191:
192: /**
193: * Supprime l'utilisateur dont le login est passé en paramètre
194: * @param userLogin le login de l'utilisateur
195: */
196: /*public void removeUserInModel(String userLogin) {
197: for (int i = 0 ; i < userList.size(); i++) {
198: if (((User)userList.get(i)).getLoginFromModel().equals(userLogin)) {
199: userList.remove(i);
200: return;
201: }
202: }
203: } // Fin de la méthode removeUser/1
204: */
205:
206: public void delteUserInDB(User pUser) throws Exception {
207: pUser.deleteInDB();
208: }
209:
210: public void delteUserInModel(User pUser) {
211: for (int i = 0; i < userList.size(); i++) {
212: if (((User) userList.get(i)).equals(pUser)) {
213: userList.remove(i);
214: return;
215: }
216: }
217: }
218:
219: public void delteUserInDBAndModel(User pUser) throws Exception {
220: delteUserInDB(pUser);
221: delteUserInModel(pUser);
222: }
223:
224: /**
225: * Retourne vrai s'il existe dans la liste des utilisateurs, un utilisateur
226: * ayant le login passé en paramètre, faux sinon.
227: * @param login un login
228: * @return vrai s'il existe dans la liste des utilisateurs, un utilisateur
229: * ayant le login passé en paramètre, faux sinon.
230: */
231: public boolean containsLoginInModel(String login) {
232: for (int i = 0; i < userList.size(); i++) {
233: if (((User) userList.get(i)).getLoginFromModel().equals(
234: login)) {
235: return true;
236: }
237: }
238: return false;
239: } // Fin de la méthode containsLogin/1
240:
241: /**
242: * Initialisation du modèle de données
243: */
244: public void initData() {
245: projectList = new ArrayList();
246: userList = new ArrayList();
247: projectAdmin = new Hashtable();
248: } // Fin de la méthode initData/0
249:
250: /**
251: * Ajoute un administrateur au projet
252: * @param userLogin le login d'un utilisateur
253: * @param project un projet
254: */
255: public void addAdminToProjectInModel(User userAdmin, Project project) {
256: Vector adminOfProject = (Vector) projectAdmin.get(project);
257: if (adminOfProject == null) {
258: adminOfProject = new Vector();
259: }
260: if (!adminOfProject.contains(userAdmin)) {
261: adminOfProject.add(userAdmin);
262: }
263: projectAdmin.put(project, adminOfProject);
264: //projectAdmin.put(project, userAdmin);
265: } // Fin de la méthode addAdminToProject/2
266:
267: /**
268: * Retourne le nombre d'administrateurs du projet
269: * @param project un projet
270: * @return le nombre d'administrateurs du projet
271: */
272: public int getAdminCountFromModel(Project project) {
273: Vector adminOfProject = (Vector) projectAdmin.get(project);
274: if (adminOfProject == null) {
275: return 0;
276: } else {
277: return adminOfProject.size();
278: }
279: /*if (projectAdmin.containsKey(project)) {
280: return 1;
281: //return projectAdmin.get(project).size();
282: }
283: return 0;
284: */
285: } // Fin de la méthode getAdminCount/1
286:
287: /**
288: * Rend vrai si le projet passé en paramètre a pour administrateur
289: * l'utilisateur dont le login est passé en paramètre
290: * @param userLogin un login d'utilisateur
291: * @param project un projet
292: * @return vrai si le projet passé en paramètre a pour administrateur
293: * l'utilisateur dont le login est passé en paramètre, faux sinon.
294: */
295: public boolean containsAdminInModel(String userLogin,
296: Project project) {
297: Vector adminOfProject = (Vector) projectAdmin.get(project);
298: if (adminOfProject == null) {
299: return false;
300: } else {
301: for (int i = 0; i < adminOfProject.size(); i++) {
302: User pUser = (User) adminOfProject.elementAt(i);
303: if (pUser.getLoginFromModel().equals(userLogin)) {
304: return true;
305: }
306: }
307: }
308: /*
309: if (projectAdmin.containsKey(project)) {
310: Enumeration enumP = projectAdmin.elements();
311: while (enumP.hasMoreElements()){
312: User pUser = (User) enumP.nextElement();
313: if (pUser.getLoginFromModel().equals(userLogin)){
314: return true;
315: }
316: }
317: }*/
318: return false;
319: } // Fin de la méthode containsAdmin/2
320:
321: public User containsAndGetAdminInModel(String userLogin,
322: Project project) {
323: Vector adminOfProject = (Vector) projectAdmin.get(project);
324: if (adminOfProject == null) {
325: return null;
326: } else {
327: for (int i = 0; i < adminOfProject.size(); i++) {
328: User pUser = (User) adminOfProject.elementAt(i);
329: if (pUser.getLoginFromModel().equals(userLogin)) {
330: return pUser;
331: }
332: }
333: }
334: /*
335: if (projectAdmin.containsKey(project)) {
336: Enumeration enumP = projectAdmin.elements();
337: while (enumP.hasMoreElements()){
338: User pUser = (User) enumP.nextElement();
339: if (pUser.getLoginFromModel().equals(userLogin)){
340: return true;
341: }
342: }
343: }*/
344: return null;
345: }
346:
347: /**
348: * Retourne la liste des projets dont l'administrateur a pour login celui
349: * passé en paramètre
350: * @param userLogin un login
351: * @return la liste des projets dont l'administrateur a pour login celui
352: * passé en paramètre
353: */
354: public ArrayList getProjectsWithThisUserAdminFromModel(
355: String userLogin) {
356: ArrayList result = new ArrayList();
357: Enumeration enumA = projectAdmin.keys();
358: while (enumA.hasMoreElements()) {
359: Project project = (Project) enumA.nextElement();
360: if (containsAdminInModel(userLogin, project)) {
361: result.add(project);
362: }
363: /*User pUser = (User) projectAdmin.get(project);
364: if (pUser.getLoginFromModel().equals(userLogin)){
365: result.add(project);
366: }*/
367: }
368: return result;
369: } // Fin de la méthode getProjectsWithThisUserAdmin/1
370:
371: /**
372: * Retourne la liste des projets
373: * @return la liste des projets
374: */
375: public ArrayList getProjectListFromModel() {
376: return projectList;
377: } // Fin de la méthode getProjectList/0
378:
379: /**
380: * Retourne vrai si le projet dont le nom est passé en paramètre exsite déjà,
381: * faux sinon.
382: * @param projectName un nom de projet
383: * @return vrai si le projet dont le nom est passé en paramètre exsite déjà,
384: * faux sinon.
385: */
386: public boolean containsProjectInModel(String projectName) {
387: for (int i = 0; i < projectList.size(); i++) {
388: if (((Project) projectList.get(i)).getNameFromModel()
389: .equals(projectName)) {
390: return true;
391: }
392: }
393: return false;
394: } // Fin de la méthode containsProject/1
395:
396: /**
397: * Retourne l'utilisateur dont le login est passé en paramètre.
398: * @param login un login d'utilisateur
399: * @return l'utilisateur dont le login est passé en paramètre, <code>null</code>
400: * si le login n'est pas celui d'un utilisateur.
401: */
402: public User getUserFromModel(String login) {
403: for (int i = 0; i < userList.size(); i++) {
404: if (((User) userList.get(i)).getLoginFromModel().equals(
405: login)) {
406: return (User) userList.get(i);
407: }
408: }
409: return null;
410: } // Fin de la méthode getUser/1
411:
412: /************************** Data Loading **********************************/
413:
414: public void loadData() throws Exception {
415: if (pISQLProject == null) {
416: pISQLProject = Api.getISQLObjectFactory().getISQLProject();
417: }
418: if (pISQLPersonne == null) {
419: pISQLPersonne = Api.getISQLObjectFactory()
420: .getISQLPersonne();
421: }
422:
423: initData();
424: ProjectWrapper[] listOfProjects = pISQLProject.getAllProjects();
425: //adminProject.setUser(ADMIN_SALOME_NAME);
426:
427: for (int i = 0; i < listOfProjects.length; i++) {
428: ProjectWrapper pProjectWrapper = listOfProjects[i];
429: Project project = new Project(pProjectWrapper);
430: try {
431: UserWrapper pUserWrapper = project
432: .getAdministratorWrapperFromDB();
433: User admin = new User(pUserWrapper);
434: project.setAdministratorInModel(admin);
435: addProjectInModel(project);
436:
437: Vector usersAdmin = project
438: .getUserOfGroupFromDB(ApiConstants.ADMINNAME);
439: for (int j = 0; j < usersAdmin.size(); j++) {
440: pUserWrapper = (UserWrapper) usersAdmin
441: .elementAt(j);
442: User pAdminProject = new User(pUserWrapper);
443: addAdminToProjectInModel(pAdminProject, project);
444: }
445: } catch (Exception e) {
446: e.printStackTrace();
447: }
448: }
449:
450: UserWrapper[] listOfUsers = pISQLProject.getAllUser();
451: for (int i = 0; i < listOfUsers.length; i++) {
452: UserWrapper pUserWrapper = listOfUsers[i];
453: if (!pUserWrapper.getLogin().equals(
454: ApiConstants.ADMIN_SALOME_NAME)) {
455: User pUser = new User(pUserWrapper);
456: addUserInModel(pUser);
457: }
458: }
459: }
460:
461: } // Fin de la classe AdminVTData
|