/// <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);
}
