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;
    });

}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private WorkflowService makeWorkflowService()
{
    WorkflowService service = mock(WorkflowService.class);
    when(service.getDefinitionByName(WF_DEF_NAME)).thenReturn(definition);
    
    String instanceId = "foo$instanceId";
    newInstance = new WorkflowInstance(instanceId,
                definition, null, null, null,
                null, true, null, null);
    WorkflowTask startTask = new WorkflowTask("foo$taskId", null, null, null, null, null, null, null);
    String pathId = "foo$pathId";
    final WorkflowPath path = new WorkflowPath(pathId, newInstance, null, true);
    
    when(service.startWorkflow(eq(definition.getId()), anyMap()))
        .thenAnswer(new Answer<WorkflowPath>()
        {
            public WorkflowPath answer(InvocationOnMock invocation) throws Throwable
            {
                Object[] arguments = invocation.getArguments();
                actualProperties = (Map<QName, Serializable>) arguments[1];
                return path;
            }
        });
    when(service.getTasksForWorkflowPath(path.getId()))
        .thenReturn(Collections.singletonList(startTask));
    when(service.createPackage(null)).thenReturn(PCKG_NODE);
    return service;
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
/**
* {@inheritDoc}
*/
@SuppressWarnings("deprecation")
@Override
protected void onSetUpInTransaction() throws Exception
{
    super.onSetUpInTransaction();
    this.workflowService = (WorkflowService) applicationContext.getBean("WorkflowService");
    
    // Enable Activiti
    workflowAdminService.setEnabledEngines(Arrays.asList(ActivitiConstants.ENGINE_ID));
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
@BeforeClass public static void initStaticData() throws Exception
{
    INVITATION_SERVICE = APP_CONTEXT_INIT.getApplicationContext().getBean("InvitationService", InvitationService.class);
    SITE_SERVICE       = APP_CONTEXT_INIT.getApplicationContext().getBean("SiteService", SiteService.class);
    TRANSACTION_HELPER = APP_CONTEXT_INIT.getApplicationContext().getBean("retryingTransactionHelper", RetryingTransactionHelper.class);
    WORKFLOW_SERVICE   = APP_CONTEXT_INIT.getApplicationContext().getBean("WorkflowService", WorkflowService.class);
    NODE_ARCHIVE_SERVICE = APP_CONTEXT_INIT.getApplicationContext().getBean("nodeArchiveService", NodeArchiveService.class);
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
@Before
public void before()
{
    this.actionService = (ActionService)ctx.getBean("actionService");
    this.ruleService = (RuleService)ctx.getBean("ruleService");
	this.fileFolderService = (FileFolderService)ctx.getBean("FileFolderService");
	this.transactionService = (TransactionService)ctx.getBean("transactionService");
	this.nodeService = (NodeService)ctx.getBean("NodeService");
	this.contentService = (ContentService)ctx.getBean("ContentService");
    this.versionService = (VersionService) ctx.getBean("versionService");
    this.lockService = (LockService) ctx.getBean("lockService");
    this.taggingService = (TaggingService) ctx.getBean("TaggingService");
    this.namespaceService = (NamespaceService) ctx.getBean("namespaceService");
    this.repositoryHelper = (Repository)ctx.getBean("repositoryHelper");
	this.factory = (AlfrescoCmisServiceFactory)ctx.getBean("CMISServiceFactory");
    this.versionService = (VersionService) ctx.getBean("versionService");
	this.cmisConnector = (CMISConnector) ctx.getBean("CMISConnector");
    this.nodeDAO = (NodeDAO) ctx.getBean("nodeDAO");
    this.authorityService = (AuthorityService)ctx.getBean("AuthorityService");
    this.auditSubsystem = (AuditModelRegistryImpl) ctx.getBean("Audit");
    this.permissionService = (PermissionService) ctx.getBean("permissionService");
	this.dictionaryDAO = (DictionaryDAO)ctx.getBean("dictionaryDAO");
	this.cmisDictionaryService = (CMISDictionaryService)ctx.getBean("OpenCMISDictionaryService1.1");
    this.auditDAO = (AuditDAO) ctx.getBean("auditDAO");
    this.nodeArchiveService = (NodeArchiveService) ctx.getBean("nodeArchiveService");
    this.dictionaryService = (DictionaryService) ctx.getBean("dictionaryService");
    this.workflowService = (WorkflowService) ctx.getBean("WorkflowService");
    this.workflowAdminService = (WorkflowAdminService) ctx.getBean("workflowAdminService");
    this.authenticationContext = (AuthenticationContext) ctx.getBean("authenticationContext");
    this.tenantAdminService = (TenantAdminService) ctx.getBean("tenantAdminService");
    this.tenantService = (TenantService) ctx.getBean("tenantService");
    this.searchService = (SearchService) ctx.getBean("SearchService");
    this.auditComponent = (AuditComponentImpl) ctx.getBean("auditComponent");

    this.globalProperties = (java.util.Properties) ctx.getBean("global-properties");
    this.globalProperties.setProperty(VersionableAspectTest.AUTO_VERSION_PROPS_KEY, "true");
}
 

import org.alfresco.service.cmr.workflow.WorkflowService; //导入依赖的package包/类
public WorkflowModelBuilder(NamespaceService namespaceService, NodeService nodeService, 
            AuthenticationService authenticationService, PersonService personService, 
            WorkflowService workflowService, DictionaryService dictionaryService)
{
    this.nodeService = nodeService;
    this.personService = personService;
    this.workflowService = workflowService;
    this.authenticationService = authenticationService;
    this.qNameConverter = new WorkflowQNameConverter(namespaceService);
    this.dictionaryService = dictionaryService;
}