public void AddToEdmType(EdmStructuredType edmType, IEnumerable <Language> languages, string schemaName, Func <EdmComplexType, EdmComplexType> typeResolver)
{
Guard.NotNull(edmType, nameof(edmType));
Guard.NotNull(languages, nameof(languages));
Guard.NotNull(typeResolver, nameof(typeResolver));
if (!RawProperties.IsLocalizable)
{
languages = new[] { Language.Invariant };
}
var edmValueType = CreateEdmType();
if (edmValueType == null)
{
return;
}
var languageType = typeResolver(new EdmComplexType("Squidex", $"{schemaName}{Name.ToPascalCase()}Property"));
foreach (var language in languages)
{
languageType.AddStructuralProperty(language.Iso2Code, edmValueType);
}
edmType.AddStructuralProperty(Name, new EdmComplexTypeReference(languageType, false));
}
private void AddPropertiesToEdmType(EdmStructuredType entityType)
{
foreach (var property in this.properties.Values)
{
entityType.AddStructuralProperty(property.EdmPropertyName, property.DataType.GetEdmTypeReference(property.CanBeNull));
}
}
private IEdmProperty CreateStructuralTypeEnumPropertyBody(EdmStructuredType type, StructuralTypeConfiguration config, EnumPropertyConfiguration enumProperty)
{
Type enumPropertyType = TypeHelper.GetUnderlyingTypeOrSelf(enumProperty.RelatedClrType);
IEdmType edmType = GetEdmType(enumPropertyType);
if (edmType == null)
{
throw Error.InvalidOperation(SRResources.EnumTypeDoesNotExist, enumPropertyType.Name);
}
IEdmEnumType enumType = (IEdmEnumType)edmType;
IEdmTypeReference enumTypeReference = new EdmEnumTypeReference(enumType, enumProperty.OptionalProperty);
// Set concurrency token if is entity type, and concurrency token is true
EdmConcurrencyMode enumConcurrencyMode = EdmConcurrencyMode.None;
if (config.Kind == EdmTypeKind.Entity && enumProperty.ConcurrencyToken)
{
enumConcurrencyMode = EdmConcurrencyMode.Fixed;
}
return(type.AddStructuralProperty(
enumProperty.Name,
enumTypeReference,
defaultValue: null,
concurrencyMode: enumConcurrencyMode));
}
/// <summary>
/// Finds property on structural type by its name.
/// </summary>
/// <param name="structuralType">The structural type to search for the property.</param>
/// <param name="propertyName">The name of the property to look for.</param>
/// <returns>The member property found, or null if no such property exists.</returns>
/// <remarks>The method will fail if there's more than one matching property.</remarks>
public static IEdmProperty GetProperty(this EdmStructuredType structuralType, string propertyName)
{
ExceptionUtilities.CheckArgumentNotNull(structuralType, "structuralType");
ExceptionUtilities.CheckArgumentNotNull(propertyName, "propertyName");
return(structuralType.FindProperty(propertyName));
}
private void AddComponents(EdmModel model, EdmStructuredType entity, IEnumerable <ComponentInfo> components)
{
foreach (ComponentInfo componentInfo in components)
{
var edmSchemaElement = ((IEdmSchemaElement)entity);
EdmComplexType complexType = new EdmComplexType(edmSchemaElement.Namespace, componentInfo.Name);
foreach (var databaseColumn in componentInfo.Columns)
{
AddPropertyToEntity(complexType, databaseColumn);
}
//// add created type
model.AddElement(complexType);
if (componentInfo.ChildComponents != null && componentInfo.ChildComponents.Any())
{
//// we are passing here acutaly created complexType because it can be nested
AddComponents(model, complexType, componentInfo.ChildComponents);
}
//// adding referenece to actual entity
entity.AddStructuralProperty(componentInfo.Name.Remove(0, (edmSchemaElement.Name + _separator).Length), new EdmComplexTypeReference(complexType, false));
}
}
private void CreateStructuralTypeBody(EdmStructuredType type, StructuralTypeConfiguration config)
{
foreach (PropertyConfiguration property in config.Properties)
{
IEdmProperty edmProperty = null;
switch (property.Kind)
{
case PropertyKind.Primitive:
PrimitivePropertyConfiguration primitiveProperty = (PrimitivePropertyConfiguration)property;
EdmPrimitiveTypeKind typeKind = primitiveProperty.TargetEdmTypeKind ??
GetTypeKind(primitiveProperty.PropertyInfo.PropertyType);
IEdmTypeReference primitiveTypeReference = EdmCoreModel.Instance.GetPrimitive(
typeKind,
primitiveProperty.OptionalProperty);
edmProperty = type.AddStructuralProperty(
primitiveProperty.Name,
primitiveTypeReference,
defaultValue: null);
break;
case PropertyKind.Complex:
ComplexPropertyConfiguration complexProperty = property as ComplexPropertyConfiguration;
IEdmComplexType complexType = GetEdmType(complexProperty.RelatedClrType) as IEdmComplexType;
edmProperty = type.AddStructuralProperty(
complexProperty.Name,
new EdmComplexTypeReference(complexType, complexProperty.OptionalProperty));
break;
case PropertyKind.Collection:
edmProperty = CreateStructuralTypeCollectionPropertyBody(type, (CollectionPropertyConfiguration)property);
break;
case PropertyKind.Enum:
edmProperty = CreateStructuralTypeEnumPropertyBody(type, (EnumPropertyConfiguration)property);
break;
default:
break;
}
if (edmProperty != null)
{
if (property.PropertyInfo != null)
{
_properties[property.PropertyInfo] = edmProperty;
}
if (property.IsRestricted)
{
_propertiesRestrictions[edmProperty] = new QueryableRestrictions(property);
}
}
}
}
private static IEdmStructuralProperty AddPropertyToEntity(EdmStructuredType entity, DatabaseColumn column)
{
var typeKind = EdmPrimitiveTypeKind.String;
var typeMap = BuildEdmTypeMap();
if (typeMap.ContainsKey(column.DataType))
{
typeKind = typeMap[column.DataType];
}
//// because of posibility of changing column table nullability from which view is generated we always set nullable to TRUE. Then it is prepared for null value.
return(entity.AddStructuralProperty(column.Name, typeKind, true));
}
private void CreateStructuralTypeBody(EdmStructuredType type, StructuralTypeConfiguration config)
{
foreach (PropertyConfiguration property in config.Properties)
{
IEdmProperty edmProperty = null;
switch (property.Kind)
{
case PropertyKind.Primitive:
PrimitivePropertyConfiguration primitiveProperty = property as PrimitivePropertyConfiguration;
CreatePrimitiveProperty(primitiveProperty, type, config, out edmProperty);
break;
case PropertyKind.Complex:
ComplexPropertyConfiguration complexProperty = property as ComplexPropertyConfiguration;
IEdmComplexType complexType = _types[complexProperty.RelatedClrType] as IEdmComplexType;
edmProperty = type.AddStructuralProperty(
complexProperty.PropertyInfo.Name,
new EdmComplexTypeReference(complexType, complexProperty.OptionalProperty));
break;
case PropertyKind.Collection:
CollectionPropertyConfiguration collectionProperty = property as CollectionPropertyConfiguration;
IEdmTypeReference elementTypeReference = null;
if (_types.ContainsKey(collectionProperty.ElementType))
{
IEdmComplexType elementType = _types[collectionProperty.ElementType] as IEdmComplexType;
elementTypeReference = new EdmComplexTypeReference(elementType, false);
}
else
{
elementTypeReference = EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(collectionProperty.ElementType);
}
edmProperty = type.AddStructuralProperty(
collectionProperty.PropertyInfo.Name,
new EdmCollectionTypeReference(
new EdmCollectionType(elementTypeReference),
collectionProperty.OptionalProperty));
break;
default:
break;
}
if (edmProperty != null && property.PropertyInfo != null)
{
_properties[property.PropertyInfo] = edmProperty;
}
}
}
private void CreateNavigationProperty(StructuralTypeConfiguration config)
{
Contract.Assert(config != null);
EdmStructuredType type = (EdmStructuredType)(this.GetEdmType(config.ClrType));
foreach (NavigationPropertyConfiguration navProp in config.NavigationProperties)
{
EdmNavigationPropertyInfo info = new EdmNavigationPropertyInfo
{
Name = navProp.Name,
TargetMultiplicity = navProp.Multiplicity,
Target = this.GetEdmType(navProp.RelatedClrType) as IEdmEntityType,
ContainsTarget = navProp.ContainsTarget,
OnDelete = navProp.OnDeleteAction
};
// Principal properties
if (navProp.PrincipalProperties.Any())
{
info.PrincipalProperties = this.GetDeclaringPropertyInfo(navProp.PrincipalProperties);
}
// Dependent properties
if (navProp.DependentProperties.Any())
{
info.DependentProperties = this.GetDeclaringPropertyInfo(navProp.DependentProperties);
}
IEdmProperty edmProperty = type.AddUnidirectionalNavigation(info);
if (navProp.PropertyInfo != null && edmProperty != null)
{
this._properties[navProp.PropertyInfo] = edmProperty;
}
if (edmProperty != null)
{
if (navProp.IsRestricted)
{
this._propertiesRestrictions[edmProperty] = new QueryableRestrictions(navProp);
}
if (navProp.QueryConfiguration.ModelBoundQuerySettings != null)
{
this._propertiesQuerySettings.Add(edmProperty, navProp.QueryConfiguration.ModelBoundQuerySettings);
}
}
}
}
private IEdmProperty CreateStructuralTypeCollectionPropertyBody(EdmStructuredType type, CollectionPropertyConfiguration collectionProperty)
{
IEdmTypeReference elementTypeReference = null;
Type clrType = TypeHelper.GetUnderlyingTypeOrSelf(collectionProperty.ElementType);
if (clrType.GetTypeInfo().IsEnum)
{
IEdmType edmType = GetEdmType(clrType);
if (edmType == null)
{
throw Error.InvalidOperation(SRResources.EnumTypeDoesNotExist, clrType.Name);
}
IEdmEnumType enumElementType = (IEdmEnumType)edmType;
bool isNullable = collectionProperty.ElementType != clrType;
elementTypeReference = new EdmEnumTypeReference(enumElementType, isNullable);
}
else
{
IEdmType edmType = GetEdmType(collectionProperty.ElementType);
if (edmType != null)
{
IEdmComplexType elementType = edmType as IEdmComplexType;
// Work around for primitive types (ex: Int32 would be typed to System.Int32 instead of EdmInt)
if (elementType != null)
{
elementTypeReference = new EdmComplexTypeReference(elementType, collectionProperty.OptionalProperty);
}
else
{
elementTypeReference =
EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(collectionProperty.ElementType);
}
}
else
{
elementTypeReference =
EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(collectionProperty.ElementType);
}
Contract.Assert(elementTypeReference != null);
}
return(type.AddStructuralProperty(
collectionProperty.Name,
new EdmCollectionTypeReference(new EdmCollectionType(elementTypeReference))));
}
private void AddProperty(EdmStructuredType edmType, RdmProperty rdmProp)
{
var edmTypeRef = env.ResolveTypeReference(rdmProp.Type);
EdmProperty edmProp;
// collection navigation property
if (edmTypeRef is IEdmCollectionTypeReference collRef &&
collRef.Definition is IEdmCollectionType collType &&
collType.ElementType is IEdmEntityTypeReference elTypeRef &&
elTypeRef.Definition is IEdmEntityType elType)
{
var info = new EdmNavigationPropertyInfo {
Name = rdmProp.Name, Target = elType, TargetMultiplicity = EdmMultiplicity.Many
};
edmProp = edmType.AddUnidirectionalNavigation(info);
}
private IEdmProperty CreateStructuralTypeEnumPropertyBody(EdmStructuredType type, EnumPropertyConfiguration enumProperty)
{
Type enumPropertyType = TypeHelper.GetUnderlyingTypeOrSelf(enumProperty.RelatedClrType);
IEdmType edmType = GetEdmType(enumPropertyType);
if (edmType == null)
{
throw Error.InvalidOperation(SRResources.EnumTypeDoesNotExist, enumPropertyType.Name);
}
IEdmEnumType enumType = (IEdmEnumType)edmType;
IEdmTypeReference enumTypeReference = new EdmEnumTypeReference(enumType, enumProperty.NullableProperty);
return(type.AddStructuralProperty(
enumProperty.Name,
enumTypeReference,
defaultValue: enumProperty.DefaultValueString));
}
private void CreateStructuralTypeBody(EdmStructuredType type, IStructuralTypeConfiguration config)
{
foreach (PrimitivePropertyConfiguration prop in config.Properties.OfType <PrimitivePropertyConfiguration>())
{
type.AddStructuralProperty(
prop.PropertyInfo.Name,
GetTypeKind(prop.PropertyInfo.PropertyType),
prop.OptionalProperty);
}
foreach (ComplexPropertyConfiguration prop in config.Properties.OfType <ComplexPropertyConfiguration>())
{
IEdmComplexType complexType = _types[prop.RelatedClrType.FullName] as IEdmComplexType;
type.AddStructuralProperty(
prop.PropertyInfo.Name,
new EdmComplexTypeReference(complexType, prop.OptionalProperty));
}
}
private IEdmProperty CreateStructuralTypeCollectionPropertyBody(EdmStructuredType type, CollectionPropertyConfiguration collectionProperty)
{
IEdmTypeReference elementTypeReference;
Type clrType = TypeHelper.GetUnderlyingTypeOrSelf(collectionProperty.ElementType);
if (clrType == typeof(object))
{
elementTypeReference = EdmCoreModel.Instance.GetUntyped();
}
else if (TypeHelper.IsEnum(clrType))
{
IEdmType edmType = GetEdmType(clrType);
if (edmType == null)
{
throw Error.InvalidOperation(SRResources.EnumTypeDoesNotExist, clrType.Name);
}
IEdmEnumType enumElementType = (IEdmEnumType)edmType;
bool isNullable = collectionProperty.ElementType != clrType;
elementTypeReference = new EdmEnumTypeReference(enumElementType, isNullable);
}
else
{
IEdmType edmType = GetEdmType(collectionProperty.ElementType);
if (edmType != null)
{
IEdmComplexType elementType = edmType as IEdmComplexType;
Contract.Assert(elementType != null);
elementTypeReference = new EdmComplexTypeReference(elementType, collectionProperty.NullableProperty);
}
else
{
elementTypeReference =
EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(collectionProperty.ElementType);
Contract.Assert(elementTypeReference != null);
}
}
return(type.AddStructuralProperty(
collectionProperty.Name,
new EdmCollectionTypeReference(new EdmCollectionType(elementTypeReference))));
}
public void AddToEdmType(EdmStructuredType edmType, PartitionResolver partitionResolver, string schemaName, Func <EdmComplexType, EdmComplexType> typeResolver)
{
Guard.NotNull(edmType, nameof(edmType));
Guard.NotNull(typeResolver, nameof(typeResolver));
Guard.NotNull(partitionResolver, nameof(partitionResolver));
var edmValueType = CreateEdmType();
if (edmValueType == null)
{
return;
}
var partitionType = typeResolver(new EdmComplexType("Squidex", $"{schemaName}{Name.ToPascalCase()}Property"));
var partition = partitionResolver(partitioning);
foreach (var partitionItem in partition)
{
partitionType.AddStructuralProperty(partitionItem.Key, edmValueType);
}
edmType.AddStructuralProperty(Name.EscapeEdmField(), new EdmComplexTypeReference(partitionType, false));
}
/// <summary>
/// Implement the creation of an EDM Entity Type or EDM Complex Type.
/// </summary>
/// <param name="clrType">The CLR type of the new schema element to create.</param>
/// <param name="context">The query context.</param>
/// <param name="entryEdmType">The new Schema element.</param>
private static void CreateSchemaType(Type clrType, ODataQueryContext context, EdmStructuredType entryEdmType)
{
foreach (var pi in clrType.GetProperties())
{
if (pi.Name == "ComparerInstance")
{
continue;
}
if (pi.PropertyType.IsPrimitive || pi.PropertyType.FullName == "System.String")
{
entryEdmType.AddStructuralProperty(pi.Name, GetPrimitiveTypeKind(pi.PropertyType), true);
}
else if (pi.PropertyType.IsEnum)
{
var enumType = GetEnumTypeKind(pi.PropertyType, context);
if (enumType != null)
{
entryEdmType.AddStructuralProperty(pi.Name, enumType);
}
else
{
entryEdmType.AddStructuralProperty(pi.Name, EdmPrimitiveTypeKind.Int32);
}
}
else
{
var propEdmType = context.Model.FindDeclaredType(pi.PropertyType.FullName);
if (propEdmType != null)
{
entryEdmType.AddStructuralProperty(pi.Name, propEdmType.ToEdmTypeReference(true));
}
else
{
//var t = Type.GetType(pi.PropertyType.FullName);
var t = pi.PropertyType;
var edmType = context.Model.GetEdmTypeReference(t);
if (edmType != null)
{
entryEdmType.AddStructuralProperty(pi.Name, edmType);
}
else
{
throw new InvalidOperationException(string.Format("Could not find EDM type of {0}", pi.PropertyType.FullName));
}
}
}
}
}
private IEdmProperty CreateProperty(EdmStructuredType declaringType, ResourceProperty resourceProperty)
{
IEdmProperty property;
List <KeyValuePair <string, object> > annotations = (resourceProperty.CustomAnnotations == null) ? null : resourceProperty.CustomAnnotations.ToList <KeyValuePair <string, object> >();
ODataNullValueBehaviorKind nullValueReadBehaviorKind = ODataNullValueBehaviorKind.Default;
if (resourceProperty.IsOfKind(ResourcePropertyKind.Primitive) || resourceProperty.IsOfKind(ResourcePropertyKind.Stream))
{
IEdmPrimitiveTypeReference typeReference = MetadataProviderUtils.CreatePrimitiveTypeReference(resourceProperty.ResourceType, annotations);
if (resourceProperty.IsOfKind(ResourcePropertyKind.Key))
{
if (typeReference.IsNullable)
{
typeReference = (IEdmPrimitiveTypeReference)typeReference.Clone(false);
}
nullValueReadBehaviorKind = ODataNullValueBehaviorKind.IgnoreValue;
}
else if (MetadataProviderUtils.ShouldDisablePrimitivePropertyNullValidation(resourceProperty, typeReference))
{
nullValueReadBehaviorKind = ODataNullValueBehaviorKind.DisableValidation;
}
string andRemoveDefaultValue = MetadataProviderUtils.GetAndRemoveDefaultValue(annotations);
EdmConcurrencyMode concurrencyMode = resourceProperty.IsOfKind(ResourcePropertyKind.ETag) ? EdmConcurrencyMode.Fixed : EdmConcurrencyMode.None;
property = declaringType.AddStructuralProperty(resourceProperty.Name, typeReference, andRemoveDefaultValue, concurrencyMode);
string mimeType = resourceProperty.MimeType;
if (!string.IsNullOrEmpty(mimeType))
{
this.SetMimeType(property, mimeType);
}
}
else if (resourceProperty.IsOfKind(ResourcePropertyKind.ComplexType))
{
IEdmTypeReference reference2 = this.EnsureTypeReference(resourceProperty.ResourceType, annotations);
string defaultValue = MetadataProviderUtils.GetAndRemoveDefaultValue(annotations);
property = declaringType.AddStructuralProperty(resourceProperty.Name, reference2, defaultValue, EdmConcurrencyMode.None);
if (this.metadataProvider.IsV1Provider && !reference2.IsNullable)
{
nullValueReadBehaviorKind = ODataNullValueBehaviorKind.DisableValidation;
}
}
else if (resourceProperty.IsOfKind(ResourcePropertyKind.Collection))
{
string str4 = MetadataProviderUtils.GetAndRemoveDefaultValue(annotations);
IEdmTypeReference reference3 = this.EnsureTypeReference(resourceProperty.ResourceType, annotations);
property = declaringType.AddStructuralProperty(resourceProperty.Name, reference3, str4, EdmConcurrencyMode.None);
}
else
{
if (!resourceProperty.IsOfKind(ResourcePropertyKind.ResourceSetReference) && !resourceProperty.IsOfKind(ResourcePropertyKind.ResourceReference))
{
throw new InvalidOperationException(System.Data.Services.Strings.MetadataProviderEdmModel_UnsupportedResourcePropertyKind(resourceProperty.Kind.ToString()));
}
EdmEntityType type = (EdmEntityType)declaringType;
IEdmTypeReference reference4 = resourceProperty.IsOfKind(ResourcePropertyKind.ResourceSetReference) ? this.EnsureEntityPrimitiveOrComplexCollectionTypeReference(resourceProperty.ResourceType, annotations) : this.EnsureTypeReference(resourceProperty.ResourceType, annotations);
property = new MetadataProviderEdmNavigationProperty(type, resourceProperty.Name, reference4);
type.AddProperty(property);
}
this.SetNullValueReaderBehavior(property, nullValueReadBehaviorKind);
MetadataProviderUtils.ConvertCustomAnnotations(this, annotations, property);
return(property);
}
private void CreateStructuralTypeBody(EdmStructuredType type, StructuralTypeConfiguration config)
{
foreach (PropertyConfiguration property in config.Properties)
{
IEdmProperty edmProperty = null;
switch (property.Kind)
{
case PropertyKind.Primitive:
PrimitivePropertyConfiguration primitiveProperty = (PrimitivePropertyConfiguration)property;
EdmPrimitiveTypeKind typeKind = primitiveProperty.TargetEdmTypeKind ??
GetTypeKind(primitiveProperty.PropertyInfo.PropertyType);
IEdmTypeReference primitiveTypeReference = EdmCoreModel.Instance.GetPrimitive(
typeKind,
primitiveProperty.NullableProperty);
if (typeKind == EdmPrimitiveTypeKind.Decimal)
{
DecimalPropertyConfiguration decimalProperty =
primitiveProperty as DecimalPropertyConfiguration;
if (decimalProperty.Precision.HasValue || decimalProperty.Scale.HasValue)
{
primitiveTypeReference = new EdmDecimalTypeReference(
(IEdmPrimitiveType)primitiveTypeReference.Definition,
primitiveTypeReference.IsNullable,
decimalProperty.Precision,
decimalProperty.Scale.HasValue ? decimalProperty.Scale : 0);
}
}
else if (EdmLibHelpers.HasPrecision(typeKind))
{
PrecisionPropertyConfiguration precisionProperty =
primitiveProperty as PrecisionPropertyConfiguration;
primitiveTypeReference = AddPrecisionConfigInPrimitiveTypeReference(
precisionProperty,
primitiveTypeReference);
}
else if (EdmLibHelpers.HasLength(typeKind))
{
LengthPropertyConfiguration lengthProperty =
primitiveProperty as LengthPropertyConfiguration;
primitiveTypeReference = AddLengthConfigInPrimitiveTypeReference(
lengthProperty,
primitiveTypeReference);
}
edmProperty = type.AddStructuralProperty(
primitiveProperty.Name,
primitiveTypeReference,
defaultValue: primitiveProperty.DefaultValueString);
break;
case PropertyKind.Complex:
ComplexPropertyConfiguration complexProperty = property as ComplexPropertyConfiguration;
IEdmComplexType complexType = GetEdmType(complexProperty.RelatedClrType) as IEdmComplexType;
edmProperty = type.AddStructuralProperty(
complexProperty.Name,
new EdmComplexTypeReference(complexType, complexProperty.NullableProperty));
break;
case PropertyKind.Collection:
edmProperty = CreateStructuralTypeCollectionPropertyBody(type, (CollectionPropertyConfiguration)property);
break;
case PropertyKind.Enum:
edmProperty = CreateStructuralTypeEnumPropertyBody(type, (EnumPropertyConfiguration)property);
break;
default:
break;
}
if (edmProperty != null)
{
if (property.PropertyInfo != null)
{
_properties[property.PropertyInfo] = edmProperty;
}
if (property.IsRestricted)
{
_propertiesRestrictions[edmProperty] = new QueryableRestrictions(property);
}
//if (property.QueryConfiguration.ModelBoundQuerySettings != null)
//{
// _propertiesQuerySettings.Add(edmProperty, property.QueryConfiguration.ModelBoundQuerySettings);
//}
}
}
}
private void CreateNavigationProperty(StructuralTypeConfiguration config)
{
Contract.Assert(config != null);
EdmStructuredType type = (EdmStructuredType)(GetEdmType(config.ClrType));
foreach (NavigationPropertyConfiguration navProp in config.NavigationProperties)
{
Func <NavigationPropertyConfiguration, EdmNavigationPropertyInfo> getInfo = nav =>
{
EdmNavigationPropertyInfo info = new EdmNavigationPropertyInfo
{
Name = nav.Name,
TargetMultiplicity = nav.Multiplicity,
Target = GetEdmType(nav.RelatedClrType) as IEdmEntityType,
ContainsTarget = nav.ContainsTarget,
OnDelete = nav.OnDeleteAction
};
// Principal properties
if (nav.PrincipalProperties.Any())
{
info.PrincipalProperties = GetDeclaringPropertyInfo(nav.PrincipalProperties);
}
// Dependent properties
if (nav.DependentProperties.Any())
{
info.DependentProperties = GetDeclaringPropertyInfo(nav.DependentProperties);
}
return(info);
};
var navInfo = getInfo(navProp);
var props = new Dictionary <IEdmProperty, NavigationPropertyConfiguration>();
EdmEntityType entityType = type as EdmEntityType;
if (entityType != null && navProp.Partner != null)
{
var edmProperty = entityType.AddBidirectionalNavigation(navInfo, getInfo(navProp.Partner));
var partnerEdmProperty = (navInfo.Target as EdmEntityType).Properties().Single(p => p.Name == navProp.Partner.Name);
props.Add(edmProperty, navProp);
props.Add(partnerEdmProperty, navProp.Partner);
}
else
{
// Do not add this if we have have a partner relationship configured, as this
// property will be added automatically through the AddBidirectionalNavigation
var targetConfig = config.ModelBuilder.GetTypeConfigurationOrNull(navProp.RelatedClrType) as StructuralTypeConfiguration;
if (!targetConfig.NavigationProperties.Any(p => p.Partner != null && p.Partner.Name == navInfo.Name))
{
var edmProperty = type.AddUnidirectionalNavigation(navInfo);
props.Add(edmProperty, navProp);
}
}
foreach (var item in props)
{
var edmProperty = item.Key;
var prop = item.Value;
if (prop.PropertyInfo != null)
{
_properties[prop.PropertyInfo] = edmProperty;
}
if (prop.IsRestricted)
{
_propertiesRestrictions[edmProperty] = new QueryableRestrictions(prop);
}
/*
* if (prop.QueryConfiguration.ModelBoundQuerySettings != null)
* {
* _propertiesQuerySettings.Add(edmProperty, prop.QueryConfiguration.ModelBoundQuerySettings);
* }*/
}
}
}
private void CreateStructuralTypeBody(EdmStructuredType type, StructuralTypeConfiguration config)
{
foreach (PropertyConfiguration property in config.Properties)
{
IEdmProperty edmProperty = null;
switch (property.Kind)
{
case PropertyKind.Primitive:
PrimitivePropertyConfiguration primitiveProperty = property as PrimitivePropertyConfiguration;
if (primitiveProperty.IsIgnored)
{
continue;
}
EdmPrimitiveTypeKind typeKind = GetTypeKind(primitiveProperty.PropertyInfo.PropertyType);
IEdmTypeReference primitiveTypeReference = EdmCoreModel.Instance.GetPrimitive(
typeKind,
primitiveProperty.OptionalProperty);
// Set concurrency token if is entity type, and concurrency token is true
EdmConcurrencyMode concurrencyMode = EdmConcurrencyMode.None;
if (config.Kind == EdmTypeKind.Entity && primitiveProperty.ConcurrencyToken)
{
concurrencyMode = EdmConcurrencyMode.Fixed;
}
edmProperty = type.AddStructuralProperty(
primitiveProperty.Name,
primitiveTypeReference,
defaultValue: null,
concurrencyMode: concurrencyMode);
break;
case PropertyKind.Complex:
ComplexPropertyConfiguration complexProperty = property as ComplexPropertyConfiguration;
IEdmComplexType complexType = GetEdmType(complexProperty.RelatedClrType) as IEdmComplexType;
edmProperty = type.AddStructuralProperty(
complexProperty.Name,
new EdmComplexTypeReference(complexType, complexProperty.OptionalProperty));
break;
case PropertyKind.Collection:
edmProperty = CreateStructuralTypeCollectionPropertyBody(type, (CollectionPropertyConfiguration)property);
break;
case PropertyKind.Enum:
edmProperty = CreateStructuralTypeEnumPropertyBody(type, config, (EnumPropertyConfiguration)property);
break;
default:
break;
}
if (edmProperty != null)
{
if (property.PropertyInfo != null)
{
_properties[property.PropertyInfo] = edmProperty;
}
if (property.IsRestricted)
{
_propertiesRestrictions[edmProperty] = new QueryableRestrictions(property);
}
}
}
}
private void CreatePrimitiveProperty(PrimitivePropertyConfiguration primitiveProperty, EdmStructuredType type, StructuralTypeConfiguration config, out IEdmProperty edmProperty)
{
EdmPrimitiveTypeKind typeKind = GetTypeKind(primitiveProperty.PropertyInfo.PropertyType);
IEdmTypeReference primitiveTypeReference = EdmCoreModel.Instance.GetPrimitive(
typeKind,
primitiveProperty.OptionalProperty);
// Set concurrency token if is entity type, and concurrency token is true
EdmConcurrencyMode concurrencyMode = EdmConcurrencyMode.None;
if (config.Kind == EdmTypeKind.Entity && primitiveProperty.ConcurrencyToken)
{
concurrencyMode = EdmConcurrencyMode.Fixed;
}
var primitiveProp = new EdmStructuralProperty(
type,
primitiveProperty.PropertyInfo.Name,
primitiveTypeReference,
defaultValueString: null,
concurrencyMode: concurrencyMode);
type.AddProperty(primitiveProp);
edmProperty = primitiveProp;
// Set Annotation StoreGeneratedPattern
if (config.Kind == EdmTypeKind.Entity &&
primitiveProperty.StoreGeneratedPattern != DatabaseGeneratedOption.None)
{
_directValueAnnotations.Add(
new StoreGeneratedPatternAnnotation(primitiveProp, primitiveProperty.StoreGeneratedPattern));
}
}
private void CreateStructuralTypeBody(EdmStructuredType type, StructuralTypeConfiguration config)
{
foreach (PropertyConfiguration property in config.Properties)
{
switch (property.Kind)
{
case PropertyKind.Primitive:
PrimitivePropertyConfiguration primitiveProperty = property as PrimitivePropertyConfiguration;
EdmPrimitiveTypeKind typeKind = GetTypeKind(primitiveProperty.PropertyInfo.PropertyType);
IEdmTypeReference primitiveTypeReference = EdmCoreModel.Instance.GetPrimitive(
typeKind,
primitiveProperty.OptionalProperty);
var primitiveProp = new EdmStructuralProperty(
type,
primitiveProperty.PropertyInfo.Name,
primitiveTypeReference);
type.AddProperty(primitiveProp);
// Set Annotation StoreGeneratedPattern
if (config.Kind == EdmTypeKind.Entity &&
primitiveProperty.StoreGeneratedPattern != DatabaseGeneratedOption.None)
{
_directValueAnnotations.Add(
new StoreGeneratedPatternAnnotation(primitiveProp, primitiveProperty.StoreGeneratedPattern));
}
break;
case PropertyKind.Complex:
ComplexPropertyConfiguration complexProperty = property as ComplexPropertyConfiguration;
IEdmComplexType complexType = _types[complexProperty.RelatedClrType] as IEdmComplexType;
type.AddStructuralProperty(
complexProperty.PropertyInfo.Name,
new EdmComplexTypeReference(complexType, complexProperty.OptionalProperty));
break;
case PropertyKind.Collection:
CollectionPropertyConfiguration collectionProperty = property as CollectionPropertyConfiguration;
IEdmTypeReference elementTypeReference = null;
if (_types.ContainsKey(collectionProperty.ElementType))
{
IEdmComplexType elementType = _types[collectionProperty.ElementType] as IEdmComplexType;
elementTypeReference = new EdmComplexTypeReference(elementType, false);
}
else
{
elementTypeReference = EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(collectionProperty.ElementType);
}
type.AddStructuralProperty(
collectionProperty.PropertyInfo.Name,
new EdmCollectionTypeReference(
new EdmCollectionType(elementTypeReference),
collectionProperty.OptionalProperty));
break;
default:
break;
}
}
}