Java Element.elementNS方法代码示例

import org.camunda.bpm.engine.impl.util.xml.Element; //导入方法依赖的package包/类
protected void parseProperties(Element formField, FormFieldHandler formFieldHandler, BpmnParse bpmnParse, ExpressionManager expressionManager) {

    Element propertiesElement = formField.elementNS(BpmnParse.CAMUNDA_BPMN_EXTENSIONS_NS, "properties");

    if(propertiesElement != null) {
      List<Element> propertyElements = propertiesElement.elementsNS(BpmnParse.CAMUNDA_BPMN_EXTENSIONS_NS, "property");

      // use linked hash map to preserve item ordering as provided in XML
      Map<String, String> propertyMap = new LinkedHashMap<String, String>();
      for (Element property : propertyElements) {
        String id = property.attribute("id");
        String value = property.attribute("value");
        propertyMap.put(id, value);
      }

      formFieldHandler.setProperties(propertyMap);
    }

  }
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入方法依赖的package包/类
protected void parseValidation(Element formField, FormFieldHandler formFieldHandler, BpmnParse bpmnParse, ExpressionManager expressionManager) {

    Element validationElement = formField.elementNS(BpmnParse.CAMUNDA_BPMN_EXTENSIONS_NS, "validation");

    if(validationElement != null) {
      List<Element> constraintElements = validationElement.elementsNS(BpmnParse.CAMUNDA_BPMN_EXTENSIONS_NS, "constraint");

      for (Element property : constraintElements) {
         FormFieldValidator validator = Context.getProcessEngineConfiguration()
           .getFormValidators()
           .createValidator(property, bpmnParse, expressionManager);

         String validatorName = property.attribute("name");
         String validatorConfig = property.attribute("config");

         if(validator != null) {
           FormFieldValidationConstraintHandler handler = new FormFieldValidationConstraintHandler();
           handler.setName(validatorName);
           handler.setConfig(validatorConfig);
           handler.setValidator(validator);
           formFieldHandler.getValidationHandlers().add(handler);
         }
      }
    }
  }
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入方法依赖的package包/类
protected void setFailedJobRetryTimeCycleValue(Element element, ActivityImpl activity) {
  String failedJobRetryTimeCycleConfiguration = null;

  Element extensionElements = element.element(EXTENSION_ELEMENTS);
  if (extensionElements != null) {
    Element failedJobRetryTimeCycleElement = extensionElements.elementNS(FOX_ENGINE_NS, FAILED_JOB_RETRY_TIME_CYCLE);
    if (failedJobRetryTimeCycleElement == null) {
      // try to get it from the activiti namespace
      failedJobRetryTimeCycleElement = extensionElements.elementNS(BpmnParse.CAMUNDA_BPMN_EXTENSIONS_NS, FAILED_JOB_RETRY_TIME_CYCLE);
    }

    if (failedJobRetryTimeCycleElement != null) {
      failedJobRetryTimeCycleConfiguration = failedJobRetryTimeCycleElement.getText();
    }
  }

  if (failedJobRetryTimeCycleConfiguration == null || failedJobRetryTimeCycleConfiguration.isEmpty()) {
    failedJobRetryTimeCycleConfiguration = Context.getProcessEngineConfiguration().getFailedJobRetryTimeCycle();
  }

  if (failedJobRetryTimeCycleConfiguration != null) {
    FailedJobRetryConfiguration configuration = ParseUtil.parseRetryIntervals(failedJobRetryTimeCycleConfiguration);
    activity.getProperties().set(FAILED_JOB_CONFIGURATION, configuration);
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入方法依赖的package包/类
protected String getStringValueFromAttributeOrElement(String attributeName, String elementName, Element element) {
  String value = null;

  String attributeValue = element.attribute(attributeName);
  Element childElement = element.elementNS(CAMUNDA_BPMN_EXTENSIONS_NS, elementName);
  String stringElementText = null;

  if (attributeValue != null && childElement != null) {
    addError("Can't use attribute '" + attributeName + "' and element '" + elementName + "' together, only use one", element);
  } else if (childElement != null) {
    stringElementText = childElement.getText();
    if (stringElementText == null || stringElementText.length() == 0) {
      addError("No valid value found in attribute '" + attributeName + "' nor element '" + elementName + "'", element);
    } else {
      // Use text of element
      value = stringElementText;
    }
  } else if (attributeValue != null && attributeValue.length() > 0) {
    // Using attribute
    value = attributeValue;
  }

  return value;
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入方法依赖的package包/类
protected void parseFormData(BpmnParse bpmnParse, ExpressionManager expressionManager, Element extensionElement) {
  Element formData = extensionElement.elementNS(BpmnParse.CAMUNDA_BPMN_EXTENSIONS_NS, "formData");
  if(formData != null) {
    this.businessKeyFieldId = formData.attribute(BUSINESS_KEY_ATTRIBUTE);
    parseFormFields(formData, bpmnParse, expressionManager);
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入方法依赖的package包/类
/**
 * Returns the camunda extension element in the camunda namespace
 * and the given name.
 *
  * @param element the parent element of the extension element
 * @param extensionElementName the name of the extension element to find
 * @return the extension element or null if not found
 */
public static Element findCamundaExtensionElement(Element element, String extensionElementName) {
  Element extensionElements = element.element("extensionElements");
  if(extensionElements != null) {
    return extensionElements.elementNS(BpmnParse.CAMUNDA_BPMN_EXTENSIONS_NS, extensionElementName);
  } else {
    return null;
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入方法依赖的package包/类
/**
 * Returns the {@link IoMapping} of an element.
 *
 * @param element the element to parse
 * @return the input output mapping or null if non defined
 * @throws BpmnParseException if a input/output parameter element is malformed
 */
public static IoMapping parseInputOutput(Element element) {
  Element inputOutputElement = element.elementNS(BpmnParse.CAMUNDA_BPMN_EXTENSIONS_NS, "inputOutput");
  if(inputOutputElement != null) {
    IoMapping ioMapping = new IoMapping();
    parseCamundaInputParameters(inputOutputElement, ioMapping);
    parseCamundaOutputParameters(inputOutputElement, ioMapping);
    return ioMapping;
  }
  return null;
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入方法依赖的package包/类
protected TaskListener parseTaskListener(Element taskListenerElement) {
  TaskListener taskListener = null;

  String className = taskListenerElement.attribute(PROPERTYNAME_CLASS);
  String expression = taskListenerElement.attribute(PROPERTYNAME_EXPRESSION);
  String delegateExpression = taskListenerElement.attribute(PROPERTYNAME_DELEGATE_EXPRESSION);
  Element scriptElement = taskListenerElement.elementNS(CAMUNDA_BPMN_EXTENSIONS_NS, "script");

  if (className != null) {
    taskListener = new ClassDelegateTaskListener(className, parseFieldDeclarations(taskListenerElement));
  } else if (expression != null) {
    taskListener = new ExpressionTaskListener(expressionManager.createExpression(expression));
  } else if (delegateExpression != null) {
    taskListener = new DelegateExpressionTaskListener(expressionManager.createExpression(delegateExpression), parseFieldDeclarations(taskListenerElement));
  } else if (scriptElement != null) {
    try {
      ExecutableScript executableScript = parseCamundaScript(scriptElement);
      if (executableScript != null) {
        taskListener = new ScriptTaskListener(executableScript);
      }
    } catch (BpmnParseException e) {
      addError(e);
    }
  } else {
    addError("Element 'class', 'expression', 'delegateExpression' or 'script' is mandatory on taskListener", taskListenerElement);
  }
  return taskListener;
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入方法依赖的package包/类
/**
 * Parses an {@link ExecutionListener} implementation for the given
 * executionListener element.
 *
 * @param executionListenerElement
 *          the XML element containing the executionListener definition.
 */
public ExecutionListener parseExecutionListener(Element executionListenerElement) {
  ExecutionListener executionListener = null;

  String className = executionListenerElement.attribute(PROPERTYNAME_CLASS);
  String expression = executionListenerElement.attribute(PROPERTYNAME_EXPRESSION);
  String delegateExpression = executionListenerElement.attribute(PROPERTYNAME_DELEGATE_EXPRESSION);
  Element scriptElement = executionListenerElement.elementNS(CAMUNDA_BPMN_EXTENSIONS_NS, "script");

  if (className != null) {
    executionListener = new ClassDelegateExecutionListener(className, parseFieldDeclarations(executionListenerElement));
  } else if (expression != null) {
    executionListener = new ExpressionExecutionListener(expressionManager.createExpression(expression));
  } else if (delegateExpression != null) {
    executionListener = new DelegateExpressionExecutionListener(expressionManager.createExpression(delegateExpression),
        parseFieldDeclarations(executionListenerElement));
  } else if (scriptElement != null) {
    try {
      ExecutableScript executableScript = parseCamundaScript(scriptElement);
      if (executableScript != null) {
        executionListener = new ScriptExecutionListener(executableScript);
      }
    } catch (BpmnParseException e) {
      addError(e);
    }
  } else {
    addError("Element 'class', 'expression', 'delegateExpression' or 'script' is mandatory on executionListener", executionListenerElement);
  }
  return executionListener;
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入方法依赖的package包/类
public void parseBPMNDiagram(Element bpmndiagramElement) {
  // Each BPMNdiagram needs to have exactly one BPMNPlane
  Element bpmnPlane = bpmndiagramElement.elementNS(BPMN_DI_NS, "BPMNPlane");
  if (bpmnPlane != null) {
    parseBPMNPlane(bpmnPlane);
  }
}
 

import org.camunda.bpm.engine.impl.util.xml.Element; //导入方法依赖的package包/类
protected void parseDIBounds(Element bpmnShapeElement, HasDIBounds target) {
  Element bounds = bpmnShapeElement.elementNS(BPMN_DC_NS, "Bounds");
  if (bounds != null) {
    target.setX(parseDoubleAttribute(bpmnShapeElement, "x", bounds.attribute("x"), true).intValue());
    target.setY(parseDoubleAttribute(bpmnShapeElement, "y", bounds.attribute("y"), true).intValue());
    target.setWidth(parseDoubleAttribute(bpmnShapeElement, "width", bounds.attribute("width"), true).intValue());
    target.setHeight(parseDoubleAttribute(bpmnShapeElement, "height", bounds.attribute("height"), true).intValue());
  } else {
    addError("'Bounds' element is required", bpmnShapeElement);
  }
}