policy/src/main/java/org/apache/wss4j/policy/SPUtils.java

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.wss4j.policy;

import javax.xml.namespace.QName;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;

import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.Text;

public final class SPUtils {

    private SPUtils() {
    }

    public static boolean hasChildElements(Element element) {
        Node firstChild = element.getFirstChild();
        while (firstChild != null) {
            if (firstChild.getNodeType() == Node.ELEMENT_NODE) {
                return true;
            }
            firstChild = firstChild.getNextSibling();
        }
        return false;
    }

    public static Element getFirstPolicyChildElement(Element element) {
        Element policy = getFirstChildElement(element, SPConstants.P_LOCALNAME);
        if (policy != null && org.apache.neethi.Constants.isPolicyNS(policy.getNamespaceURI())) {
            return policy;
        }
        return null;
    }

    public static boolean hasChildElementWithName(Element element, QName elementName) {
        Element child = SPUtils.getFirstChildElement(element, elementName);
        if (child != null) {
            return true;
        }
        return false;
    }

    public static Element getFirstChildElement(Node parent, String childNodeName) {
        Node node = parent.getFirstChild();
        while (node != null && (Node.ELEMENT_NODE != node.getNodeType()
                || !node.getLocalName().equals(childNodeName))) {
            node = node.getNextSibling();
        }
        return (Element) node;
    }

    public static Element getFirstChildElement(Node parent, QName childNodeName) {
        Node node = parent.getFirstChild();
        while (node != null && (Node.ELEMENT_NODE != node.getNodeType()
                || !isNodeEqualToQName(node, childNodeName))) {
            node = node.getNextSibling();
        }
        return (Element) node;
    }

    private static boolean isNodeEqualToQName(Node node, QName nodeName) {
        if ((node.getNamespaceURI() == null && nodeName.getNamespaceURI() == null
            || node.getNamespaceURI() != null
                && node.getNamespaceURI().equals(nodeName.getNamespaceURI()))
            && node.getLocalName().equals(nodeName.getLocalPart())) {
            return true;
        }
        return false;
    }

    public static String getFirstChildElementText(Node parent, QName childNodeName) {
        Element element = getFirstChildElement(parent, childNodeName);
        return element != null ? element.getTextContent() : null;
    }

    public static Element getFirstChildElement(Node parent) {
        Node node = parent.getFirstChild();
        while (node != null && Node.ELEMENT_NODE != node.getNodeType()) {
            node = node.getNextSibling();
        }
        return (Element) node;
    }

    public static Element getNextSiblingElement(Node node) {
        Node n = node.getNextSibling();
        while (n != null && Node.ELEMENT_NODE != n.getNodeType()) {
            n = n.getNextSibling();
        }
        return (Element) n;
    }

    public static boolean isOptional(Element element) {
        Attr attr = findOptionalAttribute(element);
        if (attr != null) {
            String v = attr.getValue();
            return "true".equalsIgnoreCase(v) || "1".equals(v);
        }
        return false;
    }

    public static Attr findOptionalAttribute(Element element) {
        NamedNodeMap attributes = element.getAttributes();
        for (int x = 0; x < attributes.getLength(); x++) {
            Attr attr = (Attr) attributes.item(x);
            QName qName = new QName(attr.getNamespaceURI(), attr.getLocalName());
            if (org.apache.neethi.Constants.isOptionalAttribute(qName)) {
                return attr;
            }
        }
        return null;
    }

    public static boolean isIgnorable(Element element) throws IllegalArgumentException {
        Attr attr = findIgnorableAttribute(element);
        if (attr != null) {
            String value = attr.getValue();
            if ("true".equalsIgnoreCase(value) || "1".equals(value)) {
                if (SP13Constants.SP_NS.equals(element.getNamespaceURI())) {
                    throw new IllegalArgumentException("Ignorable attribute not allowed.");
                }
                return true;
            }
        }
        return false;
    }

    public static Attr findIgnorableAttribute(Element element) {
        NamedNodeMap attributes = element.getAttributes();
        for (int x = 0; x < attributes.getLength(); x++) {
            Attr attr = (Attr) attributes.item(x);
            QName qName = new QName(attr.getNamespaceURI(), attr.getLocalName());
            if (org.apache.neethi.Constants.isIgnorableAttribute(qName)) {
                return attr;
            }
        }
        return null;
    }

    public static String getAttribute(Element element, QName attName) {
        Attr attr;
        if (attName.getNamespaceURI() == null || "".equals(attName.getNamespaceURI())) {
            attr = element.getAttributeNode(attName.getLocalPart());
        } else {
            attr = element.getAttributeNodeNS(attName.getNamespaceURI(), attName.getLocalPart());
        }
        return attr == null ? null : attr.getValue().trim();
    }

    public static QName getElementQName(Element element) {
        return new QName(element.getNamespaceURI(), element.getLocalName(), element.getPrefix());
    }

    public static void serialize(Node node, XMLStreamWriter xmlStreamWriter) throws XMLStreamException {
        if (node.getNodeType() == Node.DOCUMENT_NODE) {
            Document document = (Document) node;
            serialize(document.getDocumentElement(), xmlStreamWriter);
        }
        if (node.getNodeType() == Node.ELEMENT_NODE) {
            Element element = (Element) node;
            xmlStreamWriter.writeStartElement(element.getPrefix(), element.getLocalName(), element.getNamespaceURI());
            NamedNodeMap namedNodeMap = element.getAttributes();
            for (int i = 0; i < namedNodeMap.getLength(); i++) {
                Attr attr = (Attr) namedNodeMap.item(i);
                String prefix = attr.getPrefix();
                if (prefix != null && "xmlns".equals(prefix)) {
                    xmlStreamWriter.writeNamespace(attr.getLocalName(), attr.getValue());
                } else if (prefix == null && "xmlns".equals(attr.getLocalName())) {
                    xmlStreamWriter.writeDefaultNamespace(attr.getValue());
                } else {
                    xmlStreamWriter.writeAttribute(prefix,
                                                   attr.getNamespaceURI(),
                                                   attr.getLocalName(),
                                                   attr.getValue());
                }
            }
            //write ns after processing element namespaces to prevent redeclarations
            if (element.getPrefix() != null) {
                String ns = xmlStreamWriter.getNamespaceContext().getNamespaceURI(element.getPrefix());
                if (ns == null) {
                    xmlStreamWriter.writeNamespace(element.getPrefix(), element.getNamespaceURI());
                }
            }
            Node firstChild = element.getFirstChild();
            while (firstChild != null) {
                serialize(firstChild, xmlStreamWriter);
                firstChild = firstChild.getNextSibling();
            }
            xmlStreamWriter.writeEndElement();
        } else if (node.getNodeType() == Node.TEXT_NODE) {
            Text text = (Text) node;
            xmlStreamWriter.writeCharacters(text.getData());
        }
    }
}