Example usage for javax.xml.xpath XPath setNamespaceContext

List of usage examples for javax.xml.xpath XPath setNamespaceContext

Introduction

In this page you can find the example usage for javax.xml.xpath XPath setNamespaceContext.

Prototype

public void setNamespaceContext(NamespaceContext nsContext);

Source Link

Document

Establish a namespace context.

Usage

From source file:gov.nij.bundles.intermediaries.ers.EntityResolutionMessageHandler.java

/**
 * This method takes the ER response and converts the Java objects to the Merge Response XML.
 * //from   w  w w  .  java  2 s.  com
 * @param entityContainerNode
 * @param results
 * @param recordLimit
 * @param attributeParametersNode
 * @return
 * @throws ParserConfigurationException
 * @throws XPathExpressionException
 * @throws TransformerException
 */
private Document createResponseMessage(Node entityContainerNode, EntityResolutionResults results,
        Node attributeParametersNode, int recordLimit) throws Exception {

    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    dbf.setNamespaceAware(true);

    Document resultDocument = dbf.newDocumentBuilder().newDocument();

    Element entityMergeResultMessageElement = resultDocument.createElementNS(
            EntityResolutionNamespaceContext.MERGE_RESULT_NAMESPACE, "EntityMergeResultMessage");
    resultDocument.appendChild(entityMergeResultMessageElement);

    Element entityContainerElement = resultDocument
            .createElementNS(EntityResolutionNamespaceContext.MERGE_RESULT_NAMESPACE, "EntityContainer");
    entityMergeResultMessageElement.appendChild(entityContainerElement);

    NodeList inputEntityNodes = (NodeList) xpath.evaluate("er-ext:Entity", entityContainerNode,
            XPathConstants.NODESET);
    Collection<Element> inputEntityElements = null;
    if (attributeParametersNode == null) {
        inputEntityElements = new ArrayList<Element>();
    } else {
        inputEntityElements = TreeMultiset
                .create(new EntityElementComparator((Element) attributeParametersNode));
        //inputEntityElements = new ArrayList<Element>();
    }

    for (int i = 0; i < inputEntityNodes.getLength(); i++) {
        inputEntityElements.add((Element) inputEntityNodes.item(i));
    }

    if (attributeParametersNode == null) {
        LOG.warn("Attribute Parameters element was null, so records will not be sorted");
    }
    //Collections.sort((List<Element>) inputEntityElements, new EntityElementComparator((Element) attributeParametersNode));

    if (inputEntityElements.size() != inputEntityNodes.getLength()) {
        LOG.error("Lost elements in ER output sorting.  Input count=" + inputEntityNodes.getLength()
                + ", output count=" + inputEntityElements.size());
    }

    for (Element e : inputEntityElements) {
        Node clone = resultDocument.adoptNode(e.cloneNode(true));
        resultDocument.renameNode(clone, EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE,
                e.getLocalName());
        entityContainerElement.appendChild(clone);
    }

    Element mergedRecordsElement = resultDocument
            .createElementNS(EntityResolutionNamespaceContext.MERGE_RESULT_NAMESPACE, "MergedRecords");
    entityMergeResultMessageElement.appendChild(mergedRecordsElement);

    if (results != null) {

        List<RecordWrapper> records = results.getRecords();

        // Loop through RecordWrappers to extract info to create merged records
        for (RecordWrapper record : records) {
            LOG.debug("  !#!#!#!# Record 1, id=" + record.getExternalId() + ", externals="
                    + record.getRelatedIds());

            // Create Merged Record Container
            Element mergedRecordElement = resultDocument.createElementNS(
                    EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE, "MergedRecord");
            mergedRecordsElement.appendChild(mergedRecordElement);

            // Create Original Record Reference for 'first record'
            Element originalRecordRefElement = resultDocument.createElementNS(
                    EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE, "OriginalRecordReference");
            originalRecordRefElement.setAttributeNS(EntityResolutionNamespaceContext.STRUCTURES_NAMESPACE,
                    "ref", record.getExternalId());
            mergedRecordElement.appendChild(originalRecordRefElement);

            // Loop through and add any related records
            for (String relatedRecordId : record.getRelatedIds()) {
                originalRecordRefElement = resultDocument.createElementNS(
                        EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE, "OriginalRecordReference");
                originalRecordRefElement.setAttributeNS(EntityResolutionNamespaceContext.STRUCTURES_NAMESPACE,
                        "ref", relatedRecordId);
                mergedRecordElement.appendChild(originalRecordRefElement);
            }

            // Create Merge Quality Element
            Element mergeQualityElement = resultDocument.createElementNS(
                    EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE, "MergeQuality");
            mergedRecordElement.appendChild(mergeQualityElement);
            Set<AttributeStatistics> stats = results.getStatisticsForRecord(record.getExternalId());
            for (AttributeStatistics stat : stats) {
                Element stringDistanceStatsElement = resultDocument.createElementNS(
                        EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE,
                        "StringDistanceStatistics");
                mergeQualityElement.appendChild(stringDistanceStatsElement);
                Element xpathElement = resultDocument.createElementNS(
                        EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE, "AttributeXPath");
                stringDistanceStatsElement.appendChild(xpathElement);
                Node contentNode = resultDocument.createTextNode(stat.getAttributeName());
                xpathElement.appendChild(contentNode);
                Element meanElement = resultDocument.createElementNS(
                        EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE,
                        "StringDistanceMeanInRecord");
                stringDistanceStatsElement.appendChild(meanElement);
                contentNode = resultDocument.createTextNode(String.valueOf(stat.getAverageStringDistance()));
                meanElement.appendChild(contentNode);
                Element sdElement = resultDocument.createElementNS(
                        EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE,
                        "StringDistanceStandardDeviationInRecord");
                stringDistanceStatsElement.appendChild(sdElement);
                contentNode = resultDocument
                        .createTextNode(String.valueOf(stat.getStandardDeviationStringDistance()));
                sdElement.appendChild(contentNode);

            }
        }

    } else {

        for (Element e : inputEntityElements) {

            String id = e.getAttributeNS(EntityResolutionNamespaceContext.STRUCTURES_NAMESPACE, "id");

            Element mergedRecordElement = resultDocument.createElementNS(
                    EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE, "MergedRecord");
            mergedRecordsElement.appendChild(mergedRecordElement);

            Element originalRecordRefElement = resultDocument.createElementNS(
                    EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE, "OriginalRecordReference");
            originalRecordRefElement.setAttributeNS(EntityResolutionNamespaceContext.STRUCTURES_NAMESPACE,
                    "ref", id);
            mergedRecordElement.appendChild(originalRecordRefElement);

            Element mergeQualityElement = resultDocument.createElementNS(
                    EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE, "MergeQuality");
            mergedRecordElement.appendChild(mergeQualityElement);
            XPath xp = XPathFactory.newInstance().newXPath();
            xp.setNamespaceContext(new EntityResolutionNamespaceContext());
            NodeList attributeParameterNodes = (NodeList) xp.evaluate("er-ext:AttributeParameter",
                    attributeParametersNode, XPathConstants.NODESET);
            for (int i = 0; i < attributeParameterNodes.getLength(); i++) {
                String attributeName = xp.evaluate("er-ext:AttributeXPath", attributeParametersNode);
                Element stringDistanceStatsElement = resultDocument.createElementNS(
                        EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE,
                        "StringDistanceStatistics");
                mergeQualityElement.appendChild(stringDistanceStatsElement);
                Element xpathElement = resultDocument.createElementNS(
                        EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE, "AttributeXPath");
                stringDistanceStatsElement.appendChild(xpathElement);
                Node contentNode = resultDocument.createTextNode(attributeName);
                xpathElement.appendChild(contentNode);
                Element meanElement = resultDocument.createElementNS(
                        EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE,
                        "StringDistanceMeanInRecord");
                stringDistanceStatsElement.appendChild(meanElement);
                contentNode = resultDocument.createTextNode("0.0");
                meanElement.appendChild(contentNode);
                Element sdElement = resultDocument.createElementNS(
                        EntityResolutionNamespaceContext.MERGE_RESULT_EXT_NAMESPACE,
                        "StringDistanceStandardDeviationInRecord");
                stringDistanceStatsElement.appendChild(sdElement);
                contentNode = resultDocument.createTextNode("0.0");
                sdElement.appendChild(contentNode);
            }

        }

    }

    Element recordLimitExceededElement = resultDocument.createElementNS(
            EntityResolutionNamespaceContext.MERGE_RESULT_NAMESPACE, "RecordLimitExceededIndicator");
    recordLimitExceededElement.setTextContent(new Boolean(results == null).toString());
    entityMergeResultMessageElement.appendChild(recordLimitExceededElement);

    return resultDocument;

}

From source file:com.zimbra.qa.unittest.TestCalDav.java

public static Document groupMemberSetExpandProperty(Account acct, Account member, boolean proxyWrite)
        throws IOException, ServiceException {
    String url = proxyWrite ? TestCalDav.getCalendarProxyWriteUrl(acct)
            : TestCalDav.getCalendarProxyReadUrl(acct);
    url = url.replaceAll("@", "%40");
    String href = proxyWrite ? UrlNamespace.getCalendarProxyWriteUrl(acct, acct)
            : UrlNamespace.getCalendarProxyReadUrl(acct, acct);
    href = href.replaceAll("@", "%40");
    ReportMethod method = new ReportMethod(url);
    addBasicAuthHeaderForUser(method, acct);
    HttpClient client = new HttpClient();
    TestCalDav.HttpMethodExecutor executor;
    method.addRequestHeader("Content-Type", MimeConstants.CT_TEXT_XML);
    method.setRequestEntity(new ByteArrayRequestEntity(TestCalDav.expandPropertyGroupMemberSet.getBytes(),
            MimeConstants.CT_TEXT_XML));
    executor = new TestCalDav.HttpMethodExecutor(client, method, HttpStatus.SC_MULTI_STATUS);
    String respBody = new String(executor.responseBodyBytes, MimeConstants.P_CHARSET_UTF8);
    Document doc = W3cDomUtil.parseXMLToDoc(respBody);
    org.w3c.dom.Element docElement = doc.getDocumentElement();
    assertEquals("Report node name", DavElements.P_MULTISTATUS, docElement.getLocalName());
    XPath xpath = XPathFactory.newInstance().newXPath();
    xpath.setNamespaceContext(TestCalDav.NamespaceContextForXPath.forCalDAV());
    XPathExpression xPathExpr;//from   w ww .  ja v a2s . co m
    try {
        String xpathS = "/D:multistatus/D:response/D:href/text()";
        xPathExpr = xpath.compile(xpathS);
        String text = (String) xPathExpr.evaluate(doc, XPathConstants.STRING);
        assertEquals("HREF for response", href, text);

        xpathS = "/D:multistatus/D:response/D:propstat/D:prop/D:group-member-set/D:response/D:href/text()";
        xPathExpr = xpath.compile(xpathS);
        text = (String) xPathExpr.evaluate(doc, XPathConstants.STRING);
        assertEquals("HREF for sharee", UrlNamespace.getPrincipalUrl(member).replaceAll("@", "%40"), text);
    } catch (XPathExpressionException e1) {
        ZimbraLog.test.debug("xpath problem", e1);
    }
    return doc;
}

From source file:com.jkoolcloud.tnt4j.streams.parsers.ActivityXmlParserTest.java

@Test
public void testNamespaceAwareXpathResolveWithPreparser() throws Exception {
    NamespaceTestSuite testSuite = new NamespaceTestSuite().invoke();
    DocumentBuilderFactory domFactory = testSuite.getDomFactory();
    String xmlString = testSuite.getXmlString();
    XPath xPath = testSuite.getxPath();
    Map<String, String> namespaces = testSuite.getNamespaces();

    DocumentBuilder builder = domFactory.newDocumentBuilder();
    // Document document = builder.parse(IOUtils.toInputStream(xmlString, Utils.UTF8));
    XMLFromBinDataPreParser xmlFromBinDataPreParser = new XMLFromBinDataPreParser();
    Document document = xmlFromBinDataPreParser.preParse(xmlString);

    NamespaceMap nsContext = new NamespaceMap();
    xPath.setNamespaceContext(nsContext);

    nsContext.addPrefixUriMappings(namespaces);

    Document tDoc = document.getOwnerDocument();
    Element docElem = tDoc == null ? null : tDoc.getDocumentElement();
    if (tDoc == null || StringUtils.isEmpty(tDoc.getNamespaceURI())) {
        document = builder/*from   ww  w.  j av a  2s  .co m*/
                .parse(new ReaderInputStream(new StringReader(Utils.documentToString(document)), Utils.UTF8));
    }

    NamespaceMap documentNamespaces = new NamespaceMap();
    StreamsXMLUtils.resolveDocumentNamespaces(document, documentNamespaces, false);

    String evaluate = xPath.compile("/soapenv:Envelope/soapenv:Header/ch:TSYSprofileInq/ch:clientData")
            .evaluate(document);
    assertEquals("xxxxxx-343e-46af-86aa-634a3688cf30", evaluate);
    evaluate = xPath.compile("/Envelope/Header/TSYSprofileInq/clientData").evaluate(document);
    assertEquals("", evaluate);
}

From source file:com.zimbra.qa.unittest.TestCalDav.java

/**
 * @param acct/*  w w w.j av a2s  .  c  om*/
 * @param UID - null or empty if don't care
 * @param expected - false if don't expect a matching item to be in collection within timeout time
 * @return href of first matching item found
 * @throws ServiceException
 * @throws IOException
 */
public static String waitForItemInCalendarCollectionByUID(String url, Account acct, String UID,
        boolean expected, int timeout_millis) throws ServiceException, IOException {
    int orig_timeout_millis = timeout_millis;
    while (timeout_millis > 0) {
        Document doc = calendarQuery(url, acct);
        XPath xpath = XPathFactory.newInstance().newXPath();
        xpath.setNamespaceContext(TestCalDav.NamespaceContextForXPath.forCalDAV());
        XPathExpression xPathExpr;
        try {
            xPathExpr = xpath.compile("/D:multistatus/D:response/D:href/text()");
            NodeList result = (NodeList) xPathExpr.evaluate(doc, XPathConstants.NODESET);
            if (1 <= result.getLength()) {
                for (int ndx = 0; ndx < result.getLength(); ndx++) {
                    Node item = result.item(ndx);
                    String nodeValue = item.getNodeValue();
                    if ((Strings.isNullOrEmpty(UID)) || (nodeValue.contains(UID))) {
                        if (!expected) {
                            fail(String.format(
                                    "item with UID '%s' unexpectedly arrived in collection '%s' within %d millisecs",
                                    Strings.nullToEmpty(UID), url, orig_timeout_millis - timeout_millis));

                        }
                        return nodeValue;
                    }
                }
            }
        } catch (XPathExpressionException e1) {
            ZimbraLog.test.debug("xpath problem", e1);
        }
        try {
            if (timeout_millis > TestUtil.DEFAULT_WAIT) {
                Thread.sleep(TestUtil.DEFAULT_WAIT);
                timeout_millis = timeout_millis - TestUtil.DEFAULT_WAIT;
            } else {
                Thread.sleep(timeout_millis);
                timeout_millis = 0;

            }
        } catch (InterruptedException e) {
            ZimbraLog.test.debug("sleep got interrupted", e);
        }
    }
    if (expected) {
        fail(String.format("item with UID '%s' didn't arrive in collection '%s' within %d millisecs",
                Strings.nullToEmpty(UID), url, orig_timeout_millis));
    }
    return null;

}

From source file:com.servicelibre.jxsl.scenario.test.xspec.XspecTestScenarioRunner.java

private void init() {

    XPath xpath = null;
    try {/* w  ww .  j  a v a2s  .  c  om*/
        xpath = XPathFactory.newInstance(NamespaceConstant.OBJECT_MODEL_SAXON).newXPath();
    } catch (XPathFactoryConfigurationException e1) {
        logger.error("Error while creating XPathFactory", e1);
        return;
    }

    SimpleNamespaceContext namespaceContext = new SimpleNamespaceContext();
    namespaceContext.bindNamespaceUri("x", "http://www.jenitennison.com/xslt/xspec");
    xpath.setNamespaceContext(namespaceContext);

    try {

        successXpath = xpath.compile("count(//x:test[@successful ='false'] ) = 0");
        testFailedCount = xpath.compile("count(//x:test[@successful ='false'] )");
        testCount = xpath.compile("count(//x:test)");
    } catch (XPathExpressionException e) {
        logger.error("Error while initializing {}.", this.getClass().getName(), e);
    }

    DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
    docFactory.setNamespaceAware(true);

    try {
        xmlBuilder = docFactory.newDocumentBuilder();
    } catch (ParserConfigurationException e) {
        logger.error("Error while configuring XML parser", e);
    }

}

From source file:nl.armatiek.xslweb.configuration.WebApp.java

public WebApp(File webAppDefinition) throws Exception {
    logger.info(String.format("Loading webapp definition \"%s\" ...", webAppDefinition.getAbsolutePath()));

    Context context = Context.getInstance();
    this.definition = webAppDefinition;
    this.homeDir = webAppDefinition.getParentFile();
    this.name = this.homeDir.getName();

    this.configuration = new XSLWebConfiguration(this);
    this.processor = new Processor(this.configuration.getConfiguration());

    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    dbf.setNamespaceAware(true);// www.  j  a v a 2  s . c  om
    dbf.setSchema(context.getWebAppSchema());
    dbf.setXIncludeAware(true);
    DocumentBuilder db = dbf.newDocumentBuilder();
    db.setErrorHandler(this);

    String defXml = IOUtils.toString(new XmlStreamReader(webAppDefinition));
    Properties vars = new Properties(System.getProperties());
    vars.setProperty("webapp-dir", webAppDefinition.getParentFile().getAbsolutePath().replace('\\', '/'));
    String resolvedDefXml = XSLWebUtils.resolveProperties(defXml, vars);
    // Document webAppDoc = db.parse(webAppDefinition);
    InputSource src = new InputSource(new StringReader(resolvedDefXml));
    src.setSystemId(webAppDefinition.getAbsolutePath());
    Document webAppDoc = db.parse(src);

    XPath xpath = new XPathFactoryImpl().newXPath();
    xpath.setNamespaceContext(XMLUtils.getNamespaceContext("webapp", Definitions.NAMESPACEURI_XSLWEB_WEBAPP));
    Node docElem = webAppDoc.getDocumentElement();
    this.title = (String) xpath.evaluate("webapp:title", docElem, XPathConstants.STRING);
    this.description = (String) xpath.evaluate("webapp:description", docElem, XPathConstants.STRING);
    String devModeValue = (String) xpath.evaluate("webapp:development-mode", docElem, XPathConstants.STRING);
    this.developmentMode = XMLUtils.getBooleanValue(devModeValue, false);
    String maxUploadSizeValue = (String) xpath.evaluate("webapp:max-upload-size", docElem,
            XPathConstants.STRING);
    this.maxUploadSize = XMLUtils.getIntegerValue(maxUploadSizeValue, 10);
    String waitForJobsAtCloseValue = (String) xpath.evaluate("webapp:wait-for-jobs-at-close", docElem,
            XPathConstants.STRING);
    this.waitForJobsAtClose = XMLUtils.getBooleanValue(waitForJobsAtCloseValue, true);

    NodeList resourceNodes = (NodeList) xpath.evaluate("webapp:resources/webapp:resource", docElem,
            XPathConstants.NODESET);
    for (int i = 0; i < resourceNodes.getLength(); i++) {
        resources.add(new Resource((Element) resourceNodes.item(i)));
    }
    NodeList paramNodes = (NodeList) xpath.evaluate("webapp:parameters/webapp:parameter", docElem,
            XPathConstants.NODESET);
    for (int i = 0; i < paramNodes.getLength(); i++) {
        parameters.add(new Parameter(processor, (Element) paramNodes.item(i)));
    }
    NodeList jobNodes = (NodeList) xpath.evaluate("webapp:jobs/webapp:job", docElem, XPathConstants.NODESET);
    if (jobNodes.getLength() > 0) {
        File quartzFile = new File(homeDir, Definitions.FILENAME_QUARTZ);
        quartzFile = (quartzFile.isFile()) ? quartzFile
                : new File(context.getHomeDir(), "config" + File.separatorChar + Definitions.FILENAME_QUARTZ);
        SchedulerFactory sf;
        if (quartzFile.isFile()) {
            logger.info(String.format("Initializing Quartz scheduler using properties file \"%s\" ...",
                    quartzFile.getAbsolutePath()));
            Properties props = XSLWebUtils.readProperties(quartzFile);
            props.setProperty(StdSchedulerFactory.PROP_SCHED_INSTANCE_NAME, name);
            sf = new StdSchedulerFactory(props);
        } else {
            logger.info("Initializing Quartz scheduler ...");
            sf = new StdSchedulerFactory();
        }
        scheduler = sf.getScheduler();
        for (int i = 0; i < jobNodes.getLength(); i++) {
            Element jobElem = (Element) jobNodes.item(i);
            String jobName = XMLUtils.getValueOfChildElementByLocalName(jobElem, "name");
            String jobUri = XMLUtils.getValueOfChildElementByLocalName(jobElem, "uri");
            String jobCron = XMLUtils.getValueOfChildElementByLocalName(jobElem, "cron");
            boolean concurrent = XMLUtils
                    .getBooleanValue(XMLUtils.getValueOfChildElementByLocalName(jobElem, "concurrent"), true);
            String jobId = "job_" + name + "_" + jobName;
            JobDetail job = newJob(concurrent ? XSLWebJob.class : NonConcurrentExecutionXSLWebJob.class)
                    .withIdentity(jobId, name).usingJobData("webapp-path", getPath())
                    .usingJobData("uri", jobUri).build();
            Trigger trigger = newTrigger().withIdentity("trigger_" + name + "_" + jobName, name)
                    .withSchedule(cronSchedule(jobCron)).forJob(jobId, name).build();
            logger.info(String.format("Scheduling job \"%s\" of webapp \"%s\" ...", jobName, name));
            scheduler.scheduleJob(job, trigger);
        }
    }

    NodeList dataSourceNodes = (NodeList) xpath.evaluate("webapp:datasources/webapp:datasource", docElem,
            XPathConstants.NODESET);
    for (int i = 0; i < dataSourceNodes.getLength(); i++) {
        DataSource dataSource = new DataSource((Element) dataSourceNodes.item(i));
        dataSources.put(dataSource.getName(), dataSource);
    }

    NodeList fopConfigNodes = (NodeList) xpath.evaluate("webapp:fop-configs/webapp:fop-config", docElem,
            XPathConstants.NODESET);
    for (int i = 0; i < fopConfigNodes.getLength(); i++) {
        Element fopConfig = (Element) fopConfigNodes.item(i);
        Element fopElement = XMLUtils.getFirstChildElement(fopConfig);
        fopConfigs.put(fopConfig.getAttribute("name"), XMLUtils.nodeToString(fopElement));
    }

    // initClassLoader();

    initFileAlterationObservers();
}

From source file:com.esri.gpt.server.csw.provider3.GetRecordsProvider.java

/**
 * Handles a URL based request (HTTP GET).
 * @param context the operation context/*from   w  w w.  j  av a 2s . c  om*/
 * @param request the HTTP request
 * @throws Exception if a processing exception occurs
 */
public void handleGet(OperationContext context, HttpServletRequest request) throws Exception {

    // initialize
    LOGGER.finer("Handling csw:GetRecords request URL...");
    QueryOptions qOptions = context.getRequestOptions().getQueryOptions();
    qOptions.setMaxRecordsThreshold(getMaxRecordsThreshold());
    ServiceProperties svcProps = context.getServiceProperties();
    ParseHelper pHelper = new ParseHelper();
    ValidationHelper vHelper = new ValidationHelper();
    String locator;
    String[] parsed;
    ISupportedValues supported;
    IProviderFactory factory = context.getProviderFactory();

    CswNamespaces ns = CswNamespaces.CSW_30;
    XPath xpath = XPathFactory.newInstance().newXPath();
    xpath.setNamespaceContext(ns.makeNamespaceContext());

    // service and version are parsed by the parent RequestHandler

    // TODO typeNames requestId distributedSearch hopCount responseHandler
    // TODO resultype validate is not applicable for a GET request?

    // output format
    locator = "outputFormat";
    parsed = pHelper.getParameterValues(request, locator);
    supported = svcProps.getSupportedValues(CswConstants.Parameter_OutputFormat);
    try {
        context.getOperationResponse()
                .setOutputFormat(vHelper.validateValue(supported, locator, parsed, false));
    } catch (OwsException ex) {
        context.getOperationResponse().setResponseCode(HttpServletResponse.SC_BAD_REQUEST);
        throw ex;
    }

    // output schema
    locator = "outputSchema";
    parsed = pHelper.getParameterValues(request, locator);
    supported = svcProps.getSupportedValues(CswConstants.Parameter_OutputSchema);
    try {
        qOptions.setOutputSchema(vHelper.validateValue(supported, locator, parsed, false));
    } catch (OwsException ex) {
        context.getOperationResponse().setResponseCode(HttpServletResponse.SC_BAD_REQUEST);
        throw ex;
    }

    // record ids
    locator = "recordIds";
    parsed = pHelper.getParameterValues(request, locator, ",");
    qOptions.setIDs(vHelper.validateValues(locator, parsed, false));

    // keywords
    locator = "q";
    parsed = pHelper.getParameterValues(request, locator, " ");
    if ((parsed != null) && (parsed.length) > 0) {
        IQueryParser parser = factory.makeQueryParser(context);
        if (parser == null) {
            String msg = "IProviderFactory.makeFilterParser: instantiation failed.";
            context.getOperationResponse().setResponseCode(HttpServletResponse.SC_BAD_REQUEST);
            throw new OwsException(OwsException.OWSCODE_NoApplicableCode, locator, msg);
        }
        try {
            parser.parseQuery(context, parsed);
        } catch (OwsException ex) {
            context.getOperationResponse().setResponseCode(HttpServletResponse.SC_BAD_REQUEST);
            throw ex;
        }
    }

    // bbox
    locator = "bbox";
    parsed = pHelper.getParameterValues(request, locator, ",");
    if ((parsed != null) && (parsed.length) > 0) {
        try {
            IBBOXParser parser = factory.makeBBOXParser(context);
            if (parser == null) {
                String msg = "IProviderFactory.makeBBOXParser: instantiation failed.";
                throw new OwsException(OwsException.OWSCODE_NoApplicableCode, locator, msg);
            }
            if (parsed.length < 4 || parsed.length > 5) {
                String msg = "GetRecordsProvider:handleGet: invalid bbox.";
                throw new OwsException(OwsException.OWSCODE_InvalidParameterValue, locator, msg);
            }
            String crs = null;
            if (parsed.length == 5) {
                crs = parsed[4];
                parsed = ArrayUtils.subarray(parsed, 0, 4);
                supported = svcProps.getSupportedValues(CswConstants.Parameter_Crs);
                vHelper.validateValue(supported, locator + ":crs", parsed, true);
            }
            parser.parseBBOX(context, parsed, crs);
        } catch (OwsException ex) {
            context.getOperationResponse().setResponseCode(HttpServletResponse.SC_BAD_REQUEST);
            throw ex;
        }
    }

    // start and max records
    parsed = pHelper.getParameterValues(request, "startPosition");
    if ((parsed != null) && (parsed.length) > 0) {
        qOptions.setStartRecord(Math.max(Val.chkInt(parsed[0], 1), 1));
    }
    parsed = pHelper.getParameterValues(request, "maxRecords");
    if ((parsed != null) && (parsed.length) > 0) {
        if (parsed[0].equalsIgnoreCase("unlimited")) {
            qOptions.setMaxRecords(getMaxRecordsThreshold());
            qOptions.setUnlimited(true);
        } else {
            qOptions.setMaxRecords(Val.chkInt(parsed[0], 10));
        }
    }

    // result type
    locator = "resultType";
    parsed = pHelper.getParameterValues(request, locator);
    supported = svcProps.getSupportedValues(CswConstants.Parameter_ResultType);
    qOptions.setResultType(vHelper.validateValue(supported, locator, parsed, false));
    if (qOptions.getResultType() == null) {
        qOptions.setResultType(CswConstants.ResultType_Results);
    }

    // query type names
    locator = "typeNames";
    parsed = pHelper.getParameterValues(request, locator);
    if (parsed != null) {
        List<String[]> namespaces = parseNamespace(pHelper.getParameterValues(request, "namespace", ","));
        translateNamespaces(parsed, namespaces);
    }
    supported = svcProps.getSupportedValues(CswConstants.Parameter_TypeNames);
    try {
        qOptions.setQueryTypeNames(vHelper.validateValues(supported, locator, parsed, false));
    } catch (OwsException ex) {
        context.getOperationResponse().setResponseCode(HttpServletResponse.SC_BAD_REQUEST);
        throw ex;
    }

    // response element set type
    locator = "ElementSetName";
    parsed = pHelper.getParameterValues(request, locator);
    supported = svcProps.getSupportedValues(CswConstants.Parameter_ElementSetType);
    try {
        qOptions.setElementSetType(vHelper.validateValue(supported, locator, parsed, false));
    } catch (OwsException ex) {
        context.getOperationResponse().setResponseCode(HttpServletResponse.SC_BAD_REQUEST);
        throw ex;
    }

    // TODO supported ElementNames this for GetRecordById as well?
    locator = "ElementName";
    parsed = pHelper.getParameterValues(request, locator, ",");
    if (parsed != null && qOptions.getElementSetType() != null) {
        String msg = "GetRecordsProvider:handleGet: elementName not allowed if elementSetName present.";
        context.getOperationResponse().setResponseCode(HttpServletResponse.SC_BAD_REQUEST);
        throw new OwsException(OwsException.OWSCODE_NoApplicableCode, locator, msg);
    }
    if (parsed != null) {
        List<String[]> namespaces = parseNamespace(pHelper.getParameterValues(request, "namespace", ","));
        translateNamespaces(parsed, namespaces);
    }
    supported = svcProps.getSupportedValues(CswConstants.Parameter_ElementName);
    try {
        qOptions.setElementNames(vHelper.validateValues(supported, locator, parsed, false));
    } catch (OwsException ex) {
        context.getOperationResponse().setResponseCode(HttpServletResponse.SC_BAD_REQUEST);
        throw ex;
    }

    // constraint language
    locator = "constraintLanguage";
    parsed = pHelper.getParameterValues(request, locator);
    supported = new SupportedValues("CQL_TEXT,FILTER", ",");
    String constraintLanguage = vHelper.validateValue(supported, locator, parsed, false);

    // constraint version
    locator = "constraint_language_version";
    parsed = pHelper.getParameterValues(request, locator);
    String constraintVersion = vHelper.validateValue(locator, parsed, false);
    qOptions.setQueryConstraintVersion(constraintVersion);

    // constraint text
    locator = "constraint";
    parsed = pHelper.getParameterValues(request, locator);
    String constraint = vHelper.validateValue(locator, parsed, false);

    // csw:CqlText
    if ((constraintLanguage != null) && constraintLanguage.equalsIgnoreCase("CQL_TEXT")) {
        String cql = Val.chkStr(constraint);
        qOptions.setQueryConstraintCql(cql);
        ICqlParser parser = factory.makeCqlParser(context, constraintVersion);
        if (parser == null) {
            String msg = "IProviderFactory.makeCqlParser: instantiation failed.";
            throw new OwsException(OwsException.OWSCODE_NoApplicableCode, locator, msg);
        } else {
            parser.parseCql(context, cql);
        }
    }

    // ogc:Filter
    if ((constraintLanguage == null) || constraintLanguage.equalsIgnoreCase("FILTER")) {
        Node ndFilter = null;
        IFilterParser parser = factory.makeFilterParser(context, constraintVersion);
        if (parser == null) {
            String msg = "IProviderFactory.makeFilterParser: instantiation failed.";
            throw new OwsException(OwsException.OWSCODE_NoApplicableCode, locator, msg);
        }
        String constraintFilter = Val.chkStr(constraint);
        if (constraintFilter.length() > 0) {
            String[] namespace = pHelper.getParameterValues(request, "namespace", ",");
            ndFilter = this.buildFilterNode(namespace, constraintFilter);
            parser.parseFilter(context, ndFilter, xpath);
        }
    }

    // ogc:SortBy
    locator = "sortBy";
    String[] sortBy = pHelper.getParameterValues(request, "sortBy", ",");
    if (sortBy != null) {
        Node ndSortBy = this.buildSortByNode(sortBy);
        if (ndSortBy != null) {
            ISortByParser parser = factory.makeSortByParser(context);
            if (parser == null) {
                String msg = "IProviderFactory.makeSortByParser: instantiation failed.";
                throw new OwsException(OwsException.OWSCODE_NoApplicableCode, locator, msg);
            } else {
                parser.parseSortBy(context, ndSortBy, xpath);
            }
        }
    }

    // execute the request
    this.execute(context);
}

From source file:net.solarnetwork.node.support.XmlServiceSupport.java

/**
 * Compile XPathExpression mappings from String XPath expressions.
 * /*from   ww w . ja  va 2s.c  o  m*/
 * @param xpathMap
 *        the XPath string expressions
 * @return the XPathExperssion mapping
 */
protected Map<String, XPathExpression> getXPathExpressionMap(Map<String, String> xpathMap) {
    Map<String, XPathExpression> datumXPathMap = new LinkedHashMap<String, XPathExpression>();
    for (Map.Entry<String, String> me : xpathMap.entrySet()) {
        try {
            XPath xp = getXpathFactory().newXPath();
            if (getNsContext() != null) {
                xp.setNamespaceContext(getNsContext());
            }
            datumXPathMap.put(me.getKey(), xp.compile(me.getValue()));
        } catch (XPathExpressionException e) {
            throw new RuntimeException(e);
        }
    }
    return datumXPathMap;
}

From source file:com.fluidops.iwb.provider.XMLProvider.java

/**
 * Requires the input to be a single node
 * /*from w  ww  .  j  a  va  2  s.c  o  m*/
 * @param xpathOP
 * @param n
 * @return
 */
protected List<String> getHashValue(String xpathOP, Node context) {
    List<String> res = new ArrayList<String>();
    Pattern p = Pattern.compile("^\\{([^\\}]*)\\}$");
    Matcher m = p.matcher(xpathOP);

    if (m.matches()) {
        try {
            XPath xpath = xpf.newXPath();
            xpath.setNamespaceContext(ctx);
            XPathExpression xpathExp = xpath.compile(xpathOP.substring(1, xpathOP.length() - 1));
            NodeList nl = (NodeList) xpathExp.evaluate(context, XPathConstants.NODESET);

            for (int i = 0; i < nl.getLength(); i++) {
                Node n = nl.item(i);
                String s = XML.toFormattedString(n);
                res.add(SHA512.encrypt(s));
            }
        } catch (Exception e) {
            logger.warn(e.getMessage());
        }

    }
    return res;
}

From source file:com.fluidops.iwb.provider.XMLProvider.java

/**
 * Resolves a parametrized expression against a given context node.
 * A parametrized expression is a string of the form
 * //  ww w  .  j a  v  a 2s . c  om
 *   "Bla bla {XP1} some text {XP2} ... {XPn}",
 * 
 * where XP1 ... XPn are XPath expressions. When evaluating a parametrized
 * expression, the XPath expressions are evaluated against the context 
 * node and their occurences are replaced by the result nodes. The result
 * nodes is a list of strings, representing all permutations of solutions.
 * 
 * As an example, assume the parametrized expression is
 * 
 *   "{./name} - {./friend}"
 *  
 * and [[./name]] = { Pete }, [[./friend]] = { Jane, Joe }, then the result
 * of evaluating the parametrized expression is the list { "Pete - Jane", "Pete - Joe" }.
 * 
 * @param parametrizedExpression
 * @param context
 * @return
 */
protected List<String> resolveParametrizedExpression(String parametrizedExpression, Node context,
        boolean useNodeName, String ignoreIfMatches) {
    Map<String, XPathExpression> map = new HashMap<String, XPathExpression>();

    List<String> result = new ArrayList<String>();
    if (parametrizedExpression == null)
        return result;

    // first collect XPath Expression hidden in ruleExpression
    Map<String, List<String>> xPathExpressions = new HashMap<String, List<String>>();
    Matcher m = PARAMETRIZED_EXPRESSION_PATTERN.matcher(parametrizedExpression);
    while (m.find())
        xPathExpressions.put(m.group(0), new ArrayList<String>());

    XPath xpathDPExp = xpf.newXPath();
    xpathDPExp.setNamespaceContext(ctx);
    for (Entry<String, List<String>> entry : xPathExpressions.entrySet()) {
        String xPathExpression = entry.getKey();
        try {
            XPathExpression xpathExp = map.get(xPathExpression);
            if (xpathExp == null) {
                xpathExp = xpathDPExp.compile(xPathExpression.substring(1, xPathExpression.length() - 1));
                map.put(xPathExpression, xpathExp);
            }

            try {
                NodeList dpNodeList = (NodeList) xpathExp.evaluate(context, XPathConstants.NODESET);

                for (int i = 0; i < dpNodeList.getLength(); i++) {
                    Node dpNode = dpNodeList.item(i);
                    String dpNodeVal = null;
                    if (useNodeName)
                        dpNodeVal = dpNode.getNodeName();
                    else {
                        if (dpNode instanceof Element)
                            dpNodeVal = dpNode.getTextContent();
                        else
                            dpNodeVal = dpNode.getNodeValue();
                    }
                    if (!StringUtil.isNullOrEmpty(dpNodeVal))
                        entry.getValue().add(dpNodeVal);
                }
            } catch (XPathExpressionException isString) {
                String string = (String) xpathExp.evaluate(context, XPathConstants.STRING);
                if (!StringUtil.isNullOrEmpty(string))
                    entry.getValue().add(string);
            }
        } catch (Exception e) {
            logger.warn(e.getMessage());
            return result; // error
        }
    }

    // and compute set of all Literals
    result.add(parametrizedExpression);
    for (Entry<String, List<String>> entry : xPathExpressions.entrySet()) {
        String outerKey = entry.getKey();
        List<String> tempResult = new ArrayList<String>();
        List<String> outer = entry.getValue();
        for (int i = 0; i < outer.size(); i++) {
            for (String res : result) {
                while (res.contains(outerKey))
                    res = res.replace(outerKey, outer.get(i));
                tempResult.add(res);
            }
        }
        result = tempResult;
    }

    if (StringUtil.isNullOrEmpty(ignoreIfMatches))
        return result;

    // else: we filter the result
    List<String> resultFiltered = new ArrayList<String>();
    for (String s : result) {
        if (!s.matches(ignoreIfMatches))
            resultFiltered.add(s);
    }
    return resultFiltered;
}