private NeutralSchema parseElement(XmlSchemaElement element, XmlSchema schema) { QName elementTypeName = element.getSchemaTypeName(); // Derive Element Schema XmlSchemaType elementSchemaType = element.getSchemaType(); // Element annotations override type annotations. if (element.getAnnotation() != null) { elementSchemaType.setAnnotation(element.getAnnotation()); } NeutralSchema elementSchema = null; if (elementSchemaType != null) { if (elementSchemaType.getName() != null) { elementSchema = this.parse(elementSchemaType, schema); } else { elementSchema = this.parse(elementSchemaType, element.getName(), schema); } } else if (elementTypeName != null) { elementSchema = getSchemaFactory().createSchema(elementTypeName); } if (elementSchema != null) { // List Schema if (element.getMaxOccurs() > 1) { ListSchema listSchema = (ListSchema) getSchemaFactory().createSchema("list"); listSchema.getList().add(elementSchema); listSchema.updateAnnotations(); elementSchema = listSchema; } } Long min = element.getMinOccurs(); Long max = element.getMaxOccurs(); QName type = element.getSchemaTypeName(); if (min != null) { elementSchema.getProperties().put("minCardinality", min); } if (max != null) { elementSchema.getProperties().put("maxCardinality", max); } if (type != null) { elementSchema.getProperties().put("elementType", type.toString()); } return elementSchema; }
private NeutralSchema parseSimpleType( XmlSchemaSimpleType schemaSimpleType, XmlSchema schema, String name) { NeutralSchema ns = recursiveParseSimpleType(schemaSimpleType, schema); if (schemaSimpleType.getName() == null) { // Type defined in-line. Need to capture it in the element schema set. int i = 1; NeutralSchema existing = elementSchemas.get(name + i); while (existing != null && !schemasEqual(ns, existing)) { i++; existing = schemas.get(name + i); } ns.setType(name + i); elementSchemas.put(name + i, ns); } return ns; }
/** * Gets the schema for an underlying field on the given type * * @param type the type for the schema to look up * @param field the potentially nested field whose schema is to be returned */ @Override public NeutralSchema getSchema(String type, String field) { // get schema for entity NeutralSchema schema = this.getSchema(type); // loop through dotted notation for nested schemas for (String fieldName : field.split("\\.")) { schema = getNestedSchema(schema, fieldName); if (schema != null) { LOG.debug("nested schema type is {}", schema.getSchemaType()); } else { LOG.debug("nested schema type is {}", "NULL"); } } return schema; }
private void parseAttributes( XmlSchemaObjectCollection attributes, NeutralSchema complexSchema, XmlSchema schema) { if (attributes != null) { for (int i = 0; i < attributes.getCount(); i++) { XmlSchemaAttribute attribute = (XmlSchemaAttribute) attributes.getItem(i); QName attributeTypeName = attribute.getSchemaTypeName(); XmlSchemaType attributeSchemaType = attribute.getSchemaType(); if (attribute.getName() != null) { String attributeName = attribute.getName(); // Derive Attribute Schema NeutralSchema attributeSchema = null; if (attributeSchemaType != null) { attributeSchema = parse(attributeSchemaType, schema); } else if (attributeTypeName != null) { attributeSchema = getSchemaFactory().createSchema(attributeTypeName); } // Update Neutral Schema Field if (attributeSchema != null) { // Optional Attributes if (attribute.getUse().equals(REQUIRED_USE)) { AppInfo info = attributeSchema.getAppInfo(); if (info == null) { info = new AppInfo(null); } info.put(REQUIRED_USE.getValue(), "true"); attributeSchema.addAnnotation(info); } complexSchema.addField(attributeName, attributeSchema); } } } } }
private void parseDocumentation(NeutralSchema neutralSchema, XmlSchemaType schemaType) { XmlSchemaObjectCollection annotations = schemaType.getAnnotation().getItems(); for (int annotationIdx = 0; annotationIdx < annotations.getCount(); ++annotationIdx) { XmlSchemaObject annotation = annotations.getItem(annotationIdx); if (annotation instanceof XmlSchemaDocumentation) { XmlSchemaDocumentation docs = (XmlSchemaDocumentation) annotation; neutralSchema.addAnnotation(new Documentation(docs.getMarkup())); } } }
private void parseAppInfo(NeutralSchema neutralSchema, XmlSchemaType schemaType) { XmlSchemaObjectCollection annotations = schemaType.getAnnotation().getItems(); for (int annotationIdx = 0; annotationIdx < annotations.getCount(); ++annotationIdx) { XmlSchemaObject annotation = annotations.getItem(annotationIdx); if (annotation instanceof XmlSchemaAppInfo) { XmlSchemaAppInfo info = (XmlSchemaAppInfo) annotation; neutralSchema.addAnnotation(new AppInfo(info.getMarkup())); } } }
void loadSchema(XmlSchema schema) { XmlSchemaObjectCollection schemaItems = schema.getItems(); // Iterate XML Schema items for (int i = 0; i < schemaItems.getCount(); i++) { XmlSchemaObject schemaObject = schemaItems.getItem(i); NeutralSchema neutralSchema; if (schemaObject instanceof XmlSchemaType) { neutralSchema = parse((XmlSchemaType) schemaObject, schema); } else if (schemaObject instanceof XmlSchemaElement) { neutralSchema = parseElement((XmlSchemaElement) schemaObject, schema); } else if (schemaObject instanceof XmlSchemaInclude) { continue; // nothing to do for includes } else { throw new RuntimeException( "Unhandled XmlSchemaObject: " + schemaObject.getClass().getCanonicalName()); } schemas.put(neutralSchema.getType(), neutralSchema); partialSchemas.clear(); } }
private NeutralSchema getNestedSchema(NeutralSchema schema, String field) { if (schema == null) { return null; } switch (schema.getSchemaType()) { case STRING: case INTEGER: case DATE: case TIME: case DATETIME: case ID: case IDREF: case INT: case LONG: case DOUBLE: case BOOLEAN: case TOKEN: return null; case LIST: for (NeutralSchema possibleSchema : ((ListSchema) schema).getList()) { LOG.debug("possible schema type is {}", possibleSchema.getSchemaType()); if (getNestedSchema(possibleSchema, field) != null) { return getNestedSchema(possibleSchema, field); } } return null; case COMPLEX: for (String key : schema.getFields().keySet()) { NeutralSchema possibleSchema = schema.getFields().get(key); if (key.startsWith("*")) { key = key.substring(1); } if (key.equals(field)) { return possibleSchema; } } return null; default: { throw new RuntimeException("Unknown Schema Type: " + schema.getSchemaType()); } } }
private static boolean schemasEqual(NeutralSchema ns1, NeutralSchema ns2) { if (ns1.getValidatorClass().equals(ns2.getValidatorClass()) && ns1.getVersion().equals(ns2.getVersion()) && ns1.getFields().size() == ns2.getFields().size()) { for (Entry<String, NeutralSchema> entry : ns1.getFields().entrySet()) { if (!ns2.getFields().containsKey(entry.getKey())) { return false; } if (!schemasEqual(entry.getValue(), ns2.getFields().get(entry.getKey()))) { return false; } } for (Entry<String, Object> entry : ns1.getProperties().entrySet()) { if (!ns2.getProperties().containsKey(entry.getKey())) { return false; } if (!entry .getValue() .getClass() .equals(ns2.getProperties().get(entry.getKey()).getClass())) { return false; } if (entry.getValue() instanceof List) { List<?> list1 = (List<?>) entry.getValue(); List<?> list2 = (List<?>) ns2.getProperties().get(entry.getKey()); if (!list1.containsAll(list2)) { return false; } } else { if (!entry.getValue().equals(ns2.getProperties().get(entry.getKey()))) { return false; } } } return true; } else { return false; } }
private void parseParticle( XmlSchemaParticle particle, NeutralSchema complexSchema, XmlSchema schema) { if (particle != null) { if (particle instanceof XmlSchemaElement) { XmlSchemaElement element = (XmlSchemaElement) particle; NeutralSchema elementSchema = parseElement(element, schema); String elementName = element.getName(); // Required Elements if (!element.isNillable() && (element.getMinOccurs() > 0)) { AppInfo info = elementSchema.getAppInfo(); if (info == null) { info = new AppInfo(null); } info.put(REQUIRED_USE.getValue(), "true"); elementSchema.addAnnotation(info); } // Update Neutral Schema Field complexSchema.addField(elementName, elementSchema); // DE840 address.addressLines were not being encrypted for (Map.Entry<String, NeutralSchema> entry : elementSchema.getFields().entrySet()) { String fieldName = entry.getKey(); NeutralSchema fieldSchema = entry.getValue(); fieldSchema.inheritAnnotations(complexSchema.getAppInfo()); } } else if (particle instanceof XmlSchemaSequence) { XmlSchemaSequence schemaSequence = (XmlSchemaSequence) particle; for (int i = 0; i < schemaSequence.getItems().getCount(); i++) { XmlSchemaObject item = schemaSequence.getItems().getItem(i); if (item instanceof XmlSchemaParticle) { parseParticle((XmlSchemaParticle) item, complexSchema, schema); } else { throw new RuntimeException( "Unsupported XmlSchemaSequence item: " + item.getClass().getCanonicalName()); } } } else if (particle instanceof XmlSchemaChoice) { XmlSchemaChoice xmlSchemaChoice = (XmlSchemaChoice) particle; ChoiceSchema choiceSchema = (ChoiceSchema) getSchemaFactory().createSchema(NeutralSchemaType.CHOICE.name()); choiceSchema.setMinOccurs(xmlSchemaChoice.getMinOccurs()); choiceSchema.setMaxOccurs(xmlSchemaChoice.getMaxOccurs()); XmlSchemaObjectCollection choices = xmlSchemaChoice.getItems(); for (int i = 0; i < choices.getCount(); ++i) { XmlSchemaObject item = xmlSchemaChoice.getItems().getItem(i); if (item instanceof XmlSchemaParticle) { parseParticle((XmlSchemaParticle) item, choiceSchema, schema); } } complexSchema.addField("choice_" + choiceCount++, choiceSchema); } else { throw new RuntimeException( "Unsupported XmlSchemaParticle item: " + particle.getClass().getCanonicalName()); } } }
@SuppressWarnings("PMD.AvoidReassigningParameters") // makes code simpler private NeutralSchema parseComplexType( XmlSchemaComplexType schemaComplexType, NeutralSchema complexSchema, XmlSchema schema) { if ((schemaComplexType.getContentModel() != null) && (schemaComplexType.getContentModel().getContent() != null)) { XmlSchemaContent content = schemaComplexType.getContentModel().getContent(); if (content instanceof XmlSchemaComplexContentExtension) { XmlSchemaComplexContentExtension schemaComplexContent = (XmlSchemaComplexContentExtension) content; XmlSchemaComplexType complexBaseType = getComplexBaseType(schemaComplexContent, schema); if (complexBaseType != null) { complexSchema = parseComplexType(complexBaseType, complexSchema, schema); } this.parseFields(schemaComplexContent, complexSchema, schema); } else if (content instanceof XmlSchemaSimpleContentExtension) { QName baseTypeName = ((XmlSchemaSimpleContentExtension) content).getBaseTypeName(); NeutralSchema simpleContentSchema = schemaFactory.createSchema(baseTypeName); complexSchema.addField(complexSchema.getType(), simpleContentSchema); parseAttributes( ((XmlSchemaSimpleContentExtension) content).getAttributes(), complexSchema, schema); } } // Annotations are inherited by ComplexType fields so we need to parse these first. parseAnnotations(complexSchema, schemaComplexType); this.parseFields(schemaComplexType, complexSchema, schema); // Check for ChoiceSchemas. We only support complex types that contain choice if choice is // the ONLY element. If we find one, swap out the current ComplexSchema object that contains // this single choice schema for the actual choice schema itself. for (NeutralSchema ns : complexSchema.getFields().values()) { if (ns instanceof ChoiceSchema) { if (complexSchema.getFields().size() > 1 && !mergedChoiceSchemas.contains(ns)) { throw new RuntimeException( "Choice elements are only supported on complex objects with no other fields: " + schemaComplexType.getName()); } else if (!mergedChoiceSchemas.contains(ns)) { ns.setType(complexSchema.getType()); complexSchema.getAppInfo(); mergedChoiceSchemas.add(ns); if (ns.getType().equals("serviceDescriptorType")) { ns.addAnnotation(complexSchema.getAppInfo()); } return ns; } } } return complexSchema; }
private NeutralSchema recursiveParseSimpleType( XmlSchemaSimpleType schemaSimpleType, XmlSchema schema) { NeutralSchema simpleSchema = null; String simpleTypeName = schemaSimpleType.getName(); if (NeutralSchemaType.isPrimitive(schemaSimpleType.getQName())) { simpleSchema = getSchemaFactory().createSchema(schemaSimpleType.getQName()); } else if (NeutralSchemaType.exists(schemaSimpleType.getBaseSchemaTypeName())) { if (NeutralSchemaType.isPrimitive(schemaSimpleType.getBaseSchemaTypeName())) { simpleSchema = getSchemaFactory().createSchema(schemaSimpleType.getBaseSchemaTypeName()); } else { XmlSchemaSimpleType simpleBaseType = getSimpleBaseType(schemaSimpleType.getBaseSchemaTypeName(), schema); if (simpleBaseType != null) { if (simpleTypeName == null) { simpleTypeName = simpleBaseType.getName(); } simpleSchema = getSchemaFactory().createSchema(simpleTypeName); } } } else if (schemaSimpleType.getContent() != null && schemaSimpleType.getContent() instanceof XmlSchemaSimpleTypeList) { ListSchema listSchema = (ListSchema) getSchemaFactory().createSchema("list"); XmlSchemaSimpleTypeList content = (XmlSchemaSimpleTypeList) schemaSimpleType.getContent(); NeutralSchema listContentSchema = null; if (content.getItemType() != null) { listContentSchema = parseSimpleType(content.getItemType(), schema, null); } else { QName itemTypeName = content.getItemTypeName(); listContentSchema = getSchemaFactory().createSchema(itemTypeName.getLocalPart()); } listSchema.getList().add(listContentSchema); listSchema.updateAnnotations(); return listSchema; } else if (getSimpleContentTypeName(schemaSimpleType) != null) { if (NeutralSchemaType.isPrimitive(getSimpleContentTypeName(schemaSimpleType))) { simpleSchema = getSchemaFactory().createSchema(getSimpleContentTypeName(schemaSimpleType)); } else { XmlSchemaSimpleType simpleBaseType = getSimpleBaseType(getSimpleContentTypeName(schemaSimpleType), schema); simpleSchema = recursiveParseSimpleType(simpleBaseType, schema); } } if (simpleSchema != null && schemaSimpleType.getContent() != null) { if (schemaSimpleType.getContent() instanceof XmlSchemaSimpleTypeRestriction) { XmlSchemaSimpleTypeRestriction simpleRestrictedContent = (XmlSchemaSimpleTypeRestriction) schemaSimpleType.getContent(); XmlSchemaObjectCollection facets = simpleRestrictedContent.getFacets(); List<String> tokens = new ArrayList<String>(); for (int i = 0; i < facets.getCount(); i++) { XmlSchemaObject facetObject = facets.getItem(i); if (facetObject instanceof XmlSchemaEnumerationFacet) { XmlSchemaEnumerationFacet enumerationFacet = (XmlSchemaEnumerationFacet) facetObject; tokens.add(enumerationFacet.getValue().toString()); } else if (facetObject instanceof XmlSchemaFacet) { XmlSchemaFacet facet = (XmlSchemaFacet) facetObject; String facetPropertyName = NeutralSchemaType.lookupPropertyName(facet); simpleSchema.getProperties().put(facetPropertyName, facet.getValue().toString()); } } if (tokens.size() > 0) { // Token Schema Collections.sort(tokens); // sort so we can binary search simpleSchema.getProperties().put(TokenSchema.TOKENS, tokens); } } } parseAnnotations(simpleSchema, schemaSimpleType); if ((simpleSchema != null) && (simpleTypeName != null)) { simpleSchema.setType(simpleTypeName); } return simpleSchema; }