コード例 #1
0
  /**
   * Extracts the workflow from the plan.
   *
   * @param plan the plan to extract the workflow from.
   * @return The workflow File
   * @throws PluginException if an error occurs extracting the workflow from the plan.
   */
  private File getWorkflowFile(final Document plan) throws PluginException {

    final XPathFactory xPathfactory = XPathFactory.newInstance();
    final XPath xpath = xPathfactory.newXPath();

    Writer writer = null;
    try {

      xpath.setNamespaceContext(new PlanNamespaceContext());
      final XPathExpression expr = xpath.compile(xpathSelectWorkflow);
      final Element elementWorkflow = (Element) expr.evaluate(plan, XPathConstants.NODE);

      // Prepare the DOM document for writing
      final Source source = new DOMSource(elementWorkflow);
      final File workflowFile = new File(new File(RODA_HOME, "data"), WORKFLOW_FILENAME);
      writer = new OutputStreamWriter(new FileOutputStream(workflowFile));
      final Result result = new StreamResult(writer);

      // Write the DOM document to the file
      final Transformer xformer = TransformerFactory.newInstance().newTransformer();
      xformer.transform(source, result);

      writer.close();

      return workflowFile;

    } catch (XPathExpressionException e) {
      logger.error("Error compiling XPATH expression or evaluating the plan - " + e.getMessage());
      throw new PluginException(
          "Error compiling XPATH expression or evaluating the plan - " + e.getMessage(), e);
    } catch (FileNotFoundException e) {
      logger.error("Error opening output file for writting - " + e.getMessage());
      throw new PluginException("Error opening output file for writting - " + e.getMessage(), e);
    } catch (TransformerFactoryConfigurationError e) {
      logger.error("Error writing workflow file - " + e.getMessage());
      throw new PluginException("Error writing workflow file - " + e.getMessage(), e);
    } catch (TransformerException e) {
      logger.error("Error writing workflow file - " + e.getMessage());
      throw new PluginException("Error writing workflow file - " + e.getMessage(), e);
    } catch (IOException e) {
      logger.error("Error writing workflow file - " + e.getMessage());
      throw new PluginException("Error writing workflow file - " + e.getMessage(), e);
    } finally {

      if (writer != null) {
        try {
          writer.close();
        } catch (IOException e) {
          logger.error("Error closing output writer - " + e.getMessage());
        }
      }
    }
  }
コード例 #2
0
  private Node evaluateXPathNode(
      Node bindings, Node target, String expression, NamespaceContext namespaceContext) {
    NodeList nlst;
    try {
      xpath.setNamespaceContext(namespaceContext);
      nlst = (NodeList) xpath.evaluate(expression, target, XPathConstants.NODESET);
    } catch (XPathExpressionException e) {
      reportError(
          (Element) bindings, WsdlMessages.INTERNALIZER_X_PATH_EVALUATION_ERROR(e.getMessage()), e);
      return null; // abort processing this <jaxb:bindings>
    }

    if (nlst.getLength() == 0) {
      reportError(
          (Element) bindings, WsdlMessages.INTERNALIZER_X_PATH_EVALUATES_TO_NO_TARGET(expression));
      return null; // abort
    }

    if (nlst.getLength() != 1) {
      reportError(
          (Element) bindings,
          WsdlMessages.INTERNALIZER_X_PATH_EVAULATES_TO_TOO_MANY_TARGETS(
              expression, nlst.getLength()));
      return null; // abort
    }

    Node rnode = nlst.item(0);
    if (!(rnode instanceof Element)) {
      reportError(
          (Element) bindings,
          WsdlMessages.INTERNALIZER_X_PATH_EVALUATES_TO_NON_ELEMENT(expression));
      return null; // abort
    }
    return rnode;
  }
コード例 #3
0
ファイル: SimpleXMLElement.java プロジェクト: dlitz/resin
  /**
   * Runs an XPath expression on this node.
   *
   * @param env
   * @param expression
   * @return array of results
   * @throws XPathExpressionException
   */
  public Value xpath(Env env, String expression) {
    try {
      XPath xpath = XPathFactory.newInstance().newXPath();

      InputSource is = new InputSource(asXML(env).toInputStream());
      NodeList nodes = (NodeList) xpath.evaluate(expression, is, XPathConstants.NODESET);

      int nodeLength = nodes.getLength();

      if (nodeLength == 0) return NullValue.NULL;

      // There are matching nodes
      ArrayValue result = new ArrayValueImpl();
      for (int i = 0; i < nodeLength; i++) {
        Node node = nodes.item(i);

        boolean isPrefix = node.getPrefix() != null;

        SimpleXMLElement xml =
            buildNode(env, _cls, null, nodes.item(i), node.getNamespaceURI(), isPrefix);

        result.put(wrapJava(env, _cls, xml));
      }

      return result;
    } catch (XPathExpressionException e) {
      env.warning(e);
      log.log(Level.FINE, e.getMessage());

      return NullValue.NULL;
    }
  }
コード例 #4
0
  @Override
  protected String verifyWpsResponse(final String responseStr) throws Exception {
    final Document responseData = XmlDocumentBuilder.parse(responseStr, false);
    Assert.assertNotNull(responseData);
    // System.out.println(XmlDocumentBuilder.toString(responseData));

    XPath xpath = XmlDocumentBuilder.createXPath();
    String jobIdStr = null;
    try {
      Assert.assertEquals(processId, xpath.evaluate(".//Process/Identifier", responseData));
      NodeList returnedNodes = XPathAPI.selectNodeList(responseData, ".//ProcessOutputs/Output");
      Assert.assertEquals(1, returnedNodes.getLength());
      Assert.assertEquals(
          "jobId", xpath.evaluate(".//ProcessOutputs/Output/Identifier", responseData));
      Assert.assertEquals(
          "string",
          xpath.evaluate(".//ProcessOutputs/Output/Data/LiteralData/@dataType", responseData));
      jobIdStr = xpath.evaluate(".//ProcessOutputs/Output/Data/LiteralData", responseData);
      Assert.assertNotNull(UUID.fromString(jobIdStr));
    } catch (XPathExpressionException e) {
      Assert.fail("Error parsing response document: " + e.getMessage());
    }

    return jobIdStr;
  }
コード例 #5
0
  private Element evaluateXPathNode(
      Node target, String expression, NamespaceContext namespaceContext) {
    NodeList nlst;
    try {
      xpath.setNamespaceContext(namespaceContext);
      nlst = (NodeList) xpath.evaluate(expression, target, XPathConstants.NODESET);
    } catch (XPathExpressionException e) {
      Util.fail("internalizer.XPathEvaluationError", e.getMessage());
      return null; // abort processing this <jaxb:bindings>
    }

    if (nlst.getLength() == 0) {
      Util.fail("internalizer.XPathEvaluatesToNoTarget", new Object[] {expression});
      return null; // abort
    }

    if (nlst.getLength() != 1) {
      Util.fail(
          "internalizer.XPathEvaulatesToTooManyTargets",
          new Object[] {expression, nlst.getLength()});
      return null; // abort
    }

    Node rnode = nlst.item(0);
    if (!(rnode instanceof Element)) {
      Util.fail("internalizer.XPathEvaluatesToNonElement", new Object[] {expression});
      return null; // abort
    }
    return (Element) rnode;
  }
コード例 #6
0
ファイル: Helper.java プロジェクト: crystalwm/jsnose_demo
  /**
   * Removes all the given tags from the document.
   *
   * @param dom the document object.
   * @param tagName the tag name, examples: script, style, meta
   * @return the changed dom.
   */
  public static Document removeTags(Document dom, String tagName) {
    if (dom != null) {
      // NodeList list = dom.getElementsByTagName("SCRIPT");

      NodeList list;
      try {
        list = XPathHelper.evaluateXpathExpression(dom, "//" + tagName.toUpperCase());

        while (list.getLength() > 0) {
          Node sc = list.item(0);

          if (sc != null) {
            sc.getParentNode().removeChild(sc);
          }

          list = XPathHelper.evaluateXpathExpression(dom, "//" + tagName.toUpperCase());
          // list = dom.getElementsByTagName("SCRIPT");
        }
      } catch (XPathExpressionException e) {
        LOGGER.error(e.getMessage(), e);
      }

      return dom;
    }

    return null;
  }
コード例 #7
0
ファイル: NewsFeed.java プロジェクト: portellaa/UA-News
  public void retrieveNews() {

    try {

      //			HttpClient client = new DefaultHttpClient();
      //			HttpResponse response = client.execute(new
      // HttpGet("http://uaonline.ua.pt/xml/contents_xml.asp"));
      //			HttpEntity tmpEntity = response.getEntity();

      //			SAXParser xmlParser = SAXParserFactory.newInstance().newSAXParser();
      //			XMLReader xmlReader = xmlParser.getXMLReader();
      //			NewsHandler newsHandler = new NewsHandler();
      //			xmlReader.setContentHandler(newsHandler);
      //
      //			Reader test = new InputStreamReader(uaNewsURL.openStream());
      //			InputSource is = new InputSource(test);
      //			is.setEncoding("ISO-8859-1");
      //			xmlReader.parse(is);
      //			return newsHandler.getFeed();

      URL uaNewsURL = new URL("http://uaonline.ua.pt/xml/contents_xml.asp");
      DocumentBuilder xmlBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
      Document xmlNews = xmlBuilder.parse(uaNewsURL.openStream());

      XPath query;
      NodeList newsItems;
      query = XPathFactory.newInstance().newXPath();
      Object result = query.compile("/rss/channel/item").evaluate(xmlNews, XPathConstants.NODESET);
      newsItems = (NodeList) result;

      NewsItem tempItem;
      Element tmpElem;
      for (int i = 0; i < newsItems.getLength(); i++) {
        tmpElem = (Element) newsItems.item(i);

        tempItem = parseInfo(tmpElem);
        this.addItem(tempItem);
      }

    } catch (MalformedURLException e) {
      System.out.println("NewsFeed: retrieveNews: " + e.getMessage());
      System.out.println(
          "NewsFeed: retrieveNews: MalformedURLException " + e.getLocalizedMessage());
    } catch (ParserConfigurationException e) {
      System.out.println("NewsFeed: retrieveNews: " + e.getMessage());
      System.out.println(
          "NewsFeed: retrieveNews: ParserConfigurationException " + e.getLocalizedMessage());
    } catch (IOException e) {
      System.out.println("NewsFeed: retrieveNews: " + e.getMessage());
      System.out.println("NewsFeed: retrieveNews: IOException " + e.getLocalizedMessage());
    } catch (XPathExpressionException e) {
      System.out.println("NewsFeed: retrieveNews: " + e.getMessage());
      System.out.println(
          "NewsFeed: retrieveNews: XPathExpressionException " + e.getLocalizedMessage());
    } catch (SAXException e) {
      System.out.println("NewsFeed: retrieveNews: " + e.getMessage());
      System.out.println("NewsFeed: retrieveNews: SAXException " + e.getLocalizedMessage());
    }
  }
コード例 #8
0
 public KModuleDeploymentService() {
   try {
     processIdXPathExpression = XPathFactory.newInstance().newXPath().compile(PROCESS_ID_XPATH);
   } catch (XPathExpressionException e) {
     logger.error(
         "Unable to parse '{}' XPath expression due to {}", PROCESS_ID_XPATH, e.getMessage());
   }
 }
コード例 #9
0
ファイル: AbcPart.java プロジェクト: Kogara/lotro-maestro
  private void initFromXml(Element ele, Version fileVersion) throws ParseException {
    try {
      partNumber = SaveUtil.parseValue(ele, "@id", partNumber);
      title = SaveUtil.parseValue(ele, "title", title);
      instrument = SaveUtil.parseValue(ele, "instrument", instrument);
      for (Element trackEle : XmlUtil.selectElements(ele, "track")) {
        // Try to find the specified track in the midi sequence by name, in case it moved
        int t = findTrackNumberByName(SaveUtil.parseValue(trackEle, "@name", ""));
        // Fall back to the track ID if that didn't work
        if (t == -1) t = SaveUtil.parseValue(trackEle, "@id", -1);

        if (t < 0 || t >= getTrackCount()) {
          throw SaveUtil.invalidValueException(
              trackEle, "Could not find track number " + t + " in original MIDI file");
        }

        // Now set the track info
        trackEnabled[t] = true;
        enabledTrackCount++;
        trackTranspose[t] = SaveUtil.parseValue(trackEle, "transpose", trackTranspose[t]);
        trackVolumeAdjust[t] = SaveUtil.parseValue(trackEle, "volumeAdjust", trackVolumeAdjust[t]);

        if (instrument.isPercussion) {
          Element drumsEle = XmlUtil.selectSingleElement(trackEle, "drumsEnabled");
          if (drumsEle != null) {
            boolean defaultEnabled =
                SaveUtil.parseValue(drumsEle, "@defaultEnabled", !isCowbellPart());

            BitSet[] enabledSet;
            if (isCowbellPart()) {
              if (cowbellsEnabled == null) cowbellsEnabled = new BitSet[getTrackCount()];
              enabledSet = cowbellsEnabled;
            } else {
              if (drumsEnabled == null) drumsEnabled = new BitSet[getTrackCount()];
              enabledSet = drumsEnabled;
            }

            enabledSet[t] = new BitSet(MidiConstants.NOTE_COUNT);
            if (defaultEnabled) enabledSet[t].set(0, MidiConstants.NOTE_COUNT, true);

            for (Element drumEle : XmlUtil.selectElements(drumsEle, "note")) {
              int id = SaveUtil.parseValue(drumEle, "@id", -1);
              if (id >= 0 && id < MidiConstants.NOTE_COUNT)
                enabledSet[t].set(id, SaveUtil.parseValue(drumEle, "@isEnabled", !defaultEnabled));
            }
          }

          Element drumMapEle = XmlUtil.selectSingleElement(trackEle, "drumMap");
          if (drumMapEle != null) drumNoteMap[t] = DrumNoteMap.loadFromXml(drumMapEle, fileVersion);
        }
      }
    } catch (XPathExpressionException e) {
      throw new ParseException("XPath error: " + e.getMessage(), null);
    }
  }
コード例 #10
0
  private List<ICompletionProposal> proposeParameter(
      IJavaProject project,
      final int offset,
      final int length,
      Node statementNode,
      final boolean searchReadable,
      final String matchString) {
    List<ICompletionProposal> proposals = new ArrayList<ICompletionProposal>();
    if (statementNode == null) return proposals;
    String statementId = null;
    String paramType = null;
    NamedNodeMap statementAttrs = statementNode.getAttributes();
    for (int i = 0; i < statementAttrs.getLength(); i++) {
      Node attr = statementAttrs.item(i);
      String attrName = attr.getNodeName();
      if ("id".equals(attrName)) statementId = attr.getNodeValue();
      else if ("parameterType".equals(attrName)) paramType = attr.getNodeValue();
    }
    if (statementId == null || statementId.length() == 0) return proposals;

    if (paramType != null) {
      String resolved = TypeAliasCache.getInstance().resolveAlias(project, paramType, null);
      proposals =
          ProposalComputorHelper.proposePropertyFor(
              project,
              offset,
              length,
              resolved != null ? resolved : paramType,
              searchReadable,
              -1,
              matchString);
    } else {
      try {
        final List<MapperMethodInfo> methodInfos = new ArrayList<MapperMethodInfo>();
        String mapperFqn = MybatipseXmlUtil.getNamespace(statementNode.getOwnerDocument());
        JavaMapperUtil.findMapperMethod(
            methodInfos, project, mapperFqn, statementId, true, new RejectStatementAnnotation());
        if (methodInfos.size() > 0) {
          proposals =
              ProposalComputorHelper.proposeParameters(
                  project,
                  offset,
                  length,
                  methodInfos.get(0).getParams(),
                  searchReadable,
                  matchString);
        }
      } catch (XPathExpressionException e) {
        Activator.log(Status.ERROR, e.getMessage(), e);
      }
    }
    return proposals;
  }
コード例 #11
0
  @Override
  public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    response.setContentType("text/html");

    javax.servlet.http.Cookie[] theCookies = request.getCookies();

    String param = null;
    boolean foundit = false;
    if (theCookies != null) {
      for (javax.servlet.http.Cookie theCookie : theCookies) {
        if (theCookie.getName().equals("vector")) {
          param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
          foundit = true;
        }
      }
      if (!foundit) {
        // no cookie found in collection
        param = "";
      }
    } else {
      // no cookies
      param = "";
    }

    String bar = new Test().doSomething(param);

    try {
      java.io.FileInputStream file =
          new java.io.FileInputStream(
              org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
                  "employees.xml", this.getClass().getClassLoader()));
      javax.xml.parsers.DocumentBuilderFactory builderFactory =
          javax.xml.parsers.DocumentBuilderFactory.newInstance();
      javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
      org.w3c.dom.Document xmlDocument = builder.parse(file);
      javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
      javax.xml.xpath.XPath xp = xpf.newXPath();

      response.getWriter().println("Your query results are: <br/>");
      String expression = "/Employees/Employee[@emplid='" + bar + "']";
      response.getWriter().println(xp.evaluate(expression, xmlDocument) + "<br/>");

    } catch (javax.xml.xpath.XPathExpressionException e) {
      // OK to swallow
      System.out.println("XPath expression exception caught and swallowed: " + e.getMessage());
    } catch (javax.xml.parsers.ParserConfigurationException e) {
      System.out.println("XPath expression exception caught and swallowed: " + e.getMessage());
    } catch (org.xml.sax.SAXException e) {
      System.out.println("XPath expression exception caught and swallowed: " + e.getMessage());
    }
  } // end doPost
コード例 #12
0
 /** @see com.aptana.ide.core.model.ITransformObject#fromNode(org.w3c.dom.Node) */
 public void fromNode(Node node) {
   try {
     NodeList set = (NodeList) XPATH.evaluate(getItemString(), node, XPathConstants.NODESET);
     updateGroup(set);
   } catch (XPathExpressionException e1) {
     isLoading = false;
     String message =
         MessageFormat.format(
             Messages.getString("CoreGroupObject.XPath_Error_During_Parse"), // $NON-NLS-1$
             new Object[] {getLoggingPrefix(), e1.getMessage()});
     logError(message);
   }
 }
コード例 #13
0
  protected String getProcessId(String processSource) {

    try {
      InputSource inputSource = new InputSource(new StringReader(processSource));
      String processId =
          (String) processIdXPathExpression.evaluate(inputSource, XPathConstants.STRING);

      return processId;
    } catch (XPathExpressionException e) {
      logger.error("Unable to find process id from process source due to {}", e.getMessage());
      return null;
    }
  }
  public EvaluationResult evaluate(List<Evaluatable> inputs, EvaluationCtx context) {

    // Evaluate the arguments
    AttributeValue[] argValues = new AttributeValue[inputs.size()];
    EvaluationResult result = evalArgs(inputs, context, argValues);
    if (result != null) {
      return result;
    }

    switch (getFunctionId()) {
      case ID_XPATH_NODE_COUNT:
        {
          XPathAttribute xpathAttribute = ((XPathAttribute) argValues[0]);
          String xpathValue = xpathAttribute.getValue();
          String category = xpathAttribute.getXPathCategory();

          Node contextNode = null;

          // this must be XACML 3
          Set<Attributes> attributesSet = ((XACML3EvaluationCtx) context).getAttributes(category);
          if (attributesSet != null) {
            // only one attributes can be there
            Attributes attributes = attributesSet.iterator().next();
            contextNode = attributes.getContent();
          }

          if (contextNode != null) {
            // now apply XPath
            try {
              NodeList nodeList = getXPathResults(contextNode, xpathValue);
              return new EvaluationResult(new IntegerAttribute(nodeList.getLength()));
            } catch (XPathExpressionException e) {
              List<String> codes = new ArrayList<String>();
              codes.add(Status.STATUS_SYNTAX_ERROR);
              Status status = new Status(codes, e.getMessage());
              return new EvaluationResult(status);
            }
          }
        }

      case ID_XPATH_NODE_EQUAL:
        {
          // TODO
        }
    }

    List<String> codes = new ArrayList<String>();
    codes.add(Status.STATUS_SYNTAX_ERROR);
    Status status = new Status(codes, "Not supported function");
    return new EvaluationResult(status);
  }
コード例 #15
0
  private void generateResults(
      ContentAssistRequest contentAssistRequest,
      int offset,
      int length,
      Node parentNode,
      Node typeAttr) {
    if (typeAttr == null) return;

    String typeValue = typeAttr.getNodeValue();
    if (typeValue == null || typeValue.length() == 0) return;

    IJavaProject project = getJavaProject(contentAssistRequest);
    // Try resolving the alias.
    String qualifiedName = TypeAliasCache.getInstance().resolveAlias(project, typeValue, null);
    if (qualifiedName == null) {
      // Assumed to be FQN.
      qualifiedName = typeValue;
    }
    BeanPropertyInfo beanProps = BeanPropertyCache.getBeanPropertyInfo(project, qualifiedName);
    try {
      Set<String> existingProps = new HashSet<String>();
      NodeList existingPropNodes = XpathUtil.xpathNodes(parentNode, "*[@property]/@property");
      for (int i = 0; i < existingPropNodes.getLength(); i++) {
        existingProps.add(existingPropNodes.item(i).getNodeValue());
      }
      StringBuilder resultTags = new StringBuilder();
      for (Entry<String, String> prop : beanProps.getWritableFields().entrySet()) {
        String propName = prop.getKey();
        if (!existingProps.contains(propName)) {
          resultTags
              .append("<result property=\"")
              .append(propName)
              .append("\" column=\"")
              .append(propName)
              .append("\" />\n");
        }
      }
      contentAssistRequest.addProposal(
          new CompletionProposal(
              resultTags.toString(),
              offset,
              length,
              resultTags.length(),
              Activator.getIcon(),
              "<result /> for properties",
              null,
              null));
    } catch (XPathExpressionException e) {
      Activator.log(Status.ERROR, e.getMessage(), e);
    }
  }
コード例 #16
0
 @Override
 public Document modifyDocument(Document document, String value) {
   if (value == null || value.isEmpty()) {
     return document;
   }
   try {
     Node node = getNodeFromXpath(document);
     node.setTextContent(value);
   } catch (XPathExpressionException ex) {
     ex.fillInStackTrace();
     Logger.getLogger(HeritrixParameterValueModifier.class.getName()).warn(ex.getMessage());
   }
   return document;
 }
コード例 #17
0
  /**
   * Gets the URLs of files this plan applies to.
   *
   * @param plan the plan
   * @return a {@link List} of file URLs.
   * @throws PluginException if an error occurred extracting URLs from the plan.
   */
  private List<String> getFileURLsFromPlan(final Document plan) throws PluginException {

    final List<String> fileURLs = new ArrayList<String>();
    final XPath xpath = XPathFactory.newInstance().newXPath();
    xpath.setNamespaceContext(new PlanNamespaceContext());

    try {

      final XPathExpression expr = xpath.compile(xpathSelectIDs);
      final NodeList nl = (NodeList) expr.evaluate(plan, XPathConstants.NODESET);

      for (int i = 0; i < nl.getLength(); i++) {
        final Node item = nl.item(i);
        fileURLs.add(item.getNodeValue());
      }

      return fileURLs;

    } catch (XPathExpressionException e) {
      logger.error("Error reading file URLs from plan - " + e.getMessage());
      throw new PluginException("Error reading file URLs from plan - " + e.getMessage(), e);
    }
  }
  private String handleResponse(HttpResponse httpResponse) throws IOException {
    final int ok = 200;
    if (httpResponse.getStatusLine().getStatusCode() == ok) {
      String reply = IOUtils.toString(httpResponse.getEntity().getContent());

      if (reply == null) {
        LOGGER.error("Http request failed. Service did not respond.");
        return "-";
      }

      try {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document doc = builder.parse(new ByteArrayInputStream(reply.getBytes()));
        XPathFactory xPathfactory = XPathFactory.newInstance();
        XPath xpath = xPathfactory.newXPath();

        XPathExpression expr = xpath.compile("/calendarItems/status/text()");

        String status = expr.evaluate(doc);

        if ("PROCESSED".equals(status)) {
          String res = xpath.compile("/calendarItems/total/text()").evaluate(doc);
          return res;
        } else {
          return ""; // The user does not have any notes calendar and should receive nothing.
        }

      } catch (RuntimeException ex) {
        LOGGER.warn(ex.getMessage());
      } catch (ParserConfigurationException e) {
        LOGGER.warn(e.getMessage());
      } catch (SAXException e) {
        LOGGER.warn(e.getMessage());
      } catch (XPathExpressionException e) {
        LOGGER.warn(e.getMessage());
      }

      return "-";
    } else {
      LOGGER.error(
          "Http request failed. Response code="
              + httpResponse.getStatusLine().getStatusCode()
              + ". "
              + httpResponse.getStatusLine().getReasonPhrase());
      return "-";
    }
  }
コード例 #19
0
 public NodeList xpathRealQuery(String doc, String query) {
   log.debug("xpathRealQuery(String doc, String query)");
   XPathFactory xpathFact = XPathFactory.newInstance();
   XPath xpath = xpathFact.newXPath();
   XPathExpression expr = null;
   NodeList res = null;
   try {
     expr = xpath.compile(query);
     Object result = expr.evaluate(doc, XPathConstants.STRING);
     res = (NodeList) result;
   } catch (XPathExpressionException e) {
     log.debug(e.getMessage());
     return null;
   }
   return res;
 }
コード例 #20
0
ファイル: Splitter.java プロジェクト: hwh/nota.oxygen
  private boolean splitConcatDocument(File concatFile) {
    try {
      EpubUtils.outputMessage(taskOutput, "Splitting concat document");

      // create concat document
      Document sourceDoc = EpubUtils.createDocument(concatFile, taskOutput);
      if (sourceDoc == null) {
        return false;
      }

      // Find Source body
      XPathFactory factory = XPathFactory.newInstance();
      XPath xpath = factory.newXPath();

      Node sourceBody =
          (Node)
              xpath.evaluate(
                  "//*[local-name() = 'body']",
                  sourceDoc.getDocumentElement(),
                  XPathConstants.NODE);
      NodeList bodyNodes = sourceBody.getChildNodes();

      for (int i = 0; i < bodyNodes.getLength(); i++) {
        Node sectionNodeAtLevel1 = bodyNodes.item(i);
        if (sectionNodeAtLevel1.getNodeType() == Node.ELEMENT_NODE) {
          createNewEpubDoc(sectionNodeAtLevel1);
        }
      }
      return true;
    } catch (XPathExpressionException xpee) {
      EpubUtils.outputMessage(
          taskOutput,
          "Could not split concat document. An XPathExpressionException occurred: "
              + xpee.getMessage());
    } catch (AuthorOperationException aoe) {
      EpubUtils.outputMessage(
          taskOutput,
          "Could not split concat document. An AuthorOperationException occurred: "
              + aoe.getMessage());
    } catch (Exception e) {
      EpubUtils.outputMessage(
          taskOutput, "Could not split concat document. An Exception occurred: " + e.getMessage());
    }

    return false;
  }
コード例 #21
0
  @Override
  public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    response.setContentType("text/html");

    java.util.Map<String, String[]> map = request.getParameterMap();
    String param = "";
    if (!map.isEmpty()) {
      String[] values = map.get("vector");
      if (values != null) param = values[0];
    }

    String bar = new Test().doSomething(param);

    try {
      java.io.FileInputStream file =
          new java.io.FileInputStream(
              org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
                  "employees.xml", this.getClass().getClassLoader()));
      javax.xml.parsers.DocumentBuilderFactory builderFactory =
          javax.xml.parsers.DocumentBuilderFactory.newInstance();
      javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
      org.w3c.dom.Document xmlDocument = builder.parse(file);
      javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
      javax.xml.xpath.XPath xp = xpf.newXPath();

      String expression = "/Employees/Employee[@emplid='" + bar + "']";

      response.getWriter().println("Your query results are: <br/>");
      org.w3c.dom.NodeList nodeList =
          (org.w3c.dom.NodeList)
              xp.compile(expression).evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
      for (int i = 0; i < nodeList.getLength(); i++) {
        org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
        response.getWriter().println(value.getTextContent() + "<br/>");
      }
    } catch (javax.xml.xpath.XPathExpressionException e) {
      // OK to swallow
      System.out.println("XPath expression exception caught and swallowed: " + e.getMessage());
    } catch (javax.xml.parsers.ParserConfigurationException e) {
      System.out.println("XPath expression exception caught and swallowed: " + e.getMessage());
    } catch (org.xml.sax.SAXException e) {
      System.out.println("XPath expression exception caught and swallowed: " + e.getMessage());
    }
  } // end doPost
コード例 #22
0
 public void fromXML(XMLDocument xmlDocument) {
   try {
     type = MarkContactType.valueOf(xmlDocument.getNodeValue(TYPE_EXPR));
     name = xmlDocument.getNodeValue(NAME_EXPR);
     org = xmlDocument.getNodeValue(ORG_EXPR);
     voice = xmlDocument.getNodeValue(VOICE_EXPR);
     voiceExt = xmlDocument.getNodeValue(VOICE_EXT_EXPR);
     fax = xmlDocument.getNodeValue(FAX_EXPR);
     faxExt = xmlDocument.getNodeValue(FAX_EXT_EXPR);
     email = xmlDocument.getNodeValue(EMAIL_EXPR);
     Node addressElement = xmlDocument.getElement(ADDRESS_EXPR);
     if (addressElement != null) {
       address = new MarkAddress();
       address.fromXML(new XMLDocument((Element) addressElement));
     }
   } catch (XPathExpressionException e) {
     maintLogger.warning(e.getMessage());
   }
 }
コード例 #23
0
  @Override
  public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

    org.owasp.benchmark.helpers.SeparateClassRequest scr =
        new org.owasp.benchmark.helpers.SeparateClassRequest(request);
    String param = scr.getTheParameter("foo");

    String bar = doSomething(param);

    javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
    javax.xml.xpath.XPath xp = xpf.newXPath();
    try {
      xp.compile(bar);
    } catch (javax.xml.xpath.XPathExpressionException e) {
      // OK to swallow
      System.out.println("XPath expression exception caught and swallowed: " + e.getMessage());
    }
  } // end doPost
コード例 #24
0
  public static Document replaceTokens(Document doc, Policy configTokens)
      throws XPathExpressionException, TransformerConfigurationException {

    XPathFactory factory = XPathFactory.newInstance();
    XPath xpath = factory.newXPath();

    Gson gson = new GsonBuilder().setPrettyPrinting().create();
    String json = gson.toJson(configTokens);
    logger.info("============= to apply the following config tokens ================\n{}", json);

    try {
      for (int i = 0; i < configTokens.tokens.size(); i++) {

        logger.debug(
            "=============Checking for Xpath Expressions {}  ================\n",
            configTokens.tokens.get(i).xpath);
        XPathExpression expression = xpath.compile(configTokens.tokens.get(i).xpath);

        NodeList nodes = (NodeList) expression.evaluate(doc, XPathConstants.NODESET);

        for (int j = 0; j < nodes.getLength(); j++) {

          if (nodes.item(j).hasChildNodes()) {
            logger.debug(
                "=============Updated existing value {} to new value {} ================\n",
                nodes.item(j).getTextContent(),
                configTokens.tokens.get(i).value);
            nodes.item(j).setTextContent(configTokens.tokens.get(i).value);
          }
        }
      }

      return doc;
    } catch (XPathExpressionException e) {

      logger.error(
          String.format(
              "\n\n=============The Xpath Expressions in config.json are incorrect. Please check. ================\n\n%s",
              e.getMessage()),
          e);
      throw e;
    }
  }
コード例 #25
0
  /**
   * Return nodeValue of given xpath expression.
   *
   * @param payload
   * @param xpathExpression
   * @return NodeValue of xpathExpression or empty string if nothing was found
   * @throws MojoFailureException if more then one result was found
   * @throws MojoExecutionException
   */
  public static String getXpathNodeValue(Document payload, String xpathExpression)
      throws MojoExecutionException, MojoFailureException {

    String nodeValue = "";
    try {
      final XPathFactory xpf = XPathFactory.newInstance();
      final XPath xpath = xpf.newXPath();
      final XPathExpression expr = xpath.compile(xpathExpression);

      final NodeList nodes = (NodeList) expr.evaluate(payload, XPathConstants.NODESET);
      if (nodes.getLength() == 1) {
        nodeValue = getNodeValue(nodes.item(0));
      } else if (nodes.getLength() > 1) {
        throw new MojoFailureException("Error: found multiple nodes for " + xpathExpression);
      }
    } catch (XPathExpressionException e) {
      throw new MojoExecutionException(e.getMessage(), e);
    }
    return nodeValue;
  }
コード例 #26
0
  @Override
  public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

    String[] values = request.getParameterValues("foo");
    String param;
    if (values.length != 0) param = request.getParameterValues("foo")[0];
    else param = null;

    String bar = new Test().doSomething(param);

    javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
    javax.xml.xpath.XPath xp = xpf.newXPath();
    try {
      xp.compile(bar);
    } catch (javax.xml.xpath.XPathExpressionException e) {
      // OK to swallow
      System.out.println("XPath expression exception caught and swallowed: " + e.getMessage());
    }
  } // end doPost
コード例 #27
0
  @Override
  public void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

    org.owasp.benchmark.helpers.SeparateClassRequest scr =
        new org.owasp.benchmark.helpers.SeparateClassRequest(request);
    String param = scr.getTheParameter("foo");

    // Chain a bunch of propagators in sequence
    String a20448 = param; // assign
    StringBuilder b20448 = new StringBuilder(a20448); // stick in stringbuilder
    b20448.append(" SafeStuff"); // append some safe content
    b20448.replace(
        b20448.length() - "Chars".length(),
        b20448.length(),
        "Chars"); // replace some of the end content
    java.util.HashMap<String, Object> map20448 = new java.util.HashMap<String, Object>();
    map20448.put("key20448", b20448.toString()); // put in a collection
    String c20448 = (String) map20448.get("key20448"); // get it back out
    String d20448 = c20448.substring(0, c20448.length() - 1); // extract most of it
    String e20448 =
        new String(
            new sun.misc.BASE64Decoder()
                .decodeBuffer(
                    new sun.misc.BASE64Encoder()
                        .encode(d20448.getBytes()))); // B64 encode and decode it
    String f20448 = e20448.split(" ")[0]; // split it on a space
    org.owasp.benchmark.helpers.ThingInterface thing =
        org.owasp.benchmark.helpers.ThingFactory.createThing();
    String g20448 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
    String bar = thing.doSomething(g20448); // reflection

    javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
    javax.xml.xpath.XPath xp = xpf.newXPath();
    try {
      xp.compile(bar);
    } catch (javax.xml.xpath.XPathExpressionException e) {
      // OK to swallow
      System.out.println("XPath expression exception caught and swallowed: " + e.getMessage());
    }
  }
コード例 #28
0
  public boolean xpathQuery(Document doc, String query) {
    log.debug("xpathQuery(Document doc, String query)");
    log.debug("path: " + query);

    XPathFactory xpathFact = XPathFactory.newInstance();
    XPath xpath = xpathFact.newXPath();
    boolean ret = false;
    try {
      ret = (xpath.evaluate(query, doc) == null) ? false : true;
    } catch (XPathExpressionException e) {
      log.debug("exception");
      log.debug(e.getMessage());
      return false;
    }

    if (ret == false) {
      log.debug("ret is false");
      log.debug(BioFuzzUtils.domToString(doc));
    }

    return ret;
  }
  @SuppressWarnings("unused")
  @Override
  public EvaluationResult findAttribute(
      String contextPath,
      URI attributeType,
      String contextSelector,
      Node root,
      EvaluationCtx context,
      String xpathVersion) {

    Node contextNode = null;
    NamespaceContext namespaceContext = null;

    System.out.println(
        "Context path ==> "
            + contextPath
            + " AttributeType ==> "
            + attributeType
            + " Context Selector ==> "
            + contextSelector
            + " Root Node name ==> "
            + root.getNodeName()
            + " root node type==> "
            + root.getNodeType()
            + " root node value==> "
            + root.getNodeValue()
            + " Context ==> "
            + context
            + " XPath version ==> "
            + xpathVersion);

    if (root == null) {
      System.out.println("Root node is null ");

      // root == null means there is not content element defined with the
      // attributes element
      // therefore complete request is evaluated.
      // get the DOM root of the request document
      contextNode = context.getRequestRoot();
    } else if (contextSelector != null) {
      System.out.println("Content selector is not null ");

      // root != null means content element is there. we can find the
      // context node by
      // evaluating the contextSelector

      // 1st assume context node as the root

      // TODO - Check if the contextNode should be assigned to root

      contextNode = root;

      XPathFactory factory = XPathFactory.newInstance();
      XPath xpath = factory.newXPath();

      // see if the request root is in a namespace
      String namespace = null;
      if (contextNode != null) {
        namespace = contextNode.getNamespaceURI();
        System.out.println(" nameSpace ==> " + contextNode);
      }
      // name spaces are used, so we need to lookup the correct
      // prefix to use in the search string
      NamedNodeMap namedNodeMap = contextNode.getAttributes();

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

      for (int i = 0; i < namedNodeMap.getLength(); i++) {
        Node n = namedNodeMap.item(i);
        // we found the matching namespace, so get the prefix
        // and then break out
        String prefix = DOMHelper.getLocalName(n);
        String nodeValue = n.getNodeValue();
        System.out.println("nodeValue of nameaspace ==> " + nodeValue);
        nsMap.put(prefix, nodeValue);
      }

      // if there is not any namespace is defined for content element,
      // default XACML request
      // name space would be there.
      if (XACMLConstants.REQUEST_CONTEXT_3_0_IDENTIFIER.equals(namespace)
          || XACMLConstants.REQUEST_CONTEXT_2_0_IDENTIFIER.equals(namespace)
          || XACMLConstants.REQUEST_CONTEXT_1_0_IDENTIFIER.equals(namespace)) {
        nsMap.put("xacml", namespace);
      }

      namespaceContext = new DefaultNamespaceContext(nsMap);
      xpath.setNamespaceContext(namespaceContext);

      try {
        XPathExpression expression = xpath.compile(contextSelector);
        NodeList result = (NodeList) expression.evaluate(contextNode, XPathConstants.NODESET);
        if (result == null || result.getLength() == 0) {
          throw new Exception("No node is found from context selector id evaluation");
        } else if (result.getLength() != 1) {
          throw new Exception("More than one node is found from context selector id evaluation");
        }
        contextNode = result.item(0);
      } catch (Exception e) {
        List<String> codes = new ArrayList<String>();
        codes.add(Status.STATUS_SYNTAX_ERROR);
        Status status = new Status(codes, e.getMessage());
        return new EvaluationResult(status);
      }
    } else {
      contextNode = root;
    }

    XPathFactory factory = XPathFactory.newInstance();
    XPath xpath = factory.newXPath();

    if (namespaceContext == null) {

      // see if the request root is in a namespace
      String namespace = null;
      if (contextNode != null) {
        namespace = contextNode.getNamespaceURI();
      }
      // name spaces are used, so we need to lookup the correct
      // prefix to use in the search string
      NamedNodeMap namedNodeMap = contextNode.getAttributes();

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

      for (int i = 0; i < namedNodeMap.getLength(); i++) {
        Node n = namedNodeMap.item(i);
        // we found the matching namespace, so get the prefix
        // and then break out
        String prefix = DOMHelper.getLocalName(n);
        String nodeValue = n.getNodeValue();
        nsMap.put(prefix, nodeValue);
      }

      // if there is not any namespace is defined for content element,
      // default XACML request
      // name space would be there.
      if (XACMLConstants.REQUEST_CONTEXT_3_0_IDENTIFIER.equals(namespace)
          || XACMLConstants.REQUEST_CONTEXT_2_0_IDENTIFIER.equals(namespace)
          || XACMLConstants.REQUEST_CONTEXT_1_0_IDENTIFIER.equals(namespace)) {
        nsMap.put("xacml", namespace);
      }

      namespaceContext = new DefaultNamespaceContext(nsMap);
    }

    xpath.setNamespaceContext(namespaceContext);

    NodeList matches;

    try {
      XPathExpression expression = xpath.compile(contextPath);
      matches = (NodeList) expression.evaluate(contextNode, XPathConstants.NODESET);
      if (matches == null || matches.getLength() < 1) {
        throw new Exception("No node is found from xpath evaluation");
      }
    } catch (XPathExpressionException e) {
      List<String> codes = new ArrayList<String>();
      codes.add(Status.STATUS_SYNTAX_ERROR);
      Status status = new Status(codes, e.getMessage());
      return new EvaluationResult(status);
    } catch (Exception e) {
      List<String> codes = new ArrayList<String>();
      codes.add(Status.STATUS_SYNTAX_ERROR);
      Status status = new Status(codes, e.getMessage());
      return new EvaluationResult(status);
    }

    if (matches.getLength() == 0) {
      // we didn't find anything, so we return an empty bag
      return new EvaluationResult(BagAttribute.createEmptyBag(attributeType));
    }

    // there was at least one match, so try to generate the values
    try {
      ArrayList<AttributeValue> list = new ArrayList<AttributeValue>();
      AttributeFactory attrFactory = Balana.getInstance().getAttributeFactory();

      for (int i = 0; i < matches.getLength(); i++) {
        String text = null;
        Node node = matches.item(i);
        short nodeType = node.getNodeType();

        // see if this is straight text, or a node with data under
        // it and then get the values accordingly
        if ((nodeType == Node.CDATA_SECTION_NODE)
            || (nodeType == Node.COMMENT_NODE)
            || (nodeType == Node.TEXT_NODE)
            || (nodeType == Node.ATTRIBUTE_NODE)) {
          // there is no child to this node
          text = node.getNodeValue();
        } else {
          // the data is in a child node
          text = node.getFirstChild().getNodeValue();
        }

        list.add(attrFactory.createValue(attributeType, text));
      }

      return new EvaluationResult(new BagAttribute(attributeType, list));

    } catch (ParsingException pe) {
      ArrayList<String> code = new ArrayList<String>();
      code.add(Status.STATUS_PROCESSING_ERROR);
      return new EvaluationResult(new Status(code, pe.getMessage()));
    } catch (UnknownIdentifierException uie) {
      ArrayList<String> code = new ArrayList<String>();
      code.add(Status.STATUS_PROCESSING_ERROR);
      return new EvaluationResult(new Status(code, "Unknown attribute type : " + attributeType));
    }
  }
コード例 #30
0
  /** Get an RDF organization from the given RDF file */
  private RDFOrganization getOrganization(Document xmlDocument, NamedNodeMap attrs) {
    RDFOrganization organization = new RDFOrganization();
    try {
      Node node = attrs.getNamedItem("rdf:resource");
      String itemDoi = node.getNodeValue();
      LOGGER.info("Processing item {}", itemDoi);
      // Get organization name
      String orgName =
          (String)
              xPath
                  .compile(orgNameExpression.replace("%s", itemDoi))
                  .evaluate(xmlDocument, XPathConstants.STRING);
      // Get country code
      Node countryNode =
          (Node)
              xPath
                  .compile(orgCountryExpression.replace("%s", itemDoi))
                  .evaluate(xmlDocument, XPathConstants.NODE);
      NamedNodeMap countryAttrs = countryNode.getAttributes();
      String countryGeonameUrl = countryAttrs.getNamedItem("rdf:resource").getNodeValue();
      String countryCode = fetchFromGeoNames(countryGeonameUrl, "countryCode");

      // Get state name
      Node stateNode =
          (Node)
              xPath
                  .compile(orgStateExpression.replace("%s", itemDoi))
                  .evaluate(xmlDocument, XPathConstants.NODE);
      String stateName = null;
      String stateCode = null;
      if (stateNode != null) {
        NamedNodeMap stateAttrs = stateNode.getAttributes();
        String stateGeoNameCode = stateAttrs.getNamedItem("rdf:resource").getNodeValue();
        stateName = fetchFromGeoNames(stateGeoNameCode, "name");
        stateCode = fetchFromGeoNames(stateGeoNameCode, STATE_NAME);
      }

      // Get type
      String orgType =
          (String)
              xPath
                  .compile(orgTypeExpression.replace("%s", itemDoi))
                  .evaluate(xmlDocument, XPathConstants.STRING);
      // Get subType
      String orgSubType =
          (String)
              xPath
                  .compile(orgSubTypeExpression.replace("%s", itemDoi))
                  .evaluate(xmlDocument, XPathConstants.STRING);

      // Fill the organization object
      organization.doi = itemDoi;
      organization.name = orgName;
      organization.country = countryCode;
      organization.state = stateName;
      organization.stateCode = stateCode;
      // TODO: since we don't have city, we fill this with the state, this
      // should be modified soon
      organization.city = stateCode;
      organization.type = orgType;
      organization.subtype = orgSubType;
    } catch (XPathExpressionException xpe) {
      LOGGER.error("XPathExpressionException {}", xpe.getMessage());
    }

    return organization;
  }