|
1
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
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
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
51
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 (pm.getIsGroupUser()) {
75 HibernateGroupUser groupUser = this.checkGroups(session, true, pm);
76 if (pm.getProcessDefinitionId() != null) {
78 HibernateProcessLevelParticipant procLevPart = checkProcLevelParticipant(session, true, pm);
79 procLevPart.addGrouplUser(groupUser);
80 session.update(procLevPart);
81 }
82 else {
84 HibernatePackageLevelParticipant pckLevPart = checkPackLevelParticipant(session, true, pm);
85 pckLevPart.addGrouplUser(groupUser);
86 session.update(pckLevPart);
87 }
88
89 }
90 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
115
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 if (processId != null) {
139 if (isGroup) {
141 deleteGroupProcLevelPart(pm, session);
142 }
143 else {
145 deleteNormalProcLevelPart(pm, session);
146 }
147 }
148 else {
150 if (isGroup) {
152 deleteGroupPackLevelPart(pm, session);
153 }
154 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
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 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 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 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
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 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 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 HibernateGroupUser groupUser = (HibernateGroupUser)session.get(HibernateGroupUser.class,username);
283 if (groupUser == null){
284 retVal = false;
285 return retVal;
286 }
287
288 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 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 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 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 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 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 deleteProcLevParticipant(proLevPart, session);
460 deleteProcess(pro, session);
462 deletePackage(pack, session);
464 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 deleteProcLevParticipant(proLevPart, session);
517 deleteProcess(pro, session);
519 deletePackage(pack, session);
521 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 deletePackLevParticipant(packLevPart, session);
563 deletePackage(pack, session);
565 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 deletePackLevParticipant(packLevPart, session);
606 deletePackage(pack, session);
608 if (normalUser != null)
610 deleteNormalUser(normalUser, session);
611 } catch (Exception e) {
612 e.printStackTrace();
613 throw new RootException(e);
614 }
615 }
616
617
621
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 (pm.getIsGroupUser()) {
642 HibernateGroupUser groupUser = this.checkGroups(session, false, pm);
643 if (groupUser != null){
644 if (pm.getProcessDefinitionId() != null) {
646 HibernateProcessLevelParticipant procLevPart = checkProcLevelParticipant(session, false, pm);
647 if (procLevPart != null && groupUser.getProcLevelParts().contains(procLevPart))
648 isExist = true;
649 }
650 else {
652 HibernatePackageLevelParticipant pckLevPart = checkPackLevelParticipant(session, false, pm);
653 if (pckLevPart != null && groupUser.getPackLevelParts().contains(pckLevPart))
654 isExist = true;
655 }
656 }
657 }
658 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
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 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 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 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 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;
767 } catch (Exception e) {
768 e.printStackTrace();
769 throw new RootException(e);
770 }
771 }
772
773
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 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 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 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 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 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;
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 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 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 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 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
1055
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
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 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
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
|
Popular Tags
|
Java API By Example, From Geeks To Geeks.