예제 #1
0
  static {
    // events
    addConverter(
        EndEventXMLConverter.getXMLType(),
        EndEventXMLConverter.getBpmnElementType(),
        EndEventXMLConverter.class);
    addConverter(
        StartEventXMLConverter.getXMLType(),
        StartEventXMLConverter.getBpmnElementType(),
        StartEventXMLConverter.class);

    // tasks
    addConverter(
        BusinessRuleTaskXMLConverter.getXMLType(),
        BusinessRuleTaskXMLConverter.getBpmnElementType(),
        BusinessRuleTaskXMLConverter.class);
    addConverter(
        ManualTaskXMLConverter.getXMLType(),
        ManualTaskXMLConverter.getBpmnElementType(),
        ManualTaskXMLConverter.class);
    addConverter(
        ReceiveTaskXMLConverter.getXMLType(),
        ReceiveTaskXMLConverter.getBpmnElementType(),
        ReceiveTaskXMLConverter.class);
    addConverter(
        ScriptTaskXMLConverter.getXMLType(),
        ScriptTaskXMLConverter.getBpmnElementType(),
        ScriptTaskXMLConverter.class);
    addConverter(
        ServiceTaskXMLConverter.getXMLType(),
        ServiceTaskXMLConverter.getBpmnElementType(),
        ServiceTaskXMLConverter.class);
    addConverter(
        SendTaskXMLConverter.getXMLType(),
        SendTaskXMLConverter.getBpmnElementType(),
        SendTaskXMLConverter.class);
    addConverter(
        UserTaskXMLConverter.getXMLType(),
        UserTaskXMLConverter.getBpmnElementType(),
        UserTaskXMLConverter.class);
    addConverter(
        TaskXMLConverter.getXMLType(),
        TaskXMLConverter.getBpmnElementType(),
        TaskXMLConverter.class);
    addConverter(
        CallActivityXMLConverter.getXMLType(),
        CallActivityXMLConverter.getBpmnElementType(),
        CallActivityXMLConverter.class);

    // gateways
    addConverter(
        EventGatewayXMLConverter.getXMLType(),
        EventGatewayXMLConverter.getBpmnElementType(),
        EventGatewayXMLConverter.class);
    addConverter(
        ExclusiveGatewayXMLConverter.getXMLType(),
        ExclusiveGatewayXMLConverter.getBpmnElementType(),
        ExclusiveGatewayXMLConverter.class);
    addConverter(
        InclusiveGatewayXMLConverter.getXMLType(),
        InclusiveGatewayXMLConverter.getBpmnElementType(),
        InclusiveGatewayXMLConverter.class);
    addConverter(
        ParallelGatewayXMLConverter.getXMLType(),
        ParallelGatewayXMLConverter.getBpmnElementType(),
        ParallelGatewayXMLConverter.class);

    // connectors
    addConverter(
        SequenceFlowXMLConverter.getXMLType(),
        SequenceFlowXMLConverter.getBpmnElementType(),
        SequenceFlowXMLConverter.class);

    // catch, throw and boundary event
    addConverter(
        CatchEventXMLConverter.getXMLType(),
        CatchEventXMLConverter.getBpmnElementType(),
        CatchEventXMLConverter.class);
    addConverter(
        ThrowEventXMLConverter.getXMLType(),
        ThrowEventXMLConverter.getBpmnElementType(),
        ThrowEventXMLConverter.class);
    addConverter(
        BoundaryEventXMLConverter.getXMLType(),
        BoundaryEventXMLConverter.getBpmnElementType(),
        BoundaryEventXMLConverter.class);

    // artifacts
    addConverter(
        TextAnnotationXMLConverter.getXMLType(),
        TextAnnotationXMLConverter.getBpmnElementType(),
        TextAnnotationXMLConverter.class);
    addConverter(
        AssociationXMLConverter.getXMLType(),
        AssociationXMLConverter.getBpmnElementType(),
        AssociationXMLConverter.class);

    // Alfresco types
    addConverter(
        AlfrescoStartEventXMLConverter.getXMLType(),
        AlfrescoStartEventXMLConverter.getBpmnElementType(),
        AlfrescoStartEventXMLConverter.class);
    addConverter(
        AlfrescoUserTaskXMLConverter.getXMLType(),
        AlfrescoUserTaskXMLConverter.getBpmnElementType(),
        AlfrescoUserTaskXMLConverter.class);
  }
예제 #2
0
  public BpmnModel convertToBpmnModel(XMLStreamReader xtr) {
    BpmnModel model = new BpmnModel();
    try {
      Process activeProcess = null;
      List<SubProcess> activeSubProcessList = new ArrayList<SubProcess>();
      while (xtr.hasNext()) {
        try {
          xtr.next();
        } catch (Exception e) {
          LOGGER.error("Error reading XML document", e);
          throw new XMLException("Error reading XML", e);
        }

        if (xtr.isEndElement() && ELEMENT_SUBPROCESS.equals(xtr.getLocalName())) {
          activeSubProcessList.remove(activeSubProcessList.size() - 1);
        }

        if (xtr.isEndElement() && ELEMENT_TRANSACTION.equals(xtr.getLocalName())) {
          activeSubProcessList.remove(activeSubProcessList.size() - 1);
        }

        if (xtr.isStartElement() == false) continue;

        if (ELEMENT_DEFINITIONS.equals(xtr.getLocalName())) {

          model.setTargetNamespace(xtr.getAttributeValue(null, TARGET_NAMESPACE_ATTRIBUTE));
          for (int i = 0; i < xtr.getNamespaceCount(); i++) {
            String prefix = xtr.getNamespacePrefix(i);
            if (prefix != null) {
              model.addNamespace(prefix, xtr.getNamespaceURI(i));
            }
          }

        } else if (ELEMENT_SIGNAL.equals(xtr.getLocalName())) {
          new SignalParser().parse(xtr, model);

        } else if (ELEMENT_MESSAGE.equals(xtr.getLocalName())) {
          new MessageParser().parse(xtr, model);

        } else if (ELEMENT_ERROR.equals(xtr.getLocalName())) {

          if (StringUtils.isNotEmpty(xtr.getAttributeValue(null, ATTRIBUTE_ID))) {
            model.addError(
                xtr.getAttributeValue(null, ATTRIBUTE_ID),
                xtr.getAttributeValue(null, ATTRIBUTE_ERROR_CODE));
          }

        } else if (ELEMENT_IMPORT.equals(xtr.getLocalName())) {
          new ImportParser().parse(xtr, model);

        } else if (ELEMENT_ITEM_DEFINITION.equals(xtr.getLocalName())) {
          new ItemDefinitionParser().parse(xtr, model);

        } else if (ELEMENT_INTERFACE.equals(xtr.getLocalName())) {
          new InterfaceParser().parse(xtr, model);

        } else if (ELEMENT_IOSPECIFICATION.equals(xtr.getLocalName())) {
          new IOSpecificationParser().parseChildElement(xtr, activeProcess, model);

        } else if (ELEMENT_PARTICIPANT.equals(xtr.getLocalName())) {

          if (StringUtils.isNotEmpty(xtr.getAttributeValue(null, ATTRIBUTE_ID))) {
            Pool pool = new Pool();
            pool.setId(xtr.getAttributeValue(null, ATTRIBUTE_ID));
            pool.setName(xtr.getAttributeValue(null, ATTRIBUTE_NAME));
            pool.setProcessRef(xtr.getAttributeValue(null, ATTRIBUTE_PROCESS_REF));
            model.getPools().add(pool);
          }

        } else if (ELEMENT_PROCESS.equals(xtr.getLocalName())) {

          Process process = new ProcessParser().parse(xtr, model);
          if (process != null) {
            activeProcess = process;
          }

        } else if (ELEMENT_POTENTIAL_STARTER.equals(xtr.getLocalName())) {
          new PotentialStarterParser().parse(xtr, activeProcess);

        } else if (ELEMENT_LANE.equals(xtr.getLocalName())) {
          new LaneParser().parse(xtr, activeProcess);

        } else if (ELEMENT_DOCUMENTATION.equals(xtr.getLocalName())) {

          BaseElement parentElement = null;
          if (activeSubProcessList.size() > 0) {
            parentElement = activeSubProcessList.get(activeSubProcessList.size() - 1);
          } else if (activeProcess != null) {
            parentElement = activeProcess;
          }
          new DocumentationParser().parseChildElement(xtr, parentElement, model);

        } else if (ELEMENT_SUBPROCESS.equals(xtr.getLocalName())) {

          new SubProcessParser().parse(xtr, activeSubProcessList, activeProcess);

        } else if (ELEMENT_TRANSACTION.equals(xtr.getLocalName())) {

          new SubProcessParser().parse(xtr, activeSubProcessList, activeProcess);

        } else if (ELEMENT_DI_SHAPE.equals(xtr.getLocalName())) {

          new BpmnShapeParser().parse(xtr, model);

        } else if (ELEMENT_DI_EDGE.equals(xtr.getLocalName())) {

          new BpmnEdgeParser().parse(xtr, model);

        } else if (ELEMENT_EXECUTION_LISTENER.equals(xtr.getLocalName())) {

          new ExecutionListenerParser().parseChildElement(xtr, activeProcess, model);

        } else {

          if (activeSubProcessList.size() > 0
              && ELEMENT_EXTENSIONS.equalsIgnoreCase(xtr.getLocalName())) {
            new ExecutionListenerParser()
                .parseChildElement(
                    xtr, activeSubProcessList.get(activeSubProcessList.size() - 1), model);

          } else if (activeSubProcessList.size() > 0
              && ELEMENT_MULTIINSTANCE.equalsIgnoreCase(xtr.getLocalName())) {

            new MultiInstanceParser()
                .parseChildElement(
                    xtr, activeSubProcessList.get(activeSubProcessList.size() - 1), model);

          } else if (convertersToBpmnMap.containsKey(xtr.getLocalName())) {
            if (activeProcess.isExecutable()) {
              Class<? extends BaseBpmnXMLConverter> converterClass =
                  convertersToBpmnMap.get(xtr.getLocalName());
              BaseBpmnXMLConverter converter = converterClass.newInstance();
              if (userTaskFormTypes != null && ELEMENT_TASK_USER.equals(xtr.getLocalName())) {
                UserTaskXMLConverter userTaskConverter = (UserTaskXMLConverter) converter;
                for (String formType : userTaskFormTypes) {
                  userTaskConverter.addFormType(formType);
                }
              } else if (startEventFormTypes != null
                  && ELEMENT_EVENT_START.equals(xtr.getLocalName())) {
                StartEventXMLConverter startEventConverter = (StartEventXMLConverter) converter;
                for (String formType : startEventFormTypes) {
                  startEventConverter.addFormType(formType);
                }
              }
              converter.convertToBpmnModel(xtr, model, activeProcess, activeSubProcessList);
            }
          }
        }
      }

      for (Process process : model.getProcesses()) {
        processFlowElements(process.getFlowElements(), process);
      }

    } catch (Exception e) {
      LOGGER.error("Error processing BPMN document", e);
      throw new XMLException("Error processing BPMN document", e);
    }
    return model;
  }