0001: /* WAPIEJBBean.java */
0002: package org.enhydra.shark.ws;
0003:
0004: import javax.naming.InitialContext;
0005: import javax.transaction.Status;
0006: import javax.transaction.UserTransaction;
0007:
0008: import org.enhydra.shark.Shark;
0009: import org.enhydra.shark.api.client.wfmc.wapi.WAPI;
0010: import org.enhydra.shark.api.client.wfmc.wapi.WMActivityInstance;
0011: import org.enhydra.shark.api.client.wfmc.wapi.WMActivityInstanceIterator;
0012: import org.enhydra.shark.api.client.wfmc.wapi.WMActivityInstanceState;
0013: import org.enhydra.shark.api.client.wfmc.wapi.WMActivityInstanceStateIterator;
0014: import org.enhydra.shark.api.client.wfmc.wapi.WMAttribute;
0015: import org.enhydra.shark.api.client.wfmc.wapi.WMAttributeIterator;
0016: import org.enhydra.shark.api.client.wfmc.wapi.WMConnectInfo;
0017: import org.enhydra.shark.api.client.wfmc.wapi.WMFilter;
0018: import org.enhydra.shark.api.client.wfmc.wapi.WMProcessDefinition;
0019: import org.enhydra.shark.api.client.wfmc.wapi.WMProcessDefinitionIterator;
0020: import org.enhydra.shark.api.client.wfmc.wapi.WMProcessDefinitionState;
0021: import org.enhydra.shark.api.client.wfmc.wapi.WMProcessDefinitionStateIterator;
0022: import org.enhydra.shark.api.client.wfmc.wapi.WMProcessInstance;
0023: import org.enhydra.shark.api.client.wfmc.wapi.WMProcessInstanceIterator;
0024: import org.enhydra.shark.api.client.wfmc.wapi.WMProcessInstanceState;
0025: import org.enhydra.shark.api.client.wfmc.wapi.WMProcessInstanceStateIterator;
0026: import org.enhydra.shark.api.client.wfmc.wapi.WMSessionHandle;
0027: import org.enhydra.shark.api.client.wfmc.wapi.WMWorkItem;
0028: import org.enhydra.shark.api.client.wfmc.wapi.WMWorkItemIterator;
0029: import org.enhydra.shark.api.client.wfmc.wapi.WMWorkItemState;
0030: import org.enhydra.shark.api.client.wfmc.wapi.WMWorkItemStateIterator;
0031: import org.enhydra.shark.ejb.SharkEJBUtilities;
0032:
0033: /**
0034: * @author V.Puskas
0035: * @version 0.1
0036: */
0037: public class WAPIWrapper implements WAPI {
0038:
0039: /**
0040: * @ejb:interface-method view-type="all"
0041: */
0042: public WMSessionHandle connect(WMConnectInfo connectInfo)
0043: throws Exception {
0044:
0045: if (SharkEJBUtilities.getEnvType() == 1) {
0046: UserTransaction t = null;
0047: WMSessionHandle retVal = null;
0048: try {
0049: t = (UserTransaction) new InitialContext()
0050: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0051: t.begin();
0052: retVal = getSharkObject().connect(connectInfo);
0053: t.commit();
0054:
0055: } catch (Exception ex) {
0056: try {
0057: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0058: t.rollback();
0059: } catch (Exception ex1) {
0060: ex1.printStackTrace();
0061: }
0062: throw ex;
0063: }
0064:
0065: return retVal;
0066: } else {
0067: return getSharkObject().connect(connectInfo);
0068: }
0069:
0070: }
0071:
0072: /**
0073: * @ejb:interface-method view-type="all"
0074: */
0075: public void disconnect(WMSessionHandle shandle) throws Exception {
0076:
0077: if (SharkEJBUtilities.getEnvType() == 1) {
0078: UserTransaction t = null;
0079: try {
0080: t = (UserTransaction) new InitialContext()
0081: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0082: t.begin();
0083: getSharkObject().disconnect(shandle);
0084: t.commit();
0085:
0086: } catch (Exception ex) {
0087: try {
0088: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0089: t.rollback();
0090: } catch (Exception ex1) {
0091: ex1.printStackTrace();
0092: }
0093: throw ex;
0094: }
0095:
0096: } else {
0097: getSharkObject().disconnect(shandle);
0098: }
0099: }
0100:
0101: /**
0102: * @ejb:interface-method view-type="all"
0103: */
0104: public WMProcessDefinitionIterator listProcessDefinitions(
0105: WMSessionHandle shandle, WMFilter filter, boolean countFlag)
0106: throws Exception {
0107:
0108: if (SharkEJBUtilities.getEnvType() == 1) {
0109: UserTransaction t = null;
0110: WMProcessDefinitionIterator retVal = null;
0111: try {
0112: t = (UserTransaction) new InitialContext()
0113: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0114: t.begin();
0115: retVal = getSharkObject().listProcessDefinitions(
0116: shandle, filter, countFlag);
0117: t.commit();
0118:
0119: } catch (Exception ex) {
0120: try {
0121: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0122: t.rollback();
0123: } catch (Exception ex1) {
0124: ex1.printStackTrace();
0125: }
0126: throw ex;
0127: }
0128:
0129: return retVal;
0130: } else {
0131: return getSharkObject().listProcessDefinitions(shandle,
0132: filter, countFlag);
0133: }
0134:
0135: }
0136:
0137: /**
0138: * @ejb:interface-method view-type="all"
0139: */
0140: public WMProcessDefinitionStateIterator listProcessDefinitionStates(
0141: WMSessionHandle shandle, String procDefId, WMFilter filter,
0142: boolean countFlag) throws Exception {
0143:
0144: if (SharkEJBUtilities.getEnvType() == 1) {
0145: UserTransaction t = null;
0146: WMProcessDefinitionStateIterator retVal = null;
0147: try {
0148: t = (UserTransaction) new InitialContext()
0149: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0150: t.begin();
0151: retVal = getSharkObject().listProcessDefinitionStates(
0152: shandle, procDefId, filter, countFlag);
0153: t.commit();
0154:
0155: } catch (Exception ex) {
0156: try {
0157: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0158: t.rollback();
0159: } catch (Exception ex1) {
0160: ex1.printStackTrace();
0161: }
0162: throw ex;
0163: }
0164:
0165: return retVal;
0166: } else {
0167: return getSharkObject().listProcessDefinitionStates(
0168: shandle, procDefId, filter, countFlag);
0169: }
0170:
0171: }
0172:
0173: /**
0174: * @ejb:interface-method view-type="all"
0175: */
0176: public void changeProcessDefinitionState(WMSessionHandle shandle,
0177: String procDefId, WMProcessDefinitionState newState)
0178: throws Exception {
0179:
0180: if (SharkEJBUtilities.getEnvType() == 1) {
0181: UserTransaction t = null;
0182: try {
0183: t = (UserTransaction) new InitialContext()
0184: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0185: t.begin();
0186: getSharkObject().changeProcessDefinitionState(shandle,
0187: procDefId, newState);
0188: t.commit();
0189:
0190: } catch (Exception ex) {
0191: try {
0192: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0193: t.rollback();
0194: } catch (Exception ex1) {
0195: ex1.printStackTrace();
0196: }
0197: throw ex;
0198: }
0199:
0200: } else {
0201: getSharkObject().changeProcessDefinitionState(shandle,
0202: procDefId, newState);
0203: }
0204:
0205: }
0206:
0207: /**
0208: * @ejb:interface-method view-type="all"
0209: */
0210: public String createProcessInstance(WMSessionHandle shandle,
0211: String procDefId, String procInstName) throws Exception {
0212:
0213: if (SharkEJBUtilities.getEnvType() == 1) {
0214: UserTransaction t = null;
0215: String retVal = null;
0216: try {
0217: t = (UserTransaction) new InitialContext()
0218: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0219: t.begin();
0220: retVal = getSharkObject().createProcessInstance(
0221: shandle, procDefId, procInstName);
0222: t.commit();
0223:
0224: } catch (Exception ex) {
0225: try {
0226: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0227: t.rollback();
0228: } catch (Exception ex1) {
0229: ex1.printStackTrace();
0230: }
0231: throw ex;
0232: }
0233:
0234: return retVal;
0235: } else {
0236: return getSharkObject().createProcessInstance(shandle,
0237: procDefId, procInstName);
0238: }
0239:
0240: }
0241:
0242: /**
0243: * @ejb:interface-method view-type="all"
0244: */
0245: public String startProcess(WMSessionHandle shandle,
0246: String procInstId) throws Exception {
0247:
0248: if (SharkEJBUtilities.getEnvType() == 1) {
0249: UserTransaction t = null;
0250: String retVal = null;
0251: try {
0252: t = (UserTransaction) new InitialContext()
0253: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0254: t.begin();
0255: retVal = getSharkObject().startProcess(shandle,
0256: procInstId);
0257: t.commit();
0258:
0259: } catch (Exception ex) {
0260: try {
0261: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0262: t.rollback();
0263: } catch (Exception ex1) {
0264: ex1.printStackTrace();
0265: }
0266: throw ex;
0267: }
0268:
0269: return retVal;
0270: } else {
0271: return getSharkObject().startProcess(shandle, procInstId);
0272: }
0273:
0274: }
0275:
0276: /**
0277: * @ejb:interface-method view-type="all"
0278: */
0279: public void terminateProcessInstance(WMSessionHandle shandle,
0280: String procInstId) throws Exception {
0281:
0282: if (SharkEJBUtilities.getEnvType() == 1) {
0283:
0284: UserTransaction t = null;
0285: try {
0286: t = (UserTransaction) new InitialContext()
0287: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0288: t.begin();
0289: getSharkObject().terminateProcessInstance(shandle,
0290: procInstId);
0291: t.commit();
0292:
0293: } catch (Exception ex) {
0294: try {
0295: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0296: t.rollback();
0297: } catch (Exception ex1) {
0298: ex1.printStackTrace();
0299: }
0300: throw ex;
0301: }
0302:
0303: } else {
0304: getSharkObject().terminateProcessInstance(shandle,
0305: procInstId);
0306: }
0307:
0308: }
0309:
0310: /**
0311: * @ejb:interface-method view-type="all"
0312: */
0313: public WMProcessInstanceStateIterator listProcessInstanceStates(
0314: WMSessionHandle shandle, String procInstId,
0315: WMFilter filter, boolean countFlag) throws Exception {
0316:
0317: if (SharkEJBUtilities.getEnvType() == 1) {
0318: UserTransaction t = null;
0319: WMProcessInstanceStateIterator retVal = null;
0320: try {
0321: t = (UserTransaction) new InitialContext()
0322: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0323: t.begin();
0324: retVal = getSharkObject().listProcessInstanceStates(
0325: shandle, procInstId, filter, countFlag);
0326: t.commit();
0327:
0328: } catch (Exception ex) {
0329: try {
0330: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0331: t.rollback();
0332: } catch (Exception ex1) {
0333: ex1.printStackTrace();
0334: }
0335: throw ex;
0336: }
0337:
0338: return retVal;
0339: } else {
0340: return getSharkObject().listProcessInstanceStates(shandle,
0341: procInstId, filter, countFlag);
0342: }
0343:
0344: }
0345:
0346: /**
0347: * @ejb:interface-method view-type="all"
0348: */
0349: public void changeProcessInstanceState(WMSessionHandle shandle,
0350: String procInstId, WMProcessInstanceState newState)
0351: throws Exception {
0352:
0353: if (SharkEJBUtilities.getEnvType() == 1) {
0354: UserTransaction t = null;
0355: try {
0356: t = (UserTransaction) new InitialContext()
0357: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0358: t.begin();
0359: getSharkObject().changeProcessInstanceState(shandle,
0360: procInstId, newState);
0361: t.commit();
0362:
0363: } catch (Exception ex) {
0364: try {
0365: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0366: t.rollback();
0367: } catch (Exception ex1) {
0368: ex1.printStackTrace();
0369: }
0370: throw ex;
0371: }
0372: } else {
0373: getSharkObject().changeProcessInstanceState(shandle,
0374: procInstId, newState);
0375: }
0376:
0377: }
0378:
0379: /**
0380: * @ejb:interface-method view-type="all"
0381: */
0382: public WMAttributeIterator listProcessInstanceAttributes(
0383: WMSessionHandle shandle, String procInstId,
0384: WMFilter filter, boolean countFlag) throws Exception {
0385:
0386: if (SharkEJBUtilities.getEnvType() == 1) {
0387: UserTransaction t = null;
0388: WMAttributeIterator retVal = null;
0389: try {
0390: t = (UserTransaction) new InitialContext()
0391: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0392: t.begin();
0393: retVal = getSharkObject()
0394: .listProcessInstanceAttributes(shandle,
0395: procInstId, filter, countFlag);
0396: t.commit();
0397:
0398: } catch (Exception ex) {
0399: try {
0400: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0401: t.rollback();
0402: } catch (Exception ex1) {
0403: ex1.printStackTrace();
0404: }
0405: throw ex;
0406: }
0407:
0408: return retVal;
0409: } else {
0410: return getSharkObject().listProcessInstanceAttributes(
0411: shandle, procInstId, filter, countFlag);
0412: }
0413: }
0414:
0415: /**
0416: * @ejb:interface-method view-type="all"
0417: */
0418: public WMAttribute getProcessInstanceAttributeValue(
0419: WMSessionHandle shandle, String procInstId, String attrName)
0420: throws Exception {
0421:
0422: if (SharkEJBUtilities.getEnvType() == 1) {
0423: UserTransaction t = null;
0424: WMAttribute retVal = null;
0425: try {
0426: t = (UserTransaction) new InitialContext()
0427: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0428: t.begin();
0429: retVal = getSharkObject()
0430: .getProcessInstanceAttributeValue(shandle,
0431: procInstId, attrName);
0432: t.commit();
0433:
0434: } catch (Exception ex) {
0435: try {
0436: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0437: t.rollback();
0438: } catch (Exception ex1) {
0439: ex1.printStackTrace();
0440: }
0441: throw ex;
0442: }
0443:
0444: return retVal;
0445: } else {
0446: return getSharkObject().getProcessInstanceAttributeValue(
0447: shandle, procInstId, attrName);
0448: }
0449:
0450: }
0451:
0452: /**
0453: * @ejb:interface-method view-type="all"
0454: */
0455: public void assignProcessInstanceAttribute(WMSessionHandle shandle,
0456: String procInstId, String attrName, Object attrValue)
0457: throws Exception {
0458:
0459: if (SharkEJBUtilities.getEnvType() == 1) {
0460: UserTransaction t = null;
0461: try {
0462: t = (UserTransaction) new InitialContext()
0463: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0464: t.begin();
0465: getSharkObject().assignProcessInstanceAttribute(
0466: shandle, procInstId, attrName, attrValue);
0467: t.commit();
0468:
0469: } catch (Exception ex) {
0470: try {
0471: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0472: t.rollback();
0473: } catch (Exception ex1) {
0474: ex1.printStackTrace();
0475: }
0476: throw ex;
0477: }
0478:
0479: } else {
0480: getSharkObject().assignProcessInstanceAttribute(shandle,
0481: procInstId, attrName, attrValue);
0482: }
0483:
0484: }
0485:
0486: /**
0487: * @ejb:interface-method view-type="all"
0488: */
0489: public WMActivityInstanceStateIterator listActivityInstanceStates(
0490: WMSessionHandle shandle, String procInstId,
0491: String actInstId, WMFilter filter, boolean countFlag)
0492: throws Exception {
0493:
0494: if (SharkEJBUtilities.getEnvType() == 1) {
0495: UserTransaction t = null;
0496: WMActivityInstanceStateIterator retVal = null;
0497: try {
0498: t = (UserTransaction) new InitialContext()
0499: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0500: t.begin();
0501: retVal = getSharkObject().listActivityInstanceStates(
0502: shandle, procInstId, actInstId, filter,
0503: countFlag);
0504: t.commit();
0505:
0506: } catch (Exception ex) {
0507: try {
0508: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0509: t.rollback();
0510: } catch (Exception ex1) {
0511: ex1.printStackTrace();
0512: }
0513: throw ex;
0514: }
0515:
0516: return retVal;
0517: } else {
0518: return getSharkObject().listActivityInstanceStates(shandle,
0519: procInstId, actInstId, filter, countFlag);
0520: }
0521:
0522: }
0523:
0524: /**
0525: * @ejb:interface-method view-type="all"
0526: */
0527: public void changeActivityInstanceState(WMSessionHandle shandle,
0528: String procInstId, String actInstId,
0529: WMActivityInstanceState newState) throws Exception {
0530:
0531: if (SharkEJBUtilities.getEnvType() == 1) {
0532: UserTransaction t = null;
0533: try {
0534: t = (UserTransaction) new InitialContext()
0535: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0536: t.begin();
0537: getSharkObject().changeActivityInstanceState(shandle,
0538: procInstId, actInstId, newState);
0539: t.commit();
0540:
0541: } catch (Exception ex) {
0542: try {
0543: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0544: t.rollback();
0545: } catch (Exception ex1) {
0546: ex1.printStackTrace();
0547: }
0548: throw ex;
0549: }
0550:
0551: } else {
0552: getSharkObject().changeActivityInstanceState(shandle,
0553: procInstId, actInstId, newState);
0554: }
0555:
0556: }
0557:
0558: /**
0559: * @ejb:interface-method view-type="all"
0560: */
0561: public WMAttributeIterator listActivityInstanceAttributes(
0562: WMSessionHandle shandle, String procInstId,
0563: String actInstId, WMFilter filter, boolean countFlag)
0564: throws Exception {
0565:
0566: if (SharkEJBUtilities.getEnvType() == 1) {
0567: UserTransaction t = null;
0568: WMAttributeIterator retVal = null;
0569: try {
0570: t = (UserTransaction) new InitialContext()
0571: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0572: t.begin();
0573: retVal = getSharkObject()
0574: .listActivityInstanceAttributes(shandle,
0575: procInstId, actInstId, filter,
0576: countFlag);
0577: t.commit();
0578:
0579: } catch (Exception ex) {
0580: try {
0581: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0582: t.rollback();
0583: } catch (Exception ex1) {
0584: ex1.printStackTrace();
0585: }
0586: throw ex;
0587: }
0588:
0589: return retVal;
0590: } else {
0591: return getSharkObject().listActivityInstanceAttributes(
0592: shandle, procInstId, actInstId, filter, countFlag);
0593: }
0594:
0595: }
0596:
0597: /**
0598: * @ejb:interface-method view-type="all"
0599: */
0600: public WMAttribute getActivityInstanceAttributeValue(
0601: WMSessionHandle shandle, String procInstId,
0602: String actInstId, String attrName) throws Exception {
0603:
0604: if (SharkEJBUtilities.getEnvType() == 1) {
0605: UserTransaction t = null;
0606: WMAttribute retVal = null;
0607: try {
0608: t = (UserTransaction) new InitialContext()
0609: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0610: t.begin();
0611: retVal = getSharkObject()
0612: .getActivityInstanceAttributeValue(shandle,
0613: procInstId, actInstId, attrName);
0614: t.commit();
0615:
0616: } catch (Exception ex) {
0617: try {
0618: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0619: t.rollback();
0620: } catch (Exception ex1) {
0621: ex1.printStackTrace();
0622: }
0623: throw ex;
0624: }
0625:
0626: return retVal;
0627: } else {
0628: return getSharkObject().getActivityInstanceAttributeValue(
0629: shandle, procInstId, actInstId, attrName);
0630: }
0631:
0632: }
0633:
0634: /**
0635: * @ejb:interface-method view-type="all"
0636: */
0637: public void assignActivityInstanceAttribute(
0638: WMSessionHandle shandle, String procInstId,
0639: String actInstId, String attrName, Object attrValue)
0640: throws Exception {
0641:
0642: if (SharkEJBUtilities.getEnvType() == 1) {
0643: UserTransaction t = null;
0644: try {
0645: t = (UserTransaction) new InitialContext()
0646: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0647: t.begin();
0648: getSharkObject().assignActivityInstanceAttribute(
0649: shandle, procInstId, actInstId, attrName,
0650: attrValue);
0651: t.commit();
0652:
0653: } catch (Exception ex) {
0654: try {
0655: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0656: t.rollback();
0657: } catch (Exception ex1) {
0658: ex1.printStackTrace();
0659: }
0660: throw ex;
0661: }
0662:
0663: } else {
0664: getSharkObject().assignActivityInstanceAttribute(shandle,
0665: procInstId, actInstId, attrName, attrValue);
0666: }
0667:
0668: }
0669:
0670: /**
0671: * @ejb:interface-method view-type="all"
0672: */
0673: public WMProcessInstanceIterator listProcessInstances(
0674: WMSessionHandle shandle, WMFilter filter, boolean countFlag)
0675: throws Exception {
0676:
0677: if (SharkEJBUtilities.getEnvType() == 1) {
0678: UserTransaction t = null;
0679: WMProcessInstanceIterator retVal = null;
0680: try {
0681: t = (UserTransaction) new InitialContext()
0682: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0683: t.begin();
0684: retVal = getSharkObject().listProcessInstances(shandle,
0685: filter, countFlag);
0686: t.commit();
0687:
0688: } catch (Exception ex) {
0689: try {
0690: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0691: t.rollback();
0692: } catch (Exception ex1) {
0693: ex1.printStackTrace();
0694: }
0695: throw ex;
0696: }
0697:
0698: return retVal;
0699: } else {
0700: return getSharkObject().listProcessInstances(shandle,
0701: filter, countFlag);
0702: }
0703:
0704: }
0705:
0706: /**
0707: * @ejb:interface-method view-type="all"
0708: */
0709: public WMProcessInstance getProcessInstance(
0710: WMSessionHandle shandle, String procInstId)
0711: throws Exception {
0712:
0713: if (SharkEJBUtilities.getEnvType() == 1) {
0714: UserTransaction t = null;
0715: WMProcessInstance retVal = null;
0716: try {
0717: t = (UserTransaction) new InitialContext()
0718: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0719: t.begin();
0720: retVal = getSharkObject().getProcessInstance(shandle,
0721: procInstId);
0722: t.commit();
0723:
0724: } catch (Exception ex) {
0725: try {
0726: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0727: t.rollback();
0728: } catch (Exception ex1) {
0729: ex1.printStackTrace();
0730: }
0731: throw ex;
0732: }
0733:
0734: return retVal;
0735: } else {
0736: return getSharkObject().getProcessInstance(shandle,
0737: procInstId);
0738: }
0739:
0740: }
0741:
0742: /**
0743: * @ejb:interface-method view-type="all"
0744: */
0745: public WMActivityInstanceIterator listActivityInstances(
0746: WMSessionHandle shandle, WMFilter filter, boolean countFlag)
0747: throws Exception {
0748:
0749: if (SharkEJBUtilities.getEnvType() == 1) {
0750: UserTransaction t = null;
0751: WMActivityInstanceIterator retVal = null;
0752: try {
0753: t = (UserTransaction) new InitialContext()
0754: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0755: t.begin();
0756: retVal = getSharkObject().listActivityInstances(
0757: shandle, filter, countFlag);
0758: t.commit();
0759:
0760: } catch (Exception ex) {
0761: try {
0762: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0763: t.rollback();
0764: } catch (Exception ex1) {
0765: ex1.printStackTrace();
0766: }
0767: throw ex;
0768: }
0769:
0770: return retVal;
0771: } else {
0772: return getSharkObject().listActivityInstances(shandle,
0773: filter, countFlag);
0774: }
0775:
0776: }
0777:
0778: /**
0779: * @ejb:interface-method view-type="all"
0780: */
0781: public WMActivityInstance getActivityInstance(
0782: WMSessionHandle shandle, String procInstId, String actInstId)
0783: throws Exception {
0784:
0785: if (SharkEJBUtilities.getEnvType() == 1) {
0786: UserTransaction t = null;
0787: WMActivityInstance retVal = null;
0788: try {
0789: t = (UserTransaction) new InitialContext()
0790: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0791: t.begin();
0792: retVal = getSharkObject().getActivityInstance(shandle,
0793: procInstId, actInstId);
0794: t.commit();
0795:
0796: } catch (Exception ex) {
0797: try {
0798: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0799: t.rollback();
0800: } catch (Exception ex1) {
0801: ex1.printStackTrace();
0802: }
0803: throw ex;
0804: }
0805:
0806: return retVal;
0807: } else {
0808: return getSharkObject().getActivityInstance(shandle,
0809: procInstId, actInstId);
0810: }
0811:
0812: }
0813:
0814: /**
0815: * @ejb:interface-method view-type="all"
0816: */
0817: public WMWorkItemIterator listWorkItems(WMSessionHandle shandle,
0818: WMFilter filter, boolean countFlag) throws Exception {
0819:
0820: if (SharkEJBUtilities.getEnvType() == 1) {
0821: UserTransaction t = null;
0822: WMWorkItemIterator retVal = null;
0823: try {
0824: t = (UserTransaction) new InitialContext()
0825: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0826: t.begin();
0827: retVal = getSharkObject().listWorkItems(shandle,
0828: filter, countFlag);
0829: t.commit();
0830:
0831: } catch (Exception ex) {
0832: try {
0833: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0834: t.rollback();
0835: } catch (Exception ex1) {
0836: ex1.printStackTrace();
0837: }
0838: throw ex;
0839: }
0840:
0841: return retVal;
0842: } else {
0843: return getSharkObject().listWorkItems(shandle, filter,
0844: countFlag);
0845: }
0846:
0847: }
0848:
0849: /**
0850: * @ejb:interface-method view-type="all"
0851: */
0852: public WMWorkItem getWorkItem(WMSessionHandle shandle,
0853: String procInstId, String workItemId) throws Exception {
0854:
0855: if (SharkEJBUtilities.getEnvType() == 1) {
0856: UserTransaction t = null;
0857: WMWorkItem retVal = null;
0858: try {
0859: t = (UserTransaction) new InitialContext()
0860: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0861: t.begin();
0862: retVal = getSharkObject().getWorkItem(shandle,
0863: procInstId, workItemId);
0864: t.commit();
0865:
0866: } catch (Exception ex) {
0867: try {
0868: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0869: t.rollback();
0870: } catch (Exception ex1) {
0871: ex1.printStackTrace();
0872: }
0873: throw ex;
0874: }
0875:
0876: return retVal;
0877: } else {
0878: return getSharkObject().getWorkItem(shandle, procInstId,
0879: workItemId);
0880: }
0881:
0882: }
0883:
0884: /**
0885: * @ejb:interface-method view-type="all"
0886: */
0887: public void completeWorkItem(WMSessionHandle shandle,
0888: String procInstId, String workItemId) throws Exception {
0889:
0890: if (SharkEJBUtilities.getEnvType() == 1) {
0891: UserTransaction t = null;
0892: try {
0893: t = (UserTransaction) new InitialContext()
0894: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0895: t.begin();
0896: getSharkObject().completeWorkItem(shandle, procInstId,
0897: workItemId);
0898: t.commit();
0899:
0900: } catch (Exception ex) {
0901: try {
0902: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0903: t.rollback();
0904: } catch (Exception ex1) {
0905: ex1.printStackTrace();
0906: }
0907: throw ex;
0908: }
0909:
0910: } else {
0911: getSharkObject().completeWorkItem(shandle, procInstId,
0912: workItemId);
0913: }
0914:
0915: }
0916:
0917: /**
0918: * @ejb:interface-method view-type="all"
0919: */
0920: public WMWorkItemStateIterator listWorkItemStates(
0921: WMSessionHandle shandle, String procInstId,
0922: String workItemId, WMFilter filter, boolean countFlag)
0923: throws Exception {
0924:
0925: if (SharkEJBUtilities.getEnvType() == 1) {
0926: UserTransaction t = null;
0927: WMWorkItemStateIterator retVal = null;
0928: try {
0929: t = (UserTransaction) new InitialContext()
0930: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0931: t.begin();
0932: retVal = getSharkObject().listWorkItemStates(shandle,
0933: procInstId, workItemId, filter, countFlag);
0934: t.commit();
0935:
0936: } catch (Exception ex) {
0937: try {
0938: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0939: t.rollback();
0940: } catch (Exception ex1) {
0941: ex1.printStackTrace();
0942: }
0943: throw ex;
0944: }
0945:
0946: return retVal;
0947: } else {
0948: return getSharkObject().listWorkItemStates(shandle,
0949: procInstId, workItemId, filter, countFlag);
0950: }
0951:
0952: }
0953:
0954: /**
0955: * @ejb:interface-method view-type="all"
0956: */
0957: public void changeWorkItemState(WMSessionHandle shandle,
0958: String procInstId, String workItemId,
0959: WMWorkItemState newState) throws Exception {
0960:
0961: if (SharkEJBUtilities.getEnvType() == 1) {
0962: UserTransaction t = null;
0963: try {
0964: t = (UserTransaction) new InitialContext()
0965: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
0966: t.begin();
0967: getSharkObject().changeWorkItemState(shandle,
0968: procInstId, workItemId, newState);
0969: t.commit();
0970:
0971: } catch (Exception ex) {
0972: try {
0973: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
0974: t.rollback();
0975: } catch (Exception ex1) {
0976: ex1.printStackTrace();
0977: }
0978: throw ex;
0979: }
0980:
0981: } else {
0982: getSharkObject().changeWorkItemState(shandle, procInstId,
0983: workItemId, newState);
0984: }
0985:
0986: }
0987:
0988: /**
0989: * @ejb:interface-method view-type="all"
0990: */
0991: public void reassignWorkItem(WMSessionHandle shandle,
0992: String sourceUser, String targetUser, String procInstId,
0993: String workItemId) throws Exception {
0994:
0995: if (SharkEJBUtilities.getEnvType() == 1) {
0996: UserTransaction t = null;
0997:
0998: try {
0999: t = (UserTransaction) new InitialContext()
1000: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
1001: t.begin();
1002: getSharkObject().reassignWorkItem(shandle, sourceUser,
1003: targetUser, procInstId, workItemId);
1004: t.commit();
1005:
1006: } catch (Exception ex) {
1007: try {
1008: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
1009: t.rollback();
1010: } catch (Exception ex1) {
1011: ex1.printStackTrace();
1012: }
1013: throw ex;
1014: }
1015:
1016: } else {
1017: getSharkObject().reassignWorkItem(shandle, sourceUser,
1018: targetUser, procInstId, workItemId);
1019: }
1020:
1021: }
1022:
1023: /**
1024: * @ejb:interface-method view-type="all"
1025: */
1026: public WMAttributeIterator listWorkItemAttributes(
1027: WMSessionHandle shandle, String procInstId,
1028: String workItemId, WMFilter filter, boolean countFlag)
1029: throws Exception {
1030:
1031: if (SharkEJBUtilities.getEnvType() == 1) {
1032: UserTransaction t = null;
1033: WMAttributeIterator retVal = null;
1034: try {
1035: t = (UserTransaction) new InitialContext()
1036: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
1037: t.begin();
1038: retVal = getSharkObject().listWorkItemAttributes(
1039: shandle, procInstId, workItemId, filter,
1040: countFlag);
1041: t.commit();
1042:
1043: } catch (Exception ex) {
1044: try {
1045: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
1046: t.rollback();
1047: } catch (Exception ex1) {
1048: ex1.printStackTrace();
1049: }
1050: throw ex;
1051: }
1052:
1053: return retVal;
1054: } else {
1055: return getSharkObject().listWorkItemAttributes(shandle,
1056: procInstId, workItemId, filter, countFlag);
1057: }
1058:
1059: }
1060:
1061: /**
1062: * @ejb:interface-method view-type="all"
1063: */
1064: public WMAttribute getWorkItemAttributeValue(
1065: WMSessionHandle shandle, String procInstId,
1066: String workItemId, String attrName) throws Exception {
1067:
1068: if (SharkEJBUtilities.getEnvType() == 1) {
1069: UserTransaction t = null;
1070: WMAttribute retVal = null;
1071: try {
1072: t = (UserTransaction) new InitialContext()
1073: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
1074: t.begin();
1075: retVal = getSharkObject().getWorkItemAttributeValue(
1076: shandle, procInstId, workItemId, attrName);
1077: t.commit();
1078:
1079: } catch (Exception ex) {
1080: try {
1081: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
1082: t.rollback();
1083: } catch (Exception ex1) {
1084: ex1.printStackTrace();
1085: }
1086: throw ex;
1087: }
1088:
1089: return retVal;
1090: } else {
1091: return getSharkObject().getWorkItemAttributeValue(shandle,
1092: procInstId, workItemId, attrName);
1093: }
1094:
1095: }
1096:
1097: /**
1098: * @ejb:interface-method view-type="all"
1099: */
1100: public void assignWorkItemAttribute(WMSessionHandle shandle,
1101: String procInstId, String workItemId, String attrName,
1102: Object attrValue) throws Exception {
1103:
1104: if (SharkEJBUtilities.getEnvType() == 1) {
1105: UserTransaction t = null;
1106:
1107: try {
1108: t = (UserTransaction) new InitialContext()
1109: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
1110: t.begin();
1111: getSharkObject().assignWorkItemAttribute(shandle,
1112: procInstId, workItemId, attrName, attrValue);
1113: t.commit();
1114:
1115: } catch (Exception ex) {
1116: try {
1117: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
1118: t.rollback();
1119: } catch (Exception ex1) {
1120: ex1.printStackTrace();
1121: }
1122: throw ex;
1123: }
1124:
1125: } else {
1126: getSharkObject().assignWorkItemAttribute(shandle,
1127: procInstId, workItemId, attrName, attrValue);
1128: }
1129:
1130: }
1131:
1132: /**
1133: * @ejb:interface-method view-type="all"
1134: */
1135: public void changeProcessInstancesState(WMSessionHandle shandle,
1136: String procDefId, WMFilter filter,
1137: WMProcessInstanceState newState) throws Exception {
1138:
1139: if (SharkEJBUtilities.getEnvType() == 1) {
1140: UserTransaction t = null;
1141: try {
1142: t = (UserTransaction) new InitialContext()
1143: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
1144: t.begin();
1145: getSharkObject().changeProcessInstancesState(shandle,
1146: procDefId, filter, newState);
1147: t.commit();
1148:
1149: } catch (Exception ex) {
1150: try {
1151: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
1152: t.rollback();
1153: } catch (Exception ex1) {
1154: ex1.printStackTrace();
1155: }
1156: throw ex;
1157: }
1158:
1159: } else {
1160: getSharkObject().changeProcessInstancesState(shandle,
1161: procDefId, filter, newState);
1162: }
1163:
1164: }
1165:
1166: /**
1167: * @ejb:interface-method view-type="all"
1168: */
1169: public void changeActivityInstancesState(WMSessionHandle shandle,
1170: String procDefId, String actDefId, WMFilter filter,
1171: WMActivityInstanceState newState) throws Exception {
1172:
1173: if (SharkEJBUtilities.getEnvType() == 1) {
1174: UserTransaction t = null;
1175: try {
1176: t = (UserTransaction) new InitialContext()
1177: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
1178: t.begin();
1179: getSharkObject().changeActivityInstancesState(shandle,
1180: procDefId, actDefId, filter, newState);
1181: t.commit();
1182:
1183: } catch (Exception ex) {
1184: try {
1185: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
1186: t.rollback();
1187: } catch (Exception ex1) {
1188: ex1.printStackTrace();
1189: }
1190: throw ex;
1191: }
1192:
1193: } else {
1194: getSharkObject().changeActivityInstancesState(shandle,
1195: procDefId, actDefId, filter, newState);
1196: }
1197:
1198: }
1199:
1200: /**
1201: * @ejb:interface-method view-type="all"
1202: */
1203: public void terminateProcessInstances(WMSessionHandle shandle,
1204: String procDefId, WMFilter filter) throws Exception {
1205:
1206: if (SharkEJBUtilities.getEnvType() == 1) {
1207: UserTransaction t = null;
1208: try {
1209: t = (UserTransaction) new InitialContext()
1210: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
1211: t.begin();
1212: getSharkObject().terminateProcessInstances(shandle,
1213: procDefId, filter);
1214: t.commit();
1215:
1216: } catch (Exception ex) {
1217: try {
1218: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
1219: t.rollback();
1220: } catch (Exception ex1) {
1221: ex1.printStackTrace();
1222: }
1223: throw ex;
1224: }
1225:
1226: } else {
1227: getSharkObject().terminateProcessInstances(shandle,
1228: procDefId, filter);
1229: }
1230:
1231: }
1232:
1233: /**
1234: * @ejb:interface-method view-type="all"
1235: */
1236: public void assignProcessInstancesAttribute(
1237: WMSessionHandle shandle, String procDefId, WMFilter filter,
1238: String attrName, Object attrValue) throws Exception {
1239:
1240: if (SharkEJBUtilities.getEnvType() == 1) {
1241: UserTransaction t = null;
1242: try {
1243: t = (UserTransaction) new InitialContext()
1244: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
1245: t.begin();
1246: getSharkObject()
1247: .assignProcessInstancesAttribute(shandle,
1248: procDefId, filter, attrName, attrValue);
1249: t.commit();
1250:
1251: } catch (Exception ex) {
1252: try {
1253: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
1254: t.rollback();
1255: } catch (Exception ex1) {
1256: ex1.printStackTrace();
1257: }
1258: throw ex;
1259: }
1260:
1261: } else {
1262: getSharkObject().assignProcessInstancesAttribute(shandle,
1263: procDefId, filter, attrName, attrValue);
1264: }
1265:
1266: }
1267:
1268: /**
1269: * @ejb:interface-method view-type="all"
1270: */
1271: public void assignActivityInstancesAttribute(
1272: WMSessionHandle shandle, String procDefId, String actDefId,
1273: WMFilter filter, String attrName, Object attrValue)
1274: throws Exception {
1275:
1276: if (SharkEJBUtilities.getEnvType() == 1) {
1277: UserTransaction t = null;
1278: try {
1279: t = (UserTransaction) new InitialContext()
1280: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
1281: t.begin();
1282: getSharkObject().assignActivityInstancesAttribute(
1283: shandle, procDefId, actDefId, filter, attrName,
1284: attrValue);
1285: t.commit();
1286:
1287: } catch (Exception ex) {
1288: try {
1289: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
1290: t.rollback();
1291: } catch (Exception ex1) {
1292: ex1.printStackTrace();
1293: }
1294: throw ex;
1295: }
1296:
1297: } else {
1298: getSharkObject().assignActivityInstancesAttribute(shandle,
1299: procDefId, actDefId, filter, attrName, attrValue);
1300: }
1301:
1302: }
1303:
1304: /**
1305: * @ejb:interface-method view-type="all"
1306: */
1307: public void abortProcessInstances(WMSessionHandle shandle,
1308: String procDefId, WMFilter filter) throws Exception {
1309:
1310: if (SharkEJBUtilities.getEnvType() == 1) {
1311: UserTransaction t = null;
1312: try {
1313: t = (UserTransaction) new InitialContext()
1314: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
1315: t.begin();
1316: getSharkObject().abortProcessInstances(shandle,
1317: procDefId, filter);
1318: t.commit();
1319:
1320: } catch (Exception ex) {
1321: try {
1322: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
1323: t.rollback();
1324: } catch (Exception ex1) {
1325: ex1.printStackTrace();
1326: }
1327: throw ex;
1328: }
1329:
1330: } else {
1331: getSharkObject().abortProcessInstances(shandle, procDefId,
1332: filter);
1333: }
1334:
1335: }
1336:
1337: /**
1338: * @ejb:interface-method view-type="all"
1339: */
1340: public void abortProcessInstance(WMSessionHandle shandle,
1341: String procInstId) throws Exception {
1342:
1343: if (SharkEJBUtilities.getEnvType() == 1) {
1344: UserTransaction t = null;
1345: try {
1346: t = (UserTransaction) new InitialContext()
1347: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
1348: t.begin();
1349: getSharkObject().abortProcessInstance(shandle,
1350: procInstId);
1351: t.commit();
1352:
1353: } catch (Exception ex) {
1354: try {
1355: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
1356: t.rollback();
1357: } catch (Exception ex1) {
1358: ex1.printStackTrace();
1359: }
1360: throw ex;
1361: }
1362:
1363: } else {
1364: getSharkObject().abortProcessInstance(shandle, procInstId);
1365: }
1366:
1367: }
1368:
1369: /**
1370: * @ejb:interface-method view-type="all" Retrieves a process definition.
1371: * @param procDefName The process definition unique name.
1372: * @return The process definition.
1373: * @throws Exception Workflow client exception.
1374: */
1375: public WMProcessDefinition getProcessDefinition(
1376: WMSessionHandle shandle, String procDefName)
1377: throws Exception {
1378:
1379: if (SharkEJBUtilities.getEnvType() == 1) {
1380: UserTransaction t = null;
1381: WMProcessDefinition retVal = null;
1382: try {
1383: t = (UserTransaction) new InitialContext()
1384: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
1385: t.begin();
1386: retVal = getSharkObject().getProcessDefinition(shandle,
1387: procDefName);
1388: t.commit();
1389:
1390: } catch (Exception ex) {
1391: try {
1392: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
1393: t.rollback();
1394: } catch (Exception ex1) {
1395: ex1.printStackTrace();
1396: }
1397: throw ex;
1398: }
1399:
1400: return retVal;
1401: } else {
1402: return getSharkObject().getProcessDefinition(shandle,
1403: procDefName);
1404: }
1405:
1406: }
1407:
1408: protected WAPI getSharkObject() throws Exception {
1409: return (WAPI) Shark.getInstance().getWAPIConnection();
1410: }
1411: }
|