private DataServicesAtomEntry parseDSAtomEntry( String etag, XMLEventReader2 reader, XMLEvent2 event) { DataServicesAtomEntry dsae = new DataServicesAtomEntry(); dsae.etag = etag; dsae.properties = Enumerable.create(parseProperties(reader, event.asStartElement())).toList(); return dsae; }
/** * This is used by OData4J framework to build the metadata document for the service * * @param namespace Namespace to assign to entity when registering * @return The entire object as entity within the metadata */ public static EdmEntityType getEntityType(String namespace) { return new EdmEntityType( namespace, null, "Contact", null, Enumerable.create("id").toList(), getPrimitiveProperties(), null); }
/** * This method works the same as {@link * org.informea.odata.pojo.AbstractContact#getSchema(String)}, but for a list of entities. * * @param ees Entity set that describes this object. This was defined in metadata for this object, * @param contacts List of objects to encode * @return List of encoded objects */ public static List<OEntity> asEntities(final EdmEntitySet ees, List<AbstractContact> contacts) { return Enumerable.create(contacts) .select( new Func1<AbstractContact, OEntity>() { @Override public OEntity apply(AbstractContact contact) { return contact.asEntity(ees); } }) .toList(); }
@Override public Void execute() { ODataCxfClient client = new ODataCxfClient(this.getFormatType()); try { String path = Enumerable.create(getSegments()).join("/"); ODataClientRequest request = ODataClientRequest.delete(getServiceRootUri() + path); client.deleteEntity(request); return null; } finally { client.shuttdown(); } }
/** * Build the schema metadata for this object * * @param namespace Namespace to place this entity into * @return Schema used by the producer to declare entities into the metadata document */ public static EdmSchema getSchema(String namespace) { List<EdmEntitySet> entitySets = new ArrayList<EdmEntitySet>(); List<EdmEntityType> entityTypes = new ArrayList<EdmEntityType>(); // Define contact entity EdmEntityType eet = getEntityType(namespace); EdmEntitySet ees = new EdmEntitySet(COLLECTION_NAME, eet); entitySets.add(ees); entityTypes.add(eet); ////////////////////////////////////////////////////////////////////////////// Define treaties // navigable property String propertyName = NAV_PROP_TREATIES; EdmEntityType eetTreaty = Treaty.getEntityType(namespace); entityTypes.add(eetTreaty); EdmEntitySet eesTreaty = new EdmEntitySet(propertyName, eetTreaty); entitySets.add(eesTreaty); String assocName = String.format("FK_%s_%s", propertyName, COLLECTION_NAME); EdmAssociation assoc1 = new EdmAssociation( namespace, null, assocName, new EdmAssociationEnd(COLLECTION_NAME, eet, EdmMultiplicity.ZERO_TO_ONE), new EdmAssociationEnd(propertyName, eetTreaty, EdmMultiplicity.MANY)); List<EdmAssociationSet> lAssoc = new ArrayList<EdmAssociationSet>(); lAssoc.add( new EdmAssociationSet( assocName, assoc1, new EdmAssociationSetEnd( new EdmAssociationEnd(COLLECTION_NAME, eet, EdmMultiplicity.ZERO_TO_ONE), ees), new EdmAssociationSetEnd( new EdmAssociationEnd(propertyName, eetTreaty, EdmMultiplicity.MANY), eesTreaty))); EdmNavigationProperty np = new EdmNavigationProperty(propertyName, assoc1, assoc1.end1, assoc1.end2); eet.navigationProperties.add(np); // Output everything EdmEntityContainer container = new EdmEntityContainer("InforMEAService", true, null, entitySets, lAssoc, null); List<EdmEntityContainer> containers = new ArrayList<EdmEntityContainer>(); containers.add(container); return new EdmSchema( namespace, null, entityTypes, null, Enumerable.create(assoc1).toList(), containers); }
/** * This method works the same as {@link * org.informea.odata.pojo.LocalizableString#asEntity(java.lang.String)}, but for a list of * entities. * * @param namespace Namespace where this entity will be placed * @param strings List of objects to encode * @return List of encoded objects */ public static List<OEntity> asEntities(final String namespace, List<LocalizableString> strings) { if (strings != null) { return Enumerable.create(strings) .select( new Func1<LocalizableString, OEntity>() { @Override public OEntity apply(LocalizableString s) { return s.asEntity(namespace); } }) .toList(); } return new ArrayList<OEntity>(); }
public static Iterable<OProperty<?>> parseProperties( XMLEventReader2 reader, StartElement2 propertiesElement) { List<OProperty<?>> rt = new ArrayList<OProperty<?>>(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isEndElement() && event.asEndElement().getName().equals(propertiesElement.getName())) { return rt; } if (event.isStartElement() && event.asStartElement().getName().getNamespaceURI().equals(NS_DATASERVICES)) { String name = event.asStartElement().getName().getLocalPart(); Attribute2 typeAttribute = event.asStartElement().getAttributeByName(M_TYPE); Attribute2 nullAttribute = event.asStartElement().getAttributeByName(M_NULL); boolean isNull = nullAttribute != null && "true".equals(nullAttribute.getValue()); OProperty<?> op = null; String type = null; boolean isComplexType = false; if (typeAttribute != null) { type = typeAttribute.getValue(); EdmType et = EdmType.get(type); isComplexType = !et.isSimple(); } if (isComplexType) { op = OProperties.complex( name, type, isNull ? null : Enumerable.create(parseProperties(reader, event.asStartElement())) .toList()); } else { op = OProperties.parse(name, type, isNull ? null : reader.getElementText()); } rt.add(op); } } throw new RuntimeException(); }
private OEntity entityFromAtomEntry( EdmDataServices metadata, EdmEntitySet entitySet, DataServicesAtomEntry dsae, FeedCustomizationMapping mapping) { List<OProperty<?>> props = dsae.properties; if (mapping != null) { Enumerable<OProperty<?>> properties = Enumerable.create(dsae.properties); if (mapping.titlePropName != null) properties = properties.concat(OProperties.string(mapping.titlePropName, dsae.title)); if (mapping.summaryPropName != null) properties = properties.concat(OProperties.string(mapping.summaryPropName, dsae.summary)); props = properties.toList(); } OEntityKey key = entityKey != null ? entityKey : dsae.id != null ? dsae.id.endsWith(")") ? parseEntityKey(dsae.id) : OEntityKey.infer(entitySet, props) : null; if (key == null) return OEntities.createRequest( entitySet, props, toOLinks(metadata, entitySet, dsae.atomLinks, mapping), dsae.title, dsae.categoryTerm); return OEntities.create( entitySet, key, props, toOLinks(metadata, entitySet, dsae.atomLinks, mapping), dsae.title, dsae.categoryTerm); }
/** ReceivedMessageのPort用Edm 定義体. */ public class ReceivedMessagePort extends ReceivedMessage { private ReceivedMessagePort() { super(); } /** Schemaプロパティの定義体. */ public static final EdmProperty.Builder P_SCHEMA = EdmProperty.newBuilder("Schema") .setType(EdmSimpleType.BOOLEAN) .setNullable(true) .setDefaultValue("false"); /** EntityType Builder. */ public static final EdmEntityType.Builder EDM_TYPE_BUILDER = EdmEntityType.newBuilder() .setNamespace(Common.EDM_NS_CELL_CTL) .setName(EDM_TYPE_NAME) .addProperties( Enumerable.create( P_ID, P_SCHEMA, P_IN_REPLY_TO, P_FROM, P_MULTICAST_TO, P_TYPE, P_TITLE, P_BODY, P_PRIORITY, P_STATUS, P_REQUEST_RELATION, P_REQUEST_RELATION_TARGET, P_BOX_NAME, Common.P_PUBLISHED, Common.P_UPDATED) .toList()) .addKeys(P_ID.getName()); }
AtomFeed parseFeed(XMLEventReader2 reader) { AtomFeed feed = new AtomFeed(); List<AtomEntry> rt = new ArrayList<AtomEntry>(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (isStartElement(event, ATOM_ENTRY)) { rt.add(parseEntry(reader, event.asStartElement())); } else if (isStartElement(event, ATOM_LINK)) { if ("next" .equals(event.asStartElement().getAttributeByName(new QName2("rel")).getValue())) { feed.next = event.asStartElement().getAttributeByName(new QName2("href")).getValue(); } } else if (isEndElement(event, ATOM_FEED)) { // return from a sub feed, if we went down the hierarchy break; } } feed.entries = Enumerable.create(rt).cast(Entry.class); return feed; }
private List<OLink> toOLinks( final EdmDataServices metadata, EdmEntitySet fromRoleEntitySet, List<AtomLink> links, final FeedCustomizationMapping mapping) { List<OLink> rt = new ArrayList<OLink>(links.size()); for (final AtomLink link : links) { if (link.relation.startsWith(XmlFormatWriter.related)) { if (link.type.equals(XmlFormatWriter.atom_feed_content_type)) { List<OEntity> relatedEntities = null; // do we have inlined entities if (link.inlineFeed != null && link.inlineFeed.entries != null) { // get the entity set belonging to the from role type EdmNavigationProperty navProperty = fromRoleEntitySet != null ? fromRoleEntitySet.type.getNavigationProperty(link.title) : null; final EdmEntitySet toRoleEntitySet = metadata != null && navProperty != null ? metadata.getEdmEntitySet(navProperty.toRole.type) : null; // convert the atom feed entries to OEntitys relatedEntities = Enumerable.create(link.inlineFeed.entries) .cast(DataServicesAtomEntry.class) .select( new Func1<DataServicesAtomEntry, OEntity>() { @Override public OEntity apply(DataServicesAtomEntry input) { return entityFromAtomEntry(metadata, toRoleEntitySet, input, mapping); } }) .toList(); rt.add( OLinks.relatedEntitiesInline( link.relation, link.title, link.href, relatedEntities)); } else { // no inlined entities rt.add(OLinks.relatedEntities(link.relation, link.title, link.href)); } } else if (link.type.equals(XmlFormatWriter.atom_entry_content_type)) if (link.inlineEntry != null) { EdmNavigationProperty navProperty = fromRoleEntitySet != null ? fromRoleEntitySet.type.getNavigationProperty(link.title) : null; EdmEntitySet toRoleEntitySet = metadata != null && navProperty != null ? metadata.getEdmEntitySet(navProperty.toRole.type) : null; rt.add( OLinks.relatedEntityInline( link.relation, link.title, link.href, entityFromAtomEntry( metadata, toRoleEntitySet, (DataServicesAtomEntry) link.inlineEntry, mapping))); } else { // no inlined entity rt.add(OLinks.relatedEntity(link.relation, link.title, link.href)); } } } return rt; }
@Override public OProperty<?> getProperty(String propName) { return Enumerable.create(properties).first(OPredicates.propertyNameEquals(propName)); }
@Override public String toString() { return "OEntity[" + Enumerable.create(getProperties()).join(",") + "]"; }
protected String writeEntry( XMLWriter2 writer, OEntity oe, List<OProperty<?>> entityProperties, List<OLink> entityLinks, String entitySetName, String baseUri, String updated, EdmEntitySet ees, boolean isResponse) { String relid = null; String absid = null; if (isResponse) { relid = InternalUtil.getEntityRelId(oe); absid = baseUri + relid; writeElement(writer, "id", absid); } writeElement(writer, "title", null, "type", "text"); writeElement(writer, "updated", updated); writer.startElement("author"); writeElement(writer, "name", null); writer.endElement("author"); if (isResponse) { writeElement(writer, "link", null, "rel", "edit", "title", entitySetName, "href", relid); } if (isResponse) { // for responses we need to include all links whether inlined or not for (EdmNavigationProperty np : ees.type.getAllNavigationProperties()) { if (!np.selected) { continue; } String otherEntity = np.name; String rel = related + otherEntity; String type = atom_feed_content_type; if (np.toRole.multiplicity != EdmMultiplicity.MANY) { type = atom_entry_content_type; } final String title = otherEntity; String href = relid + "/" + otherEntity; // check whether we have to write inlined entities OLink linkToInline = entityLinks != null ? Enumerable.create(entityLinks) .firstOrNull( new Predicate1<OLink>() { @Override public boolean apply(OLink input) { return title.equals(input.getTitle()); } }) : null; if (linkToInline == null) { writeElement( writer, "link", null, "rel", rel, "type", type, "title", title, "href", href); } else { writer.startElement("link"); writer.writeAttribute("rel", rel); writer.writeAttribute("type", type); writer.writeAttribute("title", title); writer.writeAttribute("href", href); // write the inlined entities inside the link element writeLinkInline(writer, linkToInline, href, baseUri, updated, isResponse); writer.endElement("link"); } } writeElement( writer, "category", null, "term", ees.type.getFQNamespaceName(), "scheme", scheme); } else { // for requests we include only the provided links if (entityLinks != null) { for (OLink olink : entityLinks) { String type = olink instanceof ORelatedEntitiesLink ? atom_feed_content_type : atom_entry_content_type; writer.startElement("link"); writer.writeAttribute("rel", olink.getRelation()); writer.writeAttribute("type", type); writer.writeAttribute("title", olink.getTitle()); writer.writeAttribute("href", olink.getHref()); if (olink instanceof ORelatedEntitiesLinkInline || olink instanceof ORelatedEntityLinkInline) { // write the inlined entities inside the link element writeLinkInline(writer, olink, olink.getHref(), baseUri, updated, isResponse); } writer.endElement("link"); } } } writer.startElement("content"); writer.writeAttribute("type", MediaType.APPLICATION_XML); writer.startElement(new QName2(m, "properties", "m")); writeProperties(writer, entityProperties); writer.endElement("properties"); writer.endElement("content"); return absid; }
public class EdmxFormatParser extends XmlFormatParser { private static final Set<String> NON_USER_NAMESPACES = Enumerable.create( NS_METADATA, NS_DATASERVICES, NS_EDM2006, NS_EDM2007, NS_EDM2008_1, NS_EDM2008_9, NS_EDM2008_9, NS_EDM2009_8, NS_EDM2009_11, NS_EDMX, NS_EDMANNOTATION) .toSet(); private final EdmDataServices.Builder dataServices = EdmDataServices.newBuilder(); public EdmxFormatParser() {} public EdmDataServices parseMetadata(XMLEventReader2 reader) { List<EdmSchema.Builder> schemas = new ArrayList<EdmSchema.Builder>(); List<PrefixedNamespace> namespaces = null; ODataVersion version = null; boolean foundDataServices = false; while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); boolean shouldReturn = false; if (event.isStartElement()) { if (isElement(event, XmlFormatParser.EDMX_EDMX)) { namespaces = getExtensionNamespaces(event.asStartElement()); } else if (isElement(event, EDMX_DATASERVICES)) { foundDataServices = true; String str = getAttributeValueIfExists( event.asStartElement(), new QName2(NS_METADATA, "DataServiceVersion")); version = str != null ? ODataVersion.parse(str) : null; } else if (isElement( event, EDM2006_SCHEMA, EDM2007_SCHEMA, EDM2008_1_SCHEMA, EDM2008_9_SCHEMA, EDM2009_8_SCHEMA, EDM2009_11_SCHEMA)) { schemas.add(parseEdmSchema(reader, event.asStartElement())); if (!foundDataServices) // some dallas services have Schema as the document element! shouldReturn = true; } } if (isEndElement(event, EDMX_DATASERVICES)) shouldReturn = true; if (shouldReturn) { dataServices.setVersion(version).addSchemas(schemas).addNamespaces(namespaces); resolve(); return dataServices.build(); } } throw new UnsupportedOperationException(); } private void resolve() { final Map<String, EdmEntityType.Builder> allEetsByFQName = Enumerable.create(dataServices.getEntityTypes()) .toMap(EdmEntityType.Builder.func1_getFullyQualifiedTypeName()); final Map<String, EdmEntityType.Builder> allEetsByFQAliasName = Enumerable.create(dataServices.getEntityTypes()) .where(EdmEntityType.Builder.pred1_hasAlias()) .toMap(EdmEntityType.Builder.func1_getFQAliasName()); final Map<String, EdmAssociation.Builder> allEasByFQName = Enumerable.create(dataServices.getAssociations()) .toMap(EdmAssociation.Builder.func1_getFQNamespaceName()); for (EdmSchema.Builder edmSchema : dataServices.getSchemas()) { // resolve associations for (int i = 0; i < edmSchema.getAssociations().size(); i++) { EdmAssociation.Builder tmpAssociation = edmSchema.getAssociations().get(i); tmpAssociation .getEnd1() .setType(allEetsByFQName.get(tmpAssociation.getEnd1().getTypeName())); tmpAssociation .getEnd2() .setType(allEetsByFQName.get(tmpAssociation.getEnd2().getTypeName())); } // resolve navproperties for (EdmEntityType.Builder eet : edmSchema.getEntityTypes()) { List<EdmNavigationProperty.Builder> navProps = eet.getNavigationProperties(); for (int i = 0; i < navProps.size(); i++) { final EdmNavigationProperty.Builder tmp = navProps.get(i); final EdmAssociation.Builder ea = allEasByFQName.get(tmp.getRelationshipName()); if (ea == null) throw new IllegalArgumentException( "Invalid relationship name " + tmp.getRelationshipName()); List<EdmAssociationEnd.Builder> finalEnds = Enumerable.create(tmp.getFromRoleName(), tmp.getToRoleName()) .select( new Func1<String, EdmAssociationEnd.Builder>() { public EdmAssociationEnd.Builder apply(String input) { if (ea.getEnd1().getRole().equals(input)) return ea.getEnd1(); if (ea.getEnd2().getRole().equals(input)) return ea.getEnd2(); throw new IllegalArgumentException("Invalid role name " + input); } }) .toList(); tmp.setRelationship(ea).setFromTo(finalEnds.get(0), finalEnds.get(1)); } } // resolve entitysets for (EdmEntityContainer.Builder edmEntityContainer : edmSchema.getEntityContainers()) { for (int i = 0; i < edmEntityContainer.getEntitySets().size(); i++) { final EdmEntitySet.Builder tmpEes = edmEntityContainer.getEntitySets().get(i); EdmEntityType.Builder eet = allEetsByFQName.get(tmpEes.getEntityTypeName()); if (eet == null) eet = allEetsByFQAliasName.get(tmpEes.getEntityTypeName()); if (eet == null) throw new IllegalArgumentException("Invalid entity type " + tmpEes.getEntityTypeName()); edmEntityContainer .getEntitySets() .set( i, EdmEntitySet.newBuilder() .setName(tmpEes.getName()) .setEntityType(eet) .setAnnotationElements(tmpEes.getAnnotationElements()) .setAnnotations(tmpEes.getAnnotations())); } } // resolve associationsets for (final EdmEntityContainer.Builder edmEntityContainer : edmSchema.getEntityContainers()) { for (int i = 0; i < edmEntityContainer.getAssociationSets().size(); i++) { final EdmAssociationSet.Builder tmpEas = edmEntityContainer.getAssociationSets().get(i); final EdmAssociation.Builder ea = allEasByFQName.get(tmpEas.getAssociationName()); List<EdmAssociationSetEnd.Builder> finalEnds = Enumerable.create(tmpEas.getEnd1(), tmpEas.getEnd2()) .select( new Func1<EdmAssociationSetEnd.Builder, EdmAssociationSetEnd.Builder>() { public EdmAssociationSetEnd.Builder apply( final EdmAssociationSetEnd.Builder input) { EdmAssociationEnd.Builder eae = ea.getEnd1().getRole().equals(input.getRoleName()) ? ea.getEnd1() : ea.getEnd2().getRole().equals(input.getRoleName()) ? ea.getEnd2() : null; if (eae == null) throw new IllegalArgumentException( "Invalid role name " + input.getRoleName()); EdmEntitySet.Builder ees = Enumerable.create(edmEntityContainer.getEntitySets()) .first( OPredicates.nameEquals( EdmEntitySet.Builder.class, input.getEntitySetName())); return EdmAssociationSetEnd.newBuilder() .setRole(eae) .setEntitySet(ees) .setAnnotationElements(input.getAnnotationElements()) .setAnnotations(input.getAnnotations()); } }) .toList(); tmpEas.setAssociation(ea).setEnds(finalEnds.get(0), finalEnds.get(1)); } } // resolve functionimports for (final EdmEntityContainer.Builder edmEntityContainer : edmSchema.getEntityContainers()) { for (int i = 0; i < edmEntityContainer.getFunctionImports().size(); i++) { final EdmFunctionImport.Builder tmpEfi = edmEntityContainer.getFunctionImports().get(i); EdmEntitySet.Builder ees = Enumerable.create(edmEntityContainer.getEntitySets()) .firstOrNull( new Predicate1<EdmEntitySet.Builder>() { public boolean apply(EdmEntitySet.Builder input) { return input.getName().equals(tmpEfi.getEntitySetName()); } }); EdmType.Builder<?, ?> typeBuilder = null; if (tmpEfi.getReturnTypeName() != null) { typeBuilder = dataServices.resolveType(tmpEfi.getReturnTypeName()); if (typeBuilder == null) throw new RuntimeException("Edm-type not found: " + tmpEfi.getReturnTypeName()); if (tmpEfi.isCollection()) { typeBuilder = EdmCollectionType.newBuilder() .setKind(CollectionKind.Collection) .setCollectionType(typeBuilder); } } edmEntityContainer .getFunctionImports() .set( i, EdmFunctionImport.newBuilder() .setName(tmpEfi.getName()) .setEntitySet(ees) .setReturnType(typeBuilder) .setHttpMethod(tmpEfi.getHttpMethod()) .addParameters(tmpEfi.getParameters()) .setAnnotationElements(tmpEfi.getAnnotationElements()) .setAnnotations(tmpEfi.getAnnotations())); } } // resolve type hierarchy for (Entry<String, EdmEntityType.Builder> entry : allEetsByFQName.entrySet()) { String baseTypeName = entry.getValue().getFQBaseTypeName(); if (baseTypeName != null) { EdmEntityType.Builder baseType = allEetsByFQName.get(baseTypeName); if (baseType == null) { throw new IllegalArgumentException("Invalid baseType: " + baseTypeName); } entry.getValue().setBaseType(baseType); } } } } private EdmSchema.Builder parseEdmSchema(XMLEventReader2 reader, StartElement2 schemaElement) { String schemaNamespace = schemaElement.getAttributeByName(new QName2("Namespace")).getValue(); String schemaAlias = getAttributeValueIfExists(schemaElement, new QName2("Alias")); final List<EdmEntityType.Builder> edmEntityTypes = new ArrayList<EdmEntityType.Builder>(); List<EdmComplexType.Builder> edmComplexTypes = new ArrayList<EdmComplexType.Builder>(); List<EdmAssociation.Builder> edmAssociations = new ArrayList<EdmAssociation.Builder>(); List<EdmEntityContainer.Builder> edmEntityContainers = new ArrayList<EdmEntityContainer.Builder>(); List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_ENTITYTYPE, EDM2007_ENTITYTYPE, EDM2008_1_ENTITYTYPE, EDM2008_9_ENTITYTYPE, EDM2009_8_ENTITYTYPE, EDM2009_11_ENTITYTYPE)) { EdmEntityType.Builder edmEntityType = parseEdmEntityType(reader, schemaNamespace, schemaAlias, event.asStartElement()); edmEntityTypes.add(edmEntityType); } else if (isElement( event, EDM2006_ASSOCIATION, EDM2007_ASSOCIATION, EDM2008_1_ASSOCIATION, EDM2008_9_ASSOCIATION, EDM2009_8_ASSOCIATION, EDM2009_11_ASSOCIATION)) { EdmAssociation.Builder edmAssociation = parseEdmAssociation(reader, schemaNamespace, schemaAlias, event.asStartElement()); edmAssociations.add(edmAssociation); } else if (isElement( event, EDM2006_COMPLEXTYPE, EDM2007_COMPLEXTYPE, EDM2008_1_COMPLEXTYPE, EDM2008_9_COMPLEXTYPE, EDM2009_8_COMPLEXTYPE, EDM2009_11_COMPLEXTYPE)) { EdmComplexType.Builder edmComplexType = parseEdmComplexType(reader, schemaNamespace, event.asStartElement()); edmComplexTypes.add(edmComplexType); } else if (isElement( event, EDM2006_ENTITYCONTAINER, EDM2007_ENTITYCONTAINER, EDM2008_1_ENTITYCONTAINER, EDM2008_9_ENTITYCONTAINER, EDM2009_8_ENTITYCONTAINER, EDM2009_11_ENTITYCONTAINER)) { EdmEntityContainer.Builder edmEntityContainer = parseEdmEntityContainer(reader, schemaNamespace, event.asStartElement()); edmEntityContainers.add(edmEntityContainer); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, schemaElement.getName())) { return EdmSchema.newBuilder() .setNamespace(schemaNamespace) .setAlias(schemaAlias) .addEntityTypes(edmEntityTypes) .addComplexTypes(edmComplexTypes) .addAssociations(edmAssociations) .addEntityContainers(edmEntityContainers) .setAnnotations(getAnnotations(schemaElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); } private EdmEntityContainer.Builder parseEdmEntityContainer( XMLEventReader2 reader, String schemaNamespace, StartElement2 entityContainerElement) { String name = entityContainerElement.getAttributeByName("Name").getValue(); boolean isDefault = "true" .equals( getAttributeValueIfExists( entityContainerElement, new QName2(NS_METADATA, "IsDefaultEntityContainer"))); String lazyLoadingEnabledValue = getAttributeValueIfExists( entityContainerElement, new QName2(NS_EDMANNOTATION, "LazyLoadingEnabled")); Boolean lazyLoadingEnabled = lazyLoadingEnabledValue == null ? null : lazyLoadingEnabledValue.equals("true"); String extendz = getAttributeValueIfExists(entityContainerElement, new QName2("Extends")); List<EdmEntitySet.Builder> edmEntitySets = new ArrayList<EdmEntitySet.Builder>(); List<EdmAssociationSet.Builder> edmAssociationSets = new ArrayList<EdmAssociationSet.Builder>(); List<EdmFunctionImport.Builder> edmFunctionImports = new ArrayList<EdmFunctionImport.Builder>(); List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_ENTITYSET, EDM2007_ENTITYSET, EDM2008_1_ENTITYSET, EDM2008_9_ENTITYSET, EDM2009_8_ENTITYSET, EDM2009_11_ENTITYSET)) { EdmEntitySet.Builder entitySet = parseEdmEntitySet(reader, schemaNamespace, event.asStartElement()); edmEntitySets.add(entitySet); } else if (isElement( event, EDM2006_ASSOCIATIONSET, EDM2007_ASSOCIATIONSET, EDM2008_1_ASSOCIATIONSET, EDM2008_9_ASSOCIATIONSET, EDM2009_8_ASSOCIATIONSET, EDM2009_11_ASSOCIATIONSET)) { edmAssociationSets.add( parseEdmAssociationSet(reader, schemaNamespace, event.asStartElement())); } else if (isElement( event, EDM2006_FUNCTIONIMPORT, EDM2007_FUNCTIONIMPORT, EDM2008_1_FUNCTIONIMPORT, EDM2008_9_FUNCTIONIMPORT, EDM2009_8_FUNCTIONIMPORT, EDM2009_11_FUNCTIONIMPORT)) { edmFunctionImports.add( parseEdmFunctionImport(reader, schemaNamespace, event.asStartElement())); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, entityContainerElement.getName())) { return EdmEntityContainer.newBuilder() .setName(name) .setIsDefault(isDefault) .setLazyLoadingEnabled(lazyLoadingEnabled) .setExtendz(extendz) .addEntitySets(edmEntitySets) .addAssociationSets(edmAssociationSets) .addFunctionImports(edmFunctionImports) .setAnnotations(getAnnotations(entityContainerElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); } private EdmEntitySet.Builder parseEdmEntitySet( XMLEventReader2 reader, String schemaNamespace, StartElement2 entitySetStartElement) { List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); String name = entitySetStartElement.getAttributeByName("Name").getValue(); String entityTypeName = getAttributeValueIfExists(entitySetStartElement, "EntityType"); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } if (isEndElement(event, entitySetStartElement.getName())) { return EdmEntitySet.newBuilder() .setName(name) .setEntityTypeName(entityTypeName) .setAnnotations(getAnnotations(entitySetStartElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); } private EdmFunctionImport.Builder parseEdmFunctionImport( XMLEventReader2 reader, String schemaNamespace, StartElement2 functionImportElement) { String name = functionImportElement.getAttributeByName("Name").getValue(); String entitySet = getAttributeValueIfExists(functionImportElement, "EntitySet"); Attribute2 returnTypeAttr = functionImportElement.getAttributeByName("ReturnType"); String returnType = returnTypeAttr != null ? returnTypeAttr.getValue() : null; List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); // strict parsing boolean isCollection = returnType != null && returnType.matches("^Collection\\(.*\\)$"); if (isCollection) { returnType = returnType.substring(11, returnType.length() - 1); } String httpMethod = getAttributeValueIfExists(functionImportElement, new QName2(NS_METADATA, "HttpMethod")); List<EdmFunctionParameter.Builder> parameters = new ArrayList<EdmFunctionParameter.Builder>(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_PARAMETER, EDM2007_PARAMETER, EDM2008_1_PARAMETER, EDM2008_9_PARAMETER, EDM2009_8_PARAMETER, EDM2009_11_PARAMETER)) { StartElement2 paramStartElement = event.asStartElement(); EdmFunctionParameter.Builder functionParameter = parseEdmFunctionParameter(reader, paramStartElement); parameters.add(functionParameter); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, functionImportElement.getName())) { return EdmFunctionImport.newBuilder() .setName(name) .setEntitySetName(entitySet) .setReturnTypeName(returnType) .setIsCollection(isCollection) .setHttpMethod(httpMethod) .addParameters(parameters) .setAnnotations(getAnnotations(functionImportElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); } private EdmFunctionParameter.Builder parseEdmFunctionParameter( XMLEventReader2 reader, StartElement2 paramStartElement) { List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); Attribute2 modeAttribute = paramStartElement.getAttributeByName("Mode"); String nullableS = getAttributeValueIfExists(paramStartElement, "Nullable"); String maxLength = getAttributeValueIfExists(paramStartElement, "MaxLength"); String precision = getAttributeValueIfExists(paramStartElement, "Precision"); String scale = getAttributeValueIfExists(paramStartElement, "Scale"); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } if (isEndElement(event, paramStartElement.getName())) { return EdmFunctionParameter.newBuilder() .setName(paramStartElement.getAttributeByName("Name").getValue()) .setType( EdmType.newDeferredBuilder( paramStartElement.getAttributeByName("Type").getValue(), dataServices)) .setMode(modeAttribute != null ? Mode.valueOf(modeAttribute.getValue()) : null) .setNullable(nullableS == null ? null : "true".equalsIgnoreCase(nullableS)) .setMaxLength( maxLength == null ? null : maxLength.equals("Max") ? Integer.MAX_VALUE : Integer.parseInt(maxLength)) .setPrecision(precision == null ? null : Integer.parseInt(precision)) .setScale(scale == null ? null : Integer.parseInt(scale)) .setAnnotations(getAnnotations(paramStartElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); } private EdmAssociationSet.Builder parseEdmAssociationSet( XMLEventReader2 reader, String schemaNamespace, StartElement2 associationSetElement) { String name = associationSetElement.getAttributeByName("Name").getValue(); String associationName = associationSetElement.getAttributeByName("Association").getValue(); List<EdmAssociationSetEnd.Builder> ends = new ArrayList<EdmAssociationSetEnd.Builder>(); List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_END, EDM2007_END, EDM2008_1_END, EDM2008_9_END, EDM2009_8_END, EDM2009_11_END)) { StartElement2 endStartElement = event.asStartElement(); EdmAssociationSetEnd.Builder assocSetEnd = parseEdmAssociationSetEnd(reader, endStartElement); ends.add(assocSetEnd); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, associationSetElement.getName())) { return EdmAssociationSet.newBuilder() .setName(name) .setAssociationName(associationName) .setEnds(ends.get(0), ends.get(1)) .setAnnotations(getAnnotations(associationSetElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); } private EdmAssociationSetEnd.Builder parseEdmAssociationSetEnd( XMLEventReader2 reader, StartElement2 endStartElement) { List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); String role = endStartElement.getAttributeByName("Role").getValue(); String entitySetName = endStartElement.getAttributeByName("EntitySet").getValue(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } if (isEndElement(event, endStartElement.getName())) { return EdmAssociationSetEnd.newBuilder() .setRoleName(role) .setEntitySetName(entitySetName) .setAnnotations(getAnnotations(endStartElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); } private EdmAssociation.Builder parseEdmAssociation( XMLEventReader2 reader, String schemaNamespace, String schemaAlias, StartElement2 associationElement) { String name = associationElement.getAttributeByName("Name").getValue(); List<EdmAssociationEnd.Builder> ends = new ArrayList<EdmAssociationEnd.Builder>(); List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); EdmReferentialConstraint.Builder referentialConstraint = null; while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_END, EDM2007_END, EDM2008_1_END, EDM2008_9_END, EDM2009_8_END, EDM2009_11_END)) { EdmAssociationEnd.Builder edmAssociationEnd = parseEdmAssociationEnd(reader, event); ends.add(edmAssociationEnd); } else if (isElement( event, EDM2006_REFCONSTRAINT, EDM2007_REFCONSTRAINT, EDM2008_1_REFCONSTRAINT, EDM2008_9_REFCONSTRAINT, EDM2009_8_REFCONSTRAINT, EDM2009_11_REFCONSTRAINT)) { StartElement2 constraintElement = event.asStartElement(); referentialConstraint = parseEdmConstraintElement(reader, constraintElement); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, associationElement.getName())) { return EdmAssociation.newBuilder() .setNamespace(schemaNamespace) .setAlias(schemaAlias) .setName(name) .setEnds(ends.get(0), ends.get(1)) .setRefConstraint(referentialConstraint == null ? null : referentialConstraint) .setAnnotations(getAnnotations(associationElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); } private EdmReferentialConstraint.Builder parseEdmConstraintElement( XMLEventReader2 tmpReader, StartElement2 constraintElement) { List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); List<String> principalPropertyRef = new ArrayList<String>(); List<String> dependentPropertyRef = new ArrayList<String>(); String principalRole = null; String dependentRole = null; while (tmpReader.hasNext()) { XMLEvent2 event = tmpReader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_PRINCIPAL, EDM2007_PRINCIPAL, EDM2008_1_PRINCIPAL, EDM2008_9_PRINCIPAL, EDM2009_8_PRINCIPAL, EDM2009_11_PRINCIPAL)) { StartElement2 principalElement = event.asStartElement(); principalPropertyRef = parsePropertyRef(tmpReader, principalElement); principalRole = principalElement.getAttributeByName("Role").getValue(); } else if (isElement( event, EDM2006_DEPENDENT, EDM2007_DEPENDENT, EDM2008_1_DEPENDENT, EDM2008_9_DEPENDENT, EDM2009_8_DEPENDENT, EDM2009_11_DEPENDENT)) { StartElement2 dependentElement = event.asStartElement(); dependentPropertyRef = parsePropertyRef(tmpReader, dependentElement); dependentRole = dependentElement.getAttributeByName("Role").getValue(); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, tmpReader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, constraintElement.getName())) { return EdmReferentialConstraint.newBuilder() .setPrincipalRole(principalRole) .setDependentRole(dependentRole) .addDependentReferences(dependentPropertyRef) .addPrincipalReferences(principalPropertyRef) .setAnnotationElements(annotElements) .setAnnotations(getAnnotations(constraintElement)); } } throw new UnsupportedOperationException(); } private List<String> parsePropertyRef(XMLEventReader2 tmpReader, StartElement2 startElement) { List<String> references = new ArrayList<String>(); while (tmpReader.hasNext()) { XMLEvent2 event = tmpReader.nextEvent(); if (isStartElement( event, EDM2006_PROPERTYREF, EDM2007_PROPERTYREF, EDM2008_1_PROPERTYREF, EDM2008_9_PROPERTYREF, EDM2009_8_PROPERTYREF, EDM2009_11_PROPERTYREF)) { references.add(event.asStartElement().getAttributeByName("Name").getValue()); } if (isEndElement(event, startElement.getName())) { return references; } } throw new UnsupportedOperationException(); } private EdmAssociationEnd.Builder parseEdmAssociationEnd( XMLEventReader2 tmpReader, XMLEvent2 event) { List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); StartElement2 endStartElement = event.asStartElement(); String onDeleteAction = null; while (tmpReader.hasNext()) { XMLEvent2 event2 = tmpReader.nextEvent(); if (event2.isStartElement()) { if (isElement( event2, EDM2006_ONDELETE, EDM2007_ONDELETE, EDM2008_1_ONDELETE, EDM2008_9_ONDELETE, EDM2009_8_ONDELETE, EDM2009_11_ONDELETE)) { StartElement2 onDeleteStartElement = event2.asStartElement(); onDeleteAction = onDeleteStartElement.getAttributeByName("Action").getValue(); } else { EdmAnnotation<?> anElement = getAnnotationElements(event2, tmpReader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event2, endStartElement.getName())) { return EdmAssociationEnd.newBuilder() .setRole(endStartElement.getAttributeByName("Role").getValue()) .setTypeName(endStartElement.getAttributeByName("Type").getValue()) .setMultiplicity( EdmMultiplicity.fromSymbolString( endStartElement.getAttributeByName("Multiplicity").getValue())) .setOnDeleteAction( onDeleteAction == null ? null : EdmOnDeleteAction.fromSymbolString(onDeleteAction)) .setAnnotations(getAnnotations(endStartElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); } private EdmProperty.Builder parseEdmProperty(XMLEventReader2 reader, XMLEvent2 event) { List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); StartElement2 startElement = event.asStartElement(); String propertyName = getAttributeValueIfExists(startElement, "Name"); String propertyType = getAttributeValueIfExists(startElement, "Type"); String propertyNullable = getAttributeValueIfExists(startElement, "Nullable"); String maxLength = getAttributeValueIfExists(startElement, "MaxLength"); String unicode = getAttributeValueIfExists(startElement, "Unicode"); String fixedLength = getAttributeValueIfExists(startElement, "FixedLength"); String collation = getAttributeValueIfExists(startElement, "Collation"); String collectionKindS = getAttributeValueIfExists(startElement, "CollectionKind"); CollectionKind ckind = CollectionKind.NONE; if (collectionKindS != null) { ckind = Enum.valueOf(CollectionKind.class, collectionKindS); } String defaultValue = getAttributeValueIfExists(startElement, "DefaultValue"); String precision = getAttributeValueIfExists(startElement, "Precision"); String scale = getAttributeValueIfExists(startElement, "Scale"); String storeGeneratedPattern = getAttributeValueIfExists( startElement, new QName2(NS_EDMANNOTATION, "StoreGeneratedPattern")); String concurrencyMode = getAttributeValueIfExists(startElement, "ConcurrencyMode"); String mimeType = getAttributeValueIfExists(startElement, M_MIMETYPE); String fcTargetPath = getAttributeValueIfExists(startElement, M_FC_TARGETPATH); String fcContentKind = getAttributeValueIfExists(startElement, M_FC_CONTENTKIND); String fcKeepInContent = getAttributeValueIfExists(startElement, M_FC_KEEPINCONTENT); String fcEpmContentKind = getAttributeValueIfExists(startElement, M_FC_EPMCONTENTKIND); String fcEpmKeepInContent = getAttributeValueIfExists(startElement, M_FC_EPMKEEPINCONTENT); String fcNsPrefix = getAttributeValueIfExists(startElement, M_FC_NSPREFIX); String fcNsUri = getAttributeValueIfExists(startElement, M_FC_NSURI); while (reader.hasNext()) { XMLEvent2 event2 = reader.nextEvent(); if (event2.isStartElement()) { EdmAnnotation<?> anElement = getAnnotationElements(event2, reader); if (anElement != null) { annotElements.add(anElement); } } if (isEndElement(event2, startElement.getName())) { return EdmProperty.newBuilder(propertyName) .setType(EdmType.newDeferredBuilder(propertyType, dataServices)) .setNullable("true".equalsIgnoreCase(propertyNullable)) .setMaxLength( maxLength == null ? null : maxLength.equals("Max") ? Integer.MAX_VALUE : Integer.parseInt(maxLength)) .setUnicode(unicode == null ? null : "true".equalsIgnoreCase(unicode)) .setFixedLength(fixedLength == null ? null : "true".equalsIgnoreCase(fixedLength)) .setCollation(collation) .setConcurrencyMode(concurrencyMode) .setStoreGeneratedPattern(storeGeneratedPattern) .setMimeType(mimeType) .setFcTargetPath(fcTargetPath) .setFcContentKind(fcContentKind) .setFcKeepInContent(fcKeepInContent) .setFcEpmContentKind(fcEpmContentKind) .setFcEpmKeepInContent(fcEpmKeepInContent) .setFcNsPrefix(fcNsPrefix) .setFcNsUri(fcNsUri) .setCollectionKind(ckind) .setDefaultValue(defaultValue) .setPrecision(precision == null ? null : Integer.parseInt(precision)) .setScale(scale == null ? null : Integer.parseInt(scale)) .setAnnotations(getAnnotations(startElement)) .setAnnotationElements(annotElements.isEmpty() ? null : annotElements); } } throw new UnsupportedOperationException(); } private EdmComplexType.Builder parseEdmComplexType( XMLEventReader2 reader, String schemaNamespace, StartElement2 complexTypeElement) { String name = complexTypeElement.getAttributeByName("Name").getValue(); String isAbstractS = getAttributeValueIfExists(complexTypeElement, "Abstract"); String baseType = getAttributeValueIfExists(complexTypeElement, "BaseType"); List<EdmProperty.Builder> edmProperties = new ArrayList<EdmProperty.Builder>(); List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_PROPERTY, EDM2007_PROPERTY, EDM2008_1_PROPERTY, EDM2008_9_PROPERTY, EDM2009_8_PROPERTY, EDM2009_11_PROPERTY)) { edmProperties.add(parseEdmProperty(reader, event)); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, complexTypeElement.getName())) { EdmComplexType.Builder complexType = EdmComplexType.newBuilder() .setNamespace(schemaNamespace) .setName(name) .setBaseType(baseType) .addProperties(edmProperties) .setAnnotations(getAnnotations(complexTypeElement)) .setAnnotationElements(annotElements); if (isAbstractS != null) complexType.setIsAbstract("true".equals(isAbstractS)); return complexType; } } throw new UnsupportedOperationException(); } private EdmEntityType.Builder parseEdmEntityType( XMLEventReader2 reader, String schemaNamespace, String schemaAlias, StartElement2 entityTypeElement) { String name = entityTypeElement.getAttributeByName("Name").getValue(); String hasStreamValue = getAttributeValueIfExists(entityTypeElement, new QName2(NS_METADATA, "HasStream")); Boolean hasStream = hasStreamValue == null ? null : hasStreamValue.equals("true"); String baseType = getAttributeValueIfExists(entityTypeElement, "BaseType"); String isAbstractS = getAttributeValueIfExists(entityTypeElement, "Abstract"); String openTypeValue = getAttributeValueIfExists(entityTypeElement, "OpenType"); Boolean openType = openTypeValue == null ? null : openTypeValue.equals("true"); List<String> keys = new ArrayList<String>(); List<EdmProperty.Builder> edmProperties = new ArrayList<EdmProperty.Builder>(); List<EdmNavigationProperty.Builder> edmNavigationProperties = new ArrayList<EdmNavigationProperty.Builder>(); List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_PROPERTYREF, EDM2007_PROPERTYREF, EDM2008_1_PROPERTYREF, EDM2008_9_PROPERTYREF, EDM2009_8_PROPERTYREF, EDM2009_11_PROPERTYREF)) { keys.add(event.asStartElement().getAttributeByName("Name").getValue()); } else if (isElement( event, EDM2006_PROPERTY, EDM2007_PROPERTY, EDM2008_1_PROPERTY, EDM2008_9_PROPERTY, EDM2009_8_PROPERTY, EDM2009_11_PROPERTY)) { edmProperties.add(parseEdmProperty(reader, event)); } else if (isElement( event, EDM2006_NAVIGATIONPROPERTY, EDM2007_NAVIGATIONPROPERTY, EDM2008_1_NAVIGATIONPROPERTY, EDM2008_9_NAVIGATIONPROPERTY, EDM2009_8_NAVIGATIONPROPERTY, EDM2009_11_NAVIGATIONPROPERTY)) { edmNavigationProperties.add(parseEdmNavigationProperty(reader, event)); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, entityTypeElement.getName())) { return EdmEntityType.newBuilder() .setNamespace(schemaNamespace) .setAlias(schemaAlias) .setName(name) .setHasStream(hasStream) .setOpenType(openType) .addKeys(keys) .addProperties(edmProperties) .addNavigationProperties(edmNavigationProperties) .setBaseType(baseType) .setIsAbstract(isAbstractS == null ? null : "true".equals(isAbstractS)) .setAnnotations(getAnnotations(entityTypeElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); } private EdmNavigationProperty.Builder parseEdmNavigationProperty( XMLEventReader2 reader, XMLEvent2 event) { List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); StartElement2 navPropStartElement = event.asStartElement(); String associationName = navPropStartElement.getAttributeByName("Name").getValue(); String relationshipName = navPropStartElement.getAttributeByName("Relationship").getValue(); String fromRoleName = navPropStartElement.getAttributeByName("FromRole").getValue(); String toRoleName = navPropStartElement.getAttributeByName("ToRole").getValue(); while (reader.hasNext()) { event = reader.nextEvent(); if (event.isStartElement()) { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } if (isEndElement(event, navPropStartElement.getName())) { return EdmNavigationProperty.newBuilder(associationName) .setRelationshipName(relationshipName) .setFromToName(fromRoleName, toRoleName) .setAnnotations(getAnnotations(navPropStartElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); } protected boolean isExtensionNamespace(String namespaceUri) { return namespaceUri != null && !AndroidCompat.String_isEmpty(namespaceUri.trim()) && !namespaceUri.contains("schemas.microsoft.com"); } protected List<EdmAnnotation<?>> getAnnotations(StartElement2 element) { // extract Annotation attributes try { Enumerable<Attribute2> atts = element.getAttributes(); List<EdmAnnotation<?>> annots = new ArrayList<EdmAnnotation<?>>(); for (Attribute2 att : atts) { QName2 q = att.getName(); if (isExtensionNamespace(q.getNamespaceUri())) { // a user extension annots.add( EdmAnnotation.attribute( q.getNamespaceUri(), q.getPrefix(), q.getLocalPart(), att.getValue())); } } return annots; } catch (Exception ex) { // not all of the xml parsing implementations implement getAttributes() yet. return null; } } protected List<PrefixedNamespace> getExtensionNamespaces(StartElement2 startElement) { try { Enumerable<Namespace2> nse = startElement.getNamespaces(); List<PrefixedNamespace> nsl = new ArrayList<PrefixedNamespace>(); for (Namespace2 ns : nse) { if (this.isExtensionNamespace(ns.getNamespaceURI())) { nsl.add(new PrefixedNamespace(ns.getNamespaceURI(), ns.getPrefix())); } } return nsl; } catch (Exception ex) { // not all of the xml parsing implementations implement getNamespaces() yet. return null; } } protected EdmAnnotation<?> getAnnotationElements(XMLEvent2 event, XMLEventReader2 reader) { StartElement2 annotationStartElement = event.asStartElement(); QName2 q = annotationStartElement.getName(); String value = null; EdmAnnotationElement<?> element = null; List<EdmAnnotation<?>> list = new ArrayList<EdmAnnotation<?>>(); if (!NON_USER_NAMESPACES.contains(q.getNamespaceUri())) { // a user extension while (reader.hasNext()) { event = reader.nextEvent(); if (event.isStartElement()) { EdmAnnotation<?> childElement = getAnnotationElements(event, reader); if (childElement != null) { list.add(childElement); } } else if (event.isCharacters()) { value = event.asCharacters().getData().trim(); } else if (event.isEndElement()) { if (value != null) { element = EdmAnnotation.element( q.getNamespaceUri(), q.getPrefix(), q.getLocalPart(), String.class, value); } else { element = EdmAnnotation.element( q.getNamespaceUri(), q.getPrefix(), q.getLocalPart(), String.class, ""); } element.setAnnotationElements(list); element.setAnnotations(getAnnotations(annotationStartElement)); return element; } } } return null; } }
private void resolve() { final Map<String, EdmEntityType.Builder> allEetsByFQName = Enumerable.create(dataServices.getEntityTypes()) .toMap(EdmEntityType.Builder.func1_getFullyQualifiedTypeName()); final Map<String, EdmEntityType.Builder> allEetsByFQAliasName = Enumerable.create(dataServices.getEntityTypes()) .where(EdmEntityType.Builder.pred1_hasAlias()) .toMap(EdmEntityType.Builder.func1_getFQAliasName()); final Map<String, EdmAssociation.Builder> allEasByFQName = Enumerable.create(dataServices.getAssociations()) .toMap(EdmAssociation.Builder.func1_getFQNamespaceName()); for (EdmSchema.Builder edmSchema : dataServices.getSchemas()) { // resolve associations for (int i = 0; i < edmSchema.getAssociations().size(); i++) { EdmAssociation.Builder tmpAssociation = edmSchema.getAssociations().get(i); tmpAssociation .getEnd1() .setType(allEetsByFQName.get(tmpAssociation.getEnd1().getTypeName())); tmpAssociation .getEnd2() .setType(allEetsByFQName.get(tmpAssociation.getEnd2().getTypeName())); } // resolve navproperties for (EdmEntityType.Builder eet : edmSchema.getEntityTypes()) { List<EdmNavigationProperty.Builder> navProps = eet.getNavigationProperties(); for (int i = 0; i < navProps.size(); i++) { final EdmNavigationProperty.Builder tmp = navProps.get(i); final EdmAssociation.Builder ea = allEasByFQName.get(tmp.getRelationshipName()); if (ea == null) throw new IllegalArgumentException( "Invalid relationship name " + tmp.getRelationshipName()); List<EdmAssociationEnd.Builder> finalEnds = Enumerable.create(tmp.getFromRoleName(), tmp.getToRoleName()) .select( new Func1<String, EdmAssociationEnd.Builder>() { public EdmAssociationEnd.Builder apply(String input) { if (ea.getEnd1().getRole().equals(input)) return ea.getEnd1(); if (ea.getEnd2().getRole().equals(input)) return ea.getEnd2(); throw new IllegalArgumentException("Invalid role name " + input); } }) .toList(); tmp.setRelationship(ea).setFromTo(finalEnds.get(0), finalEnds.get(1)); } } // resolve entitysets for (EdmEntityContainer.Builder edmEntityContainer : edmSchema.getEntityContainers()) { for (int i = 0; i < edmEntityContainer.getEntitySets().size(); i++) { final EdmEntitySet.Builder tmpEes = edmEntityContainer.getEntitySets().get(i); EdmEntityType.Builder eet = allEetsByFQName.get(tmpEes.getEntityTypeName()); if (eet == null) eet = allEetsByFQAliasName.get(tmpEes.getEntityTypeName()); if (eet == null) throw new IllegalArgumentException("Invalid entity type " + tmpEes.getEntityTypeName()); edmEntityContainer .getEntitySets() .set( i, EdmEntitySet.newBuilder() .setName(tmpEes.getName()) .setEntityType(eet) .setAnnotationElements(tmpEes.getAnnotationElements()) .setAnnotations(tmpEes.getAnnotations())); } } // resolve associationsets for (final EdmEntityContainer.Builder edmEntityContainer : edmSchema.getEntityContainers()) { for (int i = 0; i < edmEntityContainer.getAssociationSets().size(); i++) { final EdmAssociationSet.Builder tmpEas = edmEntityContainer.getAssociationSets().get(i); final EdmAssociation.Builder ea = allEasByFQName.get(tmpEas.getAssociationName()); List<EdmAssociationSetEnd.Builder> finalEnds = Enumerable.create(tmpEas.getEnd1(), tmpEas.getEnd2()) .select( new Func1<EdmAssociationSetEnd.Builder, EdmAssociationSetEnd.Builder>() { public EdmAssociationSetEnd.Builder apply( final EdmAssociationSetEnd.Builder input) { EdmAssociationEnd.Builder eae = ea.getEnd1().getRole().equals(input.getRoleName()) ? ea.getEnd1() : ea.getEnd2().getRole().equals(input.getRoleName()) ? ea.getEnd2() : null; if (eae == null) throw new IllegalArgumentException( "Invalid role name " + input.getRoleName()); EdmEntitySet.Builder ees = Enumerable.create(edmEntityContainer.getEntitySets()) .first( OPredicates.nameEquals( EdmEntitySet.Builder.class, input.getEntitySetName())); return EdmAssociationSetEnd.newBuilder() .setRole(eae) .setEntitySet(ees) .setAnnotationElements(input.getAnnotationElements()) .setAnnotations(input.getAnnotations()); } }) .toList(); tmpEas.setAssociation(ea).setEnds(finalEnds.get(0), finalEnds.get(1)); } } // resolve functionimports for (final EdmEntityContainer.Builder edmEntityContainer : edmSchema.getEntityContainers()) { for (int i = 0; i < edmEntityContainer.getFunctionImports().size(); i++) { final EdmFunctionImport.Builder tmpEfi = edmEntityContainer.getFunctionImports().get(i); EdmEntitySet.Builder ees = Enumerable.create(edmEntityContainer.getEntitySets()) .firstOrNull( new Predicate1<EdmEntitySet.Builder>() { public boolean apply(EdmEntitySet.Builder input) { return input.getName().equals(tmpEfi.getEntitySetName()); } }); EdmType.Builder<?, ?> typeBuilder = null; if (tmpEfi.getReturnTypeName() != null) { typeBuilder = dataServices.resolveType(tmpEfi.getReturnTypeName()); if (typeBuilder == null) throw new RuntimeException("Edm-type not found: " + tmpEfi.getReturnTypeName()); if (tmpEfi.isCollection()) { typeBuilder = EdmCollectionType.newBuilder() .setKind(CollectionKind.Collection) .setCollectionType(typeBuilder); } } edmEntityContainer .getFunctionImports() .set( i, EdmFunctionImport.newBuilder() .setName(tmpEfi.getName()) .setEntitySet(ees) .setReturnType(typeBuilder) .setHttpMethod(tmpEfi.getHttpMethod()) .addParameters(tmpEfi.getParameters()) .setAnnotationElements(tmpEfi.getAnnotationElements()) .setAnnotations(tmpEfi.getAnnotations())); } } // resolve type hierarchy for (Entry<String, EdmEntityType.Builder> entry : allEetsByFQName.entrySet()) { String baseTypeName = entry.getValue().getFQBaseTypeName(); if (baseTypeName != null) { EdmEntityType.Builder baseType = allEetsByFQName.get(baseTypeName); if (baseType == null) { throw new IllegalArgumentException("Invalid baseType: " + baseTypeName); } entry.getValue().setBaseType(baseType); } } } }