|
1
4
5
6 package org.enhydra.shark.instancepersistence;
7
8 import java.math.BigDecimal  ;
9 import java.util.ArrayList ;
10 import java.util.HashMap ;
11 import java.util.Iterator ;
12 import java.util.List ;
13 import java.util.Map ;
14
15 import net.sf.hibernate.Query;
16 import net.sf.hibernate.Session;
17
18 import org.enhydra.shark.api.RootException;
19 import org.enhydra.shark.api.SharkTransaction;
20 import org.enhydra.shark.api.internal.instancepersistence.ActivityPersistenceInterface;
21 import org.enhydra.shark.api.internal.instancepersistence.ActivityVariablePersistenceInterface;
22 import org.enhydra.shark.api.internal.instancepersistence.AndJoinEntryInterface;
23 import org.enhydra.shark.api.internal.instancepersistence.AssignmentPersistenceInterface;
24 import org.enhydra.shark.api.internal.instancepersistence.DeadlinePersistenceInterface;
25 import org.enhydra.shark.api.internal.instancepersistence.PersistenceException;
26 import org.enhydra.shark.api.internal.instancepersistence.PersistentManagerInterface;
27 import org.enhydra.shark.api.internal.instancepersistence.ProcessMgrPersistenceInterface;
28 import org.enhydra.shark.api.internal.instancepersistence.ProcessPersistenceInterface;
29 import org.enhydra.shark.api.internal.instancepersistence.ProcessVariablePersistenceInterface;
30 import org.enhydra.shark.api.internal.instancepersistence.ResourcePersistenceInterface;
31 import org.enhydra.shark.api.internal.working.CallbackUtilities;
32 import org.enhydra.shark.instancepersistence.data.HibernateActivityState;
33 import org.enhydra.shark.instancepersistence.data.HibernateProcessState;
34 import org.enhydra.shark.transaction.SharkHibernateTransaction;
35 import org.enhydra.shark.transaction.ThreadLocalSession;
36 import org.enhydra.shark.utilities.MiscUtilities;
37 import org.enhydra.shark.utilities.hibernate.HibernateUtilities;
38
39
46 public class HibernatePersistentManager implements PersistentManagerInterface {
47
48 private static final String LOG_CHANNEL="Persistence";
49 private static final int RESOURCE_TYPE_OBJECT=0;
50 private static final int PROCESS_DEFINITION_TYPE_OBJECT=1;
51 private static final int PROCESS_TYPE_OBJECT=2;
52 private static final int ACTIVITY_TYPE_OBJECT=3;
53 private static final int ASSIGNMENT_TYPE_OBJECT=4;
54
55 private static final String [] activityAndProcessStates={"open.running",
56 "open.not_running.not_started","open.not_running.suspended",
57 "closed.completed", "closed.terminated", "closed.aborted"};
58
59 private CallbackUtilities cus;
60 private boolean deleteFinishedProcesses = false;
61 private Map _prStates;
62 private Map _acStates;
63
64
68 public void configure(CallbackUtilities cus) throws RootException {
69 this.cus = cus;
70 String del = cus.getProperty("HibernatePersistentManager.deleteFinishedProcesses");
71 deleteFinishedProcesses = new Boolean (del).booleanValue();
72 _prStates = new HashMap ();
73 _acStates = new HashMap ();
74
75 try {
76 try {
77 HibernateUtilities.init(cus.getProperties());
78 } catch (Throwable ex) {
79 ex.printStackTrace();
80 }
81 initActivityAndProcessStatesTable();
82 } catch (Throwable tr) {
83 cus.error(LOG_CHANNEL, "Problem with registering database manager with Hibernate !", new RootException(tr));
84 throw new RootException("Problem with registering database manager with Hibernate !", tr);
85 }
86 }
87
88
96 private void initActivityAndProcessStatesTable() throws PersistenceException {
97 SharkHibernateTransaction ti = null;
98 try {
99 ti = new SharkHibernateTransaction(ThreadLocalSession.currentSession().beginTransaction());
100 Session session = ti.getSession();
101 for (int i = 0; i < activityAndProcessStates.length; i++) {
102 String state = activityAndProcessStates[i];
103 HibernateProcessState hibProcessState = getPersistedProcessStateObject(state, session);
104 if (hibProcessState == null) {
105 hibProcessState = new HibernateProcessState();
106 hibProcessState.setKeyValue(state);
107 hibProcessState.setName(state);
108 hibProcessState.setDbId(getNextDecId(HibernateUtilities.HibernateProcessStateClassName).intValue());
109 session.save(hibProcessState);
110 } else {
111 hibProcessState.setName(state);
112 session.update(hibProcessState);
113 }
114 _prStates.put(state, new Integer (hibProcessState.getDbId()));
115 HibernateActivityState hibActivityState = getPersistedActivityStateObject(state, session);
116 if (hibActivityState == null) {
117 hibActivityState = new HibernateActivityState();
118 hibActivityState.setKeyValue(state);
119 hibActivityState.setName(state);
120 hibActivityState.setDbId(getNextDecId(HibernateUtilities.HibernateActivityStateClassName).intValue());
121 session.save(hibActivityState);
122 } else {
123 hibActivityState.setName(state);
124 session.update(hibActivityState);
125 }
126 _acStates.put(state, new Integer (hibActivityState.getDbId()));
127 }
128 ti.commit();
129 session.clear();
130 session.close();
131 } catch (Throwable thr) {
132 thr.printStackTrace();
133 throw new PersistenceException(thr);
134 } finally {
135 try {
136 ti = null;
137 } catch (Exception ex) {
138 }
139 }
140 }
141
142
146 public void shutdownDatabase() throws PersistenceException {
147 try {
148 ThreadLocalSession.closeSession();
149 } catch (Throwable tr) {
150 cus.error(LOG_CHANNEL, "Database is not properly shudown !", new RootException(tr));
151 throw new PersistenceException("Database is not properly shudown !", tr);
152 }
153 }
154
155
159 public void persist(ProcessMgrPersistenceInterface pm, SharkTransaction ti) throws PersistenceException {
160 try {
161 HibernateProcessMgr hibProcessMgr = getPersistedObject(pm, ti);
162 if (hibProcessMgr == null) {
163 hibProcessMgr = (HibernateProcessMgr) createProcessMgr();
164 hibProcessMgr.setName(pm.getName());
165 hibProcessMgr.setPackageId(pm.getPackageId());
166 hibProcessMgr.setProcessDefinitionId(pm.getProcessDefinitionId());
167 hibProcessMgr.setVersion(pm.getVersion());
168 hibProcessMgr.setCreated(pm.getCreated());
169 hibProcessMgr.setState(pm.getState());
170 ((SharkHibernateTransaction)ti).store(hibProcessMgr);
171 } else {
172 hibProcessMgr.setState(pm.getState());
173 ((SharkHibernateTransaction)ti).store(hibProcessMgr);
174 }
175 cus.info(LOG_CHANNEL, "ProcessDefinition[packageId=" + pm.getPackageId() + ",id=" + pm.getProcessDefinitionId() + "] persisted");
176 } catch (Throwable tr) {
177 cus.error(LOG_CHANNEL, "Persisting of ProcessDefinition " + pm.getProcessDefinitionId() + " failed");
178 throw new PersistenceException("Persisting of ProcessDefinition " + pm.getProcessDefinitionId() + " failed", tr);
179 }
180 }
181
182 public void persist(ProcessPersistenceInterface pr, SharkTransaction ti) throws PersistenceException {
183 try {
184 HibernateProcess hibProcess = getPersistedObject(pr, ti);
185 HibernateProcessRequester hibProcessRequester = getProcessRequester(pr.getId(),ti);
186
187 HibernateActivity hibActivity = null;
188 HibernateResource hibResource = null;
189
190 if (pr.getActivityRequesterId() != null)
191 hibActivity = getPersistedActivityObject(pr.getActivityRequesterId(), ti);
192 if (pr.getResourceRequesterId() != null)
193 hibResource = getPersistedResourceObject(pr.getResourceRequesterId(), ti);
194 HibernateProcessMgr hibProcessMgr = getPersistedProcessMgrObject(pr.getProcessMgrName(), ti);
195
196 if (hibProcess == null) {
197 hibProcess = (HibernateProcess) createProcess();
198
199 hibProcess.setId(pr.getId());
200 hibProcess.setProcessMgrName(hibProcessMgr.getName());
201 if (pr.getActivityRequesterId() != null)
202 hibProcess.setActivityRequesterId(hibActivity.getId());
203 if (pr.getResourceRequesterId() != null)
204 hibProcess.setResourceRequesterId(hibResource.getUsername());
205 hibProcess.setName(pr.getName());
206 hibProcess.setDescription(pr.getDescription());
207 hibProcess.setPriority(pr.getPriority());
208
209 hibProcess.setState(pr.getState());
210 Integer stateId = (Integer )_prStates.get(pr.getState());
211 hibProcess.setStateId(stateId.intValue());
212
213 hibProcess.setStartedTime(pr.getStartedTime());
214 hibProcess.setLastStateTime(pr.getLastStateTime());
215
216 hibProcessRequester.setId(pr.getId());
217 if (hibActivity != null){
218 hibProcessRequester.setActRequester(hibActivity.getId());
219 }
220 if (hibResource != null){
221 hibProcessRequester.setResRequester(hibResource.getUsername());
222 }
223
224 ((SharkHibernateTransaction)ti).store(hibProcessRequester);
225 ((SharkHibernateTransaction)ti).store(hibProcess);
226 } else {
227 if (hibActivity != null)
228 hibProcess.setActivityRequesterId(hibActivity.getId());
229 if (hibResource != null)
230 hibProcess.setResourceRequesterId(hibResource.getUsername());
231 hibProcess.setName(pr.getName());
232 hibProcess.setDescription(pr.getDescription());
233 hibProcess.setPriority(pr.getPriority());
234
235 hibProcess.setState(pr.getState());
236 Integer stateId = (Integer )_prStates.get(pr.getState());
237 hibProcess.setStateId(stateId.intValue());
238
239 hibProcess.setStartedTime(pr.getStartedTime());
240 hibProcess.setLastStateTime(pr.getLastStateTime());
241
242 hibProcessRequester.setId(pr.getId());
243 if (hibActivity != null){
244 hibProcessRequester.setActRequester(hibActivity.getId());
245 }
246 if (hibResource != null){
247 hibProcessRequester.setResRequester(hibResource.getUsername());
248 }
249
250 ((SharkHibernateTransaction)ti).store(hibProcessRequester);
251 ((SharkHibernateTransaction)ti).store(hibProcess);
252 }
253
254 cus.info(LOG_CHANNEL, "Process[id=" + pr.getId() + "] persisted");
255 } catch (Throwable tr) {
256 tr.printStackTrace();
257 cus.error(LOG_CHANNEL, "Persisting of Process " + pr.getId() + " failed");
258 throw new PersistenceException("Persisting of Process " + pr.getId() + " failed", tr);
259 }
260 }
261
262 public void persist(ActivityPersistenceInterface act, SharkTransaction ti) throws PersistenceException {
263 try {
264 HibernateActivity hibActivity = getPersistedObject(act, ti);
265
266 if (hibActivity == null) {
267 hibActivity = (HibernateActivity) createActivity();
268 hibActivity.setId(act.getId());
269 hibActivity.setActivityDefinitionId(act.getActivityDefinitionId());
270 hibActivity.setActivitySetDefinitionId(act.getActivitySetDefinitionId());
271 hibActivity.setProcessId(getPersistedProcessObject(act.getProcessId(), ti).getId());
272 String bActId = act.getBlockActivityId();
273 if (bActId != null) {
274 hibActivity.setBlockActivityId(getPersistedActivityObject(bActId, ti).getId());
275 }
276 hibActivity.setName(act.getName());
277 hibActivity.setDescription(act.getDescription());
278 hibActivity.setPriority(act.getPriority());
279 if (act.getResourceUsername() != null){
280 HibernateResource res = getPersistedResourceObject(act.getResourceUsername(), ti);
281 hibActivity.setResourceUsername(res.getUsername());
282 }
283 hibActivity.setState(act.getState());
284 Integer stateId = (Integer )_acStates.get(act.getState());
285 hibActivity.setStateId(stateId.intValue());
286
287 hibActivity.setLastStateTime(act.getLastStateTime());
288 hibActivity.setAcceptedTime(act.getAcceptedTime());
289 hibActivity.setActivatedTime(act.getActivatedTime());
290
291 ((SharkHibernateTransaction)ti).store(hibActivity);
292 } else {
293 hibActivity.setName(act.getName());
294 hibActivity.setDescription(act.getDescription());
295 hibActivity.setPriority(act.getPriority());
296 if (act.getResourceUsername() != null){
297 HibernateResource res = getPersistedResourceObject(act.getResourceUsername(), ti);
298 hibActivity.setResourceUsername(res.getUsername());
299 }
300 hibActivity.setState(act.getState());
301 Integer stateId = (Integer )_acStates.get(act.getState());
302 hibActivity.setStateId(stateId.intValue());
303
304 hibActivity.setLastStateTime(act.getLastStateTime());
305 hibActivity.setAcceptedTime(act.getAcceptedTime());
306 hibActivity.setActivatedTime(act.getActivatedTime());
307
308 ((SharkHibernateTransaction)ti).store(hibActivity);
309 }
310
311 cus.info(LOG_CHANNEL, "Activity[id=" + act.getId() + ",definitionId=" + act.getActivityDefinitionId() + "] persisted");
312 } catch (Throwable tr) {
313 tr.printStackTrace();
314 cus.error(LOG_CHANNEL, "Persisting of Activity " + act.getId() + " failed");
315 throw new PersistenceException("Persisting of Activity " + act.getId() + " failed", tr);
316 }
317 }
318
319 public void persist(ResourcePersistenceInterface res, SharkTransaction ti) throws PersistenceException {
320 try {
321 HibernateResource hibResource = getPersistedObject(res, ti);
322
323 if (hibResource == null) {
325 hibResource = (HibernateResource) createResource();
326 hibResource.setUsername(res.getUsername());
327 hibResource.setName(res.getName());
328 ((SharkHibernateTransaction)ti).store(hibResource);
329 } else {
330 hibResource.setName(res.getName());
331 ((SharkHibernateTransaction)ti).store(hibResource);
332 }
333 cus.info(LOG_CHANNEL, "Resource[username=" + res.getUsername() + "] persisted");
334 } catch (Throwable tr) {
335 cus.error(LOG_CHANNEL, "Persisting of Resource " + res.getUsername() + " failed");
336 throw new PersistenceException("Persisting of Resource " + res.getUsername() + " failed", tr);
337 }
338 }
339
340 public void persist(AssignmentPersistenceInterface ass, SharkTransaction ti) throws PersistenceException {
341 try {
342 HibernateAssignment hibAssign = getPersistedObject(ass, ti);
343
344 if (hibAssign == null) {
346 hibAssign = (HibernateAssignment) createAssignment();
347 hibAssign.setActivityId(getPersistedActivityObject(ass.getActivityId(), ti).getId());
348 hibAssign.setResourceUsername(getPersistedResourceObject(ass.getResourceUsername(), ti).getUsername());
349 hibAssign.setProcessId(ass.getProcessId());
351 ((SharkHibernateTransaction)ti).store(hibAssign);
352 } else {
353 hibAssign.setResourceUsername(getPersistedResourceObject(ass.getResourceUsername(), ti).getUsername());
354 ((SharkHibernateTransaction)ti).store(hibAssign);
355 }
356 cus.info(LOG_CHANNEL, "Assignment[activityId=" + ass.getActivityId() + ", username=" + ass.getResourceUsername() + "] persisted");
357 } catch (Throwable tr) {
358 cus.error(LOG_CHANNEL, "Persisting of Assignment failed");
359 throw new PersistenceException("Persisting of Assignment failed", tr);
360 }
361 }
362
363 public void persist(AssignmentPersistenceInterface ass, String oldResUname, SharkTransaction ti) throws PersistenceException {
364 try {
365 Session session = ((SharkHibernateTransaction) ti).getSession();
366 HibernateAssignment hibAssign = getPersistedAssignmentObject(ass.getActivityId(), oldResUname, ti);
367 if (hibAssign != null) {
368 hibAssign.setResourceUsername(getPersistedResourceObject(ass.getResourceUsername(), ti).getUsername());
369 ((SharkHibernateTransaction)ti).store(hibAssign);
370 } else {
371 cus.error(LOG_CHANNEL, "Assignment[activityId=" + ass.getActivityId() + ", with old resource name=" + oldResUname + "] cannot be updatet because it is not persisted");
372 }
373
374 cus.info(LOG_CHANNEL, "Assignment[activityId=" + ass.getActivityId() + ", username=" + ass.getResourceUsername() + "] persisted");
375 } catch (Throwable tr) {
376 cus.error(LOG_CHANNEL, "Persisting of Assignment failed");
377 throw new PersistenceException("Persisting of Assignment failed", tr);
378 }
379 }
380
381 public void persist(ProcessVariablePersistenceInterface var, SharkTransaction ti) throws PersistenceException {
382 try {
383 HibernateProcessVariable hibProcessVariable = getPersistedObject(var, ti);
384 if (hibProcessVariable == null) {
386 hibProcessVariable = (HibernateProcessVariable) createProcessVariable();
387 hibProcessVariable.setProcessId(getPersistedProcessObject(var.getProcessId(), ti).getId());
388 hibProcessVariable.setDefinitionId(var.getDefinitionId());
389 hibProcessVariable.setValue(MiscUtilities.serialize(var.getValue()));
390 ((SharkHibernateTransaction)ti).store(hibProcessVariable);
391 } else {
392 hibProcessVariable.setValue(MiscUtilities.serialize(var.getValue()));
393 ((SharkHibernateTransaction)ti).store(hibProcessVariable);
394 }
395 cus.info(LOG_CHANNEL, "ProcessVariable[processId=" + var.getProcessId() + ", definitionId=" + var.getDefinitionId() + "] persisted");
396 } catch (Throwable tr) {
397 cus.error(LOG_CHANNEL, "Persisting of ProcessVariable failed");
398 throw new PersistenceException("Persisting of ProcessVariable failed", tr);
399 }
400 }
401
402 public void persist(ActivityVariablePersistenceInterface var, SharkTransaction ti) throws PersistenceException {
403 try {
404 HibernateActivityVariable hibActivityVariable = getPersistedObject(var, ti);
405
406 if (hibActivityVariable == null) {
408 hibActivityVariable = (HibernateActivityVariable) createActivityVariable();
409 hibActivityVariable.setActivityId(getPersistedActivityObject(var.getActivityId(), ti).getId());
410 hibActivityVariable.setDefinitionId(var.getDefinitionId());
411 hibActivityVariable.setValue(MiscUtilities.serialize(var.getValue()));
412 hibActivityVariable.setResultVariable(var.isResultVariable());
413 ((SharkHibernateTransaction)ti).store(hibActivityVariable);
414 } else {
415 hibActivityVariable.setValue(MiscUtilities.serialize(var.getValue()));
416 hibActivityVariable.setResultVariable(var.isResultVariable());
417 ((SharkHibernateTransaction)ti).store(hibActivityVariable);
418 }
419
420 cus.info(LOG_CHANNEL, "ActivityVariable[activityId=" + var.getActivityId() + ", definitionId=" + var.getDefinitionId() + "] persisted");
421 } catch (Throwable tr) {
422 cus.error(LOG_CHANNEL, "Persisting of ActivityVariable failed");
423 throw new PersistenceException("Persisting of ActivityVariable failed", tr);
424 }
425 }
426
427 public void persist(AndJoinEntryInterface aje, SharkTransaction ti) throws PersistenceException {
428 try {
429 Session session = ((SharkHibernateTransaction) ti).getSession();
430 HibernateAndJoinEntry hibAJE = (HibernateAndJoinEntry) createAndJoinEntry();
431 hibAJE.setProcessId(getPersistedProcessObject(aje.getProcessId(), ti).getId());
432 hibAJE.setActivityDefinitionId(aje.getActivityDefinitionId());
433 hibAJE.setActivitySetDefinitionId(aje.getActivitySetDefinitionId());
434 hibAJE.setActivityId(getPersistedActivityObject(aje.getActivityId(), ti).getId());
435 ((SharkHibernateTransaction)ti).store(hibAJE);
436
437 cus.info(LOG_CHANNEL, "AndJoinEntry[id=" + aje.getProcessId() + ",aDefId=" + aje.getActivityDefinitionId() + ",actId=" + aje.getActivityId() + "] persisted");
438 } catch (Throwable tr) {
439 cus.error(LOG_CHANNEL, "Persisting of AndJoinEntry [id=" + aje.getProcessId() + ",aDefId=" + aje.getActivityDefinitionId() + ",actId=" + aje.getActivityId() + "] failed");
440 throw new PersistenceException("Persisting of AndJoinEntry [id=" + aje.getProcessId() + ",aDefId=" + aje.getActivityDefinitionId() + ",actId=" + aje.getActivityId() + "] failed", tr);
441 }
442 }
443
444 public void persist(DeadlinePersistenceInterface dpe, SharkTransaction ti) throws PersistenceException {
445 try {
446 System.out.println("PERSIST DEADLINE :" + dpe);
447 HibernateDeadline hibDeadline = (HibernateDeadline) createDeadline();
448 hibDeadline.setProcessId(getPersistedProcessObject(dpe.getProcessId(),ti).getId());
449 hibDeadline.setActivityId(getPersistedActivityObject(dpe.getActivityId(),ti).getId());
450 hibDeadline.setExceptionName(dpe.getExceptionName());
451 hibDeadline.setTimeLimit(dpe.getTimeLimit());
452 hibDeadline.setSynchronous(dpe.isSynchronous());
453 System.out.println("PERSIST DEADLINE 2:" + hibDeadline);
454 ((SharkHibernateTransaction)ti).store(hibDeadline);
455 cus.info(LOG_CHANNEL,"Deadline[actId="+dpe.getActivityId()+",ExcName="+dpe.getExceptionName()+"] persisted");
456 }
457 catch (Throwable tr) {
458 cus.error(LOG_CHANNEL,"Persisting of Deadline[actId="+dpe.getActivityId()+",ExcName="+dpe.getExceptionName()+"] failed");
459 throw new PersistenceException(
460 "Persisting of Deadline[actId="+dpe.getActivityId()+",ExcName="+dpe.getExceptionName()+"] failed",tr);
461 }
462 }
463
464
465
469 public ProcessMgrPersistenceInterface restoreProcessMgr(String mgrName, SharkTransaction ti) throws PersistenceException {
470 try {
471 Session session = ((SharkHibernateTransaction) ti).getSession();
472 return restore(getPersistedProcessMgrObject(mgrName, ti), session);
473
474 } catch (Throwable tr) {
475 cus.error(LOG_CHANNEL, "Restoring of ProcessDefinition name " + mgrName + " failed");
476 throw new PersistenceException("Restoring of ProcessDefinition " + mgrName + " failed", tr);
477 }
478 }
479
480 private ProcessMgrPersistenceInterface restore(HibernateProcessMgr hibProcessMgr, Session session) throws PersistenceException {
481 if (hibProcessMgr == null)
482 return null;
483 try {
484 cus.info(LOG_CHANNEL, "ProcessDefinition [name=" + hibProcessMgr.getName() + "] restored");
485 } catch (Throwable tr) {
486 cus.error(LOG_CHANNEL, "Restoring of Resource failed");
487 throw new PersistenceException("Restoring of Resource failed", tr);
488 }
489 return hibProcessMgr;
490 }
491
492 public ProcessPersistenceInterface restoreProcess(String procId, SharkTransaction ti) throws PersistenceException {
493 try {
494 Session session = ((SharkHibernateTransaction) ti).getSession();
495 return restore(getPersistedProcessObject(procId, ti), getProcessRequester(procId,ti),ti);
496 } catch (Throwable tr) {
497 tr.printStackTrace();
498 cus.error(LOG_CHANNEL, "Restoring of Process " + procId + " failed");
499 throw new PersistenceException("Restoring of Process " + procId + " failed", tr);
500 }
501 }
502
503 private ProcessPersistenceInterface restore(HibernateProcess hibProcess, HibernateProcessRequester processRequester, SharkTransaction ti) throws PersistenceException {
504 if (hibProcess == null)
505 return null;
506 try {
507 Session session = ((SharkHibernateTransaction) ti).getSession();
508 hibProcess.setState(getPersistedProcessStateObjectById(hibProcess.getStateId(), session).getName());
509
510 HibernateActivity hibActivity = null;
511 if (processRequester.getActRequester() != null)
512 hibActivity = getPersistedActivityObject(processRequester.getActRequester(), ti);
513 if (hibActivity != null) {
514 hibProcess.setActivityRequesterId(hibActivity.getId());
515 hibProcess.setActivityRequestersProcessId(hibActivity.getProcessId());
516 }
517 HibernateResource hibResource = null;
518 if (processRequester.getResRequester() != null)
519 hibResource = getPersistedResourceObject(processRequester.getResRequester(), ti);
520 if (hibResource != null){
521 hibProcess.setResourceRequesterId(hibResource.getUsername());
522 }
523 cus.info(LOG_CHANNEL, "Process[id=" + hibProcess.getId() + "] restored");
524 } catch (Throwable tr) {
525 cus.error(LOG_CHANNEL, "Restoring of Process failed");
526 throw new PersistenceException("Restoring of Process failed", tr);
527 }
528 return hibProcess;
529 }
530
531 public ActivityPersistenceInterface restoreActivity(String actId, SharkTransaction ti) throws PersistenceException {
532 try {
533 return restore(getPersistedActivityObject(actId, ti), ti);
534 } catch (Throwable tr) {
535 cus.error(LOG_CHANNEL, "Restoring of Activity " + actId + " failed");
536 throw new PersistenceException("Restoring of Activity " + actId + " failed", tr);
537 }
538 }
539
540 private ActivityPersistenceInterface restore(HibernateActivity hibActivity, SharkTransaction ti) throws PersistenceException {
541 if (hibActivity == null)
542 return null;
543
544 try {
545 Session session = ((SharkHibernateTransaction) ti).getSession();
546 HibernateProcessRequester processRequester = getProcessRequesterByActId(hibActivity.getId(),ti);
547 if (processRequester != null) {
548 hibActivity.setSubflowProcessId(processRequester.getId());
549 }
550 hibActivity.setState(getPersistedActivityStateObjectById(hibActivity.getStateId(), session).getName());
551 cus.info(LOG_CHANNEL, "Activity[id=" + hibActivity.getId() + ",definitionId=" + hibActivity.getActivityDefinitionId() + "] restored");
552 } catch (Throwable tr) {
553 cus.error(LOG_CHANNEL, "Restoring of Activity failed");
554 throw new PersistenceException("Restoring of Activity failed", tr);
555 }
556 return hibActivity;
557 }
558
559 public ResourcePersistenceInterface restoreResource(String resUsername, SharkTransaction ti) throws PersistenceException {
560 try {
561 Session session = ((SharkHibernateTransaction) ti).getSession();
562 return restore(getPersistedResourceObject(resUsername, ti), session);
563 } catch (Throwable tr) {
564 cus.error(LOG_CHANNEL, "Restoring of Resource " + resUsername + " failed");
565 throw new PersistenceException("Restoring of Resource " + resUsername + " failed", tr);
566 }
567 }
568
569 private ResourcePersistenceInterface restore(HibernateResource hibResource, Session session) throws PersistenceException {
570 if (hibResource == null)
571 return null;
572
573 try {
574 cus.info(LOG_CHANNEL, "Resource[username=" + hibResource.getUsername() + "] restored");
575 } catch (Throwable tr) {
576 cus.error(LOG_CHANNEL, "Restoring of Resource failed");
577 throw new PersistenceException("Restoring of Resource failed", tr);
578 }
579 return hibResource;
580 }
581
582 public AssignmentPersistenceInterface restoreAssignment(String actId, String resUsername, SharkTransaction ti) throws PersistenceException {
583 try {
584 return restore(getPersistedAssignmentObject(actId, resUsername, ti), ti);
585 } catch (Throwable tr) {
586 cus.error(LOG_CHANNEL, "Restoring of Assignment failed");
587 throw new PersistenceException("Restoring of Assignment failed", tr);
588 }
589 }
590
591 private AssignmentPersistenceInterface restore(HibernateAssignment hibAssign, SharkTransaction ti) throws PersistenceException {
592 if (hibAssign == null)
593 return null;
594 try {
595 hibAssign.setProcessId(getPersistedActivityObject(hibAssign.getActivityId(), ti).getProcessId());
596 cus.info(LOG_CHANNEL, "Assignment[activityId=" + hibAssign.getActivityId() + ", username=" + hibAssign.getResourceUsername() + "] restored");
597 } catch (Throwable tr) {
598 cus.error(LOG_CHANNEL, "Restoring of Assignment failed");
599 throw new PersistenceException("Restoring of Assignment failed", tr);
600 }
601 return hibAssign;
602 }
603
604 public boolean restore(ProcessVariablePersistenceInterface var, SharkTransaction ti) throws PersistenceException {
605 try {
606 Session session = ((SharkHibernateTransaction) ti).getSession();
607 return restore(var, getPersistedObject(var, ti), session);
608 } catch (Throwable tr) {
609 cus.error(LOG_CHANNEL, "Restoring of Assignment failed");
610 throw new PersistenceException("Restoring of Assignment failed", tr);
611 }
612 }
613
614 private boolean restore(ProcessVariablePersistenceInterface engineObj, HibernateProcessVariable hibProcessVariable, Session s) throws PersistenceException {
615 if (hibProcessVariable == null)
616 return false;
617 try {
618 engineObj.setProcessId(hibProcessVariable.getProcessId());
619 engineObj.setDefinitionId(hibProcessVariable.getDefinitionId());
620 engineObj.setValue(MiscUtilities.deserialize((byte[]) hibProcessVariable.getValue()));
621
622 cus.info(LOG_CHANNEL, "ProcessVariable[processId=" + engineObj.getProcessId() + ", definitionId=" + engineObj.getDefinitionId() + "] restored");
623 } catch (Throwable tr) {
624 cus.error(LOG_CHANNEL, "Restoring of ProcessVariable failed");
625 throw new PersistenceException("Restoring of ProcessVariable failed", tr);
626 }
627 return true;
628 }
629
630 public boolean restore(ActivityVariablePersistenceInterface var, SharkTransaction ti) throws PersistenceException {
631 try {
632 Session session = ((SharkHibernateTransaction) ti).getSession();
633 return restore(var, getPersistedObject(var, ti), session);
634 } catch (Throwable tr) {
635 cus.error(LOG_CHANNEL, "Restoring of Assignment failed");
636 throw new PersistenceException("Restoring of Assignment failed", tr);
637 }
638 }
639
640 private boolean restore(ActivityVariablePersistenceInterface engineObj, HibernateActivityVariable hibActivityVariable, Session s) throws PersistenceException {
641 if (hibActivityVariable == null)
642 return false;
643
644 try {
645 engineObj.setActivityId(hibActivityVariable.getActivityId());
646 engineObj.setDefinitionId(hibActivityVariable.getDefinitionId());
647 engineObj.setValue(MiscUtilities.deserialize((byte |
Java API By Example, From Geeks To Geeks.