Java > Open Source Codes > org > enhydra > shark > partmappersistence > 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 list = new ArrayList ();
695         try {
696             Session session = ((HibernateParticipantMappingTransaction) trans).getSession();
697
698             List packages = session.find("from HibernatePackage");
699             List processes = new ArrayList ();
700             for (Iterator itPackages = packages.iterator(); itPackages.hasNext();) {
701                 HibernatePackage pack = (HibernatePackage) itPackages.next();
702                 processes.addAll(pack.getProcesses());
703                 List pckLevParts = pack.getPackageLevelParticipant();
704                 for (Iterator itPckLevPart = pckLevParts.iterator(); itPckLevPart.hasNext();) {
705                     HibernatePackageLevelParticipant pckLevPart = (HibernatePackageLevelParticipant) itPckLevPart.next();
706                     //group user package level
707 List groupUsers = pckLevPart.getGroupUsers();
708                     for (Iterator itGroupUsers = groupUsers.iterator(); itGroupUsers.hasNext();) {
709                         HibernateGroupUser groupUser = (HibernateGroupUser) itGroupUsers.next();
710                         ParticipantMap pm = createParticipantMap();
711                         pm.setParticipantId(pckLevPart.getParticipantId());
712                         pm.setPackageId(pack.getPackageId());
713                         pm.setUsername(groupUser.getUserName());
714                         pm.setProcessDefinitionId(null);
715                         pm.setIsGroupUser(true);
716                         list.add(pm);
717                     }
718                     //normal user package level
719 List normalUsers = pckLevPart.getNormalUsers();
720                     for (Iterator itNormalUsers = normalUsers.iterator(); itNormalUsers.hasNext();) {
721                         HibernateNormalUser normalUser = (HibernateNormalUser) itNormalUsers.next();
722                         ParticipantMap pm = createParticipantMap();
723                         pm.setParticipantId(pckLevPart.getParticipantId());
724                         pm.setPackageId(pack.getPackageId());
725                         pm.setUsername(normalUser.getUserName());
726                         pm.setProcessDefinitionId(null);
727                         pm.setIsGroupUser(false);
728                         list.add(pm);
729                     }
730                 }
731             }
732
733             for (Iterator itProcesses = processes.iterator(); itProcesses.hasNext();) {
734                 HibernateProcessPartMap pro = (HibernateProcessPartMap) itProcesses.next();
735                 List proLevelParts = pro.getProcessLevelParticipant();
736                 for (Iterator itProLevPart = proLevelParts.iterator(); itProLevPart.hasNext();) {
737                     HibernateProcessLevelParticipant proLevPart = (HibernateProcessLevelParticipant) itProLevPart.next();
738                     //group user process level
739 List groupUsers = proLevPart.getGroupUsers();
740                     for (Iterator itGroupUsers = groupUsers.iterator(); itGroupUsers.hasNext();) {
741                         HibernateGroupUser groupUser = (HibernateGroupUser) itGroupUsers.next();
742                         ParticipantMap pm = createParticipantMap();
743                         pm.setParticipantId(proLevPart.getParticipantId());
744                         pm.setPackageId(pro.getPck().getPackageId());
745                         pm.setUsername(groupUser.getUserName());
746                         pm.setProcessDefinitionId(pro.getProcessId());
747                         pm.setIsGroupUser(true);
748                         list.add(pm);
749                     }
750                     //normal user process level
751 List normalUsers = proLevPart.getNormalUsers();
752                     for (Iterator itNormalUsers = normalUsers.iterator(); itNormalUsers.hasNext();) {
753                         HibernateNormalUser normalUser = (HibernateNormalUser) itNormalUsers.next();
754                         ParticipantMap pm = createParticipantMap();
755                         pm.setParticipantId(proLevPart.getParticipantId());
756                         pm.setPackageId(pro.getPck().getPackageId());
757                         pm.setUsername(normalUser.getUserName());
758                         pm.setProcessDefinitionId(pro.getProcessId());
759                         pm.setIsGroupUser(false);
760                         list.add(pm);
761                     }
762                 }
763             }
764
765             //return list with all participant mappings
766 return list;
767         } catch (Exception e) {
768             e.printStackTrace();
769             throw new RootException(e);
770         }
771     }
772
773     /**
774      * Gets all participant mappings for specified parameters.
775      *
776      * @param trans
777      * ParticipantMappingTransaction
778      * @param packageId
779      * Package id for this mapping.
780      * @param processDefinitionId
781      * Process id for this mapping.
782      * @param participantId
783      * Participant id for this mapping.
784      * @return a List List with objects ParticipantMap.
785      * @exception RootException
786      * RootException will be thrown if error occurs.
787      *
788      */
789     public List getParticipantMappings(ParticipantMappingTransaction trans, String packageId, String processDefinitionId, String participantId)
790     throws RootException {
791         List list = new ArrayList ();
792         boolean foundPro = false;
793         boolean foundPart = false;
794         try {
795             Session session = ((HibernateParticipantMappingTransaction) trans).getSession();
796             // empty string is same as null
797 if (processDefinitionId != null && processDefinitionId.trim().equals(""))
798                 processDefinitionId = null;
799             
800             HibernatePackage pack = (HibernatePackage)session.get(HibernatePackage.class,packageId);
801             if (pack == null)
802                 return list;
803             if (processDefinitionId == null) {
804
805                 HibernatePackageLevelParticipant packLevPart = null;
806                 for (Iterator it = pack.getPackageLevelParticipant().iterator(); it.hasNext();) {
807                     packLevPart = (HibernatePackageLevelParticipant) it.next();
808                     if (packLevPart.getParticipantId().equals(participantId)) {
809                         foundPart = true;
810                         break;
811                     }
812                 }
813                 
814                 if (!foundPart) return list;
815                 
816                 //group user package level
817 List groupUsers = packLevPart.getGroupUsers();
818                 for (Iterator itGroupUsers = groupUsers.iterator(); itGroupUsers.hasNext();) {
819                     HibernateGroupUser groupUser = (HibernateGroupUser) itGroupUsers.next();
820                     ParticipantMap pm = createParticipantMap();
821                     pm.setParticipantId(packLevPart.getParticipantId());
822                     pm.setPackageId(pack.getPackageId());
823                     pm.setUsername(groupUser.getUserName());
824                     pm.setProcessDefinitionId(null);
825                     pm.setIsGroupUser(true);
826                     list.add(pm);
827                 }
828                 //normal user package level
829 List normalUsers = packLevPart.getNormalUsers();
830                 for (Iterator itNormalUsers = normalUsers.iterator(); itNormalUsers.hasNext();) {
831                     HibernateNormalUser normalUser = (HibernateNormalUser) itNormalUsers.next();
832                     ParticipantMap pm = createParticipantMap();
833                     pm.setParticipantId(packLevPart.getParticipantId());
834                     pm.setPackageId(pack.getPackageId());
835                     pm.setUsername(normalUser.getUserName());
836                     pm.setProcessDefinitionId(null);
837                     pm.setIsGroupUser(false);
838                     list.add(pm);
839                 }
840             } else {
841                 HibernateProcessPartMap pro = null;
842                 for (Iterator it = pack.getProcesses().iterator(); it.hasNext();) {
843                     pro = (HibernateProcessPartMap) it.next();
844                     if (pro.getProcessId().equals(processDefinitionId)) {
845                         foundPro = true;
846                         break;
847                     }
848                 }
849                 
850                 if (!foundPro) return list;
851                 
852                 HibernateProcessLevelParticipant proLevPart = null;
853                 for (Iterator it = pro.getProcessLevelParticipant().iterator(); it.hasNext();) {
854                     proLevPart = (HibernateProcessLevelParticipant) it.next();
855                     if (proLevPart.getParticipantId().equals(participantId)) {
856                         foundPart = true;
857                         break;
858                     }
859                 }
860                 
861                 if (!foundPart) return list;
862                 
863                 //group user process level
864 List groupUsers = proLevPart.getGroupUsers();
865                 for (Iterator itGroupUsers = groupUsers.iterator(); itGroupUsers.hasNext();) {
866                     HibernateGroupUser groupUser = (HibernateGroupUser) itGroupUsers.next();
867                     ParticipantMap pm = createParticipantMap();
868                     pm.setParticipantId(proLevPart.getParticipantId());
869                     pm.setPackageId(pro.getPck().getPackageId());
870                     pm.setUsername(groupUser.getUserName());
871                     pm.setProcessDefinitionId(pro.getProcessId());
872                     pm.setIsGroupUser(true);
873                     list.add(pm);
874                 }
875                 //normal user process level
876 List normalUsers = proLevPart.getNormalUsers();
877                 for (Iterator itNormalUsers = normalUsers.iterator(); itNormalUsers.hasNext();) {
878                     HibernateNormalUser normalUser = (HibernateNormalUser) itNormalUsers.next();
879                     ParticipantMap pm = createParticipantMap();
880                     pm.setParticipantId(proLevPart.getParticipantId());
881                     pm.setPackageId(pro.getPck().getPackageId());
882                     pm.setUsername(normalUser.getUserName());
883                     pm.setProcessDefinitionId(pro.getProcessId());
884                     pm.setIsGroupUser(false);
885                     list.add(pm);
886                 }
887             }
888             //return list with all participant mappings
889 return list;
890         } catch (Exception e) {
891             e.printStackTrace();
892             throw new RootException(e);
893         }
894     }
895     
896     private HibernatePackage checkPackage(Session session, ParticipantMap pm) throws RootException {
897         try {
898             //package
899 HibernatePackage pack = (HibernatePackage) session.get(HibernatePackage.class, pm.getPackageId());
900             if (pack == null) {
901                 pack = createPackage();
902                 pack.setPackageId(pm.getPackageId());
903                 session.save(pack);
904             }
905
906             return pack;
907         } catch (Exception e) {
908             e.printStackTrace();
909             throw new RootException(e);
910         }
911     }
912
913     private HibernateProcessPartMap checkProcess(Session session, ParticipantMap pm) throws RootException {
914         try {
915             //process and package
916 HibernatePackage pack = null;
917             HibernateProcessPartMap pro = null;
918             boolean found = false;
919
920             String processId = pm.getProcessDefinitionId();
921             String packageId = pm.getPackageId();
922
923             if (processId != null) {
924                 pack = checkPackage(session, pm);
925             }
926             for (Iterator it = pack.getProcesses().iterator(); it.hasNext();) {
927                 pro = (HibernateProcessPartMap) it.next();
928                 if (pro.getProcessId().equals(processId)) {
929                     found = true;
930                     break;
931                 }
932             }
933             if (!found) {
934                 pro = createProcess();
935                 pro.setProcessId(processId);
936                 pro.setPck(pack);
937                 session.save(pro);
938             }
939
940             return pro;
941         } catch (Exception e) {
942             e.printStackTrace();
943             throw new RootException(e);
944         }
945     }
946
947     private HibernateProcessLevelParticipant checkProcLevelParticipant(Session session, boolean createToo, ParticipantMap pm) throws RootException {
948         try {
949             //participants
950 String participantId = pm.getParticipantId();
951             boolean found = false;
952             HibernateProcessLevelParticipant proLevPart = null;
953             HibernateProcessPartMap pro = checkProcess(session, pm);
954             
955             for (Iterator it = pro.getProcessLevelParticipant().iterator(); it.hasNext();) {
956                 proLevPart = (HibernateProcessLevelParticipant) it.next();
957                 if (proLevPart.getParticipantId().equals(participantId)) {
958                     found = true;
959                     break;
960                 }
961             }
962             
963             if (!found)
964                 proLevPart = null;
965
966             if (!found && createToo) {
967                 proLevPart = createProcessLevelParticipant();
968                 proLevPart.setParticipantId(pm.getParticipantId());
969                 proLevPart.setProcess(pro);
970                 pro.addProcessLevelParticipant(proLevPart);
971                 session.save(proLevPart);
972                 session.update(pro);
973             }
974             return proLevPart;
975
976         } catch (Exception e) {
977             e.printStackTrace();
978             throw new RootException(e);
979         }
980     }
981
982     private HibernatePackageLevelParticipant checkPackLevelParticipant(Session session, boolean createToo, ParticipantMap pm) throws RootException {
983         try {
984             //participants
985 HibernatePackageLevelParticipant packLevPart = null;
986             HibernatePackage pack = checkPackage(session, pm);
987             String participantId = pm.getParticipantId();
988             boolean found = false;
989
990             for (Iterator it = pack.getPackageLevelParticipant().iterator(); it.hasNext();) {
991                 packLevPart = (HibernatePackageLevelParticipant) it.next();
992                 if (packLevPart.getParticipantId().equals(participantId)) {
993                     found = true;
994                     break;
995                 }
996             }
997             
998             if (!found)
999                 packLevPart = null;
1000
1001            if (!found && createToo) {
1002                packLevPart = createPackageLevelParticipant();
1003                packLevPart.setParticipantId(pm.getParticipantId());
1004                packLevPart.setPackage(pack);
1005                pack.addPackageLevelParticipan(packLevPart);
1006                session.save(packLevPart);
1007                session.update(pack);
1008            }
1009            return packLevPart;
1010
1011        } catch (Exception e) {
1012            e.printStackTrace();
1013            throw new RootException(e);
1014        }
1015    }
1016
1017    private HibernateNormalUser checkUsers(Session session, boolean createToo, ParticipantMap pm) throws RootException {
1018        try {
1019            HibernateNormalUser normalUser = (HibernateNormalUser) session.get(HibernateNormalUser.class, pm.getUsername());
1020
1021            if (normalUser == null && createToo) {
1022                normalUser = createNormalUser();
1023                normalUser.setUserName(pm.getUsername());
1024                session.save(normalUser);
1025            }
1026
1027            return normalUser;
1028        } catch (Exception e) {
1029            e.printStackTrace();
1030            throw new RootException(e);
1031        }
1032    }
1033
1034    private HibernateGroupUser checkGroups(Session session, boolean createToo, ParticipantMap pm) throws RootException {
1035        try {
1036            HibernateGroupUser groupUser = (HibernateGroupUser) session.get(HibernateGroupUser.class, pm.getUsername());
1037
1038            if (groupUser == null && createToo) {
1039                groupUser = createGroupUser();
1040                groupUser.setUserName(pm.getUsername());
1041                session.save(groupUser);
1042            }
1043
1044            return groupUser;
1045        } catch (Exception e) {
1046            e.printStackTrace();
1047            throw new RootException(e);
1048        }
1049    }
1050
1051    //////////////////////////////////////////////////////////////////
1052 // Factory methods
1053 //////////////////////////////////////////////////////////////////
1054
1055    /**
1056     * Method createParticipantMap create new ParticipantMap object.
1057     *
1058     * @return a ParticipantMap
1059     *
1060     */
1061    public ParticipantMap createParticipantMap() {
1062        return new HibernateParticipantMap();
1063    }
1064
1065    public HibernateGroupUser createGroupUser() {
1066        return new HibernateGroupUser();
1067    }
1068
1069    public HibernateNormalUser createNormalUser() {
1070        return new HibernateNormalUser();
1071    }
1072
1073    public HibernatePackage createPackage() {
1074        return new HibernatePackage();
1075    }
1076
1077    public HibernateProcessPartMap createProcess() {
1078        return new HibernateProcessPartMap();
1079    }
1080
1081    public HibernateProcessLevelParticipant createProcessLevelParticipant() {
1082        return new HibernateProcessLevelParticipant();
1083    }
1084
1085    public HibernatePackageLevelParticipant createPackageLevelParticipant() {
1086        return new HibernatePackageLevelParticipant();
1087    }
1088    
1089    /**
1090     * Method getDBTransaction create Hibernate DBTransaction from
1091     * ParticipantMappingTransaction.
1092     *
1093     * @param t
1094     * ParticipantMappingTransaction
1095     * @return Transaction
1096     *
1097     */
1098    private Transaction getDBTransaction(ParticipantMappingTransaction t) throws Exception {
1099        try {
1100            if (t instanceof HibernateParticipantMappingTransaction)
1101                return ((HibernateParticipantMappingTransaction) t).getHibernateTransaction();
1102        } catch (Exception e) {
1103            e.printStackTrace();
1104            throw e;
1105        }
1106        //error
1107 return null;
1108    }
1109
1110    public ParticipantMappingTransaction getParticipantMappingTransaction() throws TransactionException {
1111        try {
1112            return new HibernateParticipantMappingTransaction(ThreadLocalSession.currentSession().beginTransaction());
1113        } catch (Exception ex) {
1114            ex.printStackTrace();
1115            throw new TransactionException(ex);
1116        }
1117    }
1118    
1119    //////////////////////////////////////////////////////////////////
1120 // Utility methods
1121 //////////////////////////////////////////////////////////////////
1122
1123    public boolean checkValidity(ParticipantMap pm) {
1124        if (pm == null
1125            || pm.getPackageId() == null
1126            || pm.getPackageId().trim().equals("")
1127            || pm.getParticipantId() == null
1128            || pm.getParticipantId().trim().equals("")
1129            || pm.getUsername() == null
1130            || pm.getUsername().trim().equals("")) {
1131            return false;
1132        } else {
1133            return true;
1134        }
1135    }
1136
1137}
1138

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags