/// <inheritdoc /> public IEdmTypeReference GetEdmType() { IEdmModel model = GetModel(); if (InstanceType != null) { IEdmEntityType entityType = model.FindType(InstanceType) as IEdmEntityType; return(entityType.ToEdmTypeReference(true)); } Type elementType = GetElementType(); return(model.GetEdmTypeReference(UntypedInstance, elementType)); }
/// <summary> /// Creates an Edm property. /// </summary> /// <param name="declaringType">Type declaring this property.</param> /// <param name="propertyInfo">PropertyInfo instance for this property.</param> /// <returns>Returns a new instance of Edm property.</returns> private IEdmProperty CreateEdmProperty(IEdmStructuredType declaringType, PropertyInfo propertyInfo) { IEdmType propertyEdmType = this.GetOrCreateEdmType(propertyInfo.PropertyType); Debug.Assert( propertyEdmType.TypeKind == EdmTypeKind.Entity || propertyEdmType.TypeKind == EdmTypeKind.Complex || propertyEdmType.TypeKind == EdmTypeKind.Enum || propertyEdmType.TypeKind == EdmTypeKind.Primitive || propertyEdmType.TypeKind == EdmTypeKind.Collection, "Property kind should be Entity, Complex, Enum, Primitive or Collection."); IEdmProperty edmProperty; bool isPropertyNullable = ClientTypeUtil.CanAssignNull(propertyInfo.PropertyType); if (propertyEdmType.TypeKind == EdmTypeKind.Entity || (propertyEdmType.TypeKind == EdmTypeKind.Collection && ((IEdmCollectionType)propertyEdmType).ElementType.TypeKind() == EdmTypeKind.Entity)) { IEdmEntityType declaringEntityType = declaringType as IEdmEntityType; if (declaringEntityType == null) { throw c.Error.InvalidOperation(c.Strings.ClientTypeCache_NonEntityTypeCannotContainEntityProperties(propertyInfo.Name, propertyInfo.DeclaringType.ToString())); } // Create a navigation property representing one side of an association. // The partner representing the other side exists only inside this property and is not added to the target entity type, // so it should not cause any name collisions. edmProperty = EdmNavigationProperty.CreateNavigationPropertyWithPartner( ClientTypeUtil.GetServerDefinedName(propertyInfo), propertyEdmType.ToEdmTypeReference(isPropertyNullable), /*dependentProperties*/ null, /*principalProperties*/ null, /*containsTarget*/ false, EdmOnDeleteAction.None, "Partner", declaringEntityType.ToEdmTypeReference(true), /*partnerDependentProperties*/ null, /*partnerPrincipalProperties*/ null, /*partnerContainsTarget*/ false, EdmOnDeleteAction.None); } else { edmProperty = new EdmStructuralProperty(declaringType, ClientTypeUtil.GetServerDefinedName(propertyInfo), propertyEdmType.ToEdmTypeReference(isPropertyNullable)); } edmProperty.SetClientPropertyAnnotation(new ClientPropertyAnnotation(edmProperty, propertyInfo, this)); return(edmProperty); }
public IHttpActionResult Get() { IEdmModel model = Request.GetModel(); IEdmEntityType customerType = model.SchemaElements.OfType <IEdmEntityType>().First(e => e.Name == "Customer"); EdmEntityObject customer = new EdmEntityObject(customerType); customer.TrySetPropertyValue("Id", 1); customer.TrySetPropertyValue("Tony", 1); EdmEntityObjectCollection customers = new EdmEntityObjectCollection( new EdmCollectionTypeReference(new EdmCollectionType(customerType.ToEdmTypeReference(false)))); customers.Add(customer); return(Ok(customers)); }
/// <inheritdoc /> public IEdmTypeReference GetEdmType() { if (InstanceType != null) { IEdmStructuredType structuredType = Model.FindType(InstanceType) as IEdmStructuredType; IEdmEntityType entityType = structuredType as IEdmEntityType; if (entityType != null) { return(entityType.ToEdmTypeReference(true)); } return(structuredType.ToEdmTypeReference(true)); } Type elementType = GetElementType(); return(Model.GetTypeMappingCache().GetEdmType(elementType, Model)); }
/// <inheritdoc /> public IEdmTypeReference GetEdmType() { IEdmModel model = GetModel(); if (InstanceType != null) { IEdmStructuredType structuredType = model.FindType(InstanceType) as IEdmStructuredType; IEdmEntityType entityType = structuredType as IEdmEntityType; if (entityType != null) { return(entityType.ToEdmTypeReference(true)); } return(structuredType.ToEdmTypeReference(true)); } Type elementType = GetElementType(); return(model.GetEdmTypeReference(elementType)); }
/// <summary> /// Add the template to the action /// </summary> /// <param name="context">The context.</param> /// <param name="edmOperation">The Edm operation.</param> /// <param name="hasKeyParameter">Has key parameter or not.</param> /// <param name="entityType">The entity type.</param> /// <param name="navigationSource">The navigation source.</param> /// <param name="castType">The type cast.</param> protected static void AddSelector(ODataControllerActionContext context, IEdmOperation edmOperation, bool hasKeyParameter, IEdmEntityType entityType, IEdmNavigationSource navigationSource, IEdmEntityType castType) { Contract.Assert(context != null); Contract.Assert(entityType != null); Contract.Assert(navigationSource != null); Contract.Assert(edmOperation != null); // Now, let's add the selector model. IList <ODataSegmentTemplate> segments = new List <ODataSegmentTemplate>(); if (context.EntitySet != null) { segments.Add(new EntitySetSegmentTemplate(context.EntitySet)); if (hasKeyParameter) { segments.Add(new KeySegmentTemplate(entityType, navigationSource)); } } else { segments.Add(new SingletonSegmentTemplate(context.Singleton)); } if (castType != null) { if (context.Singleton != null || !hasKeyParameter) { segments.Add(new CastSegmentTemplate(castType, entityType, navigationSource)); } else { segments.Add(new CastSegmentTemplate(new EdmCollectionType(castType.ToEdmTypeReference(false)), new EdmCollectionType(entityType.ToEdmTypeReference(false)), navigationSource)); } } IEdmNavigationSource targetset = null; if (edmOperation.ReturnType != null) { targetset = edmOperation.GetTargetEntitySet(navigationSource, context.Model); } string httpMethod; if (edmOperation.IsAction()) { segments.Add(new ActionSegmentTemplate((IEdmAction)edmOperation, targetset)); httpMethod = "post"; } else { ISet <String> required = GetRequiredFunctionParamters(edmOperation, context.Action); segments.Add(new FunctionSegmentTemplate((IEdmFunction)edmOperation, targetset, required)); httpMethod = "get"; } ODataPathTemplate template = new ODataPathTemplate(segments); context.Action.AddSelector(httpMethod, context.Prefix, context.Model, template); }
private IEdmProperty CreateEdmProperty(IEdmStructuredType declaringType, PropertyInfo propertyInfo) { IEdmProperty property; IEdmType edmType = this.GetOrCreateEdmTypeInternal(propertyInfo.PropertyType).EdmType; bool isNullable = ClientTypeUtil.CanAssignNull(propertyInfo.PropertyType); if ((edmType.TypeKind == EdmTypeKind.Entity) || ((edmType.TypeKind == EdmTypeKind.Collection) && (((IEdmCollectionType)edmType).ElementType.TypeKind() == EdmTypeKind.Entity))) { IEdmEntityType type2 = declaringType as IEdmEntityType; if (type2 == null) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.ClientTypeCache_NonEntityTypeCannotContainEntityProperties(propertyInfo.Name, propertyInfo.DeclaringType.ToString())); } property = EdmNavigationProperty.CreateNavigationPropertyWithPartner(propertyInfo.Name, edmType.ToEdmTypeReference(isNullable), null, false, EdmOnDeleteAction.None, "Partner", type2.ToEdmTypeReference(true), null, false, EdmOnDeleteAction.None); } else { property = new EdmStructuralProperty(declaringType, propertyInfo.Name, edmType.ToEdmTypeReference(isNullable)); } property.SetClientPropertyAnnotation(new ClientPropertyAnnotation(property, propertyInfo, this.protocolVersion)); return(property); }
private static EdmEntityObjectCollection GetCustomers() { if (_untypedSimpleOpenCustormers != null) { return(_untypedSimpleOpenCustormers); } IEdmModel edmModel = OpenEntityTypeTests.GetUntypedEdmModel(); IEdmEntityType customerType = edmModel.SchemaElements.OfType <IEdmEntityType>().First(c => c.Name == "UntypedSimpleOpenCustomer"); EdmEntityObject customer = new EdmEntityObject(customerType); customer.TrySetPropertyValue("CustomerId", 1); //Add Numbers primitive collection property customer.TrySetPropertyValue("DeclaredNumbers", new[] { 1, 2 }); //Add Color, Colors enum(collection) property IEdmEnumType colorType = edmModel.SchemaElements.OfType <IEdmEnumType>().First(c => c.Name == "Color"); EdmEnumObject color = new EdmEnumObject(colorType, "Red"); EdmEnumObject color2 = new EdmEnumObject(colorType, "0"); EdmEnumObject color3 = new EdmEnumObject(colorType, "Red"); customer.TrySetPropertyValue("Color", color); List <IEdmEnumObject> colorList = new List <IEdmEnumObject>(); colorList.Add(color); colorList.Add(color2); colorList.Add(color3); IEdmCollectionTypeReference enumCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(colorType.ToEdmTypeReference(false))); EdmEnumObjectCollection colors = new EdmEnumObjectCollection(enumCollectionType, colorList); customer.TrySetPropertyValue("Colors", colors); customer.TrySetPropertyValue("DeclaredColors", colors); //Add Addresses complex(collection) property EdmComplexType addressType = edmModel.SchemaElements.OfType <IEdmComplexType>().First(c => c.Name == "Address") as EdmComplexType; EdmComplexObject address = new EdmComplexObject(addressType); address.TrySetPropertyValue("Street", "No1"); EdmComplexObject address2 = new EdmComplexObject(addressType); address2.TrySetPropertyValue("Street", "No2"); List <IEdmComplexObject> addressList = new List <IEdmComplexObject>(); addressList.Add(address); addressList.Add(address2); IEdmCollectionTypeReference complexCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(addressType.ToEdmTypeReference(false))); EdmComplexObjectCollection addresses = new EdmComplexObjectCollection(complexCollectionType, addressList); customer.TrySetPropertyValue("DeclaredAddresses", addresses); EdmEntityObjectCollection customers = new EdmEntityObjectCollection(new EdmCollectionTypeReference(new EdmCollectionType(customerType.ToEdmTypeReference(false)))); customers.Add(customer); _untypedSimpleOpenCustormers = customers; return(_untypedSimpleOpenCustormers); }
/// <summary> /// Creates an Edm property. /// </summary> /// <param name="declaringType">Type declaring this property.</param> /// <param name="propertyInfo">PropertyInfo instance for this property.</param> /// <returns>Returns a new instance of Edm property.</returns> private IEdmProperty CreateEdmProperty(IEdmStructuredType declaringType, PropertyInfo propertyInfo) { IEdmType propertyEdmType = this.GetOrCreateEdmTypeInternal(propertyInfo.PropertyType).EdmType; Debug.Assert( propertyEdmType.TypeKind == EdmTypeKind.Entity || propertyEdmType.TypeKind == EdmTypeKind.Complex || propertyEdmType.TypeKind == EdmTypeKind.Primitive || propertyEdmType.TypeKind == EdmTypeKind.Collection, "Property kind should be Entity, Complex, Primitive or Collection."); IEdmProperty edmProperty; bool isPropertyNullable = ClientTypeUtil.CanAssignNull(propertyInfo.PropertyType); if (propertyEdmType.TypeKind == EdmTypeKind.Entity || (propertyEdmType.TypeKind == EdmTypeKind.Collection && ((IEdmCollectionType)propertyEdmType).ElementType.TypeKind() == EdmTypeKind.Entity)) { IEdmEntityType declaringEntityType = declaringType as IEdmEntityType; if (declaringEntityType == null) { throw c.Error.InvalidOperation(c.Strings.ClientTypeCache_NonEntityTypeCannotContainEntityProperties(propertyInfo.Name, propertyInfo.DeclaringType.ToString())); } // Create a navigation property representing one side of an association. // The partner representing the other side exists only inside this property and is not added to the target entity type, // so it should not cause any name collisions. edmProperty = EdmNavigationProperty.CreateNavigationPropertyWithPartner( propertyInfo.Name, propertyEdmType.ToEdmTypeReference(isPropertyNullable), /*dependentProperties*/ null, /*containsTarget*/ false, EdmOnDeleteAction.None, "Partner", declaringEntityType.ToEdmTypeReference(true), /*partnerDependentProperties*/ null, /*partnerContainsTarget*/ false, EdmOnDeleteAction.None); } else { edmProperty = new EdmStructuralProperty(declaringType, propertyInfo.Name, propertyEdmType.ToEdmTypeReference(isPropertyNullable)); } FieldInfo backingField = null; if (this.ResolveBackingField != null) { // We only do this for "collections of entities" OR "complex properties" if (propertyEdmType.TypeKind == EdmTypeKind.Collection && !propertyEdmType.IsPrimitive() || propertyEdmType.TypeKind == EdmTypeKind.Complex) { backingField = this.ResolveBackingField(propertyInfo); } if (backingField != null && backingField.FieldType != propertyInfo.PropertyType) { backingField = null; // We disregard returned FieldInfo that has the wrong type. } } edmProperty.SetClientPropertyAnnotation(new ClientPropertyAnnotation(edmProperty, propertyInfo, backingField, this)); return(edmProperty); }