001: package org.enhydra.shark.webclient.business;
002:
003: import java.io.ByteArrayOutputStream;
004: import java.io.File;
005: import java.io.RandomAccessFile;
006: import java.util.ArrayList;
007: import java.util.HashMap;
008: import java.util.Iterator;
009: import java.util.List;
010: import java.util.Map;
011: import java.util.StringTokenizer;
012:
013: import javax.xml.transform.Transformer;
014: import javax.xml.transform.TransformerFactory;
015: import javax.xml.transform.dom.DOMSource;
016: import javax.xml.transform.stream.StreamResult;
017:
018: import org.enhydra.shark.admin.repositorymanagement.RepositoryManager;
019: import org.enhydra.shark.api.admin.RepositoryMgr;
020: import org.enhydra.shark.api.admin.UserGroupManagerAdmin;
021: import org.enhydra.shark.api.client.wfmc.wapi.WAPI;
022: import org.enhydra.shark.api.client.wfmc.wapi.WMActivityInstance;
023: import org.enhydra.shark.api.client.wfmc.wapi.WMActivityInstanceIterator;
024: import org.enhydra.shark.api.client.wfmc.wapi.WMActivityInstanceState;
025: import org.enhydra.shark.api.client.wfmc.wapi.WMFilter;
026: import org.enhydra.shark.api.client.wfmc.wapi.WMProcessInstanceState;
027: import org.enhydra.shark.api.client.wfmc.wapi.WMSessionHandle;
028: import org.enhydra.shark.api.client.wfmc.wapi.WMWorkItem;
029: import org.enhydra.shark.api.client.wfservice.AdminMisc;
030: import org.enhydra.shark.api.client.wfservice.ExecutionAdministration;
031: import org.enhydra.shark.api.client.wfservice.PackageAdministration;
032: import org.enhydra.shark.api.client.wfservice.WMEntity;
033: import org.enhydra.shark.api.common.ActivityFilterBuilder;
034: import org.enhydra.shark.api.common.AssignmentFilterBuilder;
035: import org.enhydra.shark.api.common.SharkConstants;
036: import org.enhydra.shark.client.utilities.MiscClientUtilities;
037: import org.enhydra.shark.client.utilities.SharkInterfaceWrapper;
038: import org.enhydra.shark.utilities.MiscUtilities;
039: import org.enhydra.shark.utilities.WMEntityUtilities;
040: import org.enhydra.shark.webclient.spec.SharkParamConsts;
041: import org.enhydra.shark.webclient.spec.utils.ParamConsts;
042: import org.enhydra.shark.xpdl.XMLUtil;
043: import org.w3c.dom.Node;
044:
045: import com.lutris.appserver.server.ApplicationException;
046: import com.lutris.util.Config;
047: import com.lutris.util.ConfigException;
048:
049: public class SharkUtils {
050:
051: public static String sharkEdition = null;
052:
053: public static String enableComments = "false";
054:
055: public static String userGroupPlugginName = null;
056:
057: public static Map roleMap = null;
058:
059: protected static RepositoryMgr repositoryMgr;
060:
061: public static RepositoryMgr getRepositoryManager() {
062: if (repositoryMgr == null) {
063: repositoryMgr = RepositoryManager.getInstance();
064: }
065: return repositoryMgr;
066: }
067:
068: public static void init(Config config) {
069:
070: // Init Shark Edition
071:
072: Class pi = null;
073:
074: try {
075: pi = Class.forName("org.enhydra.shark.ProfInfo");
076:
077: } catch (Exception e) {
078: pi = null;
079: }
080: if (pi != null) {
081: sharkEdition = SharkParamConsts.SHARK_EDITION_PROFESSIONAL;
082:
083: } else {
084: try {
085: pi = Class
086: .forName("org.enhydra.shark.SharkObjectFactoryExt");
087: } catch (Exception e) {
088: pi = null;
089: }
090: if (pi != null) {
091: sharkEdition = SharkParamConsts.SHARK_EDITION_DEMO;
092:
093: } else {
094: sharkEdition = SharkParamConsts.SHARK_EDITION_COMMUNITY;
095:
096: }
097: }
098:
099: try {
100: enableComments = config.getString(
101: "SharkWebClient.enablecomments", "false");
102: } catch (ConfigException e1) {
103: System.err.println("Configure Comments Error....");
104: }
105: try {
106: Object ama = SharkInterfaceWrapper.getUserGroupAdmin();
107: if (ama != null) {
108: if (ama.getClass().getName().indexOf(
109: "LDAPUserGroupManagerAdmin") >= 0) {
110: userGroupPlugginName = "LDAP";
111: } else if (ama.getClass().getName().indexOf(
112: "DODSUserGroupManagerAdmin") > 0) {
113: userGroupPlugginName = "DODS";
114: }
115: }
116: } catch (Exception e) {
117:
118: }
119: try {
120: // Init role Map
121:
122: roleMap = new HashMap();
123: String values = null;
124:
125: // worklist and processlist
126: values = config.getString("SharkWebClient.Security."
127: + ParamConsts.PROPERTY_PROTECTED_WLH, "none");
128: roleMap.put(ParamConsts.PROPERTY_PROTECTED_WLH, values);
129:
130: // repository
131: values = config
132: .getString(
133: "SharkWebClient.Security."
134: + ParamConsts.PROPERTY_PROTECTED_REPOSITORY,
135: "none");
136: roleMap.put(ParamConsts.PROPERTY_PROTECTED_REPOSITORY,
137: values);
138:
139: // packagelist
140: values = config.getString("SharkWebClient.Security."
141: + ParamConsts.PROPERTY_PROTECTED_PACKAGE, "none");
142: roleMap.put(ParamConsts.PROPERTY_PROTECTED_PACKAGE, values);
143:
144: // processinst
145: values = config.getString("SharkWebClient.Security."
146: + ParamConsts.PROPERTY_PROTECTED_PROCESSINST,
147: "none");
148: roleMap.put(ParamConsts.PROPERTY_PROTECTED_PROCESSINST,
149: values);
150:
151: // processmonitor
152: values = config.getString("SharkWebClient.Security."
153: + ParamConsts.PROPERTY_PROTECTED_PROCESSMONITOR,
154: "none");
155: roleMap.put(ParamConsts.PROPERTY_PROTECTED_PROCESSMONITOR,
156: values);
157:
158: // usergroupmanager
159: values = config.getString("SharkWebClient.Security."
160: + ParamConsts.PROPERTY_PROTECTED_USERGROUPMANAG,
161: "none");
162:
163: roleMap.put(ParamConsts.PROPERTY_PROTECTED_USERGROUPMANAG,
164: values);
165:
166: // cache
167: values = config.getString("SharkWebClient.Security."
168: + ParamConsts.PROPERTY_PROTECTED_CACHE, "none");
169:
170: roleMap.put(ParamConsts.PROPERTY_PROTECTED_CACHE, values);
171:
172: // application
173: values = config.getString("SharkWebClient.Security."
174: + ParamConsts.PROPERTY_PROTECTED_APPLICATION,
175: "none");
176:
177: roleMap.put(ParamConsts.PROPERTY_PROTECTED_APPLICATION,
178: values);
179:
180: } catch (Exception ex) {
181: }
182:
183: try {
184: repositoryMgr = RepositoryManager.getInstance();
185: String xpdlRepository = config.getString("SharkWebClient."
186: + ParamConsts.PROPERTY_PREFIX_REPOSITORY
187: + ".XPDL_repository");
188: repositoryMgr.setPathToXPDLRepositoryFolder(xpdlRepository);
189: } catch (Exception ex) {
190: System.err
191: .println("Repository manager is not configured....");
192: }
193:
194: }
195:
196: public static void uploadPackage(Config appConfig) {
197: try {
198: String[] packagesToUpload = appConfig.getStrings(
199: "SharkWebClient.XPDLS_TO_UPLOAD", null);
200: PackageAdministration pa = SharkInterfaceWrapper.getShark()
201: .getPackageAdministration();
202: WMSessionHandle shandle = SharkInterfaceWrapper
203: .getDefaultSessionHandle(null);
204: int i = 0;
205: if (packagesToUpload != null) {
206: for (i = 0; i < packagesToUpload.length; i++) {
207: File cFile = new File(packagesToUpload[i]);
208: // if file don't exist, try to resolve relative path
209: if (!cFile.exists()) {
210: cFile = new File(appConfig.getConfigFile()
211: .getFile().getParentFile()
212: .getParentFile().getCanonicalPath()
213: + "/" + packagesToUpload[i]);
214: }
215:
216: if (!cFile.exists()) {
217: throw new ApplicationException("XPDL file "
218: + packagesToUpload[i]
219: + " does not exist!");
220: }
221: packagesToUpload[i] = cFile.getCanonicalPath();
222:
223: if (!pa.isPackageOpened(shandle, XMLUtil
224: .getIdFromFile(packagesToUpload[i]))) {
225: if (SharkInterfaceWrapper.getClientType()
226: .equals("POJO")) {
227: pa
228: .openPackage(shandle,
229: packagesToUpload[i]);
230: } else {
231: File pkgFile = new File(packagesToUpload[i]);
232: RandomAccessFile raf = new RandomAccessFile(
233: pkgFile, "r");
234: byte[] utf8Bytes = null;
235: long noOfBytes = raf.length();
236: if (noOfBytes > 0) {
237: utf8Bytes = new byte[(int) noOfBytes];
238: raf.seek(0);
239: raf.readFully(utf8Bytes);
240: }
241: if (utf8Bytes != null) {
242: SharkInterfaceWrapper.getShark()
243: .getPackageAdministration()
244: .uploadPackage(shandle,
245: utf8Bytes);
246: }
247: }
248: }
249: }
250: }
251: } catch (Exception e) {
252: e.printStackTrace();
253: }
254:
255: }
256:
257: public static boolean canSwitchUsers(WMSessionHandle shandle,
258: String groups, String userString) {
259:
260: boolean isSuperUser = false;
261: try {
262: UserGroupManagerAdmin ugma = SharkInterfaceWrapper
263: .getUserGroupAdmin();
264: if (ugma != null) {
265: if (!groups.equalsIgnoreCase("none")) {
266:
267: StringTokenizer st = new StringTokenizer(groups,
268: ",");
269: if (st.countTokens() > 0) {
270: String group = null;
271: while (st.hasMoreTokens()) {
272: group = st.nextToken();
273: if (ugma.doesGroupExist(shandle, group)) {
274: if (ugma.doesUserBelongToGroup(shandle,
275: group, userString)) {
276: isSuperUser = true;
277: break;
278: }
279: }
280: }
281: } else if (!groups.equals(new String(""))) {
282: if (ugma.doesGroupExist(shandle, groups)) {
283: if (ugma.doesUserBelongToGroup(shandle,
284: groups, userString)) {
285: isSuperUser = true;
286:
287: }
288: }
289: } else {
290: isSuperUser = true;
291: }
292: } else {
293: isSuperUser = true;
294: }
295: } else {
296: isSuperUser = true;
297: }
298: } catch (Exception e) {
299: e.printStackTrace();
300: }
301: return isSuperUser;
302: }
303:
304: public static void completeActivity(WMSessionHandle shandle,
305: String procId, String actId) throws Exception {
306:
307: WAPI wapi = SharkInterfaceWrapper.getShark()
308: .getWAPIConnection();
309: WMActivityInstance act = wapi.getActivityInstance(shandle,
310: procId, actId);
311: if (act.getState().getValue() == WMActivityInstanceState.OPEN_NOTRUNNING_NOTSTARTED_INT) {
312: wapi.changeActivityInstanceState(shandle, procId, actId,
313: WMActivityInstanceState.OPEN_RUNNING);
314: }
315: act = wapi.getActivityInstance(shandle, procId, actId);
316: if (act.getState().getValue() == WMActivityInstanceState.OPEN_RUNNING_INT) {
317: wapi.changeActivityInstanceState(shandle, procId, actId,
318: WMActivityInstanceState.CLOSED_COMPLETED);
319: }
320: wapi.disconnect(shandle);
321:
322: }
323:
324: public static void updateProcOrActVariablesAndOtherInfo(
325: String username, Map procInfo, Map actInfo, Map vars)
326: throws Exception {
327:
328: // System.out.println("PI="+procInfo);
329: // System.out.println("AI="+actInfo);
330: // System.out.println("VARS="+vars);
331:
332: WAPI wapi = SharkInterfaceWrapper.getShark()
333: .getWAPIConnection();
334: WMSessionHandle shandle = SharkInterfaceWrapper
335: .makeWAPIConnection(wapi, username, null);
336: ExecutionAdministration ea = SharkInterfaceWrapper.getShark()
337: .getExecutionAdministration();
338:
339: String procId = (String) procInfo.get("Id");
340: String proName = (String) procInfo.get("Name");
341: String proDesc = (String) procInfo.get("Description");
342: Integer proPri = (Integer) procInfo.get("Priority");
343: if (actInfo != null && actInfo.size() > 0) {
344: String actId = (String) actInfo.get("Id");
345: Integer actPri = (Integer) actInfo.get("Priority");
346: String actDesc = (String) actInfo.get("Description");
347: String actName = (String) actInfo.get("Name");
348: if (actName != null) {
349: ea.assignActivityInstanceProperty(shandle, procId,
350: actId, SharkConstants.PROPERTY_NAME_NAME,
351: actName);
352: }
353: if (actDesc != null) {
354: ea.assignActivityInstanceProperty(shandle, procId,
355: actId,
356: SharkConstants.PROPERTY_NAME_DESCRIPTION,
357: actDesc);
358: }
359: if (actPri != null) {
360: ea.assignActivityInstanceProperty(shandle, procId,
361: actId, SharkConstants.PROPERTY_NAME_PRIORITY,
362: new Short(actPri.shortValue()));
363: }
364: Map acnt = WMEntityUtilities
365: .getMapFromWMAttributeArray(wapi
366: .listActivityInstanceAttributes(shandle,
367: procId, actId, null, true)
368: .getArray());
369:
370: filterNonExistingNullVars(vars, acnt);
371:
372: updateVariables(shandle, procId, actId, vars);
373: }
374: if (proName != null) {
375: ea.assignProcessInstanceProperty(shandle, procId,
376: SharkConstants.PROPERTY_NAME_NAME, proName);
377: }
378: if (proDesc != null) {
379: ea.assignProcessInstanceProperty(shandle, procId,
380: SharkConstants.PROPERTY_NAME_DESCRIPTION, proDesc);
381: }
382: if (proPri != null) {
383: ea.assignProcessInstanceProperty(shandle, procId,
384: SharkConstants.PROPERTY_NAME_PRIORITY, new Short(
385: proPri.shortValue()));
386: }
387: if (actInfo == null || actInfo.size() == 0) {
388: Map pcnt = WMEntityUtilities
389: .getMapFromWMAttributeArray(wapi
390: .listProcessInstanceAttributes(shandle,
391: procId, null, true).getArray());
392:
393: filterNonExistingNullVars(vars, pcnt);
394:
395: updateVariables(shandle, procId, null, vars);
396: }
397: wapi.disconnect(shandle);
398: }
399:
400: public static void filterNonExistingNullVars(Map toUpdate,
401: Map currentVars) throws Exception {
402: if (toUpdate != null && currentVars != null) {
403: Iterator it = toUpdate.entrySet().iterator();
404: while (it.hasNext()) {
405: Map.Entry me = (Map.Entry) it.next();
406: if (me.getValue() == null
407: && !currentVars.containsKey(me.getKey())) {
408: it.remove();
409: }
410: }
411: }
412: }
413:
414: public static void acceptedActivity(String username, String procId,
415: String actId, String accepted) throws Exception {
416:
417: WAPI wapi = SharkInterfaceWrapper.getShark()
418: .getWAPIConnection();
419: WMSessionHandle shandle = SharkInterfaceWrapper
420: .makeWAPIConnection(wapi, username, null);
421: WMActivityInstance act = wapi.getActivityInstance(shandle,
422: procId, actId);
423: if (accepted.equals("false")
424: && act.getState().getValue() != WMActivityInstanceState.OPEN_RUNNING_INT) {
425: wapi.changeActivityInstanceState(shandle, procId, actId,
426: WMActivityInstanceState.OPEN_RUNNING);
427: } else if (!accepted.equals("false")
428: && act.getState().getValue() != WMActivityInstanceState.OPEN_NOTRUNNING_NOTSTARTED_INT) {
429: wapi.changeActivityInstanceState(shandle, procId, actId,
430: WMActivityInstanceState.OPEN_NOTRUNNING_NOTSTARTED);
431: } else if (accepted.equals("")) {
432: if (act.getState().getValue() == WMActivityInstanceState.OPEN_RUNNING_INT) {
433: wapi
434: .changeActivityInstanceState(
435: shandle,
436: procId,
437: actId,
438: WMActivityInstanceState.OPEN_NOTRUNNING_NOTSTARTED);
439: } else if (act.getState().getValue() == WMActivityInstanceState.OPEN_NOTRUNNING_NOTSTARTED_INT) {
440: wapi.changeActivityInstanceState(shandle, procId,
441: actId, WMActivityInstanceState.OPEN_RUNNING);
442: }
443: }
444: wapi.disconnect(shandle);
445:
446: }
447:
448: // if checkFirstActivity is true and the first (manual) activity in the
449: // process belongs to the user that started the process, activity's Id is
450: // returned
451: public static String createProcess(WMSessionHandle shandle,
452: String manName) throws Exception {
453:
454: WAPI wapi = SharkInterfaceWrapper.getShark()
455: .getWAPIConnection();
456: String procId = wapi.createProcessInstance(shandle, manName,
457: null);
458:
459: return procId;
460: }
461:
462: public static WMActivityInstance startProcess(
463: WMSessionHandle shandle, String userId, String procId,
464: boolean checkFirstActivity) throws Exception {
465:
466: WAPI wapi = SharkInterfaceWrapper.getShark()
467: .getWAPIConnection();
468:
469: wapi.startProcess(shandle, procId);
470:
471: if (checkFirstActivity) {
472: return findNextActivity(shandle, userId, procId);
473: }
474:
475: return null;
476: }
477:
478: public static WMActivityInstance findNextActivity(
479: WMSessionHandle shandle, String userId, String procId)
480: throws Exception {
481:
482: WAPI wapi = SharkInterfaceWrapper.getShark()
483: .getWAPIConnection();
484: ActivityFilterBuilder fb = SharkInterfaceWrapper.getShark()
485: .getActivityFilterBuilder();
486: WMFilter f = fb.addProcessIdEquals(shandle, procId);
487: f = fb.and(shandle, f, fb.addStateStartsWith(shandle,
488: SharkConstants.STATE_OPEN_NOT_RUNNING_NOT_STARTED));
489: WMActivityInstance[] acts = wapi.listActivityInstances(shandle,
490: f, true).getArray();
491: WMWorkItem[] ass = null;
492: if (MiscUtilities.convertNameValueArrayToProperties(
493: SharkInterfaceWrapper.getShark().getProperties())
494: .getProperty("SharkKernel.createAssignments", "true")
495: .equals("true")) {
496: AssignmentFilterBuilder afb = SharkInterfaceWrapper
497: .getShark().getAssignmentFilterBuilder();
498: f = afb.addUsernameEquals(shandle, userId);
499: ass = wapi.listWorkItems(shandle, f, true).getArray();
500: }
501:
502: WMActivityInstance nextAct = null;
503: for (int i = 0; i < acts.length; i++) {
504:
505: if (ass == null) {
506: nextAct = acts[i];
507: break;
508: }
509: for (int j = 0; j < ass.length; j++) {
510: if (ass[j].getActivityInstanceId().equals(
511: acts[i].getId())) {
512: nextAct = acts[i];
513: break;
514: }
515: }
516: if (nextAct != null) {
517: break;
518: }
519: }
520: return nextAct;
521: }
522:
523: /**
524: * Completes activity and returns true if process is not finished yet.
525: */
526: public static boolean continueProcess(WMSessionHandle shandle,
527: String procId, String actId, Map vars) throws Exception {
528: WAPI wapi = SharkInterfaceWrapper.getShark()
529: .getWAPIConnection();
530:
531: Object nav = vars.get(SharkParamConsts.NAVIGATION_VARIABLE);
532: if (nav != null) {
533: SharkInterfaceWrapper.getShark()
534: .getExecutionAdministrationExtension().goAnywhere(
535: shandle,
536: procId,
537: actId,
538: nav.toString(),
539: MiscClientUtilities
540: .makeWMAttributeArrayContext(vars));
541: } else {
542: Map acnt = WMEntityUtilities
543: .getMapFromWMAttributeArray(wapi
544: .listActivityInstanceAttributes(shandle,
545: procId, actId, null, true)
546: .getArray());
547:
548: filterNonExistingNullVars(vars, acnt);
549:
550: updateVariables(shandle, procId, actId, vars);
551:
552: WMActivityInstance act = wapi.getActivityInstance(shandle,
553: procId, actId);
554: if (act.getState().getValue() == WMActivityInstanceState.OPEN_NOTRUNNING_NOTSTARTED_INT) {
555: wapi.changeActivityInstanceState(shandle, procId,
556: actId, WMActivityInstanceState.OPEN_RUNNING);
557: }
558: wapi.changeActivityInstanceState(shandle, procId, actId,
559: WMActivityInstanceState.CLOSED_COMPLETED);
560: }
561:
562: boolean running = true;
563: if (wapi.getProcessInstance(shandle, procId).getState()
564: .getValue() != WMProcessInstanceState.OPEN_RUNNING_INT) {
565: running = false;
566: }
567:
568: return running;
569:
570: }
571:
572: public static boolean isContextUpdated(WMSessionHandle shandle,
573: String procId, String actId) throws Exception {
574:
575: boolean updated = true;
576:
577: AdminMisc am = SharkInterfaceWrapper.getShark().getAdminMisc();
578:
579: Map res = WMEntityUtilities.getMapFromWMAttributeArray(am
580: .listActivityInstanceResultAttributes(shandle, procId,
581: actId, null, true).getArray());
582:
583: if (res.size() == 0) {
584: WMEntity varEnt = am.getActivityDefinitionInfo(shandle,
585: procId, actId);
586:
587: String[][] extAttribs = WMEntityUtilities
588: .getExtAttribNVPairs(shandle, SharkInterfaceWrapper
589: .getShark().getXPDLBrowser(), varEnt);
590:
591: for (int i = 0; i < extAttribs.length; i++) {
592: String eaName = extAttribs[i][0];
593: if (eaName
594: .equals(SharkParamConsts.EA_VAR_TO_PROCESS_UPDATE)
595: || eaName
596: .equals(SharkParamConsts.EA_VAR_TO_PROCESS_FETCH)) {
597: updated = false;
598: break;
599: }
600: }
601: }
602:
603: return updated;
604: }
605:
606: /**
607: * Check activity extends attributes and retun String[2] array, where 1st element
608: * indicates the type of XForms: file definition, class, string or none, and 2nd
609: * element respectively represents either file location, full class name, the string
610: * representing XForms definition or null in the last case.
611: */
612: public static String[] getXFormsInfo(String username,
613: String procId, String actId, boolean forVariables)
614: throws Exception {
615: WMSessionHandle shandle = SharkInterfaceWrapper
616: .getSessionHandle(username, null);
617:
618: AdminMisc am = SharkInterfaceWrapper.getShark().getAdminMisc();
619:
620: WMEntity ent = null;
621: if (!forVariables || actId != null) {
622: ent = am.getActivityDefinitionInfo(shandle, procId, actId);
623: } else {
624: ent = am.getProcessDefinitionInfo(shandle, procId);
625: }
626:
627: String[][] extAttribs = WMEntityUtilities.getExtAttribNVPairs(
628: shandle, SharkInterfaceWrapper.getShark()
629: .getXPDLBrowser(), ent);
630:
631: for (int i = 0; i < extAttribs.length; i++) {
632: String eaName = extAttribs[i][0];
633: String eaVal = extAttribs[i][1];
634: boolean found = false;
635: if ((forVariables && eaName
636: .equals(SharkParamConsts.EA_XFORMS_FILE_FOR_VARIABLES))
637: || (!forVariables && eaName
638: .equals(SharkParamConsts.EA_XFORMS_FILE))) {
639: found = true;
640: } else if ((forVariables && eaName
641: .equals(SharkParamConsts.EA_XFORMS_XMLC_CLASS_FOR_VARIABLES))
642: || (!forVariables && eaName
643: .equals(SharkParamConsts.EA_XFORMS_XMLC_CLASS))) {
644: found = true;
645: } else if ((forVariables && eaName
646: .equals(SharkParamConsts.EA_XFORMS_EMBEDED_FOR_VARIABLES))
647: || (!forVariables && eaName
648: .equals(SharkParamConsts.EA_XFORMS_EMBEDED))) {
649: found = true;
650: } else if (!forVariables
651: && eaName.equals(SharkParamConsts.EA_HTML_VARIABLE)) {
652: found = true;
653: }
654: if (found && !eaVal.trim().equals("")) {
655: String[] ret = new String[2];
656: ret[0] = eaName;
657: ret[1] = extAttribs[i][1];
658: return ret;
659: }
660: }
661: String[] ret = new String[2];
662: ret[0] = null;
663: ret[1] = null;
664:
665: return ret;
666: }
667:
668: /**
669: * Completes current activity and return process Id
670: */
671: public static void goPrevious(String username, String procId,
672: String actId, Map vars) throws Exception {
673: WAPI wapi = SharkInterfaceWrapper.getShark()
674: .getWAPIConnection();
675: WMSessionHandle shandle = SharkInterfaceWrapper
676: .makeWAPIConnection(wapi, username, null);
677: Map pcnt = WMEntityUtilities.getMapFromWMAttributeArray(wapi
678: .listProcessInstanceAttributes(shandle, procId, null,
679: true).getArray());
680:
681: filterNonExistingNullVars(vars, pcnt);
682: SharkInterfaceWrapper.getShark()
683: .getExecutionAdministrationExtension().goPrevious(
684: shandle,
685: procId,
686: actId,
687: MiscClientUtilities
688: .makeWMAttributeArrayContext(vars));
689: wapi.disconnect(shandle);
690:
691: }
692:
693: public static void goBack(String username, String procId,
694: String actId, Map vars) throws Exception {
695:
696: WAPI wapi = SharkInterfaceWrapper.getShark()
697: .getWAPIConnection();
698: WMSessionHandle shandle = SharkInterfaceWrapper
699: .makeWAPIConnection(wapi, username, null);
700: Map pcnt = WMEntityUtilities.getMapFromWMAttributeArray(wapi
701: .listProcessInstanceAttributes(shandle, procId, null,
702: true).getArray());
703:
704: filterNonExistingNullVars(vars, pcnt);
705:
706: String actDefId = null;
707: if (actId != null) {
708: WMEntity actDef = SharkInterfaceWrapper.getShark()
709: .getAdminMisc().getActivityDefinitionInfo(shandle,
710: procId, actId);
711: actDefId = WMEntityUtilities.findEAAndGetValue(shandle,
712: SharkInterfaceWrapper.getShark().getXPDLBrowser(),
713: actDef,
714: SharkParamConsts.EA_BACK_ACTIVITY_DEFINITION);
715: }
716: if (actDefId != null && !actDefId.trim().equals("")) {
717: SharkInterfaceWrapper.getShark()
718: .getExecutionAdministrationExtension().goAnywhere(
719: shandle,
720: procId,
721: actId,
722: actDefId,
723: MiscClientUtilities
724: .makeWMAttributeArrayContext(vars));
725: } else {
726: SharkInterfaceWrapper.getShark()
727: .getExecutionAdministrationExtension().goBack(
728: shandle,
729: procId,
730: true,
731: MiscClientUtilities
732: .makeWMAttributeArrayContext(vars));
733: }
734: wapi.disconnect(shandle);
735: }
736:
737: public static List findRunningActivities(WMSessionHandle shandle,
738: String procId) throws Exception {
739: WAPI wapi = SharkInterfaceWrapper.getShark()
740: .getWAPIConnection();
741: ActivityFilterBuilder fb = SharkInterfaceWrapper.getShark()
742: .getActivityFilterBuilder();
743: WMFilter f = fb.addProcessIdEquals(shandle, procId);
744: f = fb.and(shandle, f, fb.addStateStartsWith(shandle,
745: SharkConstants.STATEPREFIX_OPEN));
746: WMActivityInstance[] acts = wapi.listActivityInstances(shandle,
747: f, true).getArray();
748:
749: List actL = new ArrayList();
750: for (int i = 0; i < acts.length; i++) {
751: actL.add(acts[i]);
752: }
753: return actL;
754: }
755:
756: public static String getRunningActivityId(String username,
757: String procId) throws Exception {
758: WMSessionHandle shandle = SharkInterfaceWrapper
759: .getSessionHandle(username, null);
760: if (sharkEdition
761: .equals(SharkParamConsts.SHARK_EDITION_COMMUNITY)) {
762: List l = findRunningActivities(shandle, procId);
763: if (l.size() > 1) {
764: throw new Exception(
765: "More than 1 running activity in process "
766: + procId);
767: }
768: if (l.size() > 0) {
769: return ((WMActivityInstance) l.get(0)).getId();
770: }
771: } else {
772: WMActivityInstanceIterator wmai = SharkInterfaceWrapper
773: .getShark().getAdminMiscExtension()
774: .getRunningActivities(shandle, procId, true);
775: if (wmai.getCount() > 1) {
776: throw new Exception(
777: "More than 1 running activity in process "
778: + procId);
779: }
780: if (wmai.hasNext()) {
781: return ((WMActivityInstance) wmai.next()).getId();
782: }
783: }
784: return null;
785: }
786:
787: public static byte[] transformNodeToByteArray(Node n)
788: throws Exception {
789: TransformerFactory tFactory = TransformerFactory.newInstance();
790: Transformer transformer = tFactory.newTransformer();
791: DOMSource source = new DOMSource(n);
792: ByteArrayOutputStream bas = new ByteArrayOutputStream();
793: StreamResult result = new StreamResult(bas);
794: transformer.transform(source, result);
795: return bas.toByteArray();
796: }
797:
798: protected static void updateVariables(WMSessionHandle shandle,
799: String procId, String actId, Map vars) throws Exception {
800: WAPI wapi = SharkInterfaceWrapper.getShark()
801: .getWAPIConnection();
802: Iterator it = vars.entrySet().iterator();
803: while (it.hasNext()) {
804: Map.Entry me = (Map.Entry) it.next();
805: if (actId != null) {
806: wapi.assignActivityInstanceAttribute(shandle, procId,
807: actId, me.getKey().toString(), me.getValue());
808: } else {
809: wapi.assignProcessInstanceAttribute(shandle, procId, me
810: .getKey().toString(), me.getValue());
811: }
812: }
813: }
814:
815: public static boolean isEAControledOptionTrue(
816: WMSessionHandle shandle, String ea, String procId,
817: String actId, String procManagerName, boolean defaultValue)
818: throws Exception {
819: if (SharkUtils.sharkEdition
820: .equals(SharkParamConsts.SHARK_EDITION_COMMUNITY)) {
821: return defaultValue;
822: }
823: boolean ret = defaultValue;
824: String cval = null;
825: WMEntity wmeInfo = null;
826:
827: AdminMisc am = SharkInterfaceWrapper.getShark().getAdminMisc();
828: if (null != actId && !actId.equals("")) {
829: wmeInfo = am.getActivityDefinitionInfo(shandle, procId,
830: actId);
831: cval = WMEntityUtilities.findEAAndGetValue(shandle,
832: SharkInterfaceWrapper.getShark().getXPDLBrowser(),
833: wmeInfo, ea);
834: }
835: if (cval == null && (procManagerName != null || procId != null)) {
836: if (procId != null) {
837: wmeInfo = am.getProcessDefinitionInfo(shandle, procId);
838:
839: } else {
840: AdminMisc amc = SharkInterfaceWrapper.getShark()
841: .getAdminMisc();
842: wmeInfo = amc
843: .getProcessDefinitionInfoByUniqueProcessDefinitionName(
844: shandle, procManagerName);
845: }
846:
847: cval = WMEntityUtilities.findEAAndGetValue(shandle,
848: SharkInterfaceWrapper.getShark().getXPDLBrowser(),
849: wmeInfo, ea);
850: }
851:
852: if (cval == null && wmeInfo != null) {
853: WMEntity pkgInfo = SharkInterfaceWrapper.getShark()
854: .getPackageAdministration().getPackageEntity(
855: shandle, wmeInfo.getPkgId(),
856: wmeInfo.getPkgVer());
857: cval = WMEntityUtilities.findEAAndGetValue(shandle,
858: SharkInterfaceWrapper.getShark().getXPDLBrowser(),
859: pkgInfo, ea);
860: }
861: if (cval != null) {
862: if (cval.equalsIgnoreCase("true")
863: || cval.equalsIgnoreCase("false")) {
864: ret = new Boolean(cval.toLowerCase()).booleanValue();
865: }
866: }
867:
868: return ret;
869: }
870:
871: public static String[] stringToArray(String value, String delimiter) {
872:
873: StringTokenizer st = new StringTokenizer(value, delimiter);
874: int count = st.countTokens();
875:
876: String[] strarr = new String[count];
877: for (int i = 0; i < count; i++) {
878: strarr[i] = st.nextToken();
879: }
880:
881: return strarr;
882: }
883: }
|