1 /*****************************************************************************
2 * Copyright Igor Barma, Eric Brun, Alexandre Desoubeaux, Christian Martel,
5 * Ce logiciel est un programme informatique servant à l'évaluation des
8 * Ce logiciel est régi par la licence CeCILL soumise au droit français et
9 * respectant les principes de diffusion des logiciels libres. Vous pouvez
10 * utiliser, modifier et/ou redistribuer ce programme sous les conditions
11 * de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA
12 * sur le site "http://www.cecill.info".
14 * En contrepartie de l'accessibilité au code source et des droits de copie,
15 * de modification et de redistribution accordés par cette licence, il n'est
16 * offert aux utilisateurs qu'une garantie limitée. Pour les mêmes raisons,
17 * seule une responsabilité restreinte pèse sur l'auteur du programme, le
18 * titulaire des droits patrimoniaux et les concédants successifs.
20 * A cet égard l'attention de l'utilisateur est attirée sur les risques
21 * associés au chargement, à l'utilisation, à la modification et/ou au
22 * développement et à la reproduction du logiciel par l'utilisateur étant
23 * donné sa spécificité de logiciel libre, qui peut le rendre complexe à
24 * manipuler et qui le réserve donc à des développeurs et des professionnels
25 * avertis possédant des connaissances informatiques approfondies. Les
26 * utilisateurs sont donc invités à charger et tester l'adéquation du
27 * logiciel à leurs besoins dans des conditions permettant d'assurer la
28 * sécurité de leurs systèmes et ou de leurs données et, plus généralement,
29 * à l'utiliser et l'exploiter dans les mêmes conditions de sécurité.
31 * Le fait que vous puissiez accéder à cet en-tête signifie que vous avez
32 * pris connaissance de la licence CeCILL, et que vous en avez accepté les
34 *******************************************************************************/
35 package com.pentila.evalcomp.workflow.engine;
38 import java.io.FileInputStream;
39 import java.io.FilenameFilter;
40 import java.io.UnsupportedEncodingException;
41 import java.util.ArrayList;
42 import java.util.Arrays;
43 import java.util.Collection;
44 import java.util.HashMap;
45 import java.util.HashSet;
46 import java.util.List;
48 import java.util.Map.Entry;
51 import org.ow2.bonita.facade.APIAccessor;
52 import org.ow2.bonita.facade.ManagementAPI;
53 import org.ow2.bonita.facade.QueryDefinitionAPI;
54 import org.ow2.bonita.facade.QueryRuntimeAPI;
55 import org.ow2.bonita.facade.RuntimeAPI;
56 import org.ow2.bonita.facade.def.element.Resource;
57 import org.ow2.bonita.facade.def.majorElement.ActivityDefinition;
58 import org.ow2.bonita.facade.def.majorElement.DataFieldDefinition;
59 import org.ow2.bonita.facade.def.majorElement.PackageDefinition;
60 import org.ow2.bonita.facade.def.majorElement.ParticipantDefinition;
61 import org.ow2.bonita.facade.def.majorElement.ProcessDefinition;
62 import org.ow2.bonita.facade.exception.ActivityNotFoundException;
63 import org.ow2.bonita.facade.exception.DataFieldNotFoundException;
64 import org.ow2.bonita.facade.exception.InstanceNotFoundException;
65 import org.ow2.bonita.facade.exception.PackageNotFoundException;
66 import org.ow2.bonita.facade.exception.ProcessNotFoundException;
67 import org.ow2.bonita.facade.exception.VariableNotFoundException;
68 import org.ow2.bonita.facade.runtime.ActivityBody;
69 import org.ow2.bonita.facade.runtime.ActivityInstance;
70 import org.ow2.bonita.facade.runtime.ActivityState;
71 import org.ow2.bonita.facade.runtime.ProcessInstance;
72 import org.ow2.bonita.facade.runtime.TaskInstance;
73 import org.ow2.bonita.facade.uuid.ActivityInstanceUUID;
74 import org.ow2.bonita.facade.uuid.PackageDefinitionUUID;
75 import org.ow2.bonita.facade.uuid.ProcessDefinitionUUID;
76 import org.ow2.bonita.facade.uuid.ProcessInstanceUUID;
77 import org.ow2.bonita.facade.uuid.TaskUUID;
78 import org.ow2.bonita.pvm.env.Environment;
79 import org.ow2.bonita.util.AccessorUtil;
80 import org.ow2.bonita.util.Command;
81 import org.ow2.bonita.util.Misc;
83 import com.pentila.evalcomp.domain.Role;
84 import com.pentila.evalcomp.domain.User;
85 import com.pentila.evalcomp.domain.definition.EvaluationDefinition;
86 import com.pentila.evalcomp.domain.definition.Property;
87 import com.pentila.evalcomp.domain.definition.ScenarioDefinition;
88 import com.pentila.evalcomp.domain.service.ExtendProcessDefinition;
89 import com.pentila.evalcomp.domain.transit.Activity;
90 import com.pentila.evalcomp.domain.transit.Process;
91 import com.pentila.evalcomp.domain.transit.TPackageDefinition;
92 import com.pentila.evalcomp.domain.transit.TransitProcessDefinition;
93 import com.pentila.evalcomp.domain.transit.Transition;
94 import com.pentila.evalcomp.manager.Beans;
95 import com.pentila.evalcomp.utilities.InstanceUtil;
96 import com.pentila.evalcomp.utilities.Utils;
99 * The Class Engine. Define the workflow engine application wrapper
101 public class Engine implements IEngine {
104 org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(Engine.class);
108 private String envFile;
110 /** The workflowsdir. */
111 private String workflowsdir;
113 /** The ext definitions. */
114 private Map<PackageDefinitionUUID, ExtendProcessDefinition> extDefinitions;
116 /** The property types definition. */
117 private final List<String> propertyTypesDefinition = Arrays.asList(new String[] { Property.PROPERTY,
118 Property.DEADLINE });
120 /** The property types instance. */
121 private final List<String> propertyTypesInstance = Arrays.asList(new String[] { Property.PROPERTY,
122 Property.VARIABLE });
125 * Convert. Convert a Bonita ProcessDefintion to a TrasitProcessDefinition
130 * @return the transit process definition
132 private TransitProcessDefinition convert(ProcessDefinition pd) {
133 TransitProcessDefinition tpd = new TransitProcessDefinition();
137 APIAccessor apiac = AccessorUtil.getAPIAccessor();
139 QueryDefinitionAPI e = apiac.getQueryDefinitionAPI();
141 PackageDefinition packDef = e.getPackage(pd
142 .getPackageDefinitionUUID());
144 // Get and Convert Package Definition information
145 TPackageDefinition tpack = new TPackageDefinition();
147 tpack.setAuthor(packDef.getAuthor());
148 tpack.setCreationDate(packDef.getCreated());
149 tpack.setDescription(packDef.getDescription());
150 tpack.setVersion(packDef.getVersion());
151 tpack.setXpdlVersion(packDef.getXPDLVersion());
152 tpack.setUUID(packDef.getUUID().toString());
153 tpack.setDeployedDate(packDef.getDeployedDate());
154 tpack.setName(packDef.getName());
156 tpd.setPackageDefinition(tpack);
158 // Build Process Definition information
159 tpd.setId(pd.getProcessId());
160 String defuuid = pd.getProcessDefinitionUUID().toString();
161 tpd.setUUID(defuuid);
162 tpd.setName(pd.getName());
163 tpd.setDescription(pd.getDescription());
164 tpd.setAuthor(pd.getAuthor());
165 tpd.setVersion(pd.getVersion());
167 tpd.setCreationDate(pd.getCreated());
168 ProcessDefinitionUUID uuid = new ProcessDefinitionUUID(defuuid);
170 ExtendProcessDefinition EPD = extDefinitions.get(packDef.getUUID());
173 DataFieldDefinition ob;
174 ob = e.getProcessDataField(uuid, "INIT_ROLE");
175 String value = ob.getInitialValue();
176 tpd.setInitRole(value);
177 } catch (DataFieldNotFoundException e1) {
179 // e1.printStackTrace();
183 DataFieldDefinition ob;
184 ob = e.getProcessDataField(uuid, "INSTANCIATION_MODE");
185 String value = ob.getInitialValue();
187 Integer instanciationMode = new Integer(value);
188 tpd.setInstanciationMode(instanciationMode);
189 } catch (DataFieldNotFoundException e1) {
190 // TODO Auto-generated catch block
191 // e1.printStackTrace();
192 tpd.setInstanciationMode(EvaluationDefinition.MODE_NONE);
196 DataFieldDefinition ob;
197 ob = e.getProcessDataField(uuid, "TYPE");
198 String value = ob.getInitialValue();
200 } catch (DataFieldNotFoundException e1) {
201 String type = ScenarioDefinition.EVALUATION;
204 // e1.printStackTrace();
207 Set<Role> roles = new HashSet<Role>();
209 Set<ParticipantDefinition> sp = e.getProcessParticipants(uuid);
210 for (ParticipantDefinition pad : sp) {
212 Role role = new Role();
213 role.setName(pad.getName());
215 if (EPD != null && EPD.getRoles() != null){
216 for(Role r : EPD.getRoles()){
217 if (r.getName().equals(pad.getName())){
218 role.setSingleMember(r.isSingleMember());
228 Set<ActivityDefinition> sad = e.getProcessActivities(pd
229 .getProcessDefinitionUUID());
230 Set<Activity> sa = new HashSet<Activity>();
231 for (ActivityDefinition ad : sad) {
235 // Take only manual (Humain Activities)
236 if (ad.getStartMode().equals(
237 ActivityDefinition.StartMode.Manual)) {
239 Activity a = new Activity();
240 a.setId(ad.getActivityId());
241 a.setName(ad.getName());
242 a.setDescription(ad.getDescription());
244 HashSet<String> performers = new HashSet<String>();
245 performers.add(ad.getPerformer());
247 a.setRoleNamePerformers(performers);
252 tpd.setActivities(sa);
254 Set<Property> spp = getDefProperties(e, pd
255 .getProcessDefinitionUUID(), propertyTypesDefinition);
257 tpd.getProperties().addAll(spp);
259 } catch (ProcessNotFoundException e) {
260 // TODO Auto-generated catch block
262 } catch (PackageNotFoundException e) {
263 // TODO Auto-generated catch block
271 * Deploy and return a Map of deployed ProcessDefiniton.
273 * @param managementAPI
278 * @return the map< string, process definition>
283 protected Map<String, ProcessDefinition> deploy(
284 ManagementAPI managementAPI, File barFile) throws Exception {
286 if (barFile != null) {
288 final java.io.InputStream in = new FileInputStream(barFile);
291 throw new Exception("Can't find ressource: " + barFile);
293 byte[] bar = Misc.getAllContentFrom(in);
295 logger.debug("Engine : getAllContentFrom : OK");
297 return managementAPI.deployBar(bar);
299 logger.debug("Usage: " + Engine.class + " bpar file");
301 } catch (Exception e) {
302 logger.warn("Deploy Workflow Warning");
308 * @see com.pentila.evalcomp.workflow.engine.IEngine#deployWF(org.ow2.bonita.facade.RuntimeAPI, org.ow2.bonita.facade.QueryRuntimeAPI, org.ow2.bonita.facade.ManagementAPI, org.ow2.bonita.facade.QueryDefinitionAPI, java.lang.String)
311 public void deployWF(RuntimeAPI runtimeAPI,
312 QueryRuntimeAPI queryRuntimeAPI, ManagementAPI managementAPI,
313 QueryDefinitionAPI queryDefinitionAPI, String barFile)
316 File dir = new File(Beans.getApplicationPath("/")+ "/WEB-INF/"+workflowsdir);
318 logger.info("PATH of WORKFLOW :" + dir.getAbsolutePath());
320 File[] filesWanted = dir.listFiles(new FilenameFilter() {
321 public boolean accept(File dir, String name) {
322 return name.endsWith(".bpar");
326 if (filesWanted != null){
328 for (File f : filesWanted) {
331 deploy(managementAPI, f);
333 } catch (Exception e) {
334 logger.warn("Deployer Workflow Warning");
339 if (logger.isDebugEnabled()){
340 for (File f : filesWanted){
341 logger.debug("Founded file : " + f.getAbsolutePath());
346 // Initilize Extenstion Definition data struct
347 extDefinitions = new HashMap<PackageDefinitionUUID, ExtendProcessDefinition>();
349 for (PackageDefinition pd : queryDefinitionAPI.getPackages()){
350 if (!extDefinitions.containsKey(pd.getUUID())){
351 extDefinitions.put(pd.getUUID(), XMLUtil.getExtendProcessDefinition(getExtendXML(pd.getUUID(), "extension.xml")));
357 * @see com.pentila.evalcomp.workflow.engine.IEngine#execute(org.ow2.bonita.util.Command)
359 public Object execute(Command m) {
360 Object result = null;
362 result = AccessorUtil.getAPIAccessor().getCommandAPI().execute(m);
363 } catch (Exception e) {
370 * Gets the activity transitions.
375 * @return the activity transition
378 private List<Transition> getActivityTransition(ActivityDefinition ad) {
379 List<Transition> lt = new ArrayList<Transition>();
381 Set<DataFieldDefinition> setFields = ad.getDataFields();
382 for (DataFieldDefinition dataF : setFields) {
383 String id = dataF.getDataFieldId();
384 String[] l = id.split("_");
386 if (l.length > 1 && l[0].equals("TRANSITION")) {
387 Transition t = new Transition();
389 t.setName(dataF.getInitialValue());
390 t.setDescription(dataF.getDescription());
398 * Gets the properties from Bonita ProcessDefinition.
407 * @return the def properties
409 * @throws ProcessNotFoundException
410 * the process not found exception
412 private Set<Property> getDefProperties(QueryDefinitionAPI qda,
413 ProcessDefinitionUUID pdUUID, List<String> pstyle)
414 throws ProcessNotFoundException {
416 Set<Property> sp = new HashSet<Property>();
418 for (DataFieldDefinition dfd : qda.getProcessDataFields(pdUUID)) {
419 String id = dfd.getDataFieldId();
420 String description = dfd.getDescription();
421 String v = dfd.getInitialValue();
423 String[] c = id.split("_", 2);
428 if (pstyle.contains(type)) {
429 Property p = new Property();
432 p.setDescription(description);
443 * @see com.pentila.evalcomp.workflow.engine.IEngine#getEnvFile()
445 public String getEnvFile() {
450 * @see com.pentila.evalcomp.workflow.engine.IEngine#getInstance(java.lang.String)
452 public ProcessInstance getInstance(String id)
453 throws InstanceNotFoundException {
454 ProcessInstanceUUID processInstanceUUID = new ProcessInstanceUUID(id);
456 APIAccessor apiac = AccessorUtil.getAPIAccessor();
458 return apiac.getQueryRuntimeAPI().getProcessInstance(
459 processInstanceUUID);
465 * @see com.pentila.evalcomp.workflow.engine.IEngine#printInstanceDebug(java.lang.String)
467 public void printInstanceDebug(String id)
468 throws InstanceNotFoundException {
469 ProcessInstanceUUID processInstanceUUID = new ProcessInstanceUUID(id);
471 APIAccessor apiac = AccessorUtil.getAPIAccessor();
473 ProcessInstance pi = apiac.getQueryRuntimeAPI().getProcessInstance(
474 processInstanceUUID);
476 logger.info(pi.toString());
478 apiac.getQueryRuntimeAPI().getActivityInstances(processInstanceUUID);
480 Set<ActivityInstance<TaskInstance>> b = apiac.getQueryRuntimeAPI().getTasks(processInstanceUUID);
482 for (ActivityInstance<TaskInstance> z: b){
484 logger.info("Activity ID:" + z.getActivityId());
485 logger.info("State : " + z.getBody().getState());
486 logger.info("Candidates : ");
487 for (String cand : z.getBody().getTaskCandidates()){
499 * @see com.pentila.evalcomp.workflow.engine.IEngine#getProcessDefinitionRoleNames(java.lang.String)
501 public Set<String> getProcessDefinitionRoleNames(String id) {
502 APIAccessor apiac = AccessorUtil.getAPIAccessor();
503 QueryDefinitionAPI e = apiac.getQueryDefinitionAPI();
505 Set<String> rolenames = new HashSet<String>();
507 ProcessDefinitionUUID u = new ProcessDefinitionUUID(id);
511 Set<ParticipantDefinition> sp = e.getProcessParticipants(u);
512 for (ParticipantDefinition pd : sp) {
513 rolenames.add(pd.getName());
516 } catch (ProcessNotFoundException e1) {
518 e1.printStackTrace();
525 * @see com.pentila.evalcomp.workflow.engine.IEngine#getProcessDefinitions(java.util.Set)
527 public Set<TransitProcessDefinition> getProcessDefinitions(
528 Set<String> filterTypes) {
530 Set<TransitProcessDefinition> stpd = new HashSet<TransitProcessDefinition>();
532 APIAccessor apiac = AccessorUtil.getAPIAccessor();
533 QueryDefinitionAPI e = apiac.getQueryDefinitionAPI();
535 Set<ProcessDefinition> spd = e.getProcesses();
537 Map<String, TransitProcessDefinition> map = new HashMap<String, TransitProcessDefinition>();
539 for (ProcessDefinition pd : spd) {
540 TransitProcessDefinition tpd = convert(pd);
542 if (filterTypes != null && !filterTypes.contains(tpd.getType())) {
546 // Apply a filter for get the lastest Scenario Def by Version
548 if (map.containsKey(tpd.getId())) {
549 String currentVersion = map.get(tpd.getId()).getVersion();
550 Float cv = new Float(currentVersion);
551 Float newv = new Float(tpd.getVersion());
553 if (java.lang.Math.max(cv, newv) == newv) {
554 map.put(tpd.getId(), tpd);
557 map.put(tpd.getId(), tpd);
562 stpd.addAll(map.values());
568 * @see com.pentila.evalcomp.workflow.engine.IEngine#getProcessDefinitionUUIDs()
570 public List<String> getProcessDefinitionUUIDs() {
572 List<String> ps = new ArrayList<String>();
574 APIAccessor apiac = AccessorUtil.getAPIAccessor();
575 QueryDefinitionAPI e = apiac.getQueryDefinitionAPI();
577 Set<ProcessDefinition> spd = e.getProcesses();
579 for (ProcessDefinition pd : spd) {
580 String s = pd.getProcessDefinitionUUID().toString();// pd.getProcessId();
588 * @see com.pentila.evalcomp.workflow.engine.IEngine#getProcessDefinitionVariableByUUID(java.lang.String, java.lang.String)
590 public String getProcessDefinitionVariableByUUID(String defuuid,
591 String variableName) {
595 APIAccessor apiac = AccessorUtil.getAPIAccessor();
596 QueryDefinitionAPI e = apiac.getQueryDefinitionAPI();
597 ProcessDefinitionUUID uuid = new ProcessDefinitionUUID(defuuid);
602 DataFieldDefinition ob;
603 ob = e.getProcessDataField(uuid, variableName);
604 value = ob.getInitialValue();
605 } catch (DataFieldNotFoundException e1) {
607 e1.printStackTrace();
610 } catch (ProcessNotFoundException e1) {
612 e1.printStackTrace();
620 * @see com.pentila.evalcomp.workflow.engine.IEngine#getProcesses(java.lang.String)
623 public Set<Process> getProcesses(String login) {
625 Map<String, Process> sp = new HashMap<String, Process>();
627 APIAccessor apiac = AccessorUtil.getAPIAccessor();
628 QueryRuntimeAPI queryRuntimeAPI = apiac.getQueryRuntimeAPI();
630 QueryDefinitionAPI qda = apiac.getQueryDefinitionAPI();
634 final Collection<ActivityInstance<TaskInstance>> activities = queryRuntimeAPI
635 .getTaskList(ActivityState.READY);
637 for (ActivityInstance<TaskInstance> activity : activities) {
639 if (logger.isDebugEnabled()){
641 logger.debug("getProcesses for " + login + " : " + activity.toString());
643 ExtendProcessDefinition EPD = extDefinitions.get(activity
644 .getPackageDefinitionUUID());
646 String pi = activity.getProcessInstanceUUID().toString();
648 if (!sp.containsKey(pi)) {
656 String SSIID = (String) queryRuntimeAPI
657 .getProcessInstanceVariable(activity
658 .getProcessInstanceUUID(), "SIID");
662 String TYPE = (String) queryRuntimeAPI
664 .getProcessInstanceVariable(activity
665 .getProcessInstanceUUID(), "TYPE");
668 } catch (Exception e) {
669 pp.setType(ScenarioDefinition.EVALUATION);
671 Long SIID = new Long(SSIID);
675 String activityUUID = activity.getUUID().toString();
677 String activityId = activity.getActivityId();
679 Activity a = new Activity();
681 a.setUUID(activityUUID);
683 a.setTaskCandidates(activity.getBody().getTaskCandidates());
684 }catch (Exception e){
685 //e.printStackTrace();
690 .getExtActivityByActivityId(activityId));
693 // Valiable d'activité
695 Set<Property> setP = new HashSet<Property>();
696 for ( Entry<String, Object> vv : activity.getLastKnownVariableValues().entrySet()){
698 String key = vv.getKey();
699 String value = (String) vv.getValue();
701 logger.debug("Variable : " + key + " with value : " + value);
702 if (key.startsWith(Property.VARIABLE)){
704 Property p = new Property();
705 p.setType(Property.VARIABLE);
714 a.setProperties(setP);
716 // Activity Definition
717 ActivityDefinition ad;
720 ad = qda.getProcessActivity(activity
721 .getProcessDefinitionUUID(), activityId);
723 a.setDescription(ad.getDescription());
725 // Set les roles performers
726 HashSet<String> performers = new HashSet<String>();
727 performers.add(ad.getPerformer());
729 a.setRoleNamePerformers(performers);
731 //Set les transitions
732 List<Transition> lt = getActivityTransition(ad);
734 a.setTransitions(lt);
735 pp.getActivities().add(a);
737 // Variables (Property, variable, DeadLine) de processus.
739 Set<Property> spp = getDefProperties(qda, activity
740 .getProcessDefinitionUUID(), propertyTypesInstance);
742 Map<String, Object> mapVars = queryRuntimeAPI
743 .getProcessInstanceVariables(activity
744 .getProcessInstanceUUID());
746 for (Property p : spp) {
747 if (mapVars.containsKey(p.getName())) {
748 String v = (String) mapVars.get(p.getName());
754 pp.setProperties(spp);
756 } catch (ProcessNotFoundException e) {
760 } catch (ActivityNotFoundException e) {
766 } catch (InstanceNotFoundException e) {
767 // TODO Auto-generated catch block
769 } catch (VariableNotFoundException e) {
770 // TODO Auto-generated catch block
774 return new HashSet<Process>(sp.values());
779 * @see com.pentila.evalcomp.workflow.engine.IEngine#getTransitProcessDefinition(java.lang.String)
781 public TransitProcessDefinition getTransitProcessDefinition(String uuid) {
783 TransitProcessDefinition tpd = null;
787 APIAccessor apiac = AccessorUtil.getAPIAccessor();
788 QueryDefinitionAPI e = apiac.getQueryDefinitionAPI();
789 ProcessDefinitionUUID myuuid = new ProcessDefinitionUUID(uuid);
791 ProcessDefinition pd = e.getProcess(myuuid);
795 } catch (ProcessNotFoundException e) {
796 // TODO Auto-generated catch block
804 * @see com.pentila.evalcomp.workflow.engine.IEngine#getUserScenarioInstanceIds(java.lang.String)
806 public Set<Long> getUserScenarioInstanceIds(String login) {
807 APIAccessor apiac = AccessorUtil.getAPIAccessor();
809 QueryRuntimeAPI queryRuntimeAPI = apiac.getQueryRuntimeAPI();
811 Set<Long> sid = new HashSet<Long>();
813 final Collection<ActivityInstance<TaskInstance>> activities = queryRuntimeAPI
814 .getTaskList(ActivityState.READY);
816 for (ActivityInstance<TaskInstance> activity : activities) {
818 String SSIID = (String) queryRuntimeAPI
819 .getProcessInstanceVariable(activity
820 .getProcessInstanceUUID(), "SIID");
822 Long SIID = new Long(SSIID);
826 } catch (InstanceNotFoundException e) {
829 } catch (VariableNotFoundException e) {
837 * @see com.pentila.evalcomp.workflow.engine.IEngine#getWorkflowsdir()
839 public String getWorkflowsdir() {
844 * Checks for transition.
846 * @param activity the activity uuid
847 * @param actionId the action id
848 * @return true, if successful
850 private boolean hasTransition(ActivityInstance<ActivityBody> activity,
853 return activity.getLastKnownVariableValues().keySet().contains(actionId);
854 }catch (Exception e){
860 * @see com.pentila.evalcomp.workflow.engine.IEngine#initializeWorkers()
862 public void initializeWorkers() throws Exception {
864 logger.info("Bonita environment at : " + Beans.getApplicationPath("/")+ "WEB-INF/"+envFile);
866 System.setProperty("org.ow2.bonita.environment", Beans.getApplicationPath("/")+ "WEB-INF/"+envFile);
867 System.setProperty("org.ow2.bonita.api-type", "Standard");
870 APIAccessor apiac = AccessorUtil.getAPIAccessor();
872 deployWF(apiac.getRuntimeAPI(), apiac.getQueryRuntimeAPI(), apiac
873 .getManagementAPI(), apiac.getQueryDefinitionAPI(), "");
878 * @see com.pentila.evalcomp.workflow.engine.IEngine#instanciate(java.lang.String, java.lang.String, java.util.Map)
880 public String instanciate(String login, String processDefinitionUUID,
883 ProcessInstanceUUID instanceUUID = null;
885 APIAccessor apiac = AccessorUtil.getAPIAccessor();
886 RuntimeAPI runtimeAPI = apiac.getRuntimeAPI();
888 ProcessDefinitionUUID PDUUID = new ProcessDefinitionUUID(
889 processDefinitionUUID);
893 instanceUUID = runtimeAPI.instantiateProcess(PDUUID, parameters);
894 } catch (ProcessNotFoundException e) {
896 } catch (VariableNotFoundException e) {
900 return instanceUUID.toString();
904 * @see com.pentila.evalcomp.workflow.engine.IEngine#refreshAssignation(java.lang.String)
906 public void refreshAssignation(String processInstanceId) {
907 APIAccessor apiac = AccessorUtil.getAPIAccessor();
909 final QueryRuntimeAPI queryRuntimeAPI = apiac.getQueryRuntimeAPI();
910 final RuntimeAPI runtimeAPI = apiac.getRuntimeAPI();
912 final ProcessInstanceUUID processInstanceUUID = new ProcessInstanceUUID(
915 Command<Boolean> assignCommand = new Command<Boolean>(){
917 public Boolean execute(Environment arg0) throws Exception {
918 final Collection<ActivityInstance<TaskInstance>> activities = queryRuntimeAPI
919 .getTasks(processInstanceUUID);
921 for (ActivityInstance<TaskInstance> activity : activities) {
922 if (logger.isDebugEnabled()){
923 logger.debug("refershAssignation : activity : " + activity.getActivityId() );
925 runtimeAPI.assignTask(activity.getBody().getUUID());
932 execute(assignCommand);
937 * @see com.pentila.evalcomp.workflow.engine.IEngine#removeInstance(java.lang.String)
940 public void removeInstance(String id) {
942 APIAccessor apiac = AccessorUtil.getAPIAccessor();
943 ProcessInstanceUUID processInstanceUUID = new ProcessInstanceUUID(id);
945 RuntimeAPI runtimeAPI = apiac.getRuntimeAPI();
948 if (logger.isDebugEnabled()){
949 logger.debug("Deleting ProcessInstance : " + processInstanceUUID);
951 runtimeAPI.deleteProcessInstance(processInstanceUUID);
953 } catch (InstanceNotFoundException e) {
955 } catch (Exception e) {
961 * @see com.pentila.evalcomp.workflow.engine.IEngine#getExtendXML(org.ow2.bonita.facade.uuid.PackageDefinitionUUID, java.lang.String)
964 * Gets the extend xml.
966 * @param pduuid the pduuid
967 * @param filename the filename
968 * @return the extend xml
970 public String getExtendXML(PackageDefinitionUUID pduuid, String filename) {
972 APIAccessor apiac = AccessorUtil.getAPIAccessor();
973 QueryDefinitionAPI qda = apiac.getQueryDefinitionAPI();
976 p = qda.getPackage(pduuid);
978 Resource r = p.getBusinessArchive().getResource(filename);
981 return new String(r.getData(), "UTF-8");
984 } catch (PackageNotFoundException e1) {
985 // TODO Auto-generated catch block
986 e1.printStackTrace();
987 } catch (UnsupportedEncodingException e) {
988 // TODO Auto-generated catch block
995 * @see com.pentila.evalcomp.workflow.engine.IEngine#runProcessActivity(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
998 public void runProcessActivity(String login, String processuuid,
999 String selectedActivityId, String actionId) {
1002 logger.debug("runProcessActivity : login = " + login + " ProcessUUID = " + processuuid + " selectedActivityId = " + selectedActivityId + " actionId = " + actionId);
1006 APIAccessor apiac = AccessorUtil.getAPIAccessor();
1007 QueryRuntimeAPI queryRuntimeAPI = apiac.getQueryRuntimeAPI();
1008 ActivityInstanceUUID selectedUUID = new ActivityInstanceUUID(selectedActivityId);
1010 ActivityInstance<ActivityBody> activity = queryRuntimeAPI.getActivityInstance(selectedUUID);
1012 TaskUUID taskUUID = (TaskUUID) activity.getBody().getUUID();
1013 ActivityInstanceUUID activityUUID = activity.getUUID();
1015 String value = null;
1017 if (hasTransition(activity, actionId)) {
1021 logger.debug("Value is = " + value);
1023 StartFinishCommand sfc = new StartFinishCommand(taskUUID, activityUUID, actionId, value);
1026 } catch (ActivityNotFoundException e) {
1027 e.printStackTrace();
1032 * @see com.pentila.evalcomp.workflow.engine.IEngine#setEnvFile(java.lang.String)
1034 public void setEnvFile(String envFile) {
1035 this.envFile = envFile;
1039 * @see com.pentila.evalcomp.workflow.engine.IEngine#setWorkflowsdir(java.lang.String)
1041 public void setWorkflowsdir(String workflowsdir) {
1042 this.workflowsdir = workflowsdir;
1046 * @see com.pentila.evalcomp.workflow.engine.IEngine#setProcessInstanceVariables(java.lang.String, java.util.Map)
1048 public void setProcessInstanceVariables(final String processuuid,
1049 final Map<String, String> variablesValues) {
1050 final APIAccessor apiac = AccessorUtil.getAPIAccessor();
1051 final RuntimeAPI runtimeAPI = apiac.getRuntimeAPI();
1053 Command<Boolean> setPIVariable = new Command<Boolean>(){
1055 public Boolean execute(Environment arg0) throws Exception {
1057 for (Entry<String, String> e : variablesValues.entrySet()) {
1058 runtimeAPI.setProcessInstanceVariable(new ProcessInstanceUUID(
1059 processuuid), e.getKey(), e.getValue());
1067 execute(setPIVariable);
1072 * @see com.pentila.evalcomp.workflow.engine.IEngine#getProcessByActivityUUID(java.lang.String)
1074 public Process getProcessByActivityUUID(String activityUUID) {
1078 APIAccessor apiac = AccessorUtil.getAPIAccessor();
1080 QueryRuntimeAPI queryRuntimeAPI = apiac.getQueryRuntimeAPI();
1082 QueryDefinitionAPI qda = apiac.getQueryDefinitionAPI();
1084 ActivityInstance<ActivityBody> activity = queryRuntimeAPI
1085 .getActivityInstance(new ActivityInstanceUUID(""));
1087 ExtendProcessDefinition EPD = extDefinitions.get(activity
1088 .getPackageDefinitionUUID());
1090 String pi = activity.getProcessInstanceUUID().toString();
1091 Process pp = new Process();
1093 String SSIID = (String) queryRuntimeAPI.getProcessInstanceVariable(
1094 activity.getProcessInstanceUUID(), "SIID");
1097 String TYPE = (String) queryRuntimeAPI
1099 .getProcessInstanceVariable(activity.getProcessInstanceUUID(),
1103 } catch (Exception e) {
1104 pp.setType(ScenarioDefinition.EVALUATION);
1106 Long SIID = new Long(SSIID);
1110 String activityId = activity.getActivityId();
1112 Activity a = new Activity();
1113 a.setId(activityId);
1114 a.setUUID(activityUUID);
1117 a.setExtActivity(EPD.getExtActivityByActivityId(activityId));
1120 // Valiable d'activité
1121 Set<Property> setP = new HashSet<Property>();
1122 for ( Entry<String, Object> vv : activity.getLastKnownVariableValues().entrySet()){
1124 String key = vv.getKey();
1125 String value = (String) vv.getValue();
1127 logger.debug("Variable : " + key + " with value : " + value);
1128 if (key.startsWith(Property.VARIABLE)){
1130 Property p = new Property();
1140 a.setProperties(setP);
1142 ActivityDefinition ad;
1145 ad = qda.getProcessActivity(
1146 activity.getProcessDefinitionUUID(), activityId);
1148 a.setDescription(ad.getDescription());
1151 //Set les roles performers
1152 HashSet<String> performers = new HashSet<String>();
1153 performers.add(ad.getPerformer());
1155 a.setRoleNamePerformers(performers);
1157 // Set les transitions
1158 List<Transition> lt = getActivityTransition(ad);
1160 a.setTransitions(lt);
1161 pp.getActivities().add(a);
1163 // Set les variables de processus
1164 Set<Property> spp = getDefProperties(qda, activity
1165 .getProcessDefinitionUUID(), propertyTypesInstance);
1167 Map<String, Object> mapVars = queryRuntimeAPI
1168 .getProcessInstanceVariables(activity
1169 .getProcessInstanceUUID());
1171 for (Property p : spp) {
1172 if (mapVars.containsKey(p.getName())) {
1173 String v = (String) mapVars.get(p.getName());
1179 pp.setProperties(spp);
1181 } catch (ProcessNotFoundException e) {
1182 e.printStackTrace();
1183 } catch (ActivityNotFoundException e) {
1184 e.printStackTrace();
1185 } catch (InstanceNotFoundException e) {
1186 e.printStackTrace();
1191 } catch (ActivityNotFoundException e) {
1192 e.printStackTrace();
1193 } catch (InstanceNotFoundException e) {
1194 e.printStackTrace();
1195 } catch (VariableNotFoundException e) {
1196 e.printStackTrace();
1204 * @see com.pentila.evalcomp.workflow.engine.IEngine#getCandidates(java.lang.String)
1206 public Map<String, Map<String, Object>> getCandidates(String bonitaProcessId) {
1207 APIAccessor apiac = AccessorUtil.getAPIAccessor();
1209 QueryRuntimeAPI queryRuntimeAPI = apiac.getQueryRuntimeAPI();
1212 ProcessInstanceUUID PIUUID = new ProcessInstanceUUID(bonitaProcessId);
1214 InstanceUtil IU = new InstanceUtil();
1216 IU.applyContext(getProcess("", bonitaProcessId), null, null);
1219 Map<String, Map<String, Object>> activityUsers = new HashMap<String, Map<String, Object>>();
1221 for (ActivityInstance ai : queryRuntimeAPI.getActivityInstances(PIUUID)){
1222 if (ai.getBody().getState().equals(ActivityState.READY)){
1224 if (logger.isDebugEnabled()){
1227 logger.debug("getCandidates SIID : "+queryRuntimeAPI.getProcessInstanceVariable(PIUUID, "SIID"));
1228 } catch (VariableNotFoundException e) {
1230 e.printStackTrace();
1233 ExtendProcessDefinition EPD = extDefinitions.get(ai.getPackageDefinitionUUID());
1235 ActivityInstance<TaskInstance> t = ai;
1237 Map<String, Object> map = new HashMap<String, Object>();
1239 map.put("users", t.getBody().getTaskCandidates());
1240 map.put("extActivity", IU.switchLabel(EPD.getExtActivityByActivityId(ai.getActivityId())));
1241 activityUsers.put(ai.getActivityId(), map);
1245 } catch (InstanceNotFoundException e) {
1246 e.printStackTrace();
1248 return activityUsers;
1252 * @see com.pentila.evalcomp.workflow.engine.IEngine#testCoherence(java.lang.String, java.util.Set, java.lang.String)
1254 public boolean testCoherence(String id, Set<String> uids, String actId) {
1256 boolean ret = false;
1258 ProcessInstanceUUID processInstanceUUID = new ProcessInstanceUUID(id);
1259 APIAccessor apiac = AccessorUtil.getAPIAccessor();
1263 apiac.getQueryRuntimeAPI().getProcessInstance(
1264 processInstanceUUID);
1266 Set<ActivityInstance<TaskInstance>> b = apiac.getQueryRuntimeAPI().getTasks(processInstanceUUID);
1268 for (ActivityInstance<TaskInstance> z: b){
1270 if (z.getActivityId().equals(actId)){
1272 for (String uid : uids){
1273 if (!z.getBody().getTaskCandidates().contains(uid) && z.getBody().getState().equals(ActivityState.READY)){
1274 logger.info("Process id : " + id + " is wrong !");
1275 logger.info("ProcessTaskCandidates : " + z.getBody().getTaskCandidates());
1276 logger.info("EMa localroles : " + uids);
1284 } catch (InstanceNotFoundException e) {
1285 e.printStackTrace();
1291 * @see com.pentila.evalcomp.workflow.engine.IEngine#displayDB(java.lang.String)
1293 public void displayDB(String stateName){
1295 APIAccessor apiac = AccessorUtil.getAPIAccessor();
1296 QueryRuntimeAPI queryRuntimeAPI = apiac.getQueryRuntimeAPI();
1298 if (logger.isInfoEnabled()){
1301 Set<ProcessInstance> s = queryRuntimeAPI.getProcessInstances();
1302 for (ProcessInstance pii : s){
1304 logger.info("ProcessInstanceUUID : " + pii.getUUID());
1306 for (ActivityInstance<TaskInstance>a : queryRuntimeAPI.getTasks(pii.getProcessInstanceUUID())){
1308 TaskInstance ss = a.getBody();
1311 String users = "#nousers#";
1312 String nstate = "#missing#";
1313 String gouser = "#noGOUser#";
1321 nstate = ss.getState().name();
1325 if (stateName != null && !nstate.equals(stateName)){
1329 Set<String> sss = ss.getTaskCandidates();
1332 for (String uid : sss){
1333 users += uid + "\n";
1337 gouser = ss.getTaskUser();
1338 } catch(IllegalStateException e){
1339 logger.debug(e.getMessage());
1343 logger.info("ActivityID : " + a.getActivityId() +"\n" + "State : " + nstate + "\n" + "Users Candidates = " + users + "GO USER : " + gouser + "\nDate : " + ss.getCreatedDate() + "\nStart Date : "+ ss.getStartedDate() + "\nEnd Date : "+ss.getEndedDate()+"\n\n");
1346 for ( Entry<String, Object> vu : a.getLastKnownVariableValues().entrySet()){
1347 logger.info("Variable Name : " + vu.getKey()+ " value : " + vu.getValue());
1349 if (!vu.getValue().equals("--")){
1355 if (a.getLastKnownVariableValues().size() == 0){
1360 if (nstate.equals("FINISH") && !ok){
1361 logger.info("######################## ALARM !!!!! ");
1362 logger.info("A Activity is finish and not transaction left !!!");
1369 }catch(Exception e){
1370 e.printStackTrace();
1378 * Fix les Process dans l'etat EXECUTING
1382 * @see com.pentila.evalcomp.workflow.engine.IEngine#fixState()
1384 public void fixState(){
1387 APIAccessor apiac = AccessorUtil.getAPIAccessor();
1388 QueryRuntimeAPI queryRuntimeAPI = apiac.getQueryRuntimeAPI();
1389 final RuntimeAPI runtimeAPI = apiac.getRuntimeAPI();
1390 if (logger.isInfoEnabled()){
1393 Set<ProcessInstance> s = queryRuntimeAPI.getProcessInstances();
1394 for (ProcessInstance pii : s){
1396 for (ActivityInstance<TaskInstance> a : queryRuntimeAPI.getTasks(pii.getProcessInstanceUUID())){
1398 final TaskInstance ss = a.getBody();
1401 String users = "#nousers#";
1402 String nstate = "#missing#";
1403 String gouser = "#noGOUser#";
1409 nstate = ss.getState().name();
1411 if (!ss.getState().equals(ActivityState.EXECUTING)){
1412 logger.debug(ss.getUUID() + ": State was : " + ss.getState().name());
1416 logger.info("ProcessInstanceUUID : " + pii.getUUID());
1417 Set<String> sss = ss.getTaskCandidates();
1420 for (String uid : sss){
1421 Utils.fakeUser(uid);
1422 users += uid + "\n";
1427 gouser = ss.getTaskUser();
1428 } catch(IllegalStateException e){
1429 logger.info(e.getMessage());
1433 logger.info("ActivityID : " + a.getActivityId() +"\n" + "State : " + nstate + "\n" + "Users Candidates = " + users + "GO USER : " + gouser + "\n\n");
1436 for ( Entry<String, Object> vu : a.getLastKnownVariableValues().entrySet()){
1437 logger.info("Variable Name : " + vu.getKey()+ " value : " + vu.getValue());
1444 User u = Beans.getEntityManagerBean().getCurrentUser();
1446 logger.info("Fake logged user : " + u.getLastname() + " " + u.getFirstname());
1449 Command<Boolean> finishCommand = new Command<Boolean>(){
1453 public Boolean execute(Environment arg0)
1456 runtimeAPI.finishTask(ss.getUUID(), false);
1463 execute(finishCommand);
1470 }catch(Exception e){
1471 e.printStackTrace();
1485 * @see com.pentila.evalcomp.workflow.engine.IEngine#setActivitiesInstanceVariables(java.util.Map)
1487 public void setActivitiesInstanceVariables(
1488 final Map<String, Map<String, String>> vva) {
1490 final APIAccessor apiac = AccessorUtil.getAPIAccessor();
1491 final RuntimeAPI runtimeAPI = apiac.getRuntimeAPI();
1493 Command<Boolean> setPIVariable = new Command<Boolean>(){
1495 public Boolean execute(Environment arg0) throws Exception {
1496 for (Entry<String, Map<String, String>> act : vva.entrySet() ){
1498 String ActivityUUID = act.getKey();
1499 Map<String, String> p = act.getValue();
1500 for (Entry<String, String> f : p.entrySet()){
1502 String var_name = f.getKey();
1503 String var_value = f.getValue();
1505 runtimeAPI.setActivityInstanceVariable(new ActivityInstanceUUID(ActivityUUID), var_name, var_value);
1516 execute(setPIVariable);
1523 public void testProcesses() {
1527 logger.info("Starting with Process Test occurences .... ");
1529 APIAccessor apiac = AccessorUtil.getAPIAccessor();
1531 QueryRuntimeAPI q = apiac.getQueryRuntimeAPI();
1533 Map<String, Map<String, Integer>> count = new HashMap<String, Map<String, Integer>>();
1535 logger.info("Getting all processInstances : ");
1538 Set<ProcessInstance> spi = q.getProcessInstances();
1541 logger.info("Nb processInstances : " + spi.size());
1543 for (ProcessInstance pi : spi){
1546 Set<ActivityInstance<TaskInstance>> b;
1548 b = q.getTasks(pi.getProcessInstanceUUID());
1551 //logger.info("Nb Tasks : " + b.size());
1553 for (ActivityInstance<TaskInstance> z: b){
1555 if (z != null && z.getBody() != null && z.getBody().getTaskCandidates() != null){
1558 if (!z.getBody().getState().equals(ActivityState.READY)){
1562 for (String uid : z.getBody().getTaskCandidates()){
1563 if (!count.containsKey(uid)){
1564 count.put(uid, new HashMap<String, Integer>());
1569 if (!count.get(uid).containsKey(z.getActivityId())){
1570 count.get(uid).put(z.getActivityId(), 0);
1575 count.get(uid).put(z.getActivityId(), count.get(uid).get(z.getActivityId()) + 1 );
1580 logger.info("Something is NULL");
1581 logger.info("is z : " + z );
1583 logger.info("is get Body " + z.getBody());
1584 if (z.getBody() != null){
1585 logger.info("is get TaskCandiat " + z.getBody().getTaskCandidates());
1586 logger.info("is get TaskCandiat " + z.getBody().getTaskCandidates());
1601 for (Entry<String, Map<String, Integer>> zz : count.entrySet()){
1603 String uid = zz.getKey();
1605 logger.info("User : " + uid);
1607 Map<String, Integer> mm = zz.getValue();
1610 if ((mm.containsKey("vaepp_editer") || mm.containsKey("vaepp_prevenir")) && !mm.containsKey("vaepp_creer")){
1611 logger.info("User has NOT vaepp_creer !!!!");
1613 //logger.info("vaepp_creer : " + mm.get("vaepp_creer"));
1616 for (Entry<String, Integer> pp : mm.entrySet()){
1617 String actId = pp.getKey();
1618 Integer i = pp.getValue();
1620 logger.info(" # Activity ID : " + actId + " => " + i);
1628 } catch (InstanceNotFoundException e) {
1629 // TODO Auto-generated catch block
1630 e.printStackTrace();
1643 public APIAccessor getAPI(){
1644 return AccessorUtil.getAPIAccessor();
1648 * @see com.pentila.evalcomp.workflow.engine.IEngine#getProcess(java.lang.String, java.lang.String)
1650 public Process getProcess(String login, String processuuid) {
1653 if (logger.isDebugEnabled()){
1654 logger.debug("Enter in getProcess Method" );
1655 logger.debug("ProcessUUID : " + processuuid);
1657 APIAccessor apiac = AccessorUtil.getAPIAccessor();
1658 QueryRuntimeAPI queryRuntimeAPI = apiac.getQueryRuntimeAPI();
1660 QueryDefinitionAPI qda = apiac.getQueryDefinitionAPI();
1662 ProcessInstanceUUID piu = new ProcessInstanceUUID(processuuid);
1666 final Collection<ActivityInstance<TaskInstance>> activities = queryRuntimeAPI
1671 if(!activities.isEmpty()){
1674 if (logger.isDebugEnabled()){
1675 logger.debug("Activity Collection is Empty");
1679 for (ActivityInstance<TaskInstance> activity : activities) {
1680 if (logger.isDebugEnabled()){
1682 logger.debug("getProcesses for " + login + " : " + activity.toString() + "( " + activity.getBody().getState()+") ");
1685 if (!activity.getBody().getState().equals(ActivityState.READY)){
1689 ExtendProcessDefinition EPD = extDefinitions.get(activity
1690 .getPackageDefinitionUUID());
1692 String SSIID = (String) queryRuntimeAPI
1693 .getProcessInstanceVariable(activity
1694 .getProcessInstanceUUID(), "SIID");
1698 String TYPE = (String) queryRuntimeAPI
1700 .getProcessInstanceVariable(activity
1701 .getProcessInstanceUUID(), "TYPE");
1704 } catch (Exception e) {
1705 pp.setType(ScenarioDefinition.EVALUATION);
1707 Long SIID = new Long(SSIID);
1711 String activityUUID = activity.getUUID().toString();
1713 String activityId = activity.getActivityId();
1715 Activity a = new Activity();
1716 a.setId(activityId);
1717 a.setUUID(activityUUID);
1719 a.setTaskCandidates(activity.getBody().getTaskCandidates());
1720 }catch (Exception e){
1721 //e.printStackTrace();
1726 .getExtActivityByActivityId(activityId));
1729 // Valiable d'activité
1730 Set<Property> setP = new HashSet<Property>();
1731 for ( Entry<String, Object> vv : activity.getLastKnownVariableValues().entrySet()){
1733 String key = vv.getKey();
1734 String value = (String) vv.getValue();
1736 logger.debug("Variable : " + key + " with value : " + value);
1737 if (key.startsWith(Property.VARIABLE)){
1739 Property p = new Property();
1749 a.setProperties(setP);
1751 // Activity Definition
1752 ActivityDefinition ad;
1755 ad = qda.getProcessActivity(activity
1756 .getProcessDefinitionUUID(), activityId);
1758 a.setDescription(ad.getDescription());
1760 HashSet<String> performers = new HashSet<String>();
1761 performers.add(ad.getPerformer());
1763 a.setRoleNamePerformers(performers);
1765 List<Transition> lt = getActivityTransition(ad);
1767 a.setTransitions(lt);
1768 pp.getActivities().add(a);
1770 Set<Property> spp = getDefProperties(qda, activity
1771 .getProcessDefinitionUUID(), propertyTypesInstance);
1773 Map<String, Object> mapVars = queryRuntimeAPI
1774 .getProcessInstanceVariables(activity
1775 .getProcessInstanceUUID());
1777 for (Property p : spp) {
1778 if (mapVars.containsKey(p.getName())) {
1779 String v = (String) mapVars.get(p.getName());
1785 pp.setProperties(spp);
1787 } catch (ProcessNotFoundException e) {
1789 e.printStackTrace();
1791 } catch (ActivityNotFoundException e) {
1793 e.printStackTrace();
1797 } catch (InstanceNotFoundException e) {
1799 e.printStackTrace();
1800 } catch (VariableNotFoundException e) {
1802 e.printStackTrace();