* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*      http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* Specific parsing of one BPMN 2.0 XML file, created by the {@link BpmnParser}.

*

* @author Tom Baeyens

* @author Bernd Ruecker

* @author Joram Barrez

* @author Christian Stettler

* @author Frederik Heremans

* @author Falko Menge

* @author Esteban Robles

* @author Daniel Meyer

* @author Saeid Mirzaei

* @author Nico Rehwaldt

*/

  protected static final Logger LOGGER = Logger.getLogger(BpmnParse.class.getName());

  public static final String PROPERTYNAME_DOCUMENTATION = "documentation";

  public static final String PROPERTYNAME_INITIAL = "initial";

  public static final String PROPERTYNAME_INITIATOR_VARIABLE_NAME = "initiatorVariableName";

  public static final String PROPERTYNAME_CONDITION = "condition";

  public static final String PROPERTYNAME_CONDITION_TEXT = "conditionText";

  public static final String PROPERTYNAME_VARIABLE_DECLARATIONS = "variableDeclarations";

  public static final String PROPERTYNAME_TIMER_DECLARATION = "timerDeclarations";

  public static final String PROPERTYNAME_MESSAGE_JOB_DECLARATION = "messageJobDeclaration";

  public static final String PROPERTYNAME_ISEXPANDED = "isExpanded";

  public static final String PROPERTYNAME_START_TIMER = "timerStart";

  public static final String PROPERTYNAME_COMPENSATION_HANDLER_ID = "compensationHandler";

  public static final String PROPERTYNAME_IS_FOR_COMPENSATION = "isForCompensation";

  public static final String PROPERTYNAME_ERROR_EVENT_DEFINITIONS = "errorEventDefinitions";

  public static final String PROPERTYNAME_EVENT_SUBSCRIPTION_DECLARATION = "eventDefinitions";

  public static final String PROPERTYNAME_TRIGGERED_BY_EVENT = "triggeredByEvent";

  public static final String PROPERTYNAME_TYPE = "type";

  /* process start authorization specific finals */

  protected static final String POTENTIAL_STARTER = "potentialStarter";

  protected static final String CANDIDATE_STARTER_USERS_EXTENSION = "candidateStarterUsers";

  protected static final String CANDIDATE_STARTER_GROUPS_EXTENSION = "candidateStarterGroups";

  protected static final String ATTRIBUTEVALUE_T_FORMAL_EXPRESSION = BpmnParser.BPMN20_NS + ":tFormalExpression";

  /** The deployment to which the parsed process definitions will be added. */

  protected DeploymentEntity deployment;

  /** The end result of the parsing: a list of process definition. */

  protected List<ProcessDefinitionEntity> processDefinitions = new ArrayList<ProcessDefinitionEntity>();

  /** Mapping of found errors in BPMN 2.0 file */

  protected Map<String, Error> errors = new HashMap<String, Error>();

  /** Mapping from a process definition key to his containing list of job declarations **/

  protected Map<String, List<JobDeclaration<?>>> jobDeclarations = new HashMap<String, List<JobDeclaration<?>>>();

  /** A map for storing sequence flow based on their id during parsing. */

  protected Map<String, TransitionImpl> sequenceFlows;

  /** A list of all element IDs. This allows us to parse only what we actually support but

   * still validate the references among elements we do not support. */

  protected List<String> elementIds = new ArrayList<String>();

  /** A map for storing the process references of participants */

  protected Map<String, String> participantProcesses = new HashMap<String, String>();

  /**

   * Mapping containing values stored during the first phase of parsing since

   * other elements can reference these messages.

   *

   * All the map's elements are defined outside the process definition(s), which

   * means that this map doesn't need to be re-initialized for each new process

   * definition.

   */

  protected Map<String, MessageDefinition> messages = new HashMap<String, MessageDefinition>();

  protected Map<String, SignalDefinition> signals = new HashMap<String, SignalDefinition>();

  // Members

  protected ExpressionManager expressionManager;

  protected List<BpmnParseListener> parseListeners;

  protected Map<String, XMLImporter> importers = new HashMap<String, XMLImporter>();

  protected Map<String, String> prefixs = new HashMap<String, String>();

  protected String targetNamespace;

  private Map<String, String> eventLinkTargets = new HashMap<String, String>();

  private Map<String, String> eventLinkSources = new HashMap<String, String>();

  /**

   * Constructor to be called by the {@link BpmnParser}.

   */

  public BpmnParse(BpmnParser parser) {

    super(parser);

    this.expressionManager = parser.getExpressionManager();

    this.parseListeners = parser.getParseListeners();

    setSchemaResource(ReflectUtil.getResourceUrlAsString(BpmnParser.BPMN_20_SCHEMA_LOCATION));

  }

  public BpmnParse deployment(DeploymentEntity deployment) {

    this.deployment = deployment;

    return this;

  }

  @Override

  public BpmnParse execute() {

    super.execute(); // schema validation

    try {

      parseRootElement();

    } catch (BpmnParseException e) {

      addError(e);

    } catch (Exception e) {

      LOGGER.log(Level.SEVERE, "Unknown exception", e);

      // ALL unexpected exceptions should bubble up since they are not handled

      // accordingly by underlying parse-methods and the process can't be deployed

      throw new ProcessEngineException("Error while parsing process: " + e.getMessage(), e);

    } finally {

      if (hasWarnings()) {

        logWarnings();

      }

      if (hasErrors()) {

        throwExceptionForErrors();

      }

    }

    return this;

  }

  /**

   * Parses the 'definitions' root element

   */

  protected void parseRootElement() {

    collectElementIds();

    parseDefinitionsAttributes();

    parseImports();

    parseMessages();

    parseErrors();

    parseSignals();

    parseProcessDefinitions();

    parseCollaboration();

    // Diagram interchange parsing must be after parseProcessDefinitions,

    // since it depends and sets values on existing process definition objects

    parseDiagramInterchangeElements();

    for (BpmnParseListener parseListener : parseListeners) {

      parseListener.parseRootElement(rootElement, getProcessDefinitions());

    }

  }

  protected void collectElementIds() {

    rootElement.collectIds(elementIds);

  }

  protected void parseDefinitionsAttributes() {

    this.targetNamespace = rootElement.attribute("targetNamespace");

    for (String attribute : rootElement.attributes()) {

      if (attribute.startsWith("xmlns:")) {

        String prefixValue = rootElement.attribute(attribute);

        String prefixName = attribute.substring(6);

        this.prefixs.put(prefixName, prefixValue);

      }

    }

  }

  protected String resolveName(String name) {

    if (name == null) {

      return null;

    }

    int indexOfP = name.indexOf(':');

    if (indexOfP != -1) {

      String prefix = name.substring(0, indexOfP);

      String resolvedPrefix = this.prefixs.get(prefix);

      return resolvedPrefix + ":" + name.substring(indexOfP + 1);

    } else {

      return this.targetNamespace + ":" + name;

    }

  }

  /**

   * Parses the rootElement importing structures

   */

  protected void parseImports() {

    List<Element> imports = rootElement.elements("import");

    for (Element theImport : imports) {

      String importType = theImport.attribute("importType");