Refine search
/** * Get the schema with the specified target namespace. * * @param targetNamespace * target namespace of the schema to get. * @return null if not found. */ private Schema getSchema( String targetNamespace ) { if ( _types == null ) { return null; } List<ExtensibilityElement> schemas = WsdlUtils.findExtensibilityElements( _types, "schema" ); for ( ExtensibilityElement e : schemas ) { Element schemaRoot = ( (Schema) e ).getElement(); String tns = schemaRoot.getAttribute( "targetNamespace" ); if ( targetNamespace.equals( tns ) ) { return (Schema) e; } } return null; } }
parentType, elementType); schema.setElementType(elementType); schema.setElement(el); schema.setDocumentBaseURI(def.getDocumentBaseURI()); SchemaImport im = schema.createImport(); im.setId(DOMUtils.getAttribute(tempEl, SchemaConstants.ATTR_ID)); im.setNamespaceURI(DOMUtils.getAttribute(tempEl, Constants.ATTR_NAMESPACE)); im.setSchemaLocationURI(locationURI); schema.addImport(im); sr = schema.createInclude(); schema.addInclude(sr); sr = schema.createRedefine(); schema.addRedefine(sr);
final Map<String, SchemaInfo> imports, final Definition def) { Types types = def.createTypes(); schema.setRequired(true); schema.setElementType(WSDLConstants.QNAME_SCHEMA); schema.setDocumentBaseURI(name); schema.setElement(schemaInfo.getElement()); Element docElement = schema.getElement(); String sn = el.getAttribute("namespace"); SchemaInfo schemaInfo = namespaceToSchemaInfo.get(sn); el.setAttribute("schemaLocation", referencedSchema.getDocumentBaseURI()); schema.setRequired(true); schema.setElementType(WSDLConstants.QNAME_SCHEMA); impElement.setAttribute("schemaLocation", referencedSchema.getDocumentBaseURI()); impElement.setAttribute("namespace", schemaInfo.getNamespaceURI()); nd.appendChild(impElement); schema.setElement(nd); types.addExtensibilityElement(schema);
private void extractSchema(Definition def, SchemaCollection schemaCol) { Types typesElement = def.getTypes(); if (typesElement != null) { int schemaCount = 1; for (Object obj : typesElement.getExtensibilityElements()) { org.w3c.dom.Element schemaElem = null; if (obj instanceof Schema) { Schema schema = (Schema)obj; schemaElem = schema.getElement(); } else if (obj instanceof UnknownExtensibilityElement) { org.w3c.dom.Element elem = ((UnknownExtensibilityElement)obj).getElement(); if (elem.getLocalName().equals("schema")) { schemaElem = elem; synchronized (schemaElem.getOwnerDocument()) { for (Object prefix : def.getNamespaces().keySet()) { String ns = (String)def.getNamespaces().get(prefix); if ("".equals(prefix)) { if (!schemaElem.hasAttribute("xmlns")) { Attr attr = schemaElem.getOwnerDocument() .createAttributeNS(javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI, "xmlns"); attr.setValue(ns); String namespace = javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI; Attr attr = schemaElem.getOwnerDocument() .createAttributeNS(namespace, "xmlns:" + prefix); attr.setValue(ns); schemaElem.setAttributeNodeNS(attr);
private void addSchema(String docBaseURI, Schema schema) { Element schemaEle = schema.getElement(); if (schemaList.get(docBaseURI) == null) { schemaList.put(docBaseURI, schemaEle); String tns = schema.getDocumentBaseURI() + "#" + schema.getElement().getAttribute("targetNamespace"); if (schemaList.get(tns) == null) { schemaList.put(tns, schema.getElement()); Map<String, List<?>> imports = CastUtils.cast(schema.getImports()); if (imports != null && !imports.isEmpty()) { for (Map.Entry<String, List<?>> entry : imports.entrySet()) { Schema tempImport = schemaImport.getReferencedSchema(); String key = schemaImport.getSchemaLocationURI(); if (importNamespace == null && tempImport != null) { importNamespace = tempImport.getDocumentBaseURI(); key = tempImport.getDocumentBaseURI(); && !schemaList.containsValue(tempImport.getElement())) { addSchema(key, tempImport);
private void addWSDLTypes() throws ToolException { Element sourceElement = this.xsdDoc.getDocumentElement(); Element targetElement = (Element)sourceElement.cloneNode(true); this.wsdlDefinition.setTargetNamespace((String)env.get(ToolConstants.CFG_NAMESPACE)); this.wsdlDefinition .setQName(new QName(WSDLConstants.NS_WSDL, (String)env.get(ToolConstants.CFG_NAME))); Types types = this.wsdlDefinition.createTypes(); ExtensibilityElement extElement; try { throw new ToolException(msg, wse); ((Schema)extElement).setElement(targetElement); types.addExtensibilityElement(extElement); this.wsdlDefinition.setTypes(types);
schemaImpl.setRequired(true); schemaImpl.setElementType(WSDLConstants.QNAME_SCHEMA); schemaImpl.setElement(schemaInfo.getElement()); for (XmlSchemaExternal ext : schemaInfo.getSchema().getExternals()) { if (ext.getSchema() == null) { SchemaImport imp = schemaImpl.createImport(); imp.setNamespaceURI(((XmlSchemaImport)ext).getNamespace()); imp.setSchemaLocationURI(((XmlSchemaImport)ext).getSchemaLocation()); schemaImpl2.setRequired(true); schemaImpl2.setElementType(WSDLConstants.QNAME_SCHEMA); schemaImpl2.setDocumentBaseURI(ext.getSchema().getSourceURI()); try { schemaImpl2.setElement(ext.getSchema().getSchemaDocument().getDocumentElement()); } catch (XmlSchemaSerializerException e) { schemaImpl.addImport(imp); } else if (ext instanceof XmlSchemaInclude) { SchemaReference imp = schemaImpl.createInclude(); imp.setSchemaLocationURI(((XmlSchemaInclude)ext).getSchemaLocation()); schemaImpl2.setRequired(true); schemaImpl2.setElementType(WSDLConstants.QNAME_SCHEMA); schemaImpl2.setDocumentBaseURI(ext.getSchema().getSourceURI()); try { schemaImpl2.setElement(ext.getSchema().getSchemaDocument().getDocumentElement()); } catch (XmlSchemaSerializerException e) {
if (definition.getTypes() != null) { for (Object o : definition.getTypes().getExtensibilityElements()) { if (o instanceof javax.wsdl.extensions.schema.Schema) { Element ele = ((javax.wsdl.extensions.schema.Schema) o).getElement(); Node newNode = doc.importNode(ele, true); doc.appendChild(newNode); Map<String, String> ns = definition.getNamespaces(); if (ns != null) { for (Entry<String, String> e : ns.entrySet()) { if (e.getKey() != null && !e.getKey().isEmpty()) { doc.getDocumentElement().setAttributeNS(XMLConstants.XMLNS_ATTRIBUTE_NS_URI, "xmlns:" + e.getKey(), e.getValue());
if (schema.getDocumentBaseURI() != null) this.allSchemas.put(schema.getDocumentBaseURI(), schema); Collection ic = schema.getImports().values(); Iterator importsIterator = ic.iterator(); while(importsIterator.hasNext()) allSchemaRefs.addAll(schema.getIncludes()); allSchemaRefs.addAll(schema.getRedefines()); (schema.getDocumentBaseURI() == null ? "'." : "', relative to '" + schema.getDocumentBaseURI() + "'.")); schema.getDocumentBaseURI(), schemaRef.getSchemaLocationURI()); + schemaRef.getSchemaLocationURI() + "' relative to document base '" + schema.getDocumentBaseURI() + "'"); String contextURI = schema.getDocumentBaseURI(); URL contextURL = (contextURI != null) ? StringUtils.getURL(null, contextURI) : null; URL url = StringUtils.getURL(contextURL, schemaRef.getSchemaLocationURI()); + schemaRef.getSchemaLocationURI() + "'" + (schema.getDocumentBaseURI() == null ? "." : ", relative to '"
/** * Build a list of schema target name spaces which are element form qualified. * * @return All target name spaces for schemas defined in the WSDL which are element form qualified. */ private List<String> getElementFormQualifiedNamespaces() { List<String> namespaces = new ArrayList<String>(); List<ExtensibilityElement> schemas = getSchemas(); for ( ExtensibilityElement schema : schemas ) { Element schemaElement = ( (Schema) schema ).getElement(); if ( schemaElement.hasAttribute( WsdlUtils.ELEMENT_FORM_DEFAULT_ATTR ) ) { String v = schemaElement.getAttribute( WsdlUtils.ELEMENT_FORM_DEFAULT_ATTR ); if ( WsdlUtils.ELEMENT_FORM_QUALIFIED.equalsIgnoreCase( v ) ) { namespaces.add( schemaElement.getAttribute( WsdlUtils.TARGET_NAMESPACE_ATTR ) ); } } } return namespaces; }
Types types = definition.createTypes(); docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder(); Document doc = docBuilder.newDocument(); Element element = doc.createElement("xsd:schema"); Map<String, String> schemafileMap = wmodel.getSchemaNSFileMap(); while (ite.hasNext()) { Map.Entry<String, String> entry = (Map.Entry<String, String>)ite.next(); Element importelement = doc.createElement("xsd:import"); importelement.setAttribute("namespace", entry.getKey()); importelement.setAttribute("schemaLocation", entry.getValue()); element.appendChild(importelement); schema.setElement(element); types.addExtensibilityElement(schema); definition.setTypes(types); } catch (Exception e) { throw new ToolException(msg, e); definition.setTargetNamespace(wmodel.getTargetNameSpace()); definition.addNamespace(WSDLConstants.WSDL_PREFIX, WSDLConstants.NS_WSDL);
schema.getElement().getOwnerDocument().getElementsByTagNameNS(XMLConstants.W3C_XML_SCHEMA_NS_URI, "import"); for (int i = 0; i < importsNl.getLength(); i++) { final Element importElt = (Element) importsNl.item(i); if (importElt.hasAttribute("schemaLocation")) { final Map<String, List<SchemaReference>> schemaImportsMap = schema.getImports(); final List<SchemaReference> schemaImports = schemaImportsMap.get(importElt.getAttribute("namespace")); for (final SchemaReference schemaImport : schemaImports) { if (schemaImport.getSchemaLocationURI() != null alreadyImportedXsds.add(schemaImport.getSchemaLocationURI()); WsdlInlineUtil.inlineImportedXsds(schemaImport.getReferencedSchema(), types, alreadyImportedXsds); types.addExtensibilityElement(schemaImport.getReferencedSchema()); schema.getElement().getOwnerDocument().getElementsByTagNameNS(XMLConstants.W3C_XML_SCHEMA_NS_URI, "include"); for (int i = 0; i < includeNl.getLength(); i++) { for (final SchemaReference schemaReference : (List<SchemaReference>) schema.getIncludes()) { alreadyImportedXsds.add(schemaReference.getSchemaLocationURI()); WsdlInlineUtil.inlineImportedXsds(schemaReference.getReferencedSchema(), types, alreadyImportedXsds); types.addExtensibilityElement(schemaReference.getReferencedSchema()); schema.getElement().getOwnerDocument().getElementsByTagNameNS(XMLConstants.W3C_XML_SCHEMA_NS_URI, "redefine"); for (int i = 0; i < redefinesNl.getLength(); i++) { for (final SchemaReference schemaReference : (List<SchemaReference>) schema.getRedefines()) {
Document[] docs = schemaDef.getAllSchemas(); document = docs[docs.length-1]; document.setDocumentURI(xsDef.getLocation().toString()); xsDef.setDocument(document); } catch (XmlSchemaException e) { Element schema = document.getDocumentElement(); Schema schemaExt = createSchemaExt(definition); schemaExt.setDocumentBaseURI(document.getDocumentURI()); schemaExt.setElement(schema);
Types types = definition.createTypes(); Schema schema; try { schema = (Schema) definition.getExtensionRegistry().createExtension(Types.class, SCHEMA_NAME); } catch (WSDLException e) { throw new InstallException(e); throw new InstallException(e); Element schemaElement = document.createElementNS(SCHEMA_NAME.getNamespaceURI(), "xsd:schema"); schema.setElement(schemaElement); Element importElement = document.createElementNS(IMPORT_NAME.getNamespaceURI(), "xsd:import"); importElement.setAttribute("namespace", targetNamespace); importElement.setAttribute("schemaLocation", schemaLocation); schemaElement.appendChild(importElement); types.addExtensibilityElement(schema); definition.setTypes(types);
visitedWSDLs.add(definition.getDocumentBaseURI()); Types types = definition.getTypes(); Object extensibilityElement; if (types != null) { for (Iterator iterator = types.getExtensibilityElements().iterator(); iterator.hasNext();) Element schemaElement = ((Schema) extensibilityElement).getElement(); schemaMap.put(schemaElement.getAttribute(XSD_TARGETNAMESPACE), schemaElement); Iterator iter = definition.getImports().values().iterator(); Vector values = null; Import wsdlImport = null;
private void fixSchema(Schema sc, String pfx) throws ParserConfigurationException { Document doc = DOMUtils.getEmptyDocument(); Element el = doc.createElementNS(sc.getElementType().getNamespaceURI(), pfx + ":" + sc.getElementType().getLocalPart()); sc.setElement(el); Map<String, List<String>> mp = CastUtils.cast(sc.getImports()); for (Map.Entry<String, List<String>> ent : mp.entrySet()) { Element imp = doc.createElementNS(sc.getElementType().getNamespaceURI(), pfx + ":import"); el.appendChild(imp); imp.setAttribute("namespace", ent.getKey()); } }
public void attachSchemaToWSDL(Definition definition, XmlSchema schema, boolean isSchemaGenerated) throws Exception { Types types = definition.getTypes(); if (types == null) { types = definition.createTypes(); definition.setTypes(types); Schema wsdlSchema = (Schema)definition.getExtensionRegistry() nsMap.add("tns", schema.getTargetNamespace()); org.w3c.dom.Element el = schema.getAllSchemas()[0].getDocumentElement(); wsdlSchema.setElement(el); SchemaImport schemaimport = wsdlSchema.createImport(); schemaimport.setNamespaceURI(xmlSchemaImport.getNamespace()); if (xmlSchemaImport.getSchemaLocation() != null && !ignoreImports) { schemaimport.setSchemaLocationURI(xmlSchemaImport.getSchemaLocation()); wsdlSchema.addImport(schemaimport); types.addExtensibilityElement(wsdlSchema);
if (getDefinition().getNamespace(ns.getPrefix()) == null) addNamespace(ns.getPrefix(), ns.getURI()); Types types = getDefinition().getTypes(); if (types == null) types = getDefinition().createTypes(); getDefinition().setTypes(types); uee.setElement((org.w3c.dom.Element) doc.getDocumentElement()); uee.setRequired(Boolean.TRUE); uee.setElementType(SCHEMA_QNAME); types.addExtensibilityElement(uee);
Types types = definition.getTypes(); if (types != null) { int index = 0; for (Object ext : types.getExtensibilityElements()) { ExtensibilityElement extElement = (ExtensibilityElement)ext; Element element = null; if (XSD_QNAME_LIST.contains(extElement.getElementType())) { if (extElement instanceof Schema) { element = ((Schema)extElement).getElement(); } else if (extElement instanceof UnknownExtensibilityElement) { element = ((UnknownExtensibilityElement)extElement).getElement(); XSDefinition xsDefinition = xsdFactory.createXSDefinition(); xsDefinition.setUnresolved(true); xsDefinition.setNamespace(element.getAttribute("targetNamespace")); xsDefinition.setDocument(doc); xsDefinition.setLocation(URI.create(doc.getDocumentURI() + "#" + index)); XSDefinition resolved = contribution.getModelResolver().resolveModel(XSDefinition.class, xsDefinition, context); for (Object imports : definition.getImports().values()) { List impList = (List)imports; for (Object i : impList) {
for (WSDLInfo wsdlInfo : wsdls.values()) { Definition definition = wsdlInfo.getWSDLDefinition(); Types types = definition.getTypes(); if (types != null) { List extensibleElements = types.getExtensibilityElements(); Schema schemaExtension; Object extensionObject; NodeList nodeList = schemaExtension.getElement().getChildNodes(); String tagName; for (int i = 0; i < nodeList.getLength(); i++) {