protected void validateActionDocument(String fileName, Element rootElement) {

    if (!Validator.equals(rootElement.getName(), "definition")) {
      throwValidationException(1000, fileName, rootElement);
    }

    List<Element> elements = rootElement.elements();

    if (elements.isEmpty()) {
      throwValidationException(1001, fileName, rootElement, new String[] {"command"});
    }

    for (Element element : elements) {
      String elementName = element.getName();

      if (elementName.equals("command")) {
        String attributeValue = element.attributeValue("name");

        if (attributeValue == null) {
          throwValidationException(1003, fileName, element, "name");
        } else if (Validator.isNull(attributeValue)) {
          throwValidationException(1006, fileName, element, "name");
        }

        validateActionCommandElement(
            fileName, element, new String[] {"execute"}, new String[] {"function"}, new String[0]);
      } else {
        throwValidationException(1002, fileName, element, elementName);
      }
    }
  }
  protected void validateTestSuiteDocument(String fileName, Element rootElement) {

    if (!Validator.equals(rootElement.getName(), "definition")) {
      throwValidationException(1000, fileName, rootElement);
    }

    List<Element> elements = rootElement.elements();

    if (elements.isEmpty()) {
      throwValidationException(1001, fileName, rootElement, new String[] {"execute"});
    }

    for (Element element : elements) {
      String elementName = element.getName();

      if (elementName.equals("execute")) {
        validateExecuteElement(
            fileName,
            element,
            new String[] {"test-case", "test-class", "test-suite"},
            ".+",
            new String[0]);
      } else {
        throwValidationException(1002, fileName, element, elementName);
      }
    }
  }
  protected void validateTestCaseDocument(String fileName, Element rootElement) {

    if (!Validator.equals(rootElement.getName(), "definition")) {
      throwValidationException(1000, fileName, rootElement);
    }

    List<Element> elements = rootElement.elements();

    if (elements.isEmpty()) {
      throwValidationException(1001, fileName, rootElement, new String[] {"command"});
    }

    for (Element element : elements) {
      String elementName = element.getName();

      if (elementName.equals("command")) {
        String attributeValue = element.attributeValue("name");

        if (attributeValue == null) {
          throwValidationException(1003, fileName, element, "name");
        } else if (Validator.isNull(attributeValue)) {
          throwValidationException(1006, fileName, element, "name");
        }

        validateBlockElement(
            fileName,
            element,
            new String[] {"execute", "var"},
            new String[] {"action", "macro"},
            new String[] {"var"},
            new String[0]);
      } else if (elementName.equals("set-up") || elementName.equals("tear-down")) {

        List<Attribute> attributes = element.attributes();

        for (Attribute attribute : attributes) {
          String attributeName = attribute.getName();

          if (!attributeName.equals("line-number")) {
            throwValidationException(1005, fileName, element, attributeName);
          }
        }

        validateBlockElement(
            fileName,
            element,
            new String[] {"execute", "var"},
            new String[] {"action", "macro"},
            new String[] {"var"},
            new String[0]);
      } else if (elementName.equals("var")) {
        validateVarElement(fileName, element);
      } else {
        throwValidationException(1002, fileName, element, elementName);
      }
    }
  }
Example #4
0
  public static String exportReferencedContent(
      PortletDataContext portletDataContext,
      Element dlFileEntryTypesElement,
      Element dlFoldersElement,
      Element dlFileEntriesElement,
      Element dlFileRanksElement,
      Element dlRepositoriesElement,
      Element dlRepositoryEntriesElement,
      Element entityElement,
      String content)
      throws Exception {

    content =
        exportDLFileEntries(
            portletDataContext,
            dlFileEntryTypesElement,
            dlFoldersElement,
            dlFileEntriesElement,
            dlFileRanksElement,
            dlRepositoriesElement,
            dlRepositoryEntriesElement,
            entityElement,
            content,
            false);
    content = exportLayoutFriendlyURLs(portletDataContext, content);
    content = exportLinksToLayout(portletDataContext, content);

    String entityElementName = entityElement.getName();

    if (!entityElementName.equals("article")) {
      content = StringUtil.replace(content, StringPool.AMPERSAND_ENCODED, StringPool.AMPERSAND);
    }

    return content;
  }
  protected void validate(List<Element> children, Set<String> elNames) throws PortalException {

    for (Element el : children) {
      if (el.getName().equals("meta-data")) {
        continue;
      }

      String elName = el.attributeValue("name", StringPool.BLANK);
      String elType = el.attributeValue("type", StringPool.BLANK);

      if (Validator.isNull(elName) || elName.startsWith(JournalStructureConstants.RESERVED)) {

        throw new StructureXsdException();
      } else {
        char[] c = elName.toCharArray();

        for (int i = 0; i < c.length; i++) {
          if ((!Validator.isChar(c[i]))
              && (!Validator.isDigit(c[i]))
              && (c[i] != CharPool.DASH)
              && (c[i] != CharPool.UNDERLINE)) {

            throw new StructureXsdException();
          }
        }

        String completePath = elName;

        Element parent = el.getParent();

        while (!parent.isRootElement()) {
          completePath =
              parent.attributeValue("name", StringPool.BLANK) + StringPool.SLASH + completePath;

          parent = parent.getParent();
        }

        String elNameLowerCase = completePath.toLowerCase();

        if (elNames.contains(elNameLowerCase)) {
          throw new StructureXsdException();
        } else {
          elNames.add(elNameLowerCase);
        }
      }

      if (Validator.isNull(elType)) {
        throw new StructureXsdException();
      }

      validate(el.elements(), elNames);
    }
  }
  protected void validatePathTrElement(String fileName, Element trElement) {
    List<Element> elements = trElement.elements();

    for (Element element : elements) {
      String elementName = element.getName();

      if (!elementName.equals("td")) {
        throwValidationException(1002, fileName, element, elementName);
      }
    }

    if (elements.size() < 3) {
      throwValidationException(1001, fileName, trElement, new String[] {"td"});
    }

    if (elements.size() > 3) {
      Element element = elements.get(3);

      String elementName = element.getName();

      throwValidationException(1002, fileName, element, elementName);
    }
  }
  @Override
  public boolean validateReference(Element rootElement, Element referenceElement) {

    String elementName = referenceElement.getName();

    if (elementName.equals("missing-reference")) {
      String uuid = referenceElement.attributeValue("uuid");
      long groupId = GetterUtil.getLong(referenceElement.attributeValue("group-id"));

      return validateMissingReference(uuid, groupId);
    }

    return true;
  }
  protected void validateBlockElement(
      String fileName,
      Element commandElement,
      String[] allowedBlockChildElementNames,
      String[] allowedExecuteAttributeNames,
      String[] allowedExecuteChildElementNames,
      String[] allowedIfConditionElementNames) {

    List<Element> elements = commandElement.elements();

    if (elements.isEmpty()) {
      throwValidationException(1001, fileName, commandElement, allowedBlockChildElementNames);
    }

    for (Element element : elements) {
      String elementName = element.getName();

      if (!ArrayUtil.contains(allowedBlockChildElementNames, elementName)) {

        throwValidationException(1002, fileName, element, elementName);
      }

      if (elementName.equals("echo") || elementName.equals("fail")) {
        validateSimpleElement(fileName, element, new String[] {"message"});
      } else if (elementName.equals("execute")) {
        validateExecuteElement(
            fileName, element, allowedExecuteAttributeNames, ".+", allowedExecuteChildElementNames);
      } else if (elementName.equals("if")) {
        validateIfElement(
            fileName,
            element,
            allowedBlockChildElementNames,
            allowedExecuteAttributeNames,
            allowedExecuteChildElementNames,
            allowedIfConditionElementNames);
      } else if (elementName.equals("var")) {
        validateVarElement(fileName, element);
      } else if (elementName.equals("while")) {
        validateWhileElement(
            fileName,
            element,
            allowedBlockChildElementNames,
            allowedExecuteAttributeNames,
            allowedExecuteChildElementNames,
            allowedIfConditionElementNames);
      } else {
        throwValidationException(1002, fileName, element, elementName);
      }
    }
  }
  protected void validateMacroDocument(String fileName, Element rootElement) {
    if (!Validator.equals(rootElement.getName(), "definition")) {
      throwValidationException(1000, fileName, rootElement);
    }

    List<Element> elements = rootElement.elements();

    if (elements.isEmpty()) {
      throwValidationException(1001, fileName, rootElement, new String[] {"command", "var"});
    }

    for (Element element : elements) {
      String elementName = element.getName();

      if (elementName.equals("command")) {
        String attributeValue = element.attributeValue("name");

        if (attributeValue == null) {
          throwValidationException(1003, fileName, element, "name");
        } else if (Validator.isNull(attributeValue)) {
          throwValidationException(1006, fileName, element, "name");
        }

        validateBlockElement(
            fileName,
            element,
            new String[] {"echo", "execute", "fail", "if", "var", "while"},
            new String[] {"action", "macro"},
            new String[] {"var"},
            new String[] {"condition", "contains", "equals", "isset"});
      } else if (elementName.equals("var")) {
        validateVarElement(fileName, element);
      } else {
        throwValidationException(1002, fileName, element, elementName);
      }
    }
  }
Example #10
0
  protected Map<String, Object> insertRequestVariables(Element element) {
    Map<String, Object> map = new HashMap<>();

    if (element == null) {
      return map;
    }

    for (Element childElement : element.elements()) {
      String name = childElement.getName();

      if (name.equals("attribute")) {
        Element nameElement = childElement.element("name");
        Element valueElement = childElement.element("value");

        map.put(nameElement.getText(), valueElement.getText());
      } else if (name.equals("parameter")) {
        Element nameElement = childElement.element("name");

        List<Element> valueElements = childElement.elements("value");

        if (valueElements.size() == 1) {
          Element valueElement = valueElements.get(0);

          map.put(nameElement.getText(), valueElement.getText());
        } else {
          List<String> values = new ArrayList<>();

          for (Element valueElement : valueElements) {
            values.add(valueElement.getText());
          }

          map.put(nameElement.getText(), values);
        }
      } else {
        List<Element> elements = childElement.elements();

        if (!elements.isEmpty()) {
          map.put(name, insertRequestVariables(childElement));
        } else {
          map.put(name, childElement.getText());
        }
      }
    }

    return map;
  }
  protected void validatePathDocument(String fileName, Element rootElement) {
    Element headElement = rootElement.element("head");

    Element titleElement = headElement.element("title");

    String title = titleElement.getText();

    int x = fileName.lastIndexOf(StringPool.SLASH);
    int y = fileName.lastIndexOf(CharPool.PERIOD);

    String shortFileName = fileName.substring(x + 1, y);

    if ((title == null) || !shortFileName.equals(title)) {
      throwValidationException(0, fileName);
    }

    Element bodyElement = rootElement.element("body");

    Element tableElement = bodyElement.element("table");

    Element theadElement = tableElement.element("thead");

    Element trElement = theadElement.element("tr");

    Element tdElement = trElement.element("td");

    String tdText = tdElement.getText();

    if ((tdText == null) || !shortFileName.equals(tdText)) {
      throwValidationException(0, fileName);
    }

    Element tbodyElement = tableElement.element("tbody");

    List<Element> elements = tbodyElement.elements();

    for (Element element : elements) {
      String elementName = element.getName();

      if (elementName.equals("tr")) {
        validatePathTrElement(fileName, element);
      } else {
        throwValidationException(1002, fileName, element, elementName);
      }
    }
  }
  protected void validateSimpleElement(
      String fileName, Element element, String[] neededAttributes) {

    Map<String, Boolean> hasNeededAttributes = new HashMap<String, Boolean>();

    for (String neededAttribute : neededAttributes) {
      hasNeededAttributes.put(neededAttribute, false);
    }

    List<Attribute> attributes = element.attributes();

    for (Attribute attribute : attributes) {
      String attributeName = attribute.getName();
      String attributeValue = attribute.getValue();

      if (Validator.isNull(attributeValue)) {
        throwValidationException(1006, fileName, element, attributeName);
      }

      if (hasNeededAttributes.containsKey(attributeName)) {
        hasNeededAttributes.put(attributeName, true);
      }

      if (!attributeName.equals("line-number") && !hasNeededAttributes.containsKey(attributeName)) {

        throwValidationException(1005, fileName, element, attributeName);
      }
    }

    for (String neededAttribute : neededAttributes) {
      if (!hasNeededAttributes.get(neededAttribute)) {
        throwValidationException(1004, fileName, element, neededAttributes);
      }
    }

    List<Element> childElements = element.elements();

    if (!childElements.isEmpty()) {
      Element childElement = childElements.get(0);

      String childElementName = childElement.getName();

      throwValidationException(1002, fileName, childElement, childElementName);
    }
  }
  protected void validateWhileElement(
      String fileName,
      Element whileElement,
      String[] allowedBlockChildElementNames,
      String[] allowedExecuteAttributeNames,
      String[] allowedExecuteChildElementNames,
      String[] allowedIfConditionElementNames) {

    List<Element> elements = whileElement.elements();

    Set<String> elementNames = new HashSet<String>();

    for (Element element : elements) {
      String elementName = element.getName();

      elementNames.add(elementName);

      if (elementName.equals("condition")) {
        validateExecuteElement(
            fileName,
            element,
            allowedExecuteAttributeNames,
            ".*(is|Is).+",
            allowedExecuteChildElementNames);
      } else if (elementName.equals("then")) {
        validateBlockElement(
            fileName,
            element,
            allowedBlockChildElementNames,
            allowedExecuteAttributeNames,
            allowedExecuteChildElementNames,
            allowedIfConditionElementNames);
      } else {
        throwValidationException(1002, fileName, element, elementName);
      }
    }

    if (!elementNames.contains("condition") || !elementNames.contains("then")) {

      throwValidationException(1001, fileName, whileElement, new String[] {"condition", "then"});
    }
  }
  protected void populateSkinnyJournalArticle(
      SkinnyJournalArticle skinnyJournalArticle, Element parentElement) {

    List<Element> elements = parentElement.elements();

    for (Element element : elements) {
      String elementName = element.getName();

      if (elementName.equals("dynamic-element")) {
        Element dynamicElementElement = element.element("dynamic-content");

        if (dynamicElementElement != null) {
          skinnyJournalArticle.addDynamicElement(
              element.attributeValue("name"), dynamicElementElement.getTextTrim());
        }
      } else {
        populateSkinnyJournalArticle(skinnyJournalArticle, element);
      }
    }
  }
  public List<Element> getAllChildElements(Element element, String elementName) {

    List<Element> allChildElements = new ArrayList<Element>();

    List<Element> childElements = element.elements();

    if (childElements.isEmpty()) {
      return allChildElements;
    }

    for (Element childElement : childElements) {
      String childElementName = childElement.getName();

      if (childElementName.equals(elementName)) {
        allChildElements.add(childElement);
      }

      allChildElements.addAll(getAllChildElements(childElement, elementName));
    }

    return allChildElements;
  }
  protected void validateIfElement(
      String fileName,
      Element ifElement,
      String[] allowedBlockChildElementNames,
      String[] allowedExecuteAttributeNames,
      String[] allowedExecuteChildElementNames,
      String[] allowedIfConditionElementNames) {

    List<Element> elements = ifElement.elements();

    Set<String> elementNames = new HashSet<String>();

    boolean hasAllowedIfConditionElementNames = false;

    for (Element element : elements) {
      String elementName = element.getName();

      elementNames.add(elementName);

      if (ArrayUtil.contains(allowedIfConditionElementNames, elementName)) {

        hasAllowedIfConditionElementNames = true;
      }

      if (elementName.equals("condition")) {
        validateExecuteElement(
            fileName,
            element,
            allowedExecuteAttributeNames,
            ".*(is|Is).+",
            allowedExecuteChildElementNames);
      } else if (elementName.equals("contains")) {
        validateSimpleElement(fileName, element, new String[] {"string", "substring"});
      } else if (elementName.equals("else") || elementName.equals("then")) {
        validateBlockElement(
            fileName,
            element,
            allowedBlockChildElementNames,
            allowedExecuteAttributeNames,
            allowedExecuteChildElementNames,
            allowedIfConditionElementNames);
      } else if (elementName.equals("elseif")) {
        validateIfElement(
            fileName,
            element,
            allowedBlockChildElementNames,
            allowedExecuteAttributeNames,
            allowedExecuteChildElementNames,
            allowedIfConditionElementNames);
      } else if (elementName.equals("equals")) {
        validateSimpleElement(fileName, element, new String[] {"arg1", "arg2"});
      } else if (elementName.equals("isset")) {
        validateSimpleElement(fileName, element, new String[] {"var"});
      } else {
        throwValidationException(1002, fileName, element, elementName);
      }
    }

    if (!hasAllowedIfConditionElementNames) {
      throwValidationException(1001, fileName, ifElement, allowedIfConditionElementNames);
    }

    if (!elementNames.contains("then")) {
      throwValidationException(1001, fileName, ifElement, new String[] {"then"});
    }
  }
  protected void validateExecuteElement(
      String fileName,
      Element executeElement,
      String[] allowedExecuteAttributeNames,
      String allowedExecuteAttributeValuesRegex,
      String[] allowedExecuteChildElementNames) {

    boolean hasAllowedAttributeName = false;

    List<Attribute> attributes = executeElement.attributes();

    for (Attribute attribute : attributes) {
      String attributeName = attribute.getName();

      if (ArrayUtil.contains(allowedExecuteAttributeNames, attributeName)) {

        hasAllowedAttributeName = true;

        break;
      }
    }

    if (!hasAllowedAttributeName) {
      throwValidationException(1004, fileName, executeElement, allowedExecuteAttributeNames);
    }

    String action = executeElement.attributeValue("action");
    String function = executeElement.attributeValue("function");
    String macro = executeElement.attributeValue("macro");
    String selenium = executeElement.attributeValue("selenium");
    String testCase = executeElement.attributeValue("test-case");
    String testClass = executeElement.attributeValue("test-class");
    String testSuite = executeElement.attributeValue("test-suite");

    if (action != null) {
      if (Validator.isNull(action) || !action.matches(allowedExecuteAttributeValuesRegex)) {

        throwValidationException(1006, fileName, executeElement, "action");
      }

      for (Attribute attribute : attributes) {
        String attributeName = attribute.getName();

        if (!attributeName.equals("action")
            && !attributeName.equals("line-number")
            && !attributeName.startsWith("locator")
            && !attributeName.startsWith("locator-key")
            && !attributeName.startsWith("value")) {

          throwValidationException(1005, fileName, executeElement, attributeName);
        }

        if (attributeName.equals("locator")
            || attributeName.equals("locator-key")
            || attributeName.equals("value")) {

          throwValidationException(1005, fileName, executeElement, attributeName);
        }
      }
    } else if (function != null) {
      if (Validator.isNull(function) || !function.matches(allowedExecuteAttributeValuesRegex)) {

        throwValidationException(1006, fileName, executeElement, "function");
      }

      for (Attribute attribute : attributes) {
        String attributeName = attribute.getName();

        if (!attributeName.equals("function")
            && !attributeName.equals("line-number")
            && !attributeName.startsWith("locator")
            && !attributeName.startsWith("value")) {

          throwValidationException(1005, fileName, executeElement, attributeName);
        }

        if (attributeName.equals("locator") || attributeName.equals("value")) {

          throwValidationException(1005, fileName, executeElement, attributeName);
        }
      }
    } else if (macro != null) {
      if (Validator.isNull(macro) || !macro.matches(allowedExecuteAttributeValuesRegex)) {

        throwValidationException(1006, fileName, executeElement, "macro");
      }

      for (Attribute attribute : attributes) {
        String attributeName = attribute.getName();

        if (!attributeName.equals("macro") && !attributeName.equals("line-number")) {

          throwValidationException(1005, fileName, executeElement, attributeName);
        }
      }
    } else if (selenium != null) {
      if (Validator.isNull(selenium) || !selenium.matches(allowedExecuteAttributeValuesRegex)) {

        throwValidationException(1006, fileName, executeElement, "selenium");
      }

      for (Attribute attribute : attributes) {
        String attributeName = attribute.getName();

        if (!attributeName.equals("argument1")
            && !attributeName.equals("argument2")
            && !attributeName.equals("line-number")
            && !attributeName.equals("selenium")) {

          throwValidationException(1005, fileName, executeElement, attributeName);
        }
      }
    } else if (testCase != null) {
      if (Validator.isNull(testCase) || !testCase.matches(allowedExecuteAttributeValuesRegex)) {

        throwValidationException(1006, fileName, executeElement, "test-case");
      }

      for (Attribute attribute : attributes) {
        String attributeName = attribute.getName();

        if (!attributeName.equals("line-number") && !attributeName.equals("test-case")) {

          throwValidationException(1005, fileName, executeElement, attributeName);
        }
      }
    } else if (testClass != null) {
      if (Validator.isNull(testClass) || !testClass.matches(allowedExecuteAttributeValuesRegex)) {

        throwValidationException(1006, fileName, executeElement, "test-class");
      }

      for (Attribute attribute : attributes) {
        String attributeName = attribute.getName();

        if (!attributeName.equals("line-number") && !attributeName.equals("test-class")) {

          throwValidationException(1005, fileName, executeElement, attributeName);
        }
      }
    } else if (testSuite != null) {
      if (Validator.isNull(testSuite) || !testSuite.matches(allowedExecuteAttributeValuesRegex)) {

        throwValidationException(1006, fileName, executeElement, "test-suite");
      }

      for (Attribute attribute : attributes) {
        String attributeName = attribute.getName();

        if (!attributeName.equals("line-number") && !attributeName.equals("test-suite")) {

          throwValidationException(1005, fileName, executeElement, attributeName);
        }
      }
    } else {
      throwValidationException(0, fileName);
    }

    List<Element> elements = executeElement.elements();

    if (allowedExecuteChildElementNames.length == 0) {
      if (!elements.isEmpty()) {
        Element element = elements.get(0);

        String elementName = element.getName();

        throwValidationException(1002, fileName, element, elementName);
      }
    } else {
      String executeElementName = executeElement.getName();

      for (Element element : elements) {
        String elementName = element.getName();

        if (executeElementName.equals("condition")) {
          throwValidationException(1002, fileName, element, elementName);
        }

        if (elementName.equals("var")) {
          validateVarElement(fileName, element);
        } else {
          throwValidationException(1002, fileName, element, elementName);
        }
      }
    }
  }
  protected void validateActionCommandElement(
      String fileName,
      Element commandElement,
      String[] allowedBlockChildElementNames,
      String[] allowedExecuteAttributeNames,
      String[] allowedExecuteChildElementNames) {

    List<Element> elements = commandElement.elements();

    if (elements.isEmpty()) {
      throwValidationException(1001, fileName, commandElement, new String[] {"case", "default"});
    }

    for (Element element : elements) {
      List<Element> childElements = element.elements();

      String elementName = element.getName();

      if (childElements.size() > 1) {
        throwValidationException(2000, fileName, childElements.get(1), elementName);
      }

      if (elementName.equals("case")) {
        List<Attribute> attributes = element.attributes();

        boolean hasNeededAttributeName = false;

        for (Attribute attribute : attributes) {
          String attributeName = attribute.getName();

          if (attributeName.equals("comparator")) {
            String attributeValue = attribute.getValue();

            if (!attributeValue.equals("contains")
                && !attributeValue.equals("endsWith")
                && !attributeValue.equals("equals")
                && !attributeValue.equals("startsWith")) {

              throwValidationException(1006, fileName, element, attributeName);
            }
          } else if (attributeName.startsWith("locator")
              || attributeName.startsWith("locator-key")) {

            String attributeValue = attribute.getValue();

            if (Validator.isNull(attributeValue)) {
              throwValidationException(1006, fileName, element, attributeName);
            }

            hasNeededAttributeName = true;
          }

          if (!attributeName.equals("comparator")
              && !attributeName.equals("line-number")
              && !attributeName.startsWith("locator")
              && !attributeName.startsWith("locator-key")) {

            throwValidationException(1005, fileName, element, attributeName);
          }

          if (attributeName.equals("locator") || attributeName.equals("locator-key")) {

            throwValidationException(1005, fileName, element, attributeName);
          }
        }

        if (!hasNeededAttributeName) {
          throwValidationException(
              1004, fileName, element, new String[] {"locator1", "locator-key1"});
        }

        validateBlockElement(
            fileName,
            element,
            new String[] {"execute"},
            new String[] {"function"},
            new String[0],
            new String[0]);
      } else if (elementName.equals("default")) {
        List<Attribute> attributes = element.attributes();

        if (attributes.size() != 1) {
          Attribute attribute = attributes.get(1);

          String attributeName = attribute.getName();

          throwValidationException(1005, fileName, element, attributeName);
        }

        validateBlockElement(
            fileName,
            element,
            new String[] {"execute"},
            new String[] {"function"},
            new String[0],
            new String[0]);
      } else {
        throwValidationException(1002, fileName, element, elementName);
      }
    }
  }
  protected void validateVarElement(String fileName, Element element) {
    List<Attribute> attributes = element.attributes();

    Map<String, String> attributeMap = new HashMap<String, String>();

    for (Attribute attribute : attributes) {
      String attributeName = attribute.getName();
      String attributeValue = attribute.getValue();

      if (!attributeName.equals("value") && Validator.isNull(attributeValue)) {

        throwValidationException(1006, fileName, element, attributeName);
      }

      if (!_allowedVarAttributes.contains(attributeName)) {
        throwValidationException(1005, fileName, element, attributeName);
      }

      attributeMap.put(attributeName, attributeValue);
    }

    if (!attributeMap.containsKey("name")) {
      throwValidationException(1004, fileName, element, new String[] {"name"});
    } else {
      String nameValue = attributeMap.get("name");

      if (Validator.isNull(nameValue)) {
        throwValidationException(1006, fileName, element, "name");
      }
    }

    String varText = element.getText();

    if (Validator.isNull(varText)
        && !attributeMap.containsKey("locator-key")
        && !attributeMap.containsKey("path")
        && !attributeMap.containsKey("value")) {

      throwValidationException(1004, fileName, element, new String[] {"value"});
    }

    if (!attributeMap.containsKey("value")) {
      String locatorKeyValue = attributeMap.get("locator-key");
      String pathValue = attributeMap.get("path");

      if (Validator.isNull(locatorKeyValue) && Validator.isNotNull(pathValue)) {

        throwValidationException(1004, fileName, element, new String[] {"locator-key"});
      }

      if (Validator.isNotNull(locatorKeyValue) && Validator.isNull(pathValue)) {

        throwValidationException(1004, fileName, element, new String[] {"path"});
      }
    } else {
      String varValue = attributeMap.get("value");

      Pattern pattern = Pattern.compile("\\$\\{([^\\}]*?)\\}");

      Matcher matcher = pattern.matcher(varValue);

      while (matcher.find()) {
        String statement = matcher.group(1);

        Pattern statementPattern = Pattern.compile("(.*)\\?(.*)\\(([^\\)]*?)\\)");

        Matcher statementMatcher = statementPattern.matcher(statement);

        if (statementMatcher.find()) {
          String operand = statementMatcher.group(1);

          String method = statementMatcher.group(2);

          if (operand.equals("") || method.equals("")) {
            throwValidationException(1006, fileName, element, "value");
          }

          if (!_methodNames.contains(method)) {
            throwValidationException(1013, fileName, element, method);
          }
        } else {
          if (statement.matches(".*[\\?\\(\\)\\}\\{].*")) {
            throwValidationException(1006, fileName, element, "value");
          }
        }
      }
    }

    List<Element> childElements = element.elements();

    if (!childElements.isEmpty()) {
      Element childElement = childElements.get(0);

      String childElementName = childElement.getName();

      throwValidationException(1002, fileName, childElement, childElementName);
    }
  }
  protected int doProcess(WebDAVRequest webDAVRequest) throws Exception {
    WebDAVStorage storage = webDAVRequest.getWebDAVStorage();

    if (!storage.isSupportsClassTwo()) {
      return HttpServletResponse.SC_METHOD_NOT_ALLOWED;
    }

    HttpServletRequest request = webDAVRequest.getHttpServletRequest();
    HttpServletResponse response = webDAVRequest.getHttpServletResponse();

    Lock lock = null;
    Status status = null;

    String lockUuid = webDAVRequest.getLockUuid();
    long timeout = WebDAVUtil.getTimeout(request);

    if (Validator.isNull(lockUuid)) {

      // Create new lock

      String owner = null;
      String xml = new String(FileUtil.getBytes(request.getInputStream()));

      if (Validator.isNotNull(xml)) {
        if (_log.isDebugEnabled()) {
          _log.debug("Request XML\n" + XMLFormatter.toString(xml));
        }

        Document document = SAXReaderUtil.read(xml);

        Element rootElement = document.getRootElement();

        boolean exclusive = false;

        Element lockscopeElement = rootElement.element("lockscope");

        for (Element element : lockscopeElement.elements()) {
          String name = GetterUtil.getString(element.getName());

          if (name.equals("exclusive")) {
            exclusive = true;
          }
        }

        if (!exclusive) {
          return HttpServletResponse.SC_BAD_REQUEST;
        }

        Element ownerElement = rootElement.element("owner");

        owner = ownerElement.getTextTrim();

        if (Validator.isNull(owner)) {
          List<Element> hrefElements = ownerElement.elements("href");

          for (Element hrefElement : hrefElements) {
            owner = "<D:href>" + hrefElement.getTextTrim() + "</D:href>";
          }
        }
      } else {
        _log.error("Empty request XML");

        return HttpServletResponse.SC_PRECONDITION_FAILED;
      }

      status = storage.lockResource(webDAVRequest, owner, timeout);

      lock = (Lock) status.getObject();
    } else {
      try {

        // Refresh existing lock

        lock = storage.refreshResourceLock(webDAVRequest, lockUuid, timeout);

        status = new Status(HttpServletResponse.SC_OK);
      } catch (WebDAVException wde) {
        if (wde.getCause() instanceof NoSuchLockException) {
          return HttpServletResponse.SC_PRECONDITION_FAILED;
        } else {
          throw wde;
        }
      }
    }

    // Return lock details

    if (lock == null) {
      return status.getCode();
    }

    long depth = WebDAVUtil.getDepth(request);

    String xml = getResponseXML(lock, depth);

    if (_log.isDebugEnabled()) {
      _log.debug("Response XML\n" + xml);
    }

    String lockToken = "<" + WebDAVUtil.TOKEN_PREFIX + lock.getUuid() + ">";

    response.setContentType(ContentTypes.TEXT_XML_UTF8);
    response.setHeader("Lock-Token", lockToken);
    response.setStatus(status.getCode());

    if (_log.isDebugEnabled()) {
      _log.debug("Returning lock token " + lockToken);
    }

    try {
      ServletResponseUtil.write(response, xml);
    } catch (Exception e) {
      if (_log.isWarnEnabled()) {
        _log.warn(e);
      }
    }

    return status.getCode();
  }