Java WorkflowService类代码示例

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
public TaskFormPersister(ContentModelItemData<WorkflowTask> itemData,
            NamespaceService namespaceService,
            DictionaryService dictionaryService,
            WorkflowService workflowService,
            NodeService nodeService,
            AuthenticationService authenticationService,
            BehaviourFilter behaviourFilter, Log logger)
{
    super(itemData, namespaceService, dictionaryService, logger);
    WorkflowTask item = itemData.getItem();

    // make sure that the task is not already completed
    if (item.getState().equals(WorkflowTaskState.COMPLETED))
    {
        throw new AlfrescoRuntimeException("workflowtask.already.done.error");
    }

    // make sure the current user is able to edit the task
    if (!workflowService.isTaskEditable(item, authenticationService.getCurrentUserName()))
    {
        throw new AccessDeniedException("Failed to update task with id '" + item.getId() + "'.");
    }
    
    this.updater = new TaskUpdater(item.getId(), workflowService, nodeService, behaviourFilter);
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
/**
 * Get all paths for the specified workflow instance
 */
public Scriptable getPaths()
{
	WorkflowService workflowService = serviceRegistry.getWorkflowService();
	
	List<WorkflowPath> cmrPaths = workflowService.getWorkflowPaths(this.id);
	ArrayList<Serializable> paths = new ArrayList<Serializable>();
	for (WorkflowPath cmrPath : cmrPaths)
	{
		paths.add(new JscriptWorkflowPath(cmrPath, this.serviceRegistry, this.scope));
	}
	
	Scriptable pathsScriptable =
		(Scriptable)new ValueConverter().convertValueForScript(this.serviceRegistry, this.scope, null, paths);
	
	return pathsScriptable;
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
/**
 * Get all tasks associated with this workflow path
 * 
 * @return all the tasks associated with this workflow path instance
 */
public Scriptable getTasks()
{
	WorkflowService workflowService = serviceRegistry.getWorkflowService();
	
	List<WorkflowTask> cmrTasks = workflowService.getTasksForWorkflowPath(id);
	ArrayList<Serializable> tasks = new ArrayList<Serializable>();
	for (WorkflowTask cmrTask : cmrTasks)
	{
		tasks.add(new JscriptWorkflowTask(cmrTask, this.serviceRegistry, this.scope));
	}
	
	Scriptable tasksScriptable =
		(Scriptable)new ValueConverter().convertValueForScript(this.serviceRegistry, scope, null, tasks);
	
	return tasksScriptable;
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
/**
 * Get active workflow instances of this workflow definition
 * 
 * @return the active workflow instances spawned from this workflow definition
 */
public synchronized Scriptable getActiveInstances()
{
	WorkflowService workflowService = this.serviceRegistry.getWorkflowService();
	
	List<WorkflowInstance> cmrWorkflowInstances = workflowService.getActiveWorkflows(this.id);
	ArrayList<Serializable> activeInstances = new ArrayList<Serializable>();
	for (WorkflowInstance cmrWorkflowInstance : cmrWorkflowInstances)
	{
		activeInstances.add(new JscriptWorkflowInstance(cmrWorkflowInstance, this.serviceRegistry, this.scope));
	}
	
	Scriptable activeInstancesScriptable =
		(Scriptable)getValueConverter().convertValueForScript(this.serviceRegistry, this.scope, null, activeInstances);
	
	return activeInstancesScriptable;
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
/**
 * Get active workflow instances this node belongs to
 * 
 * @return the active workflow instances this node belongs to
 */
public Scriptable getActiveWorkflows()
{
    if (this.activeWorkflows == null)
    {
        WorkflowService workflowService = this.services.getWorkflowService();
        
        List<WorkflowInstance> workflowInstances = workflowService.getWorkflowsForContent(this.nodeRef, true);
        Object[] jsWorkflowInstances = new Object[workflowInstances.size()];
        int index = 0;
        for (WorkflowInstance workflowInstance : workflowInstances)
        {
            jsWorkflowInstances[index++] = new JscriptWorkflowInstance(workflowInstance, this.services, this.scope);
        }
        this.activeWorkflows = Context.getCurrentContext().newArray(this.scope, jsWorkflowInstances);		
    }

    return this.activeWorkflows;
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
protected void doGet(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException
   {
       // retrieve workflow definition id
       String uri = request.getRequestURI();
       uri = uri.substring(request.getContextPath().length());
       StringTokenizer t = new StringTokenizer(uri, "/");
       if (t.countTokens() != 2)
       {
           throw new WorkflowException("Workflow Definition Image servlet does not contain workflow definition id : " + uri); 
       }
       t.nextToken();  // skip servlet name
       String workflowDefinitionId = t.nextToken();

       // retrieve workflow definition image
       WebApplicationContext wc = WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());
       WorkflowService workflowService = (WorkflowService)wc.getBean(ServiceRegistry.WORKFLOW_SERVICE.getLocalName());
       byte[] definitionImage = workflowService.getDefinitionImage(workflowDefinitionId); 
       
       // stream out through response
       OutputStream out = response.getOutputStream();
       out.write(definitionImage);
       out.flush();
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public void encodeBegin(FacesContext context) throws IOException
{
   if (!isRendered()) return;
   
   // get the node to display the information for
   Node node = getValue();
   
   if (node != null)
   {
      // get the services we need
      NodeService nodeService = Repository.getServiceRegistry(context).getNodeService();
      DictionaryService ddService = Repository.getServiceRegistry(context).getDictionaryService();
      WorkflowService workflowService = Repository.getServiceRegistry(context).getWorkflowService();
      ResponseWriter out = context.getResponseWriter();
      ResourceBundle bundle = Application.getBundle(context);
      
      // render simple workflow info
      renderSimpleWorkflowInfo(context, node, nodeService, ddService, out, bundle);
      
      // render advanced workflow info
      renderAdvancedWorkflowInfo(context, node, nodeService, ddService, workflowService, out, bundle);
   }
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
public WorkflowFormPersister(ContentModelItemData<?> itemData,
            NamespaceService namespaceService,
            DictionaryService dictionaryService,
            WorkflowService workflowService,
            NodeService nodeService,
            BehaviourFilter behaviourFilter, Log logger)
{
    super(itemData, namespaceService, dictionaryService, logger);
    WorkflowDefinition definition = (WorkflowDefinition) itemData.getItem();
    this.builder = new WorkflowBuilder(definition, workflowService, nodeService, behaviourFilter);
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
public TaskFormProcessor(WorkflowService workflowService, NamespaceService namespaceService,
        DictionaryService dictionaryService, AuthenticationService authenticationService,
        PersonService personService, FieldProcessorRegistry fieldProcessorRegistry)
{
    this.workflowService = workflowService;
    this.namespaceService = namespaceService;
    this.dictionaryService = dictionaryService;
    this.authenticationService = authenticationService;
    this.personService = personService;
    this.fieldProcessorRegistry = fieldProcessorRegistry;
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
public TaskUpdater(String taskId,
            WorkflowService workflowService,
            NodeService nodeService,
            BehaviourFilter behaviourFilter)
{
    this.taskId = taskId;
    this.workflowService = workflowService;
    this.packageMgr = new PackageManager(workflowService, nodeService, behaviourFilter, LOGGER);
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
/**
 * Get tasks assigned to the current user, filtered by workflow task state.
 * Only tasks having the specified state will be returned.
 * 
 * @param state  workflow task state to filter assigned tasks by
 * @return  the list of assigned tasks, filtered by state
 */
private Scriptable getAssignedTasksByState(WorkflowTaskState state)
{
    WorkflowService workflowService = services.getWorkflowService();
    String currentUser = services.getAuthenticationService().getCurrentUserName();
    List<WorkflowTask> cmrAssignedTasks = workflowService.getAssignedTasks(currentUser, state);
    ArrayList<Serializable> assignedTasks = new ArrayList<Serializable>();
    for (WorkflowTask cmrTask : cmrAssignedTasks)
    {
        assignedTasks.add(new JscriptWorkflowTask(cmrTask, services, getScope()));
    }
    return (Scriptable)new ValueConverter().convertValueForScript(services, getScope(), null, assignedTasks);
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
/**
 * Start workflow instance from workflow definition
 * 
 * @param workflowPackage workflow package node to 'attach' to the new workflow
 * 		instance
 * @param properties Associative array of properties used to populate the 
 * 		start task properties
 * @return the initial workflow path
 */
@SuppressWarnings("unchecked")
public JscriptWorkflowPath startWorkflow(ScriptNode workflowPackage,
	Object properties)
{
	WorkflowService workflowService = this.serviceRegistry.getWorkflowService();
	
	// if properties object is a scriptable object, then extract property name/value pairs
	// into property Map<QName, Serializable>, otherwise leave property map as null
	Map<QName, Serializable> workflowParameters = null;
       if (properties instanceof ScriptableObject)
       {
           ScriptableObject scriptableProps = (ScriptableObject)properties;
           workflowParameters = new HashMap<QName, Serializable>(scriptableProps.getIds().length);
           extractScriptablePropertiesToMap(scriptableProps, workflowParameters);
       }
	
	// attach given workflow package node if it is not null
       if (workflowPackage != null)
       {
           if (workflowParameters == null)
           {
               workflowParameters = new HashMap<QName, Serializable>(1);
           }
           workflowParameters.put(WorkflowModel.ASSOC_PACKAGE, getValueConverter().convertValueForRepo(workflowPackage));
       }        

       // provide a default context, if one is not specified
       Serializable context = workflowParameters.get(WorkflowModel.PROP_CONTEXT);
       if (context == null)
       {
           workflowParameters.put(WorkflowModel.PROP_CONTEXT, workflowPackage.getNodeRef());
       }

	WorkflowPath cmrWorkflowPath = workflowService.startWorkflow(this.id, workflowParameters);
	
	return new JscriptWorkflowPath(cmrWorkflowPath, this.serviceRegistry, this.scope);
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
public PackageManager(WorkflowService workflowService,
            NodeService nodeService,
            BehaviourFilter behaviourFilter,
            Log logger)
{
    this.workflowService = workflowService;
    this.nodeService = nodeService;
    this.behaviourFilter =behaviourFilter;
    this.logger = logger ==null ? LOGGER : logger;
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
public WorkflowBuilder(WorkflowDefinition definition,
            WorkflowService workflowService,
            NodeService nodeService,
            BehaviourFilter behaviourFilter)
{
    this.workflowService = workflowService;
    this.packageMgr = new PackageManager(workflowService, nodeService, behaviourFilter, null);
    this.definition = definition;
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
@BeforeClass
public static void initStaticData() throws Exception
{
    resetPasswordService = APP_CONTEXT_INIT.getApplicationContext().getBean("resetPasswordService", ResetPasswordServiceImpl.class);
    resetPasswordService.setSendEmailAsynchronously(false);
    resetPasswordService.setDefaultEmailSender(DEFAULT_SENDER);
    authenticationService = APP_CONTEXT_INIT.getApplicationContext().getBean("authenticationService", MutableAuthenticationService.class);
    transactionHelper = APP_CONTEXT_INIT.getApplicationContext().getBean("retryingTransactionHelper", RetryingTransactionHelper.class);
    personService = APP_CONTEXT_INIT.getApplicationContext().getBean("personService", PersonService.class);
    globalProperties = APP_CONTEXT_INIT.getApplicationContext().getBean("global-properties", Properties.class);
    workflowService = APP_CONTEXT_INIT.getApplicationContext().getBean("WorkflowService", WorkflowService.class);
    emailUtil = new EmailUtil(APP_CONTEXT_INIT.getApplicationContext());
    emailUtil.reset();

    String userName = "jane.doe" + System.currentTimeMillis();
    testPerson = new TestPerson()
                .setUserName(userName)
                .setFirstName("Jane")
                .setLastName("doe")
                .setPassword("password")
                .setEmail(userName + "@example.com");

    transactionHelper.doInTransaction((RetryingTransactionCallback<Void>) () ->
    {
        createUser(testPerson);
        return null;
    });

}