/// <summary>
/// Initializes a new instance of the <see cref="EnumTypeConfiguration"/> class.
/// </summary>
public EnumTypeConfiguration(ODataModelBuilder builder, Type clrType)
{
if (builder == null)
{
throw Error.ArgumentNull("builder");
}
if (clrType == null)
{
throw Error.ArgumentNull("clrType");
}
if (!TypeHelper.IsEnum(clrType))
{
throw Error.Argument("clrType", SRResources.TypeCannotBeEnum, clrType.FullName);
}
ClrType = clrType;
IsFlags = TypeHelper.AsMemberInfo(clrType).GetCustomAttributes(typeof(FlagsAttribute), false).Any();
UnderlyingType = Enum.GetUnderlyingType(clrType);
ModelBuilder = builder;
_name = clrType.EdmName();
// Use the namespace if one was provided in builder by the user, otherwise fallback to CLR Namespace.
// If CLR Namespace is null we fallback to "Default"
// This can still be overriden by using DataContract attribute.
_namespace = builder.HasAssignedNamespace ? builder.Namespace : clrType.Namespace ?? builder.Namespace;
ExplicitMembers = new Dictionary <Enum, EnumMemberConfiguration>();
RemovedMembers = new List <Enum>();
}
/// <summary>
/// Removes the property from the edm type.
/// </summary>
/// <param name="edmProperty">The property being removed.</param>
/// <param name="structuralTypeConfiguration">The edm type from which the property is being removed.</param>
/// <param name="attribute">The <see cref="Attribute"/> found on this type.</param>
/// <param name="model">The ODataConventionModelBuilder used to build the model.</param>
public override void Apply(PropertyConfiguration edmProperty,
StructuralTypeConfiguration structuralTypeConfiguration,
Attribute attribute,
ODataConventionModelBuilder model)
{
if (structuralTypeConfiguration == null)
{
throw Error.ArgumentNull("structuralTypeConfiguration");
}
if (edmProperty == null)
{
throw Error.ArgumentNull("edmProperty");
}
if (!edmProperty.AddedExplicitly)
{
bool isTypeDataContract = TypeHelper.AsMemberInfo(structuralTypeConfiguration.ClrType).GetCustomAttributes(typeof(DataContractAttribute), inherit: true).Any();
bool isPropertyDataMember = edmProperty.PropertyInfo.GetCustomAttributes(typeof(DataMemberAttribute), inherit: true).Any();
if (isTypeDataContract && isPropertyDataMember)
{
// both Datamember and IgnoreDataMember. DataMember wins as this a DataContract
return;
}
else
{
structuralTypeConfiguration.RemoveProperty(edmProperty.PropertyInfo);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EnumTypeConfiguration"/> class.
/// </summary>
public EnumTypeConfiguration(ODataModelBuilder builder, Type clrType)
{
if (builder == null)
{
throw Error.ArgumentNull("builder");
}
if (clrType == null)
{
throw Error.ArgumentNull("clrType");
}
if (!TypeHelper.IsEnum(clrType))
{
throw Error.Argument("clrType", SRResources.TypeCannotBeEnum, clrType.FullName);
}
ClrType = clrType;
IsFlags = TypeHelper.AsMemberInfo(clrType).GetCustomAttributes(typeof(FlagsAttribute), false).Any();
UnderlyingType = Enum.GetUnderlyingType(clrType);
ModelBuilder = builder;
_name = clrType.EdmName();
_namespace = clrType.Namespace ?? DefaultNamespace;
ExplicitMembers = new Dictionary <Enum, EnumMemberConfiguration>();
RemovedMembers = new List <Enum>();
}
public NavigationPropertyBindingConfiguration HasManyBinding <TTargetType, TDerivedEntityType>(
Expression <Func <TDerivedEntityType, IEnumerable <TTargetType> > > navigationExpression, string entitySetName)
where TTargetType : class
where TDerivedEntityType : class, TEntityType
{
if (navigationExpression == null)
{
throw Error.ArgumentNull("navigationExpression");
}
if (String.IsNullOrEmpty(entitySetName))
{
throw Error.ArgumentNullOrEmpty("entitySetName");
}
EntityTypeConfiguration <TDerivedEntityType> derivedEntityType =
_modelBuilder.EntityType <TDerivedEntityType>().DerivesFrom <TEntityType>();
NavigationPropertyConfiguration navigation = derivedEntityType.HasMany(navigationExpression);
IList <MemberInfo> bindingPath = new List <MemberInfo>
{
TypeHelper.AsMemberInfo(typeof(TDerivedEntityType)),
navigation.PropertyInfo
};
return(this.Configuration.AddBinding(navigation,
_modelBuilder.EntitySet <TTargetType>(entitySetName)._configuration, bindingPath));
}
public NavigationPropertyBindingConfiguration HasSingletonBinding <TTargetType, TDerivedEntityType>(
Expression <Func <TDerivedEntityType, TTargetType> > navigationExpression,
NavigationSourceConfiguration <TTargetType> targetSingleton)
where TTargetType : class
where TDerivedEntityType : class, TEntityType
{
if (navigationExpression == null)
{
throw Error.ArgumentNull("navigationExpression");
}
if (targetSingleton == null)
{
throw Error.ArgumentNull("targetSingleton");
}
EntityTypeConfiguration <TDerivedEntityType> derivedEntityType =
_modelBuilder.EntityType <TDerivedEntityType>().DerivesFrom <TEntityType>();
NavigationPropertyConfiguration navigation = derivedEntityType.HasRequired(navigationExpression);
IList <MemberInfo> bindingPath = new List <MemberInfo>
{
TypeHelper.AsMemberInfo(typeof(TDerivedEntityType)),
navigation.PropertyInfo
};
return(this.Configuration.AddBinding(navigation, targetSingleton.Configuration, bindingPath));
}
public BindingPathConfiguration <TTargetType> HasSinglePath <TTargetType, TDerivedType>(
Expression <Func <TDerivedType, TTargetType> > pathExpression,
bool required,
bool contained)
where TTargetType : class
where TDerivedType : class, TStructuralType
{
if (pathExpression == null)
{
throw Error.ArgumentNull("pathExpression");
}
PropertyInfo pathProperty = PropertySelectorVisitor.GetSelectedProperty(pathExpression);
IList <MemberInfo> bindingPath = new List <MemberInfo>(_bindingPath);
bindingPath.Add(TypeHelper.AsMemberInfo(typeof(TDerivedType)));
bindingPath.Add(pathProperty);
// make sure the derived type has the same type kind with the resource type.
StructuralTypeConfiguration <TDerivedType> derivedConfiguration;
if (_structuralType.Configuration.Kind == EdmTypeKind.Entity)
{
derivedConfiguration = _modelBuilder.EntityType <TDerivedType>().DerivesFrom <TStructuralType>();
}
else
{
derivedConfiguration = _modelBuilder.ComplexType <TDerivedType>().DerivesFrom <TStructuralType>();
}
StructuralTypeConfiguration <TTargetType> target;
if (contained)
{
target = _modelBuilder.EntityType <TTargetType>();
if (required)
{
derivedConfiguration.ContainsRequired(pathExpression);
}
else
{
derivedConfiguration.ContainsOptional(pathExpression);
}
}
else
{
target = _modelBuilder.ComplexType <TTargetType>();
derivedConfiguration.ComplexProperty(pathExpression).OptionalProperty = !required;
}
return(new BindingPathConfiguration <TTargetType>(_modelBuilder, target, _navigationSource, bindingPath));
}
/// <summary>
/// Applies the convention.
/// </summary>
/// <param name="edmTypeConfiguration">The edm type to apply the convention to.</param>
/// <param name="model">The model that this edm type belongs to.</param>
public void Apply(TEdmTypeConfiguration edmTypeConfiguration, ODataConventionModelBuilder model)
{
if (edmTypeConfiguration == null)
{
throw Error.ArgumentNull("edmTypeConfiguration");
}
foreach (Attribute attribute in GetAttributes(TypeHelper.AsMemberInfo(edmTypeConfiguration.ClrType)))
{
Apply(edmTypeConfiguration, model, attribute);
}
}
public override void Apply(PropertyConfiguration edmProperty,
StructuralTypeConfiguration structuralTypeConfiguration,
Attribute attribute,
ODataConventionModelBuilder model)
{
if (structuralTypeConfiguration == null)
{
throw Error.ArgumentNull("structuralTypeConfiguration");
}
if (edmProperty == null)
{
throw Error.ArgumentNull("edmProperty");
}
if (model == null)
{
throw Error.ArgumentNull("model");
}
bool isTypeDataContract = TypeHelper.AsMemberInfo(structuralTypeConfiguration.ClrType).GetCustomAttributes(typeof(DataContractAttribute), inherit: true).Any();
DataMemberAttribute dataMember = attribute as DataMemberAttribute;
if (isTypeDataContract && dataMember != null && !edmProperty.AddedExplicitly)
{
// set the name alias
if (model.ModelAliasingEnabled &&
!String.IsNullOrWhiteSpace(dataMember.Name))
{
edmProperty.Name = dataMember.Name;
}
StructuralPropertyConfiguration structuralProperty = edmProperty as StructuralPropertyConfiguration;
if (structuralProperty != null)
{
structuralProperty.NullableProperty = !dataMember.IsRequired;
}
NavigationPropertyConfiguration navigationProperty = edmProperty as NavigationPropertyConfiguration;
if (navigationProperty != null && navigationProperty.Multiplicity != EdmMultiplicity.Many)
{
if (dataMember.IsRequired)
{
navigationProperty.Required();
}
else
{
navigationProperty.Nullable();
}
}
}
}
private static void FindAllNavigationPropertiesRecursive(this ODataModelBuilder builder,
StructuralTypeConfiguration configuration,
IList <Tuple <StructuralTypeConfiguration, IList <MemberInfo>, NavigationPropertyConfiguration> > navigations,
Stack <MemberInfo> path,
HashSet <Type> typesAlreadyProcessed)
{
if (builder == null)
{
throw Error.ArgumentNull("builder");
}
if (configuration == null)
{
throw Error.ArgumentNull("configuration");
}
if (navigations == null)
{
throw Error.ArgumentNull("navigations");
}
if (path == null)
{
throw Error.ArgumentNull("path");
}
IEnumerable <StructuralTypeConfiguration> thisAndBaseTypes = configuration.ThisAndBaseTypes();
foreach (var config in thisAndBaseTypes)
{
builder.FindNavigationProperties(config, navigations, path, typesAlreadyProcessed);
}
IEnumerable <StructuralTypeConfiguration> derivedTypes = builder.DerivedTypes(configuration);
foreach (var config in derivedTypes)
{
if (path.OfType <Type>().Any(p => p == config.ClrType))
{
continue;
}
path.Push(TypeHelper.AsMemberInfo(config.ClrType));
builder.FindNavigationProperties(config, navigations, path, typesAlreadyProcessed);
path.Pop();
}
}
public NavigationPropertyBindingConfiguration HasOptionalBinding <TTargetType, TDerivedType>(
Expression <Func <TDerivedType, TTargetType> > navigationExpression,
string targetEntitySet)
where TTargetType : class
where TDerivedType : class, TStructuralType
{
if (navigationExpression == null)
{
throw Error.ArgumentNull("navigationExpression");
}
if (String.IsNullOrEmpty(targetEntitySet))
{
throw Error.ArgumentNullOrEmpty("targetEntitySet");
}
StructuralTypeConfiguration <TDerivedType> derivedConfiguration;
if (this._structuralType.Configuration.Kind == EdmTypeKind.Entity)
{
derivedConfiguration = _modelBuilder.EntityType <TDerivedType>().DerivesFrom <TStructuralType>();
}
else
{
derivedConfiguration = _modelBuilder.ComplexType <TDerivedType>().DerivesFrom <TStructuralType>();
}
NavigationPropertyConfiguration navigation = derivedConfiguration.HasOptional(navigationExpression);
IList <MemberInfo> bindingPath = new List <MemberInfo>(_bindingPath);
bindingPath.Add(TypeHelper.AsMemberInfo(typeof(TDerivedType)));
bindingPath.Add(navigation.PropertyInfo);
NavigationSourceConfiguration entitySet = _modelBuilder.EntitySet <TTargetType>(targetEntitySet).Configuration;
return(this._navigationSource.AddBinding(navigation, entitySet, bindingPath));
}
/// <summary>
/// Binds the given navigation property to the target navigation source.
/// </summary>
/// <param name="navigationConfiguration">The navigation property.</param>
/// <param name="targetNavigationSource">The target navigation source.</param>
/// <returns>The <see cref="NavigationPropertyBindingConfiguration"/> so that it can be further configured.</returns>
public virtual NavigationPropertyBindingConfiguration AddBinding(NavigationPropertyConfiguration navigationConfiguration,
NavigationSourceConfiguration targetNavigationSource)
{
if (navigationConfiguration == null)
{
throw Error.ArgumentNull("navigationConfiguration");
}
if (targetNavigationSource == null)
{
throw Error.ArgumentNull("targetNavigationSource");
}
IList <MemberInfo> bindingPath = new List <MemberInfo> {
navigationConfiguration.PropertyInfo
};
if (navigationConfiguration.DeclaringType != EntityType)
{
bindingPath.Insert(0, TypeHelper.AsMemberInfo(navigationConfiguration.DeclaringType.ClrType));
}
return(AddBinding(navigationConfiguration, targetNavigationSource, bindingPath));
}
