private void CreateEntityTypeBody(EdmEntityType type, EntityTypeConfiguration config)
{
Contract.Assert(type != null);
Contract.Assert(config != null);
CreateStructuralTypeBody(type, config);
IEnumerable <IEdmStructuralProperty> keys = config.Keys.Select(p => type.DeclaredProperties.OfType <IEdmStructuralProperty>().First(dp => dp.Name == p.Name));
type.AddKeys(keys);
foreach (NavigationPropertyConfiguration navProp in config.NavigationProperties)
{
EdmNavigationPropertyInfo info = new EdmNavigationPropertyInfo();
info.Name = navProp.Name;
info.TargetMultiplicity = navProp.Multiplicity;
info.Target = GetEdmType(navProp.RelatedClrType) as IEdmEntityType;
IEdmProperty edmProperty = type.AddUnidirectionalNavigation(info);
if (navProp.PropertyInfo != null && edmProperty != null)
{
_properties[navProp.PropertyInfo] = edmProperty;
}
if (edmProperty != null && navProp.IsRestricted)
{
_propertiesRestrictions[edmProperty] = new QueryableRestrictions(navProp);
}
}
}
private static void AddPropertyRestrictionsAnnotations(this EdmModel model, Dictionary <IEdmProperty, QueryableRestrictions> edmPropertiesRestrictions)
{
foreach (KeyValuePair <IEdmProperty, QueryableRestrictions> edmPropertyRestriction in edmPropertiesRestrictions)
{
IEdmProperty edmProperty = edmPropertyRestriction.Key;
QueryableRestrictions restrictions = edmPropertyRestriction.Value;
model.SetAnnotationValue(edmProperty, new QueryableRestrictionsAnnotation(restrictions));
}
}
/// <summary>
/// Initializes a new instance of <see cref="QueryableRestrictionsAnnotation"/> class.
/// </summary>
/// <param name="restrictions">The queryable restrictions for the EDM property.</param>
public QueryableRestrictionsAnnotation(QueryableRestrictions restrictions)
{
if (restrictions == null)
{
throw Error.ArgumentNull("restrictions");
}
Restrictions = restrictions;
}
/// <summary>
/// Initializes a new instance of <see cref="QueryableRestrictionsAnnotation"/> class.
/// </summary>
/// <param name="restrictions">The queryable restrictions for the EDM property.</param>
public QueryableRestrictionsAnnotation(QueryableRestrictions restrictions)
{
if (restrictions == null)
{
throw Error.ArgumentNull("restrictions");
}
Restrictions = restrictions;
}
private void CreateNavigationProperty(StructuralTypeConfiguration config, List <EdmNavigationPropertyInfo> infos)
{
Contract.Assert(config != null);
EdmEntityType type = (EdmEntityType)(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);
}
infos.Add(info);
return(info);
};
var navInfo = getInfo(navProp);
IEdmProperty edmProperty;
if (navProp.Partner != null)
{
edmProperty = type.AddBidirectionalNavigation(navInfo,
getInfo(navProp.Partner)
//infos.Single(i => i.Name == navProp.Partner.Name && i.Target == GetEdmType(navProp.Partner.RelatedClrType))
);
}
else
{
edmProperty = type.AddUnidirectionalNavigation(navInfo);
}
if (navProp.PropertyInfo != null && edmProperty != null)
{
_properties[navProp.PropertyInfo] = edmProperty;
}
if (edmProperty != null && navProp.IsRestricted)
{
_propertiesRestrictions[edmProperty] = new QueryableRestrictions(navProp);
}
}
}
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 void CreateNavigationProperty(StructuralTypeConfiguration config)
{
Contract.Assert(config != null);
EdmStructuredType type = (EdmStructuredType)(GetEdmType(config.ClrType));
foreach (NavigationPropertyConfiguration navProp in config.NavigationProperties)
{
EdmNavigationPropertyInfo info = new EdmNavigationPropertyInfo
{
Name = navProp.Name,
TargetMultiplicity = navProp.Multiplicity,
Target = GetEdmType(navProp.RelatedClrType) as IEdmEntityType,
ContainsTarget = navProp.ContainsTarget,
OnDelete = navProp.OnDeleteAction
};
// Principal properties
if (navProp.PrincipalProperties.Any())
{
info.PrincipalProperties = GetDeclaringPropertyInfo(navProp.PrincipalProperties);
}
// Dependent properties
if (navProp.DependentProperties.Any())
{
info.DependentProperties = GetDeclaringPropertyInfo(navProp.DependentProperties);
}
IEdmProperty edmProperty = type.AddUnidirectionalNavigation(info);
if (navProp.PropertyInfo != null && edmProperty != null)
{
_properties[navProp.PropertyInfo] = edmProperty;
}
if (edmProperty != null)
{
if (navProp.IsRestricted)
{
_propertiesRestrictions[edmProperty] = new QueryableRestrictions(navProp);
}
if (navProp.QueryConfiguration.ModelBoundQuerySettings != null)
{
_propertiesQuerySettings.Add(edmProperty, navProp.QueryConfiguration.ModelBoundQuerySettings);
}
}
}
}
private void DoIt(NavigationPropertyConfiguration navProp, EdmEntityType type)
{
foreach (var dependentProperty in navProp.DependentProperties)
{
if (dependentProperty.GetConfiguration(_configurations).IsIgnored)
{
navProp.IsIgnored = true;
return;
}
}
if (navProp.IsIgnored)
{
return;
}
EdmNavigationPropertyInfo info = new EdmNavigationPropertyInfo
{
Name = navProp.Name,
TargetMultiplicity = navProp.Multiplicity,
Target = GetEdmType(navProp.RelatedClrType) as IEdmEntityType,
ContainsTarget = navProp.ContainsTarget,
OnDelete = navProp.OnDeleteAction
};
// Principal properties
if (navProp.PrincipalProperties.Any())
{
info.PrincipalProperties = GetDeclaringPropertyInfo(navProp.PrincipalProperties);
}
// Dependent properties
if (navProp.DependentProperties.Any())
{
info.DependentProperties = GetDeclaringPropertyInfo(navProp.DependentProperties);
}
IEdmProperty edmProperty = type.AddUnidirectionalNavigation(info);
if (navProp.PropertyInfo != null && edmProperty != null)
{
_properties[navProp.PropertyInfo] = edmProperty;
}
if (edmProperty != null && navProp.IsRestricted)
{
_propertiesRestrictions[edmProperty] = new QueryableRestrictions(navProp);
}
}
private void CreateNavigationProperty(EntityTypeConfiguration config)
{
Contract.Assert(config != null);
EdmEntityType type = (EdmEntityType)(GetEdmType(config.ClrType));
foreach (NavigationPropertyConfiguration navProp in config.NavigationProperties)
{
EdmNavigationPropertyInfo info = new EdmNavigationPropertyInfo
{
Name = navProp.Name,
TargetMultiplicity = navProp.Multiplicity,
Target = GetEdmType(navProp.RelatedClrType) as IEdmEntityType,
ContainsTarget = navProp.ContainsTarget,
OnDelete = navProp.OnDeleteAction
};
// Principal properties
if (navProp.PrincipalProperties.Any())
{
info.PrincipalProperties = GetDeclaringPropertyInfo(navProp.PrincipalProperties);
}
// Dependent properties
if (navProp.DependentProperties.Any())
{
info.DependentProperties = GetDeclaringPropertyInfo(navProp.DependentProperties);
}
IEdmProperty edmProperty = type.AddUnidirectionalNavigation(info);
if (navProp.PropertyInfo != null && edmProperty != null)
{
_properties[navProp.PropertyInfo] = edmProperty;
}
if (edmProperty != null && navProp.IsRestricted)
{
_propertiesRestrictions[edmProperty] = new QueryableRestrictions(navProp);
}
}
}
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);
// 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 CreateEntityTypeBody(EdmEntityType type, EntityTypeConfiguration config)
{
Contract.Assert(type != null);
Contract.Assert(config != null);
CreateStructuralTypeBody(type, config);
IEnumerable<IEdmStructuralProperty> keys = config.Keys.Select(p => type.DeclaredProperties.OfType<IEdmStructuralProperty>().First(dp => dp.Name == p.Name));
type.AddKeys(keys);
foreach (NavigationPropertyConfiguration navProp in config.NavigationProperties)
{
EdmNavigationPropertyInfo info = new EdmNavigationPropertyInfo
{
Name = navProp.Name,
TargetMultiplicity = navProp.Multiplicity,
Target = GetEdmType(navProp.RelatedClrType) as IEdmEntityType,
ContainsTarget = navProp.ContainsTarget
};
IEdmProperty edmProperty = type.AddUnidirectionalNavigation(info);
if (navProp.PropertyInfo != null && edmProperty != null)
{
_properties[navProp.PropertyInfo] = edmProperty;
}
if (edmProperty != null && navProp.IsRestricted)
{
_propertiesRestrictions[edmProperty] = new QueryableRestrictions(navProp);
}
}
}
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 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;
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 = _types[complexProperty.RelatedClrType] as IEdmComplexType;
edmProperty = type.AddStructuralProperty(
complexProperty.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.Name,
new EdmCollectionTypeReference(
new EdmCollectionType(elementTypeReference),
collectionProperty.OptionalProperty));
break;
default:
break;
}
if (property.PropertyInfo != null && edmProperty != null)
{
_properties[property.PropertyInfo] = edmProperty;
}
if (edmProperty != null && property.IsRestricted)
{
_propertiesRestrictions[edmProperty] = new QueryableRestrictions(property);
}
}
}
private void CreateEntityTypeBody(EdmEntityType type, EntityTypeConfiguration config)
{
CreateStructuralTypeBody(type, config);
IEdmStructuralProperty[] keys = config.Keys.Select(p => type.DeclaredProperties.OfType<IEdmStructuralProperty>().First(dp => dp.Name == p.Name)).ToArray();
type.AddKeys(keys);
foreach (NavigationPropertyConfiguration navProp in config.NavigationProperties)
{
EdmNavigationPropertyInfo info = new EdmNavigationPropertyInfo();
info.Name = navProp.Name;
info.TargetMultiplicity = navProp.Multiplicity;
info.Target = _types[navProp.RelatedClrType] as IEdmEntityType;
//TODO: If target end has a multiplity of 1 this assumes the source end is 0..1.
// I think a better default multiplicity is *
IEdmProperty edmProperty = type.AddUnidirectionalNavigation(info);
if (navProp.PropertyInfo != null && edmProperty != null)
{
_properties[navProp.PropertyInfo] = edmProperty;
}
if (edmProperty != null && navProp.IsRestricted)
{
_propertiesRestrictions[edmProperty] = new QueryableRestrictions(navProp);
}
}
}
/// <summary>
/// Initializes a new instance of <see cref="QueryableRestrictionsAnnotation"/> class.
/// </summary>
/// <param name="restrictions">The queryable restrictions for the EDM property.</param>
public QueryableRestrictionsAnnotation(QueryableRestrictions restrictions)
{
Restrictions = restrictions ?? throw new ArgumentNullException(nameof(restrictions));
}
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 = (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 DoIt(NavigationPropertyConfiguration navProp, EdmEntityType type)
{
foreach (var dependentProperty in navProp.DependentProperties)
{
if (dependentProperty.GetConfiguration(_configurations).IsIgnored)
{
navProp.IsIgnored = true;
return;
}
}
if (navProp.IsIgnored)
{
return;
}
EdmNavigationPropertyInfo info = new EdmNavigationPropertyInfo
{
Name = navProp.Name,
TargetMultiplicity = navProp.Multiplicity,
Target = GetEdmType(navProp.RelatedClrType) as IEdmEntityType,
ContainsTarget = navProp.ContainsTarget,
OnDelete = navProp.OnDeleteAction
};
// Principal properties
if (navProp.PrincipalProperties.Any())
{
info.PrincipalProperties = GetDeclaringPropertyInfo(navProp.PrincipalProperties);
}
// Dependent properties
if (navProp.DependentProperties.Any())
{
info.DependentProperties = GetDeclaringPropertyInfo(navProp.DependentProperties);
}
IEdmProperty edmProperty = type.AddUnidirectionalNavigation(info);
if (navProp.PropertyInfo != null && edmProperty != null)
{
_properties[navProp.PropertyInfo] = edmProperty;
}
if (edmProperty != null && navProp.IsRestricted)
{
_propertiesRestrictions[edmProperty] = new QueryableRestrictions(navProp);
}
}
