import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
/**
 * Parses the generic information of an activity element (id, name,
 * documentation, etc.), and creates a new {@link ActivityImpl} on the given
 * scope element.
 */
public ActivityImpl createActivityOnScope(Element activityElement, ScopeImpl scopeElement) {
  String id = activityElement.attribute("id");

  LOG.parsingElement("activity", id);
  ActivityImpl activity = scopeElement.createActivity(id);

  activity.setProperty("name", activityElement.attribute("name"));
  activity.setProperty("documentation", parseDocumentation(activityElement));
  activity.setProperty("default", activityElement.attribute("default"));
  activity.getProperties().set(BpmnProperties.TYPE, activityElement.getTagName());
  activity.setProperty("line", activityElement.getLine());
  setActivityAsyncDelegates(activity);
  activity.setProperty(PROPERTYNAME_JOB_PRIORITY, parsePriority(activityElement, PROPERTYNAME_JOB_PRIORITY));

  if (isCompensationHandler(activityElement)) {
    activity.setProperty(PROPERTYNAME_IS_FOR_COMPENSATION, true);
  }

  return activity;
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
protected void validateFieldDeclarationsForShell(Element serviceTaskElement, List<FieldDeclaration> fieldDeclarations) {
  boolean shellCommandDefined = false;

  for (FieldDeclaration fieldDeclaration : fieldDeclarations) {
    String fieldName = fieldDeclaration.getName();
    FixedValue fieldFixedValue = (FixedValue) fieldDeclaration.getValue();
    String fieldValue = fieldFixedValue.getExpressionText();

    shellCommandDefined |= fieldName.equals("command");

    if ((fieldName.equals("wait") || fieldName.equals("redirectError") || fieldName.equals("cleanEnv")) && !fieldValue.toLowerCase().equals(TRUE)
        && !fieldValue.toLowerCase().equals("false")) {
      addError("undefined value for shell " + fieldName + " parameter :" + fieldValue.toString(), serviceTaskElement);
    }

  }

  if (!shellCommandDefined) {
    addError("No shell command is defined on the shell activity", serviceTaskElement);
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
protected ParameterValueProvider parsePriority(Element element, String priorityAttribute) {
  String priorityAttributeValue = element.attributeNS(CAMUNDA_BPMN_EXTENSIONS_NS, priorityAttribute);

  if (priorityAttributeValue == null) {
    return null;

  } else {
    Object value = priorityAttributeValue;
    if (!StringUtil.isExpression(priorityAttributeValue)) {
      // constant values must be valid integers
      try {
        value = Integer.parseInt(priorityAttributeValue);

      } catch (NumberFormatException e) {
        addError("Value '" + priorityAttributeValue + "' for attribute '" + priorityAttribute + "' is not a valid number", element);
      }
    }

    return createParameterValueProvider(value, expressionManager);
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
protected void validateFieldDeclarationsForEmail(Element serviceTaskElement, List<FieldDeclaration> fieldDeclarations) {
  boolean toDefined = false;
  boolean textOrHtmlDefined = false;
  for (FieldDeclaration fieldDeclaration : fieldDeclarations) {
    if (fieldDeclaration.getName().equals("to")) {
      toDefined = true;
    }
    if (fieldDeclaration.getName().equals("html")) {
      textOrHtmlDefined = true;
    }
    if (fieldDeclaration.getName().equals("text")) {
      textOrHtmlDefined = true;
    }
  }

  if (!toDefined) {
    addError("No recipient is defined on the mail activity", serviceTaskElement);
  }
  if (!textOrHtmlDefined) {
    addError("Text or html field should be provided", serviceTaskElement);
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
protected void parseCompensationEventSubprocess(ActivityImpl startEventActivity, Element startEventElement, ActivityImpl scopeActivity, Element compensateEventDefinition) {
  startEventActivity.getProperties().set(BpmnProperties.TYPE, ActivityTypes.START_EVENT_COMPENSATION);
  scopeActivity.setProperty(PROPERTYNAME_IS_FOR_COMPENSATION, Boolean.TRUE);

  if (scopeActivity.getFlowScope() instanceof ProcessDefinitionEntity) {
    addError("event subprocess with compensation start event is only supported for embedded subprocess "
        + "(since throwing compensation through a call activity-induced process hierarchy is not supported)", startEventElement);
  }

  ScopeImpl subprocess = scopeActivity.getFlowScope();
  ActivityImpl compensationHandler = ((ActivityImpl) subprocess).findCompensationHandler();
  if (compensationHandler == null) {
    // add property to subprocess
    subprocess.setProperty(PROPERTYNAME_COMPENSATION_HANDLER_ID, scopeActivity.getActivityId());
  } else {

    if (compensationHandler.isSubProcessScope()) {
      addError("multiple event subprocesses with compensation start event are not supported on the same scope", startEventElement);
    } else {
      addError("compensation boundary event and event subprocess with compensation start event are not supported on the same scope", startEventElement);
    }
  }

  validateCatchCompensateEventDefinition(compensateEventDefinition);
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
protected void parsePotentialOwnerResourceAssignment(Element performerElement, TaskDefinition taskDefinition) {
  Element raeElement = performerElement.element(RESOURCE_ASSIGNMENT_EXPR);
  if (raeElement != null) {
    Element feElement = raeElement.element(FORMAL_EXPRESSION);
    if (feElement != null) {
      List<String> assignmentExpressions = parseCommaSeparatedList(feElement.getText());
      for (String assignmentExpression : assignmentExpressions) {
        assignmentExpression = assignmentExpression.trim();
        if (assignmentExpression.startsWith(USER_PREFIX)) {
          String userAssignementId = getAssignmentId(assignmentExpression, USER_PREFIX);
          taskDefinition.addCandidateUserIdExpression(expressionManager.createExpression(userAssignementId));
        } else if (assignmentExpression.startsWith(GROUP_PREFIX)) {
          String groupAssignementId = getAssignmentId(assignmentExpression, GROUP_PREFIX);
          taskDefinition.addCandidateGroupIdExpression(expressionManager.createExpression(groupAssignementId));
        } else { // default: given string is a goupId, as-is.
          taskDefinition.addCandidateGroupIdExpression(expressionManager.createExpression(assignmentExpression));
        }
      }
    }
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
protected ActivityImpl parseTransaction(Element transactionElement, ScopeImpl scope) {
  ActivityImpl activity = createActivityOnScope(transactionElement, scope);

  parseAsynchronousContinuationForActivity(transactionElement, activity);

  activity.setScope(true);
  activity.setSubProcessScope(true);
  activity.setActivityBehavior(new SubProcessActivityBehavior());
  activity.getProperties().set(BpmnProperties.TRIGGERED_BY_EVENT, false);
  parseScope(transactionElement, activity);

  for (BpmnParseListener parseListener : parseListeners) {
    parseListener.parseTransaction(transactionElement, scope, activity);
  }
  return activity;
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
/**
 * Returns a {@link ScriptTaskActivityBehavior} for the script task element
 * corresponding to the script source or resource specified.
 *
 * @param scriptTaskElement
 *          the script task element
 * @return the corresponding {@link ScriptTaskActivityBehavior}
 */
protected ScriptTaskActivityBehavior parseScriptTaskElement(Element scriptTaskElement) {
  // determine script language
  String language = scriptTaskElement.attribute("scriptFormat");
  if (language == null) {
    language = ScriptingEngines.DEFAULT_SCRIPTING_LANGUAGE;
  }
  String resultVariableName = parseResultVariable(scriptTaskElement);

  // determine script source
  String scriptSource = null;
  Element scriptElement = scriptTaskElement.element("script");
  if (scriptElement != null) {
    scriptSource = scriptElement.getText();
  }
  String scriptResource = scriptTaskElement.attributeNS(CAMUNDA_BPMN_EXTENSIONS_NS, PROPERTYNAME_RESOURCE);

  try {
    ExecutableScript script = ScriptUtil.getScript(language, scriptSource, scriptResource, expressionManager);
    return new ScriptTaskActivityBehavior(script, resultVariableName);
  } catch (ProcessEngineException e) {
    addError("Unable to process ScriptTask: " + e.getMessage(), scriptElement);
    return null;
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
public void parseConfiguration(Element activityElement, DeploymentEntity deployment, ProcessDefinitionEntity processDefinition, BpmnParse bpmnParse) {
  this.deploymentId = deployment.getId();

  ExpressionManager expressionManager = Context
      .getProcessEngineConfiguration()
      .getExpressionManager();

  Element extensionElement = activityElement.element("extensionElements");
  if (extensionElement != null) {

    // provide support for deprecated form properties
    parseFormProperties(bpmnParse, expressionManager, extensionElement);

    // provide support for new form field metadata
    parseFormData(bpmnParse, expressionManager, extensionElement);
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
@Override
public void parseServiceTask(Element serviceTaskElement, ScopeImpl scope, ActivityImpl activity) {
  Element connectorDefinition = findCamundaExtensionElement(serviceTaskElement, "connector");
  if (connectorDefinition != null) {
    Element connectorIdElement = connectorDefinition.element("connectorId");

    String connectorId = null;
    if (connectorIdElement != null)  {
      connectorId = connectorIdElement.getText().trim();
    }
    if (connectorIdElement == null || connectorId.isEmpty()) {
      throw new BpmnParseException("No 'id' defined for connector.", connectorDefinition);
    }

    IoMapping ioMapping = parseInputOutput(connectorDefinition);
    activity.setActivityBehavior(new ServiceTaskConnectorActivityBehavior(connectorId, ioMapping));
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
protected ActivityImpl parseCompensationHandlerForCompensationBoundaryEvent(ScopeImpl parentScope, ActivityImpl sourceActivity, String targetRef,
    Map<String, Element> compensationHandlers) {

  Element compensationHandler = compensationHandlers.get(targetRef);

  ActivityImpl eventScope = (ActivityImpl) sourceActivity.getEventScope();
  ActivityImpl compensationHandlerActivity = null;
  if (eventScope.isMultiInstance()) {
    ScopeImpl miBody = eventScope.getFlowScope();
    compensationHandlerActivity = parseActivity(compensationHandler, null, miBody);
  } else {
    compensationHandlerActivity = parseActivity(compensationHandler, null, parentScope);
  }

  compensationHandlerActivity.getProperties().set(BpmnProperties.COMPENSATION_BOUNDARY_EVENT, sourceActivity);
  return compensationHandlerActivity;
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
protected XMLImporter getImporter(String importType, Element theImport) {
  if (this.importers.containsKey(importType)) {
    return this.importers.get(importType);
  } else {
    if (importType.equals("http://schemas.xmlsoap.org/wsdl/")) {
      Class<?> wsdlImporterClass;
      try {
        wsdlImporterClass = Class.forName("org.camunda.bpm.engine.impl.webservice.CxfWSDLImporter", true, Thread.currentThread().getContextClassLoader());
        XMLImporter newInstance = (XMLImporter) wsdlImporterClass.newInstance();
        this.importers.put(importType, newInstance);
        return newInstance;
      } catch (Exception e) {
        addError("Could not find importer for type " + importType, theImport);
      }
    }
    return null;
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
/**
 * Parses a camunda script element.
 *
 * @param scriptElement the script element ot parse
 * @return the generated executable script
 * @throws BpmnParseException if the a attribute is missing or the script cannot be processed
 */
public static ExecutableScript parseCamundaScript(Element scriptElement) {
  String scriptLanguage = scriptElement.attribute("scriptFormat");
  if (scriptLanguage == null || scriptLanguage.isEmpty()) {
    throw new BpmnParseException("Missing attribute 'scriptFormatAttribute' for 'script' element", scriptElement);
  }
  else {
    String scriptResource = scriptElement.attribute("resource");
    String scriptSource = scriptElement.getText();
    try {
      return ScriptUtil.getScript(scriptLanguage, scriptSource, scriptResource, getExpressionManager());
    }
    catch (ProcessEngineException e) {
      throw new BpmnParseException("Unable to process script", scriptElement, e);
    }
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
/**
 * Hooks listeners to assignment and creation of tasks.
 * @param userTaskElement task to hook to
 * @param scope a BPMN scope
 * @param activity an Activity scope
 */
@Override
public void parseUserTask(Element userTaskElement, ScopeImpl scope, ActivityImpl activity) {
    UserTaskActivityBehavior activityBehavior = (UserTaskActivityBehavior) activity.getActivityBehavior();
    TaskDefinition taskDefinition = activityBehavior.getTaskDefinition();
    addTaskAssignmentListeners(taskDefinition);
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
@Override
public void preInit(final ProcessEngineConfigurationImpl configuration) {
  new ShowcaseSetup().run();

  customPreBPMNParseListeners(configuration).add(new AbstractBpmnParseListener() {
    @Override
    public void parseUserTask(final Element userTaskElement, final ScopeImpl scope, final ActivityImpl activity) {
      taskDefinition(activity).addTaskListener(EVENTNAME_CREATE, new SkillBasedRoutingListener());
    }
  });
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
@Override
public void parseSequenceFlow(Element sequenceFlowElement, ScopeImpl scopeElement,
        org.camunda.bpm.engine.impl.pvm.process.TransitionImpl transition) {

    final PathCoverageExecutionListener pathCoverageExecutionListener = new PathCoverageExecutionListener(
            coverageTestRunState);
    transition.addListener(ExecutionListener.EVENTNAME_TAKE, pathCoverageExecutionListener);

}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
@Override
public void parseIntermediateCatchEvent(Element intermediateEventElement, ScopeImpl scope,
        org.camunda.bpm.engine.impl.pvm.process.ActivityImpl activity) {

    final IntermediateEventExecutionListener startListener = new IntermediateEventExecutionListener(
            coverageTestRunState);
    activity.addListener(ExecutionListener.EVENTNAME_START, startListener);

    final IntermediateEventExecutionListener endListener = new IntermediateEventExecutionListener(
            coverageTestRunState);
    activity.addListener(ExecutionListener.EVENTNAME_END, endListener);
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
@Override
public void parseIntermediateCatchEvent(Element intermediateEventElement, ScopeImpl scope, ActivityImpl activity) {
  String type = activity.getProperties().get(BpmnProperties.TYPE);
  if (type != null && type.equals(INTERMEDIATE_TIMER)) {
    this.setFailedJobRetryTimeCycleValue(intermediateEventElement, activity);
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
protected void validateCatchCompensateEventDefinition(Element compensateEventDefinitionElement) {
  String activityRef = compensateEventDefinitionElement.attribute("activityRef");
  if (activityRef != null) {
    addWarning("attribute 'activityRef' is not supported on catching compensation event. attribute will be ignored", compensateEventDefinitionElement);
  }

  String waitForCompletion = compensateEventDefinitionElement.attribute("waitForCompletion");
  if (waitForCompletion != null) {
    addWarning("attribute 'waitForCompletion' is not supported on catching compensation event. attribute will be ignored", compensateEventDefinitionElement);
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入依赖的package包/类
/**
 * Parses a scope: a process, subprocess, etc.
 *
 * Note that a process definition is a scope on itself.
 *
 * @param scopeElement
 *          The XML element defining the scope
 * @param parentScope
 *          The scope that contains the nested scope.
 */
public void parseScope(Element scopeElement, ScopeImpl parentScope) {

  // Not yet supported on process level (PVM additions needed):
  // parseProperties(processElement);

  // filter activities that must be parsed separately
  List<Element> activityElements = new ArrayList<Element>(scopeElement.elements());
  Map<String, Element> intermediateCatchEvents = filterIntermediateCatchEvents(activityElements);
  activityElements.removeAll(intermediateCatchEvents.values());
  Map<String, Element> compensationHandlers = filterCompensationHandlers(activityElements);
  activityElements.removeAll(compensationHandlers.values());

  parseStartEvents(scopeElement, parentScope);
  parseActivities(activityElements, scopeElement, parentScope);
  parseIntermediateCatchEvents(scopeElement, parentScope, intermediateCatchEvents);
  parseEndEvents(scopeElement, parentScope);
  parseBoundaryEvents(scopeElement, parentScope);
  parseSequenceFlow(scopeElement, parentScope, compensationHandlers);
  parseExecutionListenersOnScope(scopeElement, parentScope);
  parseAssociations(scopeElement, parentScope, compensationHandlers);
  parseCompensationHandlers(parentScope, compensationHandlers);

  for (ScopeImpl.BacklogErrorCallback callback : parentScope.getBacklogErrorCallbacks()) {
    callback.callback();
  }

  if (parentScope instanceof ProcessDefinition) {
    parseProcessDefinitionCustomExtensions(scopeElement, (ProcessDefinition) parentScope);
  }
}