Returns the WorkTransitionVO
@param pWorkTransId
@returb WorkTransitionVO
187010
public Transition getWorkTransitionVO(Long pWorkTransId) {
         if(this.transitions == null){
            return null;
        }
        for(int i=0; i<transitions.size(); i++){
            if(pWorkTransId.longValue() == transitions.get(i).getId().longValue()){
                return transitions.get(i);
            }
        }
        return null;

    }
652483
public void resumeWorkflow(String workflowId) {
        Preconditions.checkArgument(StringUtils.isNotBlank(workflowId), "workflow id cannot be blank");
        stub.resumeWorkflow(WorkflowServicePb.ResumeWorkflowRequest.newBuilder()
                .setWorkflowId(workflowId)
                .build()
        );
    }
942194
public synchronized void removeWorkManager(String id)
   {
      if (id == null || id.trim().equals(""))
         throw new IllegalArgumentException("The id of WorkManager is invalid: " + id);

      Integer i = refCountWorkmanagers.get(id);
      if (i != null)
      {
         int newValue = i.intValue() - 1;
         if (newValue == 0)
         {
            if (trace)
               log.tracef("Removed WorkManager: %s", id);

            WorkManager wm = activeWorkmanagers.get(id);
            if (wm instanceof DistributedWorkManager)
            {
               DistributedWorkManager dwm = (DistributedWorkManager)wm;
               if (dwm.getTransport() != null)
                  dwm.getTransport().unregister(new Address(wm.getId(), wm.getName(), dwm.getTransport().getId()));
            }

            activeWorkmanagers.remove(id);
            refCountWorkmanagers.remove(id);
         }
         else
         {
            if (trace)
               log.tracef("DerefCount WorkManager: %s", id);

            refCountWorkmanagers.put(id, Integer.valueOf(newValue));
         }
      }
   }
1121874
@Service
    public Workflow getExecutionStatus(String workflowId, boolean includeTasks) {
        Workflow workflow = executionService.getExecutionStatus(workflowId, includeTasks);
        if (workflow == null) {
            throw new ApplicationException(ApplicationException.Code.NOT_FOUND,
                    String.format("Workflow with Id: %s not found.", workflowId));
        }
        return workflow;
    }
612388
public Map<Integer, ResourceWorkerSlot> getTaskToNodePortbyNode(String supervisorId) {
        Map<Integer, ResourceWorkerSlot> result = new HashMap<>();
        for (ResourceWorkerSlot worker : workers) {
            if (worker.getNodeId().equals(supervisorId)) {
                result.put(worker.getPort(), worker);
            }
        }
        return result;
    }
497420
public Workflow getWorkflow(String workflowId, boolean includeTasks) {
        Preconditions.checkArgument(StringUtils.isNotBlank(workflowId), "workflow id cannot be blank");
        Workflow workflow = getForEntity("workflow/{workflowId}", new Object[]{"includeTasks", includeTasks}, Workflow.class, workflowId);
        populateWorkflowOutput(workflow);
        return workflow;
    }
181800
public OvhFidelityMovement fidelityAccount_movements_movementId_GET(Long movementId) throws IOException {
		String qPath = "/me/fidelityAccount/movements/{movementId}";
		StringBuilder sb = path(qPath, movementId);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhFidelityMovement.class);
	}
880709
public Transition getTransition(Long fromId, Integer eventType, String completionCode) {
        Transition ret = null;
        for (Transition transition : getTransitions()) {
            if (transition.getFromId().equals(fromId)
                    && transition.match(eventType, completionCode)) {
                if (ret == null) ret = transition;
                else {
                    throw new IllegalStateException("Multiple matching work transitions when one expected:\n"
                            + " processId: " + getId() + " fromId: " + fromId + " eventType: "
                            + eventType + "compCode: " + completionCode);
                }
            }
        }
        return ret;
    }
708412
public void completeTransfer(String connId, String parentConnId) throws WorkspaceApiException {
        this.completeTransfer(connId, parentConnId, null, null);
    }
1205927
public void pauseWorkflow(String workflowId) {
        Preconditions.checkArgument(StringUtils.isNotBlank(workflowId), "workflow id cannot be blank");
        stub.pauseWorkflow(WorkflowServicePb.PauseWorkflowRequest.newBuilder()
                .setWorkflowId(workflowId)
                .build()
        );
    }
317486
private FadeTransition getSlideLabelTransition(final Duration gap) {
        return FadeTransitionBuilder.create()
                                    .node(this.slideLabel)
                                    .delay(gap)
                                    .duration(Duration.millis(1200))
                                    .fromValue(0).toValue(1)
                                    .build();
    }
1057016
public boolean isWorkActivity(Long pWorkId) {

        if(this.activities == null){
            return false;
        }
        for(int i=0; i<activities.size(); i++){
            if(pWorkId.longValue() == activities.get(i).getId().longValue()){
                return true;
            }
        }
        return false;
    }
706512
public String rerunWorkflow(String workflowId, RerunWorkflowRequest rerunWorkflowRequest) {
        Preconditions.checkArgument(StringUtils.isNotBlank(workflowId), "workflow id cannot be blank");
        Preconditions.checkNotNull(rerunWorkflowRequest, "RerunWorkflowRequest cannot be null");

        return postForEntity("workflow/{workflowId}/rerun", rerunWorkflowRequest, null, String.class, workflowId);
    }
465490
private static TransitionType getTransitionType(String groupIn, Collection<String> neighborGroups)
    {
        final boolean[] bits = new boolean[TransitionType.BITS];
        int i = 0;
        for (final String neighborGroup : neighborGroups)
        {
            bits[i] = !groupIn.equals(neighborGroup);
            i++;
        }
        return TransitionType.from(bits);
    }
14564
public void deleteWorkflow(String workflowId, boolean archiveWorkflow) {
        Preconditions.checkArgument(StringUtils.isNotBlank(workflowId), "Workflow id cannot be blank");

        Object[] params = new Object[]{"archiveWorkflow", archiveWorkflow};
        delete(params, "workflow/{workflowId}/remove", workflowId);
    }
791384
public Transition getTransition(Long id) {
        for (Transition transition : getTransitions()) {
            if (transition.getId().equals(id))
                return transition;
        }
        return null; // not found
    }
697568
public void singleStepTransfer(String connId, String destination) throws WorkspaceApiException {
        this.singleStepTransfer(connId, destination, null, null, null, null);
    }