コード例 #1
0
  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;
  }
コード例 #2
0
  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;
  }
コード例 #3
0
  /**
   * 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;
  }
コード例 #4
0
  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);
          }
        }
      }
    }
  }
コード例 #5
0
  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()));
      }
    }
  }
コード例 #6
0
  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()));
      }
    }
  }
コード例 #7
0
  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();
    }
  }
コード例 #8
0
 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());
       }
   }
 }
コード例 #9
0
 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;
   }
 }
コード例 #10
0
  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());
      }
    }
  }
コード例 #11
0
  @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;
  }
コード例 #12
0
  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;
  }