001: package org.enhydra.shark.corba;
002:
003: import javax.transaction.UserTransaction;
004:
005: import org.enhydra.shark.api.client.wfmc.wapi.WMConnectInfo;
006: import org.enhydra.shark.api.client.wfservice.XPDLBrowser;
007: import org.enhydra.shark.api.common.SharkConstants;
008: import org.enhydra.shark.corba.WorkflowService.ConnectFailed;
009: import org.enhydra.shark.corba.WorkflowService.NotConnected;
010: import org.enhydra.shark.corba.WorkflowService.WfProcessMgrIterator;
011: import org.enhydra.shark.corba.WorkflowService.WfResourceIterator;
012: import org.enhydra.shark.corba.WorkflowService._SharkConnectionImplBase;
013: import org.omg.CORBA.ORB;
014: import org.omg.WfBase.BaseException;
015: import org.omg.WorkflowModel.InvalidRequester;
016: import org.omg.WorkflowModel.NotEnabled;
017: import org.omg.WorkflowModel.RequesterRequired;
018: import org.omg.WorkflowModel.WfActivity;
019: import org.omg.WorkflowModel.WfActivityIterator;
020: import org.omg.WorkflowModel.WfAssignment;
021: import org.omg.WorkflowModel.WfAssignmentEventAudit;
022: import org.omg.WorkflowModel.WfAssignmentIterator;
023: import org.omg.WorkflowModel.WfCreateProcessEventAudit;
024: import org.omg.WorkflowModel.WfDataEventAudit;
025: import org.omg.WorkflowModel.WfProcess;
026: import org.omg.WorkflowModel.WfProcessIterator;
027: import org.omg.WorkflowModel.WfProcessMgr;
028: import org.omg.WorkflowModel.WfRequester;
029: import org.omg.WorkflowModel.WfResource;
030: import org.omg.WorkflowModel.WfStateEventAudit;
031:
032: /**
033: * The client interface through which client accesses the engine objects, and performs the
034: * various actions on engine.
035: *
036: * @author Sasa Bojanic
037: * @version 0.2
038: */
039: public class SharkConnectionCORBA extends _SharkConnectionImplBase
040: implements Collective {
041:
042: org.enhydra.shark.api.client.wfservice.SharkConnection mySharkConn;
043:
044: private SharkCORBAServer myServer;
045:
046: SharkConnectionCORBA(SharkCORBAServer server,
047: org.enhydra.shark.api.client.wfservice.SharkConnection sc) {
048: this .myServer = server;
049: this .mySharkConn = sc;
050: if (myServer.trackObjects) {
051: __collective = new Collective.CollectiveCORBA();
052: }
053: }
054:
055: public void connect(String userId, String password,
056: String engineName, String scope) throws BaseException,
057: ConnectFailed {
058: UserTransaction ut = null;
059: boolean e = SharkCORBAServer.doesTransactionExist();
060: try {
061: ut = SharkCORBAUtilities.beginTransaction(e);
062: WMConnectInfo wmci = new WMConnectInfo(userId, password,
063: engineName, scope);
064: mySharkConn.connect(wmci);
065: SharkCORBAUtilities.commitTransaction(ut, e);
066: } catch (org.enhydra.shark.api.client.wfservice.ConnectFailed cf) {
067: SharkCORBAUtilities.rollbackTransaction(ut, e);
068: throw new ConnectFailed();
069: } catch (Exception ex) {
070: SharkCORBAUtilities.rollbackTransaction(ut, e);
071: throw new BaseException();
072: }
073: }
074:
075: public void disconnect() throws BaseException, NotConnected {
076: UserTransaction ut = null;
077: boolean e = SharkCORBAServer.doesTransactionExist();
078: try {
079: ut = SharkCORBAUtilities.beginTransaction(e);
080: mySharkConn.disconnect();
081: SharkCORBAUtilities.commitTransaction(ut, e);
082: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
083: SharkCORBAUtilities.rollbackTransaction(ut, e);
084: throw new NotConnected(nc.getMessage());
085: } catch (Exception ex) {
086: SharkCORBAUtilities.rollbackTransaction(ut, e);
087: throw new BaseException();
088: } finally {
089: this .__disband(this ._orb());
090: }
091: }
092:
093: public WfResource getResourceObject() throws BaseException,
094: NotConnected {
095: UserTransaction ut = null;
096: boolean e = SharkCORBAServer.doesTransactionExist();
097: try {
098: ut = SharkCORBAUtilities.beginTransaction(e);
099: WfResource ret = new WfResourceCORBA(this , mySharkConn
100: .getResourceObject());
101: SharkCORBAUtilities.commitTransaction(ut, e);
102: return ret;
103: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
104: SharkCORBAUtilities.rollbackTransaction(ut, e);
105: throw new NotConnected(nc.getMessage());
106: } catch (Exception ex) {
107: SharkCORBAUtilities.rollbackTransaction(ut, e);
108: throw new BaseException();
109: }
110: }
111:
112: public WfProcessMgrIterator get_iterator_processmgr()
113: throws BaseException, NotConnected {
114: UserTransaction ut = null;
115: boolean e = SharkCORBAServer.doesTransactionExist();
116: try {
117: ut = SharkCORBAUtilities.beginTransaction(e);
118: WfProcessMgrIterator ret = new WfProcessMgrIteratorCORBA(
119: this , mySharkConn.get_iterator_processmgr());
120: SharkCORBAUtilities.commitTransaction(ut, e);
121: return ret;
122: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
123: SharkCORBAUtilities.rollbackTransaction(ut, e);
124: throw new NotConnected(nc.getMessage());
125: } catch (Exception ex) {
126: SharkCORBAUtilities.rollbackTransaction(ut, e);
127: throw new BaseException();
128: }
129: }
130:
131: public WfProcessMgr[] get_sequence_processmgr(int max_number)
132: throws BaseException, NotConnected {
133: UserTransaction ut = null;
134: boolean e = SharkCORBAServer.doesTransactionExist();
135: try {
136: ut = SharkCORBAUtilities.beginTransaction(e);
137: WfProcessMgr[] ret = SharkCORBAUtilities
138: .makeCORBAProcessMgrs(this , mySharkConn
139: .get_sequence_processmgr(max_number));
140: SharkCORBAUtilities.commitTransaction(ut, e);
141: return ret;
142: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
143: SharkCORBAUtilities.rollbackTransaction(ut, e);
144: throw new NotConnected(nc.getMessage());
145: } catch (Exception ex) {
146: SharkCORBAUtilities.rollbackTransaction(ut, e);
147: throw new BaseException();
148: }
149: }
150:
151: public WfResourceIterator get_iterator_resource()
152: throws BaseException, NotConnected {
153: UserTransaction ut = null;
154: boolean e = SharkCORBAServer.doesTransactionExist();
155: try {
156: ut = SharkCORBAUtilities.beginTransaction(e);
157: WfResourceIterator ret = new WfResourceIteratorCORBA(this ,
158: mySharkConn.get_iterator_resource());
159: SharkCORBAUtilities.commitTransaction(ut, e);
160: return ret;
161: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
162: SharkCORBAUtilities.rollbackTransaction(ut, e);
163: throw new NotConnected(nc.getMessage());
164: } catch (Exception ex) {
165: SharkCORBAUtilities.rollbackTransaction(ut, e);
166: throw new BaseException();
167: }
168: }
169:
170: public WfResource[] get_sequence_resource(int max_number)
171: throws BaseException, NotConnected {
172: UserTransaction ut = null;
173: boolean e = SharkCORBAServer.doesTransactionExist();
174: try {
175: ut = SharkCORBAUtilities.beginTransaction(e);
176: WfResource[] ret = SharkCORBAUtilities
177: .makeCORBAResources(this , mySharkConn
178: .get_sequence_resource(max_number));
179: SharkCORBAUtilities.commitTransaction(ut, e);
180: return ret;
181: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
182: SharkCORBAUtilities.rollbackTransaction(ut, e);
183: throw new NotConnected(nc.getMessage());
184: } catch (Exception ex) {
185: SharkCORBAUtilities.rollbackTransaction(ut, e);
186: throw new BaseException();
187: }
188: }
189:
190: public WfProcessMgr getProcessMgr(String name)
191: throws BaseException, NotConnected {
192: UserTransaction ut = null;
193: boolean e = SharkCORBAServer.doesTransactionExist();
194: try {
195: ut = SharkCORBAUtilities.beginTransaction(e);
196: WfProcessMgr ret = new WfProcessMgrCORBA(this , mySharkConn
197: .getProcessMgr(name));
198: SharkCORBAUtilities.commitTransaction(ut, e);
199: return ret;
200: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
201: SharkCORBAUtilities.rollbackTransaction(ut, e);
202: throw new NotConnected(nc.getMessage());
203: } catch (Exception ex) {
204: SharkCORBAUtilities.rollbackTransaction(ut, e);
205: throw new BaseException();
206: }
207: }
208:
209: public WfProcessMgr getProcessMgrByXPDLDefinition(String pkgId,
210: String pDefId) throws BaseException, NotConnected {
211: UserTransaction ut = null;
212: boolean e = SharkCORBAServer.doesTransactionExist();
213: try {
214: ut = SharkCORBAUtilities.beginTransaction(e);
215: XPDLBrowser xpdlb = myServer.getShark().getXPDLBrowser();
216: String mgrName = xpdlb.getUniqueProcessDefinitionName(
217: mySharkConn.getSessionHandle(), pkgId, "", pDefId);
218:
219: WfProcessMgr ret = new WfProcessMgrCORBA(this , mySharkConn
220: .getProcessMgr(mgrName));
221: SharkCORBAUtilities.commitTransaction(ut, e);
222: return ret;
223: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
224: SharkCORBAUtilities.rollbackTransaction(ut, e);
225: throw new NotConnected(nc.getMessage());
226: } catch (Exception ex) {
227: SharkCORBAUtilities.rollbackTransaction(ut, e);
228: throw new BaseException();
229: }
230: }
231:
232: public WfProcess getProcess(String procId) throws BaseException,
233: NotConnected {
234: UserTransaction ut = null;
235: boolean e = SharkCORBAServer.doesTransactionExist();
236: try {
237: ut = SharkCORBAUtilities.beginTransaction(e);
238: WfProcess ret = new WfProcessCORBA(this , mySharkConn
239: .getProcess(procId));
240: SharkCORBAUtilities.commitTransaction(ut, e);
241: return ret;
242: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
243: SharkCORBAUtilities.rollbackTransaction(ut, e);
244: throw new NotConnected(nc.getMessage());
245: } catch (Exception ex) {
246: SharkCORBAUtilities.rollbackTransaction(ut, e);
247: throw new BaseException();
248: }
249: }
250:
251: public WfActivity getActivity(String procId, String actId)
252: throws BaseException, NotConnected {
253: UserTransaction ut = null;
254: boolean e = SharkCORBAServer.doesTransactionExist();
255: try {
256: ut = SharkCORBAUtilities.beginTransaction(e);
257: WfActivity ret = new WfActivityCORBA(this , mySharkConn
258: .getActivity(procId, actId));
259: SharkCORBAUtilities.commitTransaction(ut, e);
260: return ret;
261: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
262: SharkCORBAUtilities.rollbackTransaction(ut, e);
263: throw new NotConnected(nc.getMessage());
264: } catch (Exception ex) {
265: SharkCORBAUtilities.rollbackTransaction(ut, e);
266: throw new BaseException();
267: }
268: }
269:
270: public WfResource getResource(String username)
271: throws BaseException, NotConnected {
272: UserTransaction ut = null;
273: boolean e = SharkCORBAServer.doesTransactionExist();
274: try {
275: ut = SharkCORBAUtilities.beginTransaction(e);
276: WfResource ret = new WfResourceCORBA(this , mySharkConn
277: .getResource(username));
278: SharkCORBAUtilities.commitTransaction(ut, e);
279: return ret;
280: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
281: SharkCORBAUtilities.rollbackTransaction(ut, e);
282: throw new NotConnected(nc.getMessage());
283: } catch (Exception ex) {
284: SharkCORBAUtilities.rollbackTransaction(ut, e);
285: throw new BaseException();
286: }
287: }
288:
289: public WfAssignment getAssignment(String procId, String actId,
290: String username) throws BaseException, NotConnected {
291: UserTransaction ut = null;
292: boolean e = SharkCORBAServer.doesTransactionExist();
293: try {
294: ut = SharkCORBAUtilities.beginTransaction(e);
295: WfAssignment ret = new WfAssignmentCORBA(this , mySharkConn
296: .getAssignment(procId, actId, username));
297: SharkCORBAUtilities.commitTransaction(ut, e);
298: return ret;
299: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
300: SharkCORBAUtilities.rollbackTransaction(ut, e);
301: throw new NotConnected(nc.getMessage());
302: } catch (Exception ex) {
303: SharkCORBAUtilities.rollbackTransaction(ut, e);
304: throw new BaseException();
305: }
306: }
307:
308: public WfAssignment getAssignmentById(String procId, String assId)
309: throws BaseException, NotConnected {
310: UserTransaction ut = null;
311: boolean e = SharkCORBAServer.doesTransactionExist();
312: try {
313: ut = SharkCORBAUtilities.beginTransaction(e);
314: WfAssignment ret = new WfAssignmentCORBA(this , mySharkConn
315: .getAssignment(procId, assId));
316: SharkCORBAUtilities.commitTransaction(ut, e);
317: return ret;
318: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
319: SharkCORBAUtilities.rollbackTransaction(ut, e);
320: throw new NotConnected(nc.getMessage());
321: } catch (Exception ex) {
322: SharkCORBAUtilities.rollbackTransaction(ut, e);
323: throw new BaseException();
324: }
325: }
326:
327: public WfAssignmentIterator get_iterator_assignment()
328: throws BaseException, NotConnected {
329: UserTransaction ut = null;
330: boolean e = SharkCORBAServer.doesTransactionExist();
331: try {
332: ut = SharkCORBAUtilities.beginTransaction(e);
333: WfAssignmentIterator ret = new WfAssignmentIteratorCORBA(
334: this , mySharkConn.get_iterator_assignment());
335: SharkCORBAUtilities.commitTransaction(ut, e);
336: return ret;
337: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
338: SharkCORBAUtilities.rollbackTransaction(ut, e);
339: throw new NotConnected(nc.getMessage());
340: } catch (Exception ex) {
341: SharkCORBAUtilities.rollbackTransaction(ut, e);
342: throw new BaseException();
343: }
344: }
345:
346: public WfProcessIterator get_iterator_process()
347: throws BaseException, NotConnected {
348: UserTransaction ut = null;
349: boolean e = SharkCORBAServer.doesTransactionExist();
350: try {
351: ut = SharkCORBAUtilities.beginTransaction(e);
352: WfProcessIterator ret = new WfProcessIteratorCORBA(this ,
353: mySharkConn.get_iterator_process());
354: SharkCORBAUtilities.commitTransaction(ut, e);
355: return ret;
356: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
357: SharkCORBAUtilities.rollbackTransaction(ut, e);
358: throw new NotConnected(nc.getMessage());
359: } catch (Exception ex) {
360: SharkCORBAUtilities.rollbackTransaction(ut, e);
361: throw new BaseException();
362: }
363: }
364:
365: public WfActivityIterator get_iterator_activity()
366: throws BaseException, NotConnected {
367: UserTransaction ut = null;
368: boolean e = SharkCORBAServer.doesTransactionExist();
369: try {
370: ut = SharkCORBAUtilities.beginTransaction(e);
371: WfActivityIterator ret = new WfActivityIteratorCORBA(this ,
372: mySharkConn.get_iterator_activity());
373: SharkCORBAUtilities.commitTransaction(ut, e);
374: return ret;
375: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
376: SharkCORBAUtilities.rollbackTransaction(ut, e);
377: throw new NotConnected(nc.getMessage());
378: } catch (Exception ex) {
379: SharkCORBAUtilities.rollbackTransaction(ut, e);
380: throw new BaseException();
381: }
382: }
383:
384: public WfProcess createProcess(String pkgId, String pDefId)
385: throws BaseException, NotConnected, NotEnabled {
386: UserTransaction ut = null;
387: boolean e = SharkCORBAServer.doesTransactionExist();
388: try {
389: ut = SharkCORBAUtilities.beginTransaction(e);
390: XPDLBrowser xpdlb = myServer.getShark().getXPDLBrowser();
391: String mgrName = xpdlb.getUniqueProcessDefinitionName(
392: mySharkConn.getSessionHandle(), pkgId, "", pDefId);
393: org.enhydra.shark.api.client.wfmodel.WfProcess procInternal = mySharkConn
394: .getProcessMgr(mgrName).create_process(null);
395: WfProcessCORBA ret = new WfProcessCORBA(this , procInternal);
396: SharkCORBAUtilities.commitTransaction(ut, e);
397: return ret;
398: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
399: SharkCORBAUtilities.rollbackTransaction(ut, e);
400: throw new NotConnected(nc.getMessage());
401: } catch (org.enhydra.shark.api.client.wfmodel.NotEnabled ne) {
402: SharkCORBAUtilities.rollbackTransaction(ut, e);
403: throw new NotEnabled(ne.getMessage());
404: } catch (Exception ex) {
405: SharkCORBAUtilities.rollbackTransaction(ut, e);
406: throw new BaseException();
407: }
408:
409: }
410:
411: public WfProcess createProcessWithRequester(WfRequester requester,
412: String pkgId, String pDefId) throws BaseException,
413: NotConnected, NotEnabled, InvalidRequester,
414: RequesterRequired {
415: UserTransaction ut = null;
416: boolean e = SharkCORBAServer.doesTransactionExist();
417: try {
418: ut = SharkCORBAUtilities.beginTransaction(e);
419: WfLinkingRequesterForCORBA lr = new WfLinkingRequesterForCORBA();
420: XPDLBrowser xpdlb = myServer.getShark().getXPDLBrowser();
421: String mgrName = xpdlb.getUniqueProcessDefinitionName(
422: mySharkConn.getSessionHandle(), pkgId, "", pDefId);
423: org.enhydra.shark.api.client.wfmodel.WfProcess procInternal = mySharkConn
424: .getProcessMgr(mgrName).create_process(lr);
425: WfLinkingRequesterForCORBA.setCORBARequester(procInternal
426: .key(), requester);
427: WfProcessCORBA ret = new WfProcessCORBA(this , procInternal);
428: SharkCORBAUtilities.commitTransaction(ut, e);
429: return ret;
430: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
431: SharkCORBAUtilities.rollbackTransaction(ut, e);
432: throw new NotConnected(nc.getMessage());
433: } catch (org.enhydra.shark.api.client.wfmodel.NotEnabled ne) {
434: SharkCORBAUtilities.rollbackTransaction(ut, e);
435: throw new NotEnabled(ne.getMessage());
436: } catch (org.enhydra.shark.api.client.wfmodel.InvalidRequester ir) {
437: SharkCORBAUtilities.rollbackTransaction(ut, e);
438: throw new InvalidRequester(ir.getMessage());
439: } catch (org.enhydra.shark.api.client.wfmodel.RequesterRequired rr) {
440: SharkCORBAUtilities.rollbackTransaction(ut, e);
441: throw new RequesterRequired(rr.getMessage());
442: } catch (Exception ex) {
443: SharkCORBAUtilities.rollbackTransaction(ut, e);
444: throw new BaseException();
445: }
446:
447: }
448:
449: public void removeProcessRequester(String procId)
450: throws BaseException, NotConnected {
451: UserTransaction ut = null;
452: boolean e = SharkCORBAServer.doesTransactionExist();
453: try {
454: ut = SharkCORBAUtilities.beginTransaction(e);
455: mySharkConn.getProcess(procId).set_requester(null);
456: WfLinkingRequesterForCORBA.removeCORBARequester(procId);
457: SharkCORBAUtilities.commitTransaction(ut, e);
458: } catch (org.enhydra.shark.api.client.wfservice.NotConnected nc) {
459: SharkCORBAUtilities.rollbackTransaction(ut, e);
460: throw new NotConnected(nc.getMessage());
461: } catch (Exception ex) {
462: SharkCORBAUtilities.rollbackTransaction(ut, e);
463: throw new BaseException();
464: }
465: }
466:
467: public WfCreateProcessEventAudit getCreateProcessHistory(
468: String procId) throws BaseException, NotConnected {
469: UserTransaction ut = null;
470: boolean e = SharkCORBAServer.doesTransactionExist();
471: try {
472: ut = SharkCORBAUtilities.beginTransaction(e);
473: String query = "event_type.equals(\""
474: + SharkConstants.EVENT_PROCESS_CREATED + "\")";
475: WfCreateProcessEventAudit ret = new WfCreateProcessEventAuditCORBA(
476: this ,
477: (org.enhydra.shark.api.client.wfmodel.WfCreateProcessEventAudit) mySharkConn
478: .getProcess(procId).get_iterator_history(
479: query, null).get_next_object());
480: SharkCORBAUtilities.commitTransaction(ut, e);
481: return ret;
482: } catch (Exception ex) {
483: SharkCORBAUtilities.rollbackTransaction(ut, e);
484: throw new BaseException();
485: }
486: }
487:
488: public WfDataEventAudit[] getProcessSequenceDataHistory(
489: String procId, int max_number) throws BaseException,
490: NotConnected {
491: UserTransaction ut = null;
492: boolean e = SharkCORBAServer.doesTransactionExist();
493: try {
494: ut = SharkCORBAUtilities.beginTransaction(e);
495: String query = "event_type.equals(\""
496: + SharkConstants.EVENT_PROCESS_CONTEXT_CHANGED
497: + "\")";
498: WfDataEventAudit[] ret = SharkCORBAUtilities
499: .makeCORBADataEventAudits(this , mySharkConn
500: .getProcess(procId).get_iterator_history(
501: query, null).get_next_n_sequence(0));
502: SharkCORBAUtilities.commitTransaction(ut, e);
503: return ret;
504: } catch (Exception ex) {
505: SharkCORBAUtilities.rollbackTransaction(ut, e);
506: throw new BaseException();
507: }
508: }
509:
510: public WfStateEventAudit[] getProcessSequenceStateHistory(
511: String procId, int max_number) throws BaseException,
512: NotConnected {
513: UserTransaction ut = null;
514: boolean e = SharkCORBAServer.doesTransactionExist();
515: try {
516: ut = SharkCORBAUtilities.beginTransaction(e);
517: String query = "event_type.equals(\""
518: + SharkConstants.EVENT_PROCESS_STATE_CHANGED
519: + "\")";
520: WfStateEventAudit[] ret = SharkCORBAUtilities
521: .makeCORBAStateEventAudits(this , mySharkConn
522: .getProcess(procId).get_iterator_history(
523: query, null).get_next_n_sequence(0));
524: SharkCORBAUtilities.commitTransaction(ut, e);
525: return ret;
526: } catch (Exception ex) {
527: SharkCORBAUtilities.rollbackTransaction(ut, e);
528: throw new BaseException();
529: }
530: }
531:
532: public WfAssignmentEventAudit[] getSequenceAssignmentHistory(
533: String procId, String actId, int max_number)
534: throws BaseException, NotConnected {
535: UserTransaction ut = null;
536: boolean e = SharkCORBAServer.doesTransactionExist();
537: try {
538: ut = SharkCORBAUtilities.beginTransaction(e);
539: String query = "event_type.equals(\""
540: + SharkConstants.EVENT_ACTIVITY_ASSIGNMENT_CHANGED
541: + "\")";
542: WfAssignmentEventAudit[] ret = SharkCORBAUtilities
543: .makeCORBAAssignmentEventAudits(this , mySharkConn
544: .getActivity(procId, actId)
545: .get_iterator_history(query, null)
546: .get_next_n_sequence(0));
547: SharkCORBAUtilities.commitTransaction(ut, e);
548: return ret;
549: } catch (Exception ex) {
550: SharkCORBAUtilities.rollbackTransaction(ut, e);
551: throw new BaseException();
552: }
553: }
554:
555: public WfDataEventAudit[] getActivitySequenceDataHistory(
556: String procId, String actId, int max_number)
557: throws BaseException, NotConnected {
558: UserTransaction ut = null;
559: boolean e = SharkCORBAServer.doesTransactionExist();
560: try {
561: ut = SharkCORBAUtilities.beginTransaction(e);
562: String query = "event_type.equals(\""
563: + SharkConstants.EVENT_ACTIVITY_CONTEXT_CHANGED
564: + "\") || " + "event_type.equals(\""
565: + SharkConstants.EVENT_ACTIVITY_RESULT_CHANGED
566: + "\")";
567: WfDataEventAudit[] ret = SharkCORBAUtilities
568: .makeCORBADataEventAudits(this , mySharkConn
569: .getActivity(procId, actId)
570: .get_iterator_history(query, null)
571: .get_next_n_sequence(0));
572: SharkCORBAUtilities.commitTransaction(ut, e);
573: return ret;
574: } catch (Exception ex) {
575: SharkCORBAUtilities.rollbackTransaction(ut, e);
576: throw new BaseException();
577: }
578: }
579:
580: public WfStateEventAudit[] getActivitySequenceStateHistory(
581: String procId, String actId, int max_number)
582: throws BaseException, NotConnected {
583: UserTransaction ut = null;
584: boolean e = SharkCORBAServer.doesTransactionExist();
585: try {
586: ut = SharkCORBAUtilities.beginTransaction(e);
587: String query = "event_type.equals(\""
588: + SharkConstants.EVENT_ACTIVITY_STATE_CHANGED
589: + "\")";
590: WfStateEventAudit[] ret = SharkCORBAUtilities
591: .makeCORBAStateEventAudits(this , mySharkConn
592: .getActivity(procId, actId)
593: .get_iterator_history(query, null)
594: .get_next_n_sequence(0));
595: SharkCORBAUtilities.commitTransaction(ut, e);
596: return ret;
597: } catch (Exception ex) {
598: SharkCORBAUtilities.rollbackTransaction(ut, e);
599: throw new BaseException();
600: }
601: }
602:
603: public void shutdown() throws BaseException, NotConnected {
604: myServer.shutdown();
605: }
606:
607: Collective __collective;
608:
609: public void __recruit(org.omg.CORBA.Object obj) {
610: if (myServer.trackObjects)
611: __collective.__recruit(obj);
612: }
613:
614: public void __leave(org.omg.CORBA.Object obj) {
615: if (myServer.trackObjects)
616: __collective.__leave(obj);
617: }
618:
619: public void __disband(ORB _orb) {
620: if (myServer.trackObjects) {
621: __collective.__disband(_orb);
622: }
623: this ._orb().disconnect(this );
624: }
625:
626: public void doneWith(org.omg.CORBA.Object toDisconnect) {
627: myServer.doneWith(toDisconnect);
628: __leave(toDisconnect);
629: }
630: }
|