001: package com.calipso.reportgenerator.usermanager;
002:
003: import com.calipso.reportgenerator.common.InfoException;
004:
005: import java.util.*;
006: import java.io.IOException;
007:
008: import com.calipso.reportgenerator.common.*;
009: import com.calipso.reportgenerator.reportmanager.RolsRepository;
010: import com.calipso.reportgenerator.reportmanager.RolDataRepository;
011: import com.calipso.reportgenerator.reportmanager.UserDataRepository;
012: import com.calipso.reportgenerator.reportmanager.UsersRepository;
013:
014: /**
015: *
016: * User: alozada
017: * Date: 08/09/2005
018: * Time: 12:32:29
019: *
020: */
021: public class UserManager {
022: public Map mapObjects = new HashMap();
023: public Map map = new HashMap();
024: public Set listUsers = new TreeSet();
025: public List listRols = new ArrayList();
026: private Collection listeners;
027: private ReportGeneratorConfiguration reportGeneratorConfiguration;
028:
029: /**
030: * Crea una instancia de <code>UserManager</code>
031: * @param reportGeneratorConfiguration
032: * @throws InfoException
033: */
034: public UserManager(
035: ReportGeneratorConfiguration reportGeneratorConfiguration)
036: throws InfoException {
037: this .reportGeneratorConfiguration = reportGeneratorConfiguration;
038: this .refreshListUsers();
039: this .refreshListRols();
040: this .refreshMap();
041: this .fillMapToMapRolsRepository();
042: }
043:
044: /**
045: * Utilizado para agregar a un usuario un rol y tambien para agregarle a un rol un usuario.
046: * Verificando que los mismos sean validos para luego almacenarlo primeramente en un mapa,
047: * luego si siguiera la ejecucion correctamente, se volcarian los datos en el file rolsrepository.
048: * @param role
049: * @param us
050: * @throws InfoException
051: */
052: public void addUsersToCollectionRol(Rol role, User us)
053: throws InfoException {
054: if (!(this .isValid(us))) {
055: throw new InfoException(LanguageTraslator.traslate("453"));
056: }
057: if (!(this .isValid(role))) {
058: throw new InfoException(LanguageTraslator.traslate("454"));
059: }
060: addUserRol(us.getId(), role.getId(),
061: reportGeneratorConfiguration.getRolsRepositoryPath());
062: fireModelChange();
063: }
064:
065: /**
066: * Llama al metodo addUserRol de RolsRepository desde el UserManager, para agragarle al file
067: * rolsRepository el par : "username=rol", lo que quedara actualizado en un mapa (rol->"username", ...,""), para manipularlo
068: * internamente
069: * @param rol
070: * @param rolsRepositoryPath
071: * @throws InfoException
072: */
073:
074: private void addUserRol(String userName, String rol,
075: String rolsRepositoryPath) throws InfoException {
076: RolsRepository repository = new RolsRepository(
077: rolsRepositoryPath);
078: repository.addUserRol(userName, rol);
079: refreshMap();
080: fireModelChange();
081: }
082:
083: /**
084: * Devuelve una coleccion con todos los objetos usuario, que existen
085: * @return lista de objetos usuario
086: * @throws InfoException
087: */
088: public Set getUsers() throws InfoException {
089: this .refreshListUsers();
090: return listUsers;
091: }
092:
093: /**
094: * Llama al metodo addRol de RolDataRepository desde el UserManager, para agregarle al file
095: * RolData la linea "rol.getId();rol.getDescription()" por ejemplo "rol1;rol1" lo que quedara actualizado
096: * en una coleccion de objetos Roles debiendo por esta actualizacion llamar al fireModelChange que avisara
097: * sobre los cambios
098: * @param rol
099: * @throws InfoException
100: */
101: public void addRol(Rol rol) throws InfoException {
102: RolDataRepository rolsDataRepository;
103: rolsDataRepository = new RolDataRepository(
104: reportGeneratorConfiguration.getRolDataRepositoryPath());
105: rolsDataRepository.addNewRol(rol.getId(), rol.getDescription());
106: listRols.add(rol);
107: fireModelChange();
108: }
109:
110: /**
111: * Llama al metodo addUser de UserDataRepository desde el UserManager, para agregarle al file
112: * UserData la linea "us.getId();us.getUserName();us.getCompany()" por ejemplo "11;Usuario1;Company1" lo que
113: * quedara actualizado en una coleccion de objetos Usuario debiendo por esta actualizacion llamar al
114: * fireModelChange que avisara sobre los cambios
115: *
116: * @param us
117: * @throws InfoException
118: */
119: public void addUser(User us) throws InfoException {
120: UserDataRepository userDataRepository;
121: userDataRepository = new UserDataRepository(
122: reportGeneratorConfiguration
123: .getUserDataRepositoryPath());
124: userDataRepository.addNewUser(us.getId(), us.getUserName(), us
125: .getCompany());
126: listUsers.add(us);
127: fireModelChange();
128: }
129:
130: /**
131: * Obtiene una copia local del mapa que contiene por ejemplo : "rol1-> us1, us2, ..., usn"
132: * con todos los elementos como String.
133: * @throws InfoException
134: */
135:
136: private void refreshMap() throws InfoException {
137: RolsRepository repository = new RolsRepository(
138: reportGeneratorConfiguration.getRolsRepositoryPath());
139: map = repository.getMap();
140: fillMapToMapRolsRepository();
141: }
142:
143: /**
144: * Devuelve una lista de objetos Roles , pertenecientes al usuario indicado
145: * como parametro
146: * @param us
147: * @return lista de roles
148: * @throws InfoException
149: */
150: public List getRolsByUser(User us) throws InfoException {
151: fillMapToMapRolsRepository();
152: Iterator it = getMap().entrySet().iterator();
153: List list = new ArrayList();
154: while (it.hasNext()) {
155: Map.Entry e = (Map.Entry) it.next();
156: Rol role = (Rol) e.getKey();
157: List listUsers = (List) e.getValue();
158: if (listUsers.contains(us)) {
159: list.add(role);
160: }
161: }
162: return list;
163: }
164:
165: /**
166: *Devuelve una lista de objetos Usuario , pertenecientes al Rol indicado
167: * como parametro
168: * @param role
169: * @return lista de usuarios
170: * @throws InfoException
171: */
172: public List getUsersByRol(Rol role) throws InfoException {
173: fillMapToMapRolsRepository();
174: List list = new ArrayList();
175: Set keySet = (Set) getMap().keySet();
176: if (keySet.contains(role)) {
177: list = (List) getMap().get(role);
178: }
179: return list;
180: }
181:
182: /**
183: * Indica si un rol es valido , dentro de la lista de roles
184: * @param role
185: * @return boolean
186: * @throws InfoException
187: */
188: private boolean isValid(Rol role) throws InfoException {
189: this .refreshListRols();
190: return listRols.contains(role);
191: }
192:
193: /**
194: * Indica si un usuario es valido , dentro de la lista de usuarios
195: * @param us
196: * @return boolean
197: * @throws InfoException
198: */
199: private boolean isValid(User us) throws InfoException {
200: this .refreshListUsers();
201: return listUsers.contains(us);
202: }
203:
204: /**
205: * Devuelve una lista con todos los objetos usuario q tienen algun rol establecido
206: * (no usado por el momento )
207: * @throws InfoException
208: * @return lista de usuarios
209: */
210: public List getUsersWithRols() throws InfoException {
211: this .refreshMap();
212: this .refreshListUsers();
213: this .fillMapToMapRolsRepository();
214: List list = new ArrayList();
215: Iterator it = getMap().entrySet().iterator();
216: while (it.hasNext()) {
217: Map.Entry e = (Map.Entry) it.next();
218: List list2 = (List) e.getValue();
219: Iterator it2 = list2.iterator();
220: while (it2.hasNext()) {
221: User us = (User) it2.next();
222: if (!(list.contains(us))) {
223: list.add(us);
224: }
225: }
226: }
227: return list;
228: }
229:
230: /**
231: * Actualiza la lista de usuarios , introduciendo todos los usuarios en una coleccion de objetos usuario
232: * @throws InfoException
233: */
234: private void refreshListUsers() throws InfoException {
235: UserDataRepository userDataRepository = new UserDataRepository(
236: reportGeneratorConfiguration
237: .getUserDataRepositoryPath());
238: listUsers = userDataRepository.getAllUsers();
239: }
240:
241: /**
242: * Actualiza la lista de roles , introduciendo todos los roles en una coleccion de objetos rol
243: * @throws InfoException
244: */
245:
246: public void refreshListRols() throws InfoException {
247: RolDataRepository rolsDataRepository = new RolDataRepository(
248: reportGeneratorConfiguration.getRolDataRepositoryPath());
249: listRols = (List) rolsDataRepository.getAllRols();
250: }
251:
252: /**
253: * Devuelve una coleccion con todos los objetos Roles que existen
254: * @return lista de roles
255: */
256:
257: public List getRols() throws InfoException {
258: this .refreshListRols();
259: return listRols;
260: }
261:
262: /**
263: * Recibe un obj usuario, lo valida y luego busca su homólogo al cual reemplazará
264: * @param us
265: * @throws com.calipso.reportgenerator.common.InfoException
266: * @throws IOException
267: */
268: public void modifyUser(User us) throws InfoException, IOException {
269: if (!(this .isValidUserId(us.getId()))) {
270: throw new InfoException(LanguageTraslator.traslate("455"));
271: }
272: Iterator it = listUsers.iterator();
273: while (it.hasNext()) {
274: User us1 = (User) it.next();
275: if (us1.getId().equals(us.getId())) {
276: UserDataRepository userDataRepository = new UserDataRepository(
277: reportGeneratorConfiguration
278: .getUserDataRepositoryPath());
279: userDataRepository.removeUser(us.getId());
280: this .addUser(us);
281: this .fillMapToMapRolsRepository();
282: break;
283: }
284: }
285: fireModelChange();
286: }
287:
288: /**
289: * Comprueba que el id de usuario pertenezca a alguno de los usuarios, q existen dentro del
290: * entorno
291: * @param idUser
292: * @return boolean
293: */
294: private boolean isValidUserId(String idUser) {
295: Iterator it = listUsers.iterator();
296: while (it.hasNext()) {
297: User us = (User) it.next();
298: if (us.getId().equals(idUser)) {
299: return true;
300: }
301: }
302: return false;
303: }
304:
305: /**
306: * Comprueba que el id de rol pertenezca a alguno de los roles, q existen dentro del
307: * entorno
308: * @param idRol
309: * @return boolean
310: */
311: private boolean isValidRolId(String idRol) {
312: Iterator it = listRols.iterator();
313: while (it.hasNext()) {
314: Rol role = (Rol) it.next();
315: if (role.getId().equals(idRol)) {
316: return true;
317: }
318: }
319: return false;
320: }
321:
322: /**
323: * Borra un usuario del file de usuarios (UserData) y si el mismo tiene ademas roles , tambien los elimina de
324: * el file de usuarios - roles (rolsRepository), actulizando entre medio los mapas y listas relacionadas
325: * @param us
326: * @return boolean
327: * @throws com.calipso.reportgenerator.common.InfoException
328: * @throws IOException
329: */
330: public boolean removeUser(User us) throws InfoException,
331: IOException {
332: if (!(this .isValid(us))) {
333: throw new InfoException(LanguageTraslator.traslate("453"));
334: }
335: UserDataRepository userDataRepository = new UserDataRepository(
336: reportGeneratorConfiguration
337: .getUserDataRepositoryPath());
338: userDataRepository.removeUser(us.getId());
339: refreshListUsers();
340: if (!(hasRol(us))) {
341: return false;
342: }
343: RolsRepository rolsRepository = new RolsRepository(
344: reportGeneratorConfiguration.getRolsRepositoryPath());
345: rolsRepository.removeUser(us.getId());
346: refreshMap();
347: fireModelChange();
348: return true;
349: }
350:
351: /**
352: * Indica si ese usuario tiene ó no rol/es asignados (es decir si existe en el file rolsrepository,
353: * la linea "us1=rol1" por ejemplo, siendo us.id igual a "us1" y rol1 el id de algun rol)
354: * @param us
355: * @return boolean
356: */
357: private boolean hasRol(User us) {
358: Iterator it = map.entrySet().iterator();
359: while (it.hasNext()) {
360: Map.Entry e = (Map.Entry) it.next();
361: Vector vector = (Vector) e.getValue();
362: if (vector.contains(us.getId()))
363: return true;
364:
365: }
366: return false;
367: }
368:
369: /**
370: * Borra un rol del file de roles (RolData) y si el mismo tiene ademas usuarios , tambien los elimina de
371: * el file de usuarios - roles (rolsRepository), actulizando entre medio los mapas y listas relacionadas
372: * @param role
373: * @return
374: * @throws InfoException
375: * @throws IOException
376: */
377:
378: public boolean removeRol(Rol role) throws InfoException,
379: IOException {
380: if (!(this .isValid(role))) {
381: throw new InfoException(LanguageTraslator.traslate("454"));
382: }
383: RolDataRepository rolsDataRepository = new RolDataRepository(
384: reportGeneratorConfiguration.getRolDataRepositoryPath());
385: rolsDataRepository.removeRol(role.getId());
386: refreshListRols();
387:
388: if (!(map.containsKey(role.getId()))) {
389: return false;
390: }
391: RolsRepository rolsRepository = new RolsRepository(
392: reportGeneratorConfiguration.getRolsRepositoryPath());
393: rolsRepository.removeRol(role.getId());
394: refreshMap();
395: fireModelChange();
396: return true;
397: }
398:
399: /**
400: * Avisa al userManagerChange que ha habido una modificacion
401: * en alguno de los metodos
402: */
403:
404: private void fireModelChange() {
405: for (Iterator iterator = listeners.iterator(); iterator
406: .hasNext();) {
407: UserManagerListener userManagerListener = (UserManagerListener) iterator
408: .next();
409: userManagerListener.userManagerChange(this );
410: }
411: }
412:
413: /**
414: * Agrega a la lista de Listener un nuevo elemento
415: * @param userManagerListener
416: */
417: public void addListener(UserManagerListener userManagerListener) {
418: getListeners().add(userManagerListener);
419: }
420:
421: /**
422: * Devuelve una coleccion con todos los listener que existen por el momento
423: * @return
424: */
425: private Collection getListeners() {
426: if (listeners == null) {
427: listeners = new Vector();
428: }
429: return listeners;
430: }
431:
432: /**
433: * Carga un mapa de objetos usuarios / roles(por ejemplo : RoL1-> Us1, Us2 - Rol2-> Us3,Us1 )
434: * partiendo de otro map pero de String (por ejemplo : "rol1" ->"us2" , "us2" - "rol2"-> "us3", "us1")
435: * con las mismas caracateristicas
436: * @throws com.calipso.reportgenerator.common.InfoException
437: */
438: public void fillMapToMapRolsRepository() throws InfoException {
439: map = new HashMap();
440: mapObjects = new HashMap();
441: RolsRepository repository = new RolsRepository(
442: reportGeneratorConfiguration.getRolsRepositoryPath());
443: map = repository.getMap();
444: Iterator it = map.entrySet().iterator();
445:
446: while (it.hasNext()) {
447: Map.Entry e = (Map.Entry) it.next();
448: String idRol = (String) e.getKey();
449:
450: if (!(isValidRolId(idRol))) {
451: throw new InfoException(LanguageTraslator
452: .traslate("457"));
453: }
454: Rol role = getObjectRolFrom(idRol);
455: Vector vector = (Vector) e.getValue();
456: List users = new ArrayList();
457: for (int i = 0; i < vector.size(); i++) {
458: String idUser = (String) vector.get(i);
459: if (!(isValidUserId(idUser))) {
460: throw new InfoException(LanguageTraslator
461: .traslate("457"));
462: }
463: User us = getObjectUserFrom(idUser);
464: users.add(us);
465: }
466: mapObjects.put(role, users);
467: }
468: }
469:
470: /**
471: * Obtiene a partir de un id del rol, un objeto Rol al q ese identificador corresponde
472: * @param idRol
473: * @return Objeto Rol
474: */
475: private Rol getObjectRolFrom(String idRol) {
476: Iterator it = listRols.iterator();
477: while (it.hasNext()) {
478: Rol role = (Rol) it.next();
479: if (role.getId().equals(idRol)) {
480: return role;
481: }
482: }
483: return null;
484: }
485:
486: /**
487: * Obtiene apartir de un id de usuario ,un objeto Usuario al q ese identificador corresponde
488: * @param idUser
489: * @return Objeto Usuario
490: */
491: private User getObjectUserFrom(String idUser) {
492: Iterator it = listUsers.iterator();
493: while (it.hasNext()) {
494: User us = (User) it.next();
495: if (us.getId().equals(idUser)) {
496: return us;
497: }
498: }
499: return null;
500: }
501:
502: /**
503: * Getter del mapa de objetos (por ejemplo : RoL1-> Us1, Us2 - Rol2-> Us3,Us1 )
504: * @return
505: */
506: public Map getMap() {
507: return mapObjects;
508: }
509:
510: /**
511: * Corrobora que el password y el usuario pasados como parametro sean correspondidos
512: * @param userName
513: * @param password
514: * @return boolean
515: * @throws InfoException
516: */
517: public boolean validate(String userName, String password)
518: throws InfoException {
519: UsersRepository usersRepository = new UsersRepository(
520: reportGeneratorConfiguration.getUsersRepositoryPath());
521: return usersRepository.validate(userName, password);
522: }
523:
524: /**
525: * Elimina una relacion entre un usuario y un rol (por ejemplo : " us1=rol1" ),
526: * actualizando el file rolsRepository además de las estructuras concernientes
527: * @param role
528: * @param us
529: * @throws InfoException
530: */
531: public void removeRolToUser(Rol role, User us) throws InfoException {
532: refreshMap();
533: List list;
534: if (!(this .isValid(role))) {
535: throw new InfoException(LanguageTraslator.traslate("454"));
536: }
537: if (!(this .isValid(us))) {
538: throw new InfoException(LanguageTraslator.traslate("453"));
539: }
540: list = ((List) getMap().get(role));
541: if (!(list.remove(us))) {
542: throw new InfoException(LanguageTraslator.traslate("456"));
543: }
544: RolsRepository rolsRepository = new RolsRepository(
545: reportGeneratorConfiguration.getRolsRepositoryPath());
546: rolsRepository.removeUser(us.getId());
547: refreshMap();
548: fireModelChange();
549: }
550:
551: }
|