Example usage for org.w3c.dom Element getElementsByTagNameNS

List of usage examples for org.w3c.dom Element getElementsByTagNameNS

Introduction

In this page you can find the example usage for org.w3c.dom Element getElementsByTagNameNS.

Prototype

public NodeList getElementsByTagNameNS(String namespaceURI, String localName) throws DOMException;

Source Link

Document

Returns a NodeList of all the descendant Elements with a given local name and namespace URI in document order.

Usage

From source file:org.eclipse.smila.processing.bpel.PipeletManager.java

/**
 * parse a PipeletConfiguration from the content of extension activity.
 * //from   ww w .ja v a2s  . c  om
 * @param content
 *          extension activity content.
 * @return the parsed PipeletConfiguration if one was contained, else null.
 */
private AnyMap parseConfiguration(final Element content) {
    AnyMap configuration = null;
    final NodeList config = content.getElementsByTagNameNS(ODEWorkflowProcessor.NAMESPACE_PROCESSOR,
            BPELConstants.TAG_CONFIGURATION);
    if (config.getLength() > 0) {
        final Element configElement = (Element) config.item(0);
        configuration = _configReader.parseMap(configElement);
    }
    return configuration;
}

From source file:org.eclipse.smila.processing.bpel.PipeletManager.java

/**
 * find element with given local name (proc: namespace) and return value of given attribute. return null, if not
 * found.//from   ww w  .j a v  a 2  s  .c  o  m
 * 
 * @param content
 *          an element to search in.
 * @param localName
 *          local name of element to look for.
 * @param attribute
 *          attribute name.
 * @return attribute value if found, else null.
 */
private String getAttributeOfElement(final Element content, final String localName, final String attribute) {
    String attributeValue = null;
    final NodeList nodes = content.getElementsByTagNameNS(ODEWorkflowProcessor.NAMESPACE_PROCESSOR, localName);
    if (nodes.getLength() > 0) {
        attributeValue = ((Element) nodes.item(0)).getAttribute(attribute);
        if (StringUtils.isBlank(attributeValue)) {
            attributeValue = null;
        }
    }
    return attributeValue;
}

From source file:org.exist.http.urlrewrite.XQueryURLRewrite.java

@Override
protected void service(HttpServletRequest servletRequest, HttpServletResponse servletResponse)
        throws IOException, ServletException {
    if (rewriteConfig == null) {
        configure();/*w ww.ja  v a2s . c  o m*/
        rewriteConfig = new RewriteConfig(this);
    }

    final long start = System.currentTimeMillis();
    final HttpServletRequest request = servletRequest;
    final HttpServletResponse response = servletResponse;

    if (LOG.isTraceEnabled()) {
        LOG.trace(request.getRequestURI());
    }
    final Descriptor descriptor = Descriptor.getDescriptorSingleton();
    if (descriptor != null && descriptor.requestsFiltered()) {
        final String attr = (String) request.getAttribute("XQueryURLRewrite.forwarded");
        if (attr == null) {
            //                request = new HttpServletRequestWrapper(request, /*formEncoding*/ "utf-8" );
            //logs the request if specified in the descriptor
            descriptor.doLogRequestInReplayLog(request);

            request.setAttribute("XQueryURLRewrite.forwarded", "true");
        }
    }

    Subject user = defaultUser;

    Subject requestUser = HttpAccount.getUserFromServletRequest(request);
    if (requestUser != null) {
        user = requestUser;
    } else {
        // Secondly try basic authentication
        final String auth = request.getHeader("Authorization");
        if (auth != null) {
            requestUser = authenticator.authenticate(request, response);
            if (requestUser != null) {
                user = requestUser;
            }
        }
    }

    try {
        configure();
        //checkCache(user);

        final RequestWrapper modifiedRequest = new RequestWrapper(request);
        final URLRewrite staticRewrite = rewriteConfig.lookup(modifiedRequest);
        if (staticRewrite != null && !staticRewrite.isControllerForward()) {
            modifiedRequest.setPaths(staticRewrite.resolve(modifiedRequest), staticRewrite.getPrefix());

            if (LOG.isTraceEnabled()) {
                LOG.trace("Forwarding to target: " + staticRewrite.getTarget());
            }
            staticRewrite.doRewrite(modifiedRequest, response);
        } else {

            if (LOG.isTraceEnabled()) {
                LOG.trace("Processing request URI: " + request.getRequestURI());
            }
            if (staticRewrite != null) {
                // fix the request URI
                staticRewrite.updateRequest(modifiedRequest);
            }

            // check if the request URI is already in the url cache
            ModelAndView modelView = getFromCache(request.getHeader("Host") + request.getRequestURI(), user);

            if (LOG.isDebugEnabled()) {
                LOG.debug("Checked cache for URI: " + modifiedRequest.getRequestURI() + " original: "
                        + request.getRequestURI());
            }
            // no: create a new model and view configuration
            if (modelView == null) {
                modelView = new ModelAndView();
                // Execute the query
                Sequence result = Sequence.EMPTY_SEQUENCE;
                DBBroker broker = null;
                try {
                    broker = pool.get(user);
                    modifiedRequest.setAttribute(RQ_ATTR_REQUEST_URI, request.getRequestURI());

                    final Properties outputProperties = new Properties();

                    outputProperties.setProperty(OutputKeys.INDENT, "yes");
                    outputProperties.setProperty(OutputKeys.ENCODING, "UTF-8");
                    outputProperties.setProperty(OutputKeys.MEDIA_TYPE, MimeType.XML_TYPE.getName());

                    result = runQuery(broker, modifiedRequest, response, modelView, staticRewrite,
                            outputProperties);

                    logResult(broker, result);

                    if (response.isCommitted()) {
                        return;
                    }

                    // process the query result
                    if (result.getItemCount() == 1) {
                        final Item resource = result.itemAt(0);
                        if (!Type.subTypeOf(resource.getType(), Type.NODE)) {
                            throw new ServletException(
                                    "XQueryURLRewrite: urlrewrite query should return an element!");
                        }
                        Node node = ((NodeValue) resource).getNode();
                        if (node.getNodeType() == Node.DOCUMENT_NODE) {
                            node = ((Document) node).getDocumentElement();
                        }
                        if (node.getNodeType() != Node.ELEMENT_NODE) {
                            //throw new ServletException("Redirect XQuery should return an XML element!");
                            response(broker, response, outputProperties, result);
                            return;
                        }
                        Element elem = (Element) node;
                        if (!(Namespaces.EXIST_NS.equals(elem.getNamespaceURI()))) {
                            response(broker, response, outputProperties, result);
                            return;
                            //                            throw new ServletException("Redirect XQuery should return an element in namespace " + Namespaces.EXIST_NS);
                        }

                        if (Namespaces.EXIST_NS.equals(elem.getNamespaceURI())
                                && "dispatch".equals(elem.getLocalName())) {
                            node = elem.getFirstChild();
                            while (node != null) {
                                if (node.getNodeType() == Node.ELEMENT_NODE
                                        && Namespaces.EXIST_NS.equals(node.getNamespaceURI())) {
                                    final Element action = (Element) node;
                                    if ("view".equals(action.getLocalName())) {
                                        parseViews(modifiedRequest, action, modelView);
                                    } else if ("error-handler".equals(action.getLocalName())) {
                                        parseErrorHandlers(modifiedRequest, action, modelView);
                                    } else if ("cache-control".equals(action.getLocalName())) {
                                        final String option = action.getAttribute("cache");
                                        modelView.setUseCache("yes".equals(option));
                                    } else {
                                        final URLRewrite urw = parseAction(modifiedRequest, action);
                                        if (urw != null) {
                                            modelView.setModel(urw);
                                        }
                                    }
                                }
                                node = node.getNextSibling();
                            }
                            if (modelView.getModel() == null) {
                                modelView.setModel(new PassThrough(config, elem, modifiedRequest));
                            }
                        } else if (Namespaces.EXIST_NS.equals(elem.getNamespaceURI())
                                && "ignore".equals(elem.getLocalName())) {
                            modelView.setModel(new PassThrough(config, elem, modifiedRequest));
                            final NodeList nl = elem.getElementsByTagNameNS(Namespaces.EXIST_NS,
                                    "cache-control");
                            if (nl.getLength() > 0) {
                                elem = (Element) nl.item(0);
                                final String option = elem.getAttribute("cache");
                                modelView.setUseCache("yes".equals(option));
                            }
                        } else {
                            response(broker, response, outputProperties, result);
                            return;
                        }
                    } else if (result.getItemCount() > 1) {
                        response(broker, response, outputProperties, result);
                        return;
                    }

                    if (modelView.useCache()) {
                        LOG.debug("Caching request to " + request.getRequestURI());
                        urlCache.put(modifiedRequest.getHeader("Host") + request.getRequestURI(), modelView);
                    }

                } finally {
                    pool.release(broker);
                }

                // store the original request URI to org.exist.forward.request-uri
                modifiedRequest.setAttribute(RQ_ATTR_REQUEST_URI, request.getRequestURI());
                modifiedRequest.setAttribute(RQ_ATTR_SERVLET_PATH, request.getServletPath());

            }
            if (LOG.isTraceEnabled()) {
                LOG.trace("URLRewrite took " + (System.currentTimeMillis() - start) + "ms.");
            }
            final HttpServletResponse wrappedResponse = new CachingResponseWrapper(response,
                    modelView.hasViews() || modelView.hasErrorHandlers());
            if (modelView.getModel() == null) {
                modelView.setModel(new PassThrough(config, modifiedRequest));
            }

            if (staticRewrite != null) {
                if (modelView.getModel().doResolve()) {
                    staticRewrite.rewriteRequest(modifiedRequest);
                } else {
                    modelView.getModel().setAbsolutePath(modifiedRequest);
                }
            }
            modifiedRequest.allowCaching(!modelView.hasViews());
            doRewrite(modelView.getModel(), modifiedRequest, wrappedResponse);

            int status = ((CachingResponseWrapper) wrappedResponse).getStatus();
            if (status == HttpServletResponse.SC_NOT_MODIFIED) {
                response.flushBuffer();
            } else if (status < 400) {
                if (modelView.hasViews()) {
                    applyViews(modelView, modelView.views, response, modifiedRequest, wrappedResponse);
                } else {
                    ((CachingResponseWrapper) wrappedResponse).flush();
                }
            } else {
                // HTTP response code indicates an error
                if (modelView.hasErrorHandlers()) {
                    final byte[] data = ((CachingResponseWrapper) wrappedResponse).getData();
                    if (data != null) {
                        modifiedRequest.setAttribute(RQ_ATTR_ERROR, new String(data, UTF_8));
                    }
                    applyViews(modelView, modelView.errorHandlers, response, modifiedRequest, wrappedResponse);
                } else {
                    flushError(response, wrappedResponse);
                }
            }
        }
        //            Sequence result;
        //            if ((result = (Sequence) request.getAttribute(RQ_ATTR_RESULT)) != null) {
        //                writeResults(response, broker, result);
        //            }
    } catch (final Throwable e) {
        LOG.error("Error while processing " + servletRequest.getRequestURI() + ": " + e.getMessage(), e);
        throw new ServletException("An error occurred while processing request to "
                + servletRequest.getRequestURI() + ": " + e.getMessage(), e);

    }
}

From source file:org.exist.xquery.modules.httpclient.POSTFunction.java

private Part[] parseFields(Element fields) throws XPathException {
    NodeList nlField = fields.getElementsByTagNameNS(HTTPClientModule.NAMESPACE_URI, "field");

    Part[] parts = new Part[nlField.getLength()];

    for (int i = 0; i < nlField.getLength(); i++) {
        Element field = (Element) nlField.item(i);

        if (field.hasAttribute("type") && field.getAttribute("type").equals("file")) {
            try {

                String url = field.getAttribute("value");
                if (url.startsWith("xmldb:exist://")) {
                    parts[i] = new FilePart(field.getAttribute("name"), new DBFile(url.substring(13)));
                } else {
                    parts[i] = new FilePart(field.getAttribute("name"), new File(url));
                }//from   ww  w  . j a  v a2 s. c o m

            } catch (FileNotFoundException e) {
                throw (new XPathException(e));
            }

        } else {
            parts[i] = new StringPart(field.getAttribute("name"), field.getAttribute("value"));
        }

    }

    return (parts);
}

From source file:org.exist.xquery.modules.oracle.ExecuteFunction.java

private void setParametersOnPreparedStatement(Statement stmt, Element parametersElement)
        throws SQLException, XPathException {

    if (parametersElement.getNamespaceURI().equals(OracleModule.NAMESPACE_URI)
            && parametersElement.getLocalName().equals(PARAMETERS_ELEMENT_NAME)) {
        NodeList paramElements = parametersElement.getElementsByTagNameNS(OracleModule.NAMESPACE_URI,
                PARAM_ELEMENT_NAME);//from ww w .  j a  v  a 2  s. co m

        for (int i = 0; i < paramElements.getLength(); i++) {
            Element param = ((Element) paramElements.item(i));
            String value = param.getFirstChild().getNodeValue();
            String type = param.getAttributeNS(OracleModule.NAMESPACE_URI, TYPE_ATTRIBUTE_NAME);
            int position = Integer
                    .parseInt(param.getAttributeNS(OracleModule.NAMESPACE_URI, POSITION_ATTRIBUTE_NAME));
            try {
                int sqlType = SQLUtils.sqlTypeFromString(type);
                // What if SQL type is date???
                if (sqlType == Types.DATE) {
                    Date date = xmlDf.parse(value);
                    ((PreparedStatement) stmt).setTimestamp(position, new Timestamp(date.getTime()));
                } else {
                    ((PreparedStatement) stmt).setObject(position, value, sqlType);
                }
            } catch (ParseException pex) {
                throw new XPathException(this, "Unable to parse date from value " + value
                        + ". Expected format is YYYY-MM-DDThh:mm:ss.sss");
            } catch (Exception ex) {
                throw new XPathException(this, "Failed to set stored procedure parameter at position "
                        + position + " as " + type + " with value " + value);
            }
        }
    }
}

From source file:org.exist.xquery.modules.sql.ExecuteFunction.java

/**
 * evaluate the call to the XQuery execute() function, it is really the main entry point of this class.
 *
 * @param   args             arguments from the execute() function call
 * @param   contextSequence  the Context Sequence to operate on (not used here internally!)
 *
 * @return  A node representing the SQL result set
 *
 * @throws  XPathException  DOCUMENT ME!
 *
 * @see     org.exist.xquery.BasicFunction#eval(org.exist.xquery.value.Sequence[], org.exist.xquery.value.Sequence)
 *//* w w  w  .j ava 2s  . co  m*/
@Override
public Sequence eval(Sequence[] args, Sequence contextSequence) throws XPathException {
    // was a connection and SQL statement specified?
    if (args[0].isEmpty() || args[1].isEmpty()) {
        return (Sequence.EMPTY_SEQUENCE);
    }

    // get the Connection
    long connectionUID = ((IntegerValue) args[0].itemAt(0)).getLong();
    Connection con = SQLModule.retrieveConnection(context, connectionUID);

    if (con == null) {
        return (Sequence.EMPTY_SEQUENCE);
    }

    boolean preparedStmt = false;

    //setup the SQL statement
    String sql = null;
    Statement stmt = null;
    boolean executeResult = false;
    ResultSet rs = null;

    try {
        boolean makeNodeFromColumnName = false;
        MemTreeBuilder builder = context.getDocumentBuilder();
        int iRow = 0;

        //SQL or PreparedStatement?
        if (args.length == 3) {

            // get the SQL statement
            sql = args[1].getStringValue();
            stmt = con.createStatement();
            makeNodeFromColumnName = ((BooleanValue) args[2].itemAt(0)).effectiveBooleanValue();

            //execute the statement
            executeResult = stmt.execute(sql);

        } else if (args.length == 4) {

            preparedStmt = true;

            //get the prepared statement
            long statementUID = ((IntegerValue) args[1].itemAt(0)).getLong();
            PreparedStatementWithSQL stmtWithSQL = SQLModule.retrievePreparedStatement(context, statementUID);
            sql = stmtWithSQL.getSql();
            stmt = stmtWithSQL.getStmt();
            makeNodeFromColumnName = ((BooleanValue) args[3].itemAt(0)).effectiveBooleanValue();

            if (!args[2].isEmpty()) {
                setParametersOnPreparedStatement(stmt, (Element) args[2].itemAt(0));
            }

            //execute the prepared statement
            executeResult = ((PreparedStatement) stmt).execute();
        } else {
            //TODO throw exception
        }

        // DW: stmt can be null ?

        // execute the query statement
        if (executeResult) {
            /* SQL Query returned results */

            // iterate through the result set building an XML document
            rs = stmt.getResultSet();
            ResultSetMetaData rsmd = rs.getMetaData();
            int iColumns = rsmd.getColumnCount();

            builder.startDocument();

            builder.startElement(new QName("result", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
            builder.addAttribute(new QName("count", null, null), String.valueOf(-1));

            while (rs.next()) {
                builder.startElement(new QName("row", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
                builder.addAttribute(new QName("index", null, null), String.valueOf(rs.getRow()));

                // get each tuple in the row
                for (int i = 0; i < iColumns; i++) {
                    String columnName = rsmd.getColumnLabel(i + 1);

                    if (columnName != null) {

                        String colElement = "field";

                        if (makeNodeFromColumnName && columnName.length() > 0) {
                            // use column names as the XML node

                            /**
                             * Spaces in column names are replaced with
                             * underscore's
                             */
                            colElement = SQLUtils.escapeXmlAttr(columnName.replace(' ', '_'));
                        }

                        builder.startElement(new QName(colElement, SQLModule.NAMESPACE_URI, SQLModule.PREFIX),
                                null);

                        if (!makeNodeFromColumnName || columnName.length() <= 0) {
                            String name;

                            if (columnName.length() > 0) {
                                name = SQLUtils.escapeXmlAttr(columnName);
                            } else {
                                name = "Column: " + String.valueOf(i + 1);
                            }

                            builder.addAttribute(new QName("name", null, null), name);
                        }

                        builder.addAttribute(
                                new QName(TYPE_ATTRIBUTE_NAME, SQLModule.NAMESPACE_URI, SQLModule.PREFIX),
                                rsmd.getColumnTypeName(i + 1));
                        builder.addAttribute(new QName(TYPE_ATTRIBUTE_NAME, Namespaces.SCHEMA_NS, "xs"),
                                Type.getTypeName(SQLUtils.sqlTypeToXMLType(rsmd.getColumnType(i + 1))));

                        //get the content
                        if (rsmd.getColumnType(i + 1) == Types.SQLXML) {
                            //parse sqlxml value
                            try {
                                final SQLXML sqlXml = rs.getSQLXML(i + 1);

                                if (rs.wasNull()) {
                                    // Add a null indicator attribute if the value was SQL Null
                                    builder.addAttribute(
                                            new QName("null", SQLModule.NAMESPACE_URI, SQLModule.PREFIX),
                                            "true");
                                } else {

                                    SAXParserFactory factory = SAXParserFactory.newInstance();
                                    factory.setNamespaceAware(true);
                                    InputSource src = new InputSource(sqlXml.getCharacterStream());
                                    SAXParser parser = factory.newSAXParser();
                                    XMLReader xr = parser.getXMLReader();

                                    SAXAdapter adapter = new AppendingSAXAdapter(builder);
                                    xr.setContentHandler(adapter);
                                    xr.setProperty(Namespaces.SAX_LEXICAL_HANDLER, adapter);
                                    xr.parse(src);
                                }
                            } catch (Exception e) {
                                throw new XPathException(
                                        "Could not parse column of type SQLXML: " + e.getMessage(), e);
                            }
                        } else {
                            //otherwise assume string value
                            final String colValue = rs.getString(i + 1);

                            if (rs.wasNull()) {
                                // Add a null indicator attribute if the value was SQL Null
                                builder.addAttribute(
                                        new QName("null", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), "true");
                            } else {
                                if (colValue != null) {
                                    builder.characters(SQLUtils.escapeXmlText(colValue));
                                }
                            }
                        }

                        builder.endElement();
                    }
                }

                builder.endElement();
                iRow++;
            }

            builder.endElement();
        } else {
            /* SQL Query performed updates */

            builder.startDocument();

            builder.startElement(new QName("result", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
            builder.addAttribute(new QName("updateCount", null, null), String.valueOf(stmt.getUpdateCount()));
            builder.endElement();
        }

        // Change the root element count attribute to have the correct value
        NodeValue node = (NodeValue) builder.getDocument().getDocumentElement();
        Node count = node.getNode().getAttributes().getNamedItem("count");

        if (count != null) {
            count.setNodeValue(String.valueOf(iRow));
        }

        builder.endDocument();

        // return the XML result set
        return (node);

    } catch (SQLException sqle) {
        LOG.error("sql:execute() Caught SQLException \"" + sqle.getMessage() + "\" for SQL: \"" + sql + "\"",
                sqle);

        //return details about the SQLException
        MemTreeBuilder builder = context.getDocumentBuilder();

        builder.startDocument();
        builder.startElement(new QName("exception", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);

        boolean recoverable = false;

        if (sqle instanceof SQLRecoverableException) {
            recoverable = true;
        }
        builder.addAttribute(new QName("recoverable", null, null), String.valueOf(recoverable));

        builder.startElement(new QName("state", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
        builder.characters(sqle.getSQLState());
        builder.endElement();

        builder.startElement(new QName("message", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);

        String state = sqle.getMessage();

        if (state != null) {
            builder.characters(state);
        }

        builder.endElement();

        builder.startElement(new QName("stack-trace", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
        ByteArrayOutputStream bufStackTrace = new ByteArrayOutputStream();
        sqle.printStackTrace(new PrintStream(bufStackTrace));
        builder.characters(new String(bufStackTrace.toByteArray()));
        builder.endElement();

        builder.startElement(new QName("sql", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
        builder.characters(SQLUtils.escapeXmlText(sql));
        builder.endElement();

        if (stmt instanceof PreparedStatement) {
            Element parametersElement = (Element) args[2].itemAt(0);

            if (parametersElement.getNamespaceURI().equals(SQLModule.NAMESPACE_URI)
                    && parametersElement.getLocalName().equals(PARAMETERS_ELEMENT_NAME)) {
                NodeList paramElements = parametersElement.getElementsByTagNameNS(SQLModule.NAMESPACE_URI,
                        PARAM_ELEMENT_NAME);

                builder.startElement(
                        new QName(PARAMETERS_ELEMENT_NAME, SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);

                for (int i = 0; i < paramElements.getLength(); i++) {
                    Element param = ((Element) paramElements.item(i));
                    String value = param.getFirstChild().getNodeValue();
                    String type = param.getAttributeNS(SQLModule.NAMESPACE_URI, TYPE_ATTRIBUTE_NAME);

                    builder.startElement(
                            new QName(PARAM_ELEMENT_NAME, SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);

                    builder.addAttribute(
                            new QName(TYPE_ATTRIBUTE_NAME, SQLModule.NAMESPACE_URI, SQLModule.PREFIX), type);
                    builder.characters(SQLUtils.escapeXmlText(value));

                    builder.endElement();
                }

                builder.endElement();
            }
        }

        builder.startElement(new QName("xquery", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
        builder.addAttribute(new QName("line", null, null), String.valueOf(getLine()));
        builder.addAttribute(new QName("column", null, null), String.valueOf(getColumn()));
        builder.endElement();

        builder.endElement();
        builder.endDocument();

        return ((NodeValue) builder.getDocument().getDocumentElement());
    } finally {

        // close any record set or statement
        if (rs != null) {

            try {
                rs.close();
            } catch (SQLException se) {
                LOG.warn("Unable to cleanup JDBC results", se);
            }
            rs = null;
        }

        if (!preparedStmt && stmt != null) {

            try {
                stmt.close();
            } catch (SQLException se) {
                LOG.warn("Unable to cleanup JDBC results", se);
            }
            stmt = null;
        }

    }
}

From source file:org.exist.xquery.modules.sql.ExecuteFunction.java

private void setParametersOnPreparedStatement(Statement stmt, Element parametersElement)
        throws SQLException, XPathException {
    if (parametersElement.getNamespaceURI().equals(SQLModule.NAMESPACE_URI)
            && parametersElement.getLocalName().equals(PARAMETERS_ELEMENT_NAME)) {
        NodeList paramElements = parametersElement.getElementsByTagNameNS(SQLModule.NAMESPACE_URI,
                PARAM_ELEMENT_NAME);/*from  w  w w .j a  v a 2  s . c  om*/

        for (int i = 0; i < paramElements.getLength(); i++) {
            Element param = ((Element) paramElements.item(i));
            Node child = param.getFirstChild();

            // Prevent NPE
            if (child != null) {
                if (child instanceof ReferenceNode) {
                    child = ((ReferenceNode) child).getReference().getNode();
                }

                final String value = child.getNodeValue();
                final String type = param.getAttributeNS(SQLModule.NAMESPACE_URI, TYPE_ATTRIBUTE_NAME);
                final int sqlType = SQLUtils.sqlTypeFromString(type);

                if (sqlType == Types.TIMESTAMP) {
                    final DateTimeValue dv = new DateTimeValue(value);
                    final Timestamp timestampValue = new Timestamp(dv.getDate().getTime());
                    ((PreparedStatement) stmt).setTimestamp(i + 1, timestampValue);

                } else {
                    ((PreparedStatement) stmt).setObject(i + 1, value, sqlType);
                }
            }

        }
    }
}

From source file:org.fusesource.cloudmix.agent.jbi.JBIInstallerAgent.java

private Element getChildElement(Element e, String name) {
    NodeList nl = e.getElementsByTagNameNS(JBI_NS, name);
    return (Element) nl.item(0);
}

From source file:org.fusesource.ide.foundation.ui.archetypes.ArchetypeHelper.java

private static Map<String, String> getArchetypeRequiredProperties(ByteArrayOutputStream copyOfArchetypeJar,
        boolean excludeDepVersionProperties, boolean defaultAllProperties)
        throws ParserConfigurationException, SAXException, IOException, XPathExpressionException {
    Map<String, String> propertiesMap = new LinkedHashMap<String, String>();

    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    dbf.setNamespaceAware(true);//w  w  w .  j  a v a 2 s.c  o  m
    DocumentBuilder db = dbf.newDocumentBuilder();

    InputSource inputSource = new InputSource(new ByteArrayInputStream(copyOfArchetypeJar.toByteArray()));
    Document document = db.parse(inputSource);

    XPath xpath = XPathFactory.newInstance().newXPath();
    SimpleNamespaceContext nsContext = new SimpleNamespaceContext();
    nsContext.registerMapping("ad", archetypeDescriptorUri);
    xpath.setNamespaceContext(nsContext);

    NodeList properties = (NodeList) xpath.evaluate(requiredPropertyXPath, document, XPathConstants.NODESET);

    for (int p = 0; p < properties.getLength(); p++) {
        Element requiredProperty = (Element) properties.item(p);

        String key = requiredProperty.getAttribute("key");
        //exclude version properties (externalize and specify the excluded properties?)
        if (excludeDepVersionProperties && (key.startsWith("version") || key.endsWith("version"))) {
            continue;
        }
        NodeList children = requiredProperty.getElementsByTagNameNS(archetypeDescriptorUri, "defaultValue");
        String value = "";
        if (children.getLength() == 1 && children.item(0).hasChildNodes()) {
            value = children.item(0).getTextContent();
        } else {
            if (("name".equals(key) || defaultAllProperties) && value.isEmpty()) {
                value = "HelloWorld";
            }
        }
        propertiesMap.put(key, value);
    }
    return propertiesMap;
}

From source file:org.globus.wsrf.tools.wsdl.TypesProcessor.java

public void addResourceProperties(QName portTypeName, Map resourcePropertyElements, Map schemaDocumentLocations)
        throws Exception {
    logger.debug("Starting to build resource properties element");
    PortType portType = this.getPortType(portTypeName);

    QName resourceProperties = (QName) portType.getExtensionAttribute(RP);

    addPrefix(WSRP_NS, "wsrp");

    Element schema = getSchema();
    Document doc = schema.getOwnerDocument();
    String schemaPrefix = "";
    if (schema.getPrefix() != null) {
        schemaPrefix = schema.getPrefix() + ":";
    }//w w w. j  a  v a 2s  . co  m

    Element properties = null;
    if (resourceProperties == null) {
        resourceProperties = new QName(portType.getQName().getLocalPart() + "GTWSDLResourceProperties");
        portType.setExtensionAttribute(RP, resourceProperties);
        properties = doc.createElementNS(XSD_NS, schemaPrefix + "element");
        properties.setAttribute("name", resourceProperties.getLocalPart());
        properties.appendChild(doc.createTextNode("\n        "));
        schema.appendChild(properties);
        schema.appendChild(doc.createTextNode("\n    "));
    } else {
        NodeList elementNodes = schema.getElementsByTagNameNS(XSD_NS, "element");
        String name;
        Element element;
        for (int i = 0; i < elementNodes.getLength(); i++) {
            element = (Element) elementNodes.item(i);
            name = element.getAttribute("name");
            if (name != null && XmlUtils.getFullQNameFromString(name, element).getLocalPart()
                    .equals(resourceProperties.getLocalPart())) {
                properties = element;
                break;
            }
        }

        if (properties == null) {
            throw new Exception(
                    "Unable to find '" + resourceProperties + "' element in WSDL schema section of '"
                            + this.definition.getDocumentBaseURI() + "' document.");
        }
    }
    String type = properties.getAttribute("type");
    NodeList complexTypeElements;
    Element complexType = null;

    if (type != null && !type.equals("")) {
        complexTypeElements = schema.getElementsByTagNameNS(XSD_NS, "complexType");
        Element currentType;
        QName currentName;
        QName typeName = XmlUtils.getFullQNameFromString(type, properties);
        for (int i = 0; i < complexTypeElements.getLength(); i++) {
            currentType = (Element) complexTypeElements.item(i);
            currentName = XmlUtils.getFullQNameFromString(currentType.getAttribute("name"), currentType);
            if (currentName.getLocalPart().equals(typeName.getLocalPart())) {
                complexType = currentType;
                break;
            }
        }
        if (complexType == null) {
            throw new Exception("Unable to find type entry for '" + resourceProperties + "' element");
        }
    } else {
        complexTypeElements = properties.getElementsByTagNameNS(XSD_NS, "complexType");
        if (complexTypeElements.getLength() > 0) {
            complexType = (Element) complexTypeElements.item(0);
        } else {
            complexType = doc.createElementNS(XSD_NS, schemaPrefix + "complexType");
            complexType.appendChild(doc.createTextNode("\n          "));
            properties.appendChild(complexType);
            properties.appendChild(doc.createTextNode("\n      "));
        }
    }

    NodeList sequenceElements = complexType.getElementsByTagNameNS(XSD_NS, "sequence");
    Element sequence;
    if (sequenceElements.getLength() > 0) {
        sequence = (Element) sequenceElements.item(0);
    } else {
        sequence = doc.createElementNS(XSD_NS, schemaPrefix + "sequence");
        complexType.appendChild(sequence);
        complexType.appendChild(doc.createTextNode("\n        "));
    }

    Collection resourcePropertiesList = resourcePropertyElements.values();
    Iterator elementIterator = resourcePropertiesList.iterator();
    int nsCounter = 0;

    while (elementIterator.hasNext()) {
        sequence.appendChild(doc.createTextNode("\n            "));
        Element resourcePropertyElement = doc.createElementNS(XSD_NS, schemaPrefix + "element");
        XSParticle particle = (XSParticle) elementIterator.next();
        XSElementDeclaration element = (XSElementDeclaration) particle.getTerm();
        String prefix = XmlUtils.getPrefix(element.getNamespace(), schema);

        addSchemaDefinitions(element, schemaDocumentLocations, schema);

        if (prefix == null) {
            prefix = "rpns" + String.valueOf(nsCounter++);
            Attr nameSpace = doc.createAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:" + prefix);
            nameSpace.setValue(element.getNamespace());
            schema.setAttributeNode(nameSpace);
        }

        resourcePropertyElement.setAttribute("ref", prefix + ":" + element.getName());
        resourcePropertyElement.setAttribute("minOccurs", String.valueOf(particle.getMinOccurs()));
        if (particle.getMaxOccursUnbounded()) {
            resourcePropertyElement.setAttribute("maxOccurs", String.valueOf("unbounded"));
        } else {
            resourcePropertyElement.setAttribute("maxOccurs", String.valueOf(particle.getMaxOccurs()));
        }
        sequence.appendChild(resourcePropertyElement);
    }
    sequence.appendChild(doc.createTextNode("\n          "));
    logger.debug("Resource properties element: " + XmlUtils.getElementAsString(properties));
}