HibernateParticipantMappingMgr


1   /*
2    * Shark Hibernate PartMapPersistence - Open Wide
3    */
4   package org.enhydra.shark.partmappersistence;
5   
6   import java.util.ArrayList  ;
7   import java.util.Iterator  ;
8   import java.util.List  ;
9   
10  import net.sf.hibernate.Session;
11  import net.sf.hibernate.Transaction;
12  
13  import org.enhydra.shark.api.ParticipantMappingTransaction;
14  import org.enhydra.shark.api.RootException;
15  import org.enhydra.shark.api.TransactionException;
16  import org.enhydra.shark.api.internal.partmappersistence.ParticipantMap;
17  import org.enhydra.shark.api.internal.partmappersistence.ParticipantMappingManager;
18  import org.enhydra.shark.api.internal.working.CallbackUtilities;
19  import org.enhydra.shark.partmappersistence.data.HibernateGroupUser;
20  import org.enhydra.shark.partmappersistence.data.HibernateNormalUser;
21  import org.enhydra.shark.partmappersistence.data.HibernatePackage;
22  import org.enhydra.shark.partmappersistence.data.HibernatePackageLevelParticipant;
23  import org.enhydra.shark.partmappersistence.data.HibernateProcessLevelParticipant;
24  import org.enhydra.shark.partmappersistence.data.HibernateProcessPartMap;
25  
26  /**
27   * Implementation of ParticipantMappingsManager interface
28   * 
29   * @author Vladislav Pernin
30   */
31  public class HibernateParticipantMappingMgr implements ParticipantMappingManager {
32  
33      public static boolean _debug_ = false;
34  
35      private static final String   DBG_PARAM_NAME = "HibernateParticipantMappingMgr.debug";
36  
37      //////////////////////////////////////////////////////////////////
38      //  Initialization methods
39      //////////////////////////////////////////////////////////////////
40      
41      public void configure(CallbackUtilities cus) throws RootException {
42          if (null == cus)
43              throw new RootException("Cannot configure without call back impl.");
44          _debug_ = Boolean.valueOf(cus.getProperty(DBG_PARAM_NAME, "false")).booleanValue();
45      }
46  
47      //////////////////////////////////////////////////////////////////
48      //  Save methods
49      //////////////////////////////////////////////////////////////////
50      
51      /**
52       * Save new ParticipantMap to database.
53       * 
54       * @param trans
55       *                  ParticipantMappingTransaction
56       * @param pm
57       *                  ParticipantMap to save
58       * @return boolean true if everything is ok, false otherwise
59       * @exception RootException
60       *                       RootException will be thrown if error occure.
61       *  
62       */
63      public boolean saveParticipantMapping(ParticipantMappingTransaction trans, ParticipantMap pm) throws RootException {
64          boolean retVal = true;
65          if (!checkValidity(pm)) {
66              throw new RootException("Participant mapping [ " + pm + " ] is not valid");
67          }
68          if (doesParticipantMappingExist(trans, pm)) {
69              throw new RootException("Participant mapping already exists");
70          }
71          try {
72              Session session = ((HibernateParticipantMappingTransaction) trans).getSession();
73              //if group user
74              if (pm.getIsGroupUser()) {
75                  HibernateGroupUser groupUser = this.checkGroups(session, true, pm);
76                  //process level participant
77                  if (pm.getProcessDefinitionId() != null) {
78                      HibernateProcessLevelParticipant procLevPart = checkProcLevelParticipant(session, true, pm);
79                      procLevPart.addGrouplUser(groupUser);
80                      session.update(procLevPart);
81                  }
82                  //package level participant
83                  else {
84                      HibernatePackageLevelParticipant pckLevPart = checkPackLevelParticipant(session, true, pm);
85                      pckLevPart.addGrouplUser(groupUser);
86                      session.update(pckLevPart);
87                  }
88  
89              }
90              //if single user
91              else {
92                  HibernateNormalUser user = checkUsers(session, true, pm);
93                  if (pm.getProcessDefinitionId() != null) {
94                      HibernateProcessLevelParticipant procLevPart = checkProcLevelParticipant(session, true, pm);
95                      procLevPart.addNormalUser(user);
96                      session.update(procLevPart);
97                  } else {
98                      HibernatePackageLevelParticipant pckLevPart = checkPackLevelParticipant(session, true, pm);
99                      pckLevPart.addNormalUser(user);
100                     session.update(pckLevPart);
101                 }
102             }
103 
104         } catch (Exception   e) {
105             e.printStackTrace();
106             throw new RootException(e);
107         }
108         return retVal;
109     }
110 
111     //////////////////////////////////////////////////////////////////
112     //  Delete methods
113     //////////////////////////////////////////////////////////////////
114     
115     /**
116      * Delete specified ParticipantMap from database.
117      * 
118      * @param trans
119      *                  ParticipantMappingTransaction
120      * @param pm
121      *                  ParticipantMap to delete
122      * @return boolean true if everything is ok, false otherwise
123      * @exception RootException
124      *                       RootException will be thrown if error occure.
125      *  
126      */
127     public boolean deleteParticipantMapping(ParticipantMappingTransaction trans, ParticipantMap pm) throws RootException {
128 
129         boolean retVal = true;
130         if (!checkValidity(pm)) {
131             throw new RootException("Participant mapping [ " + pm + " ] is not valid");
132         }
133         try {
134             Session session = ((HibernateParticipantMappingTransaction) trans).getSession();
135             String   processId = pm.getProcessDefinitionId();
136             boolean isGroup = pm.getIsGroupUser();
137             //process level part.
138             if (processId != null) {
139                 //group user
140                 if (isGroup) {
141                     deleteGroupProcLevelPart(pm, session);
142                 }
143                 //single user
144                 else {
145                     deleteNormalProcLevelPart(pm, session);
146                 }
147             }
148             //package level part.
149             else {
150                 //group user
151                 if (isGroup) {
152                     deleteGroupPackLevelPart(pm, session);
153                 }
154                 //single user
155                 else {
156                     deleteNormalPackLevelPart(pm, session);
157                 }
158             }
159         } catch (Exception   e) {
160             e.printStackTrace();
161             throw new RootException(e);
162         }
163 
164         return retVal;
165 
166     }
167 
168     /**
169      * Method deleteParticipantMappings delete participant mappings for
170      * specified parameters.
171      * 
172      * @param trans
173      *                  ParticipantMappingTransaction
174      * @param packageId
175      *                  Package id
176      * @param processDefinitionId
177      *                  Process id
178      * @param participantId
179      *                  Participant id
180      * @return boolean true if OK, false otherwise
181      * @exception RootException
182      *                       RootException will be thrown if error occure.
183      *  
184      */
185     public boolean deleteParticipantMappings(ParticipantMappingTransaction trans, String   packageId, String   processDefinitionId, String   participantId)
186     throws RootException {
187         boolean retVal = true;
188         try {
189             Session session = ((HibernateParticipantMappingTransaction) trans).getSession();
190             //empty string is same as null
191             if (processDefinitionId != null && processDefinitionId.trim().equals(""))
192                 processDefinitionId = null;
193             ParticipantMap pm = this.createParticipantMap();
194             pm.setPackageId(packageId);
195             pm.setProcessDefinitionId(processDefinitionId);
196             pm.setParticipantId(participantId);
197             //normal users
198             List   normalUsers = session.find("from HibernateNormalUser");
199             for (Iterator   it = normalUsers.iterator();it.hasNext();){
200                 pm.setIsGroupUser(false);
201                 pm.setUsername(((HibernateNormalUser)it.next()).getUserName());
202                 if (processDefinitionId != null) {
203                     deleteNormalProcLevelPart(pm, session);
204                 } else {
205                     deleteNormalPackLevelPart(pm, session);
206                 }
207             }
208             //group users
209             List   groupUsers = session.find("from HibernateGroupUser");
210             for (Iterator   it = groupUsers.iterator();it.hasNext();){
211                 pm.setIsGroupUser(true);
212                 pm.setUsername(((HibernateGroupUser)it.next()).getUserName());
213                 if (processDefinitionId != null) {
214                     this.deleteGroupProcLevelPart(pm, session);
215                 } else {
216                     this.deleteGroupPackLevelPart(pm, session);
217                 }
218             }
219         } catch (Exception   e) {
220             e.printStackTrace();
221             retVal = false;
222             throw new RootException(e);
223         }
224         return retVal;
225     }
226 
227     /**
228      * Method deleteParticipantMappings delete participant mappings for
229      * specified parameters.
230      * 
231      * @param trans
232      *                  ParticipantMappingTransaction
233      * @param username
234      *                  username(s) to delete
235      * @return boolean true if everything is OK, false otherwise
236      * @exception RootException
237      *                       RootException will be thrown if error occurs.
238      *  
239      */
240     public boolean deleteParticipantMappings(ParticipantMappingTransaction trans, String   username) throws RootException {
241         boolean retVal = true;
242         try {
243             Session session = ((HibernateParticipantMappingTransaction) trans).getSession();
244             String   packageId = null;
245             String   processId = null;
246             String   participantId = null;
247 
248             HibernateNormalUser normalUser = (HibernateNormalUser)session.get(HibernateNormalUser.class,username);
249             if (normalUser == null){
250                 retVal = false;
251                 return retVal;
252             }
253 
254             //process level part
255             List   normalUserProcLevParts = normalUser.getProcLevelParts();
256             for (Iterator   it = normalUserProcLevParts.iterator();it.hasNext();){
257                 HibernateProcessLevelParticipant procLevPart = (HibernateProcessLevelParticipant)it.next();
258                 normalUser.removeProcLevelParts(procLevPart);
259                 HibernateProcessPartMap pro = procLevPart.getProcess();
260                 deleteProcLevParticipant(procLevPart,session);
261                 deleteProcess(pro, session);
262                 HibernatePackage pack = pro.getPck();
263                 deletePackage(pack, session);
264             }
265             session.update(normalUser);
266 
267             //package level part.
268             List   normalUserPackLevParts = normalUser.getPackLevelParts();
269             for (Iterator   it = normalUserPackLevParts.iterator();it.hasNext();){
270                 HibernatePackageLevelParticipant packLevPart = (HibernatePackageLevelParticipant)it.next();
271                 normalUser.removePackLevelParts(packLevPart);
272                 deletePackLevParticipant(packLevPart,session);
273                 HibernatePackage pack = packLevPart.getPackage();
274                 deletePackage(pack, session);
275             }
276             session.update(normalUser);
277             
278             if (normalUser != null)
279                 deleteNormalUser(normalUser, session);
280             
281             //group user
282             HibernateGroupUser groupUser = (HibernateGroupUser)session.get(HibernateGroupUser.class,username);
283             if (groupUser == null){
284                 retVal = false;
285                 return retVal;
286             }
287 
288             //process level part
289             List   groupUserProcLevParts = groupUser.getProcLevelParts();
290             for (Iterator   it = groupUserProcLevParts.iterator();it.hasNext();){
291                 HibernateProcessLevelParticipant procLevPart = (HibernateProcessLevelParticipant)it.next();
292                 groupUser.removeProcLevelParts(procLevPart);
293                 HibernateProcessPartMap pro = procLevPart.getProcess();
294                 deleteProcLevParticipant(procLevPart,session);
295                 deleteProcess(pro, session);
296                 HibernatePackage pack = pro.getPck();
297                 deletePackage(pack, session);
298             }
299             session.update(groupUser);
300             
301             //package level part.
302             List   groupUserPackLevParts = groupUser.getPackLevelParts();
303             for (Iterator   it = groupUserPackLevParts.iterator();it.hasNext();){
304                 HibernatePackageLevelParticipant packLevPart = (HibernatePackageLevelParticipant)it.next();
305                 groupUser.removePackLevelParts(packLevPart);
306                 deletePackLevParticipant(packLevPart,session);
307                 HibernatePackage pack = packLevPart.getPackage();
308                 deletePackage(pack, session);
309             }
310             session.update(groupUser);
311             
312             if (groupUser != null)
313                 deleteGroupUser(groupUser, session);
314 
315         } catch (Exception   e) {
316             e.printStackTrace();
317             e.printStackTrace();
318             throw new RootException(e);
319         }
320         return retVal;
321     }
322     
323     private void deleteProcLevParticipant(HibernateProcessLevelParticipant proLevPart, Session session) throws RootException {
324         try {
325             //proc level participant
326             if (proLevPart == null)
327                 return;
328 
329             if (proLevPart.getGroupUsers().size() == 0 && proLevPart.getNormalUsers().size() == 0) {
330                 session.delete(proLevPart);
331             }
332 
333         } catch (Exception   e) {
334             e.printStackTrace();
335             throw new RootException(e);
336         }
337     }
338 
339     private void deletePackLevParticipant(HibernatePackageLevelParticipant packLevPart, Session session) throws RootException {
340         try {
341             //pack level participant
342             if (packLevPart == null)
343                 return;
344 
345             if (packLevPart.getGroupUsers().size() == 0 && packLevPart.getNormalUsers().size() == 0) {
346                 session.delete(packLevPart);
347             }
348 
349         } catch (Exception   e) {
350             e.printStackTrace();
351             throw new RootException(e);
352         }
353     }
354 
355     private void deleteNormalUser(HibernateNormalUser normalUser, Session session) throws RootException {
356         try {
357             if (normalUser == null)
358                 return;
359 
360             if (normalUser.getProcLevelParts().size() == 0 && normalUser.getPackLevelParts().size() == 0) {
361                 session.delete(normalUser);
362             }
363 
364         } catch (Exception   e) {
365             e.printStackTrace();
366             throw new RootException(e);
367         }
368     }
369 
370     private void deleteGroupUser(HibernateGroupUser groupUser, Session session) throws RootException {
371         try {
372             if (groupUser == null)
373                 return;
374 
375             if (groupUser.getProcLevelParts().size() == 0 && groupUser.getPackLevelParts().size() == 0) {
376                 session.delete(groupUser);
377             }
378 
379         } catch (Exception   e) {
380             e.printStackTrace();
381             throw new RootException(e);
382         }
383     }
384 
385     private void deleteProcess(HibernateProcessPartMap pro, Session session) throws RootException {
386         try {
387             //process
388             if (pro == null)
389                 return;
390 
391             if (pro.getProcessLevelParticipant().size() == 0) {
392                 session.delete(pro);
393             }
394 
395         } catch (Exception   e) {
396             e.printStackTrace();
397             throw new RootException(e);
398         }
399     }
400 
401     private void deletePackage(HibernatePackage pack, Session session) throws RootException {
402         try {
403             //package
404             if (pack == null)
405                 return;
406 
407             if (pack.getProcesses().size() == 0 && pack.getPackageLevelParticipant().size() == 0) {
408                 session.delete(pack);
409             }
410 
411         } catch (Exception   e) {
412             e.printStackTrace();
413             throw new RootException(e);
414         }
415     }
416     private void deleteGroupProcLevelPart(ParticipantMap pm, Session session) throws RootException {
417         try {
418             String   username = pm.getUsername();
419             String   packageId = pm.getPackageId();
420             String   processId = pm.getProcessDefinitionId();
421             String   participantId = pm.getParticipantId();
422 
423             HibernateGroupUser groupUser = null;
424             if (username != null && !username.trim().equals("")) {
425                 groupUser = (HibernateGroupUser) session.get(HibernateGroupUser.class, username);
426             }
427             if (groupUser == null) return;
428 
429             HibernatePackage pack = (HibernatePackage) session.get(HibernatePackage.class, packageId);
430             if (pack == null) return;
431 
432             HibernateProcessPartMap pro = null;
433             boolean foundPro = false;
434             for (Iterator   it = pack.getProcesses().iterator(); it.hasNext();) {
435                 pro = (HibernateProcessPartMap) it.next();
436                 if (pro.getProcessId().equals(processId)) {
437                     foundPro = true;
438                     break;
439                 }
440             }
441             if (!foundPro) return;
442 
443             HibernateProcessLevelParticipant proLevPart = null;
444             boolean foundPart = false;
445             for (Iterator   it = pro.getProcessLevelParticipant().iterator(); it.hasNext();) {
446                 proLevPart = (HibernateProcessLevelParticipant) it.next();
447                 if (proLevPart.getParticipantId().equals(participantId)) {
448                     foundPart = true;
449                     break;
450                 }
451             }
452             if (!foundPro) return;
453 
454             proLevPart.removeGroupUser(groupUser);
455             session.update(proLevPart);
456 
457             //delete unnecessairly data
458             //proc level participant
459             deleteProcLevParticipant(proLevPart, session);
460             //process
461             deleteProcess(pro, session);
462             //package
463             deletePackage(pack, session);
464             //group user
465             if (groupUser != null)
466                 deleteGroupUser(groupUser, session);
467         } catch (Exception   e) {
468             e.printStackTrace();
469             throw new RootException(e);
470         }
471     }
472 
473     private void deleteNormalProcLevelPart(ParticipantMap pm, Session session) throws RootException {
474         try {
475             String   username = pm.getUsername();
476             String   packageId = pm.getPackageId();
477             String   processId = pm.getProcessDefinitionId();
478             String   participantId = pm.getParticipantId();
479 
480             HibernateNormalUser normalUser = null;
481             if (username != null && !username.trim().equals("")) {
482                 normalUser = (HibernateNormalUser) session.get(HibernateNormalUser.class, username);
483             }
484             if (normalUser == null) return;
485 
486             HibernatePackage pack = (HibernatePackage) session.get(HibernatePackage.class, packageId);
487             if (pack == null) return;
488             
489             HibernateProcessPartMap pro = null;
490             boolean foundPro = false;
491             
492             for (Iterator   it = pack.getProcesses().iterator(); it.hasNext();) {
493                 pro = (HibernateProcessPartMap) it.next();          
494                 if (pro.getProcessId().equals(processId)) {
495                     foundPro = true;
496                     break;
497                 }
498             }
499             if (!foundPro) return;
500 
501             HibernateProcessLevelParticipant proLevPart = null;
502             boolean foundPart = false;
503             for (Iterator   it = pro.getProcessLevelParticipant().iterator(); it.hasNext();) {
504                 proLevPart = (HibernateProcessLevelParticipant) it.next();
505                 if (proLevPart.getParticipantId().equals(participantId)) {
506                     foundPart = true;
507                     break;
508                 }
509             }
510             if (!foundPart) return;
511             proLevPart.removeNormalUser(normalUser);
512             session.update(proLevPart);
513 
514             //delete unnecessairly data
515             //proc level participant
516             deleteProcLevParticipant(proLevPart, session);
517             //process
518             deleteProcess(pro, session);
519             //package
520             deletePackage(pack, session);
521             //single user
522             if (normalUser != null)
523                 deleteNormalUser(normalUser, session);
524         } catch (Exception   e) {
525             e.printStackTrace();
526             e.printStackTrace();
527             throw new RootException(e);
528         }
529     }
530 
531     private void deleteGroupPackLevelPart(ParticipantMap pm, Session session) throws RootException {
532         try {
533             String   username = pm.getUsername();
534             String   packageId = pm.getPackageId();
535             String   participantId = pm.getParticipantId();
536 
537             HibernateGroupUser groupUser = null;
538             if (username != null && !username.trim().equals("")) {
539                 groupUser = (HibernateGroupUser) session.get(HibernateGroupUser.class, username);
540             }
541             if (groupUser == null) return;
542 
543             HibernatePackage pack = (HibernatePackage) session.get(HibernatePackage.class, packageId);
544             if (pack == null) return;
545             
546             HibernatePackageLevelParticipant packLevPart = null;
547             boolean found = false;
548             for (Iterator   it = pack.getPackageLevelParticipant().iterator(); it.hasNext();) {
549                 packLevPart = (HibernatePackageLevelParticipant) it.next();
550                 if (packLevPart.getParticipantId().equals(participantId)) {
551                     found = true;
552                     break;
553                 }
554             }
555             if (!found) return;
556             
557             packLevPart.removeGroupUser(groupUser);
558             session.update(packLevPart);
559 
560             //delete unnecessairly data
561             //pack level participant
562             deletePackLevParticipant(packLevPart, session);
563             //package
564             deletePackage(pack, session);
565             //group user
566             if (groupUser != null)
567                 deleteGroupUser(groupUser, session);
568         } catch (Exception   e) {
569             e.printStackTrace();
570             throw new RootException(e);
571         }
572     }
573 
574     private void deleteNormalPackLevelPart(ParticipantMap pm, Session session) throws RootException {
575         try {
576             String   username = pm.getUsername();
577             String   packageId = pm.getPackageId();
578             String   participantId = pm.getParticipantId();
579 
580             HibernateNormalUser normalUser = null;
581             if (username != null && !username.trim().equals("")) {
582                 normalUser = (HibernateNormalUser) session.get(HibernateNormalUser.class, username);
583             }
584             if (normalUser == null) return;
585             
586             HibernatePackage pack = (HibernatePackage) session.get(HibernatePackage.class, packageId);
587             if (pack == null) return;
588             
589             HibernatePackageLevelParticipant packLevPart = null;
590             boolean found = false;
591             for (Iterator   it = pack.getPackageLevelParticipant().iterator(); it.hasNext();) {
592                 packLevPart = (HibernatePackageLevelParticipant) it.next();
593                 if (packLevPart.getParticipantId().equals(participantId)) {
594                     found = true;
595                     break;
596                 }
597             }
598             if (!found) return;
599             
600             packLevPart.removeNormalUser(normalUser);
601             session.update(packLevPart);
602 
603             //delete unnecessairly data
604             //pack level participant
605             deletePackLevParticipant(packLevPart, session);
606             //package
607             deletePackage(pack, session);
608             //single user
609             if (normalUser != null)
610                 deleteNormalUser(normalUser, session);
611         } catch (Exception   e) {
612             e.printStackTrace();
613             throw new RootException(e);
614         }
615     }
616     
617     //////////////////////////////////////////////////////////////////
618     //  Query methods
619     //////////////////////////////////////////////////////////////////
620     
621     /**
622      * Check if specified participant map exist in database.
623      * 
624      * @param trans
625      *                  ParticipantMappingTransaction
626      * @param pm
627      *                  ParticipantMap to check
628      * @return boolean true if everything is ok, false otherwise
629      * @exception RootException
630      *                       RootException will be thrown if error occure.
631      *  
632      */
633     public boolean doesParticipantMappingExist(ParticipantMappingTransaction trans, ParticipantMap pm) throws RootException {
634         boolean isExist = false;
635         if (!checkValidity(pm)) {
636             throw new RootException("Participant mapping [ " + pm + " ] is not valid");
637         }
638         try {
639             Session session = ((HibernateParticipantMappingTransaction) trans).getSession();
640             //if group user
641             if (pm.getIsGroupUser()) {
642                 HibernateGroupUser groupUser = this.checkGroups(session, false, pm);
643                 if (groupUser != null){
644                     //process level participant
645                     if (pm.getProcessDefinitionId() != null) {
646                         HibernateProcessLevelParticipant procLevPart = checkProcLevelParticipant(session, false, pm);
647                         if (procLevPart != null && groupUser.getProcLevelParts().contains(procLevPart))
648                             isExist = true;
649                     }
650                     //package level participant
651                     else {
652                         HibernatePackageLevelParticipant pckLevPart = checkPackLevelParticipant(session, false, pm);
653                         if (pckLevPart != null && groupUser.getPackLevelParts().contains(pckLevPart))
654                             isExist = true;
655                     }
656                 }
657             }
658             //if single user
659             else {
660                 HibernateNormalUser user = checkUsers(session, false, pm);
661                 if (user != null){
662                     if (pm.getProcessDefinitionId() != null) {
663                         HibernateProcessLevelParticipant procLevPart = checkProcLevelParticipant(session, false, pm);
664                         if (procLevPart != null && user.getProcLevelParts().contains(procLevPart)){
665                             isExist = true;
666                         }
667                     } else {
668                         HibernatePackageLevelParticipant pckLevPart = checkPackLevelParticipant(session, false, pm);
669                         if (pckLevPart != null && user.getPackLevelParts().contains(pckLevPart)){
670                             isExist = true;
671                         }
672                     }
673                 }
674             }
675 
676         } catch (Exception   e) {
677             e.printStackTrace();
678             throw new RootException(e);
679         }
680         return isExist;
681     }
682 
683     /**
684      * Gets all ParticipantMappings from database.
685      * 
686      * @param trans
687      *                  ParticipantMappingTransaction
688      * @return List List with participant mappings.
689      * @exception RootException
690      *                       RootException will be thrown if error occure.
691      *  
692      */
693     public List   getAllParticipantMappings(ParticipantMappingTransaction trans) throws RootException {
694         List