private static void AddCoreVocabularyAnnotations(this EdmModel model, IEnumerable <NavigationSourceAndAnnotations> navigationSources, EdmTypeMap edmTypeMap)
{
Contract.Assert(model != null);
Contract.Assert(edmTypeMap != null);
if (navigationSources == null)
{
return;
}
foreach (NavigationSourceAndAnnotations source in navigationSources)
{
IEdmVocabularyAnnotatable navigationSource = source.NavigationSource as IEdmVocabularyAnnotatable;
if (navigationSource == null)
{
continue;
}
NavigationSourceConfiguration navigationSourceConfig = source.Configuration as NavigationSourceConfiguration;
if (navigationSourceConfig == null)
{
continue;
}
model.AddOptimisticConcurrencyAnnotation(navigationSource, navigationSourceConfig, edmTypeMap);
}
}
private static void AddNavigationBindings(EdmTypeMap edmMap,
NavigationSourceConfiguration navigationSourceConfiguration,
EdmNavigationSource navigationSource,
// NavigationSourceLinkBuilderAnnotation linkBuilder,
Dictionary <string, EdmNavigationSource> edmNavigationSourceMap)
{
foreach (var binding in navigationSourceConfiguration.Bindings)
{
NavigationPropertyConfiguration navigationProperty = binding.NavigationProperty;
bool isContained = navigationProperty.ContainsTarget;
IEdmType edmType = edmMap.EdmTypes[navigationProperty.DeclaringType.ClrType];
IEdmStructuredType structuraType = edmType as IEdmStructuredType;
IEdmNavigationProperty edmNavigationProperty = structuraType.NavigationProperties()
.Single(np => np.Name == navigationProperty.Name);
string bindingPath = ConvertBindingPath(edmMap, binding);
if (!isContained)
{
// calculate the binding path
navigationSource.AddNavigationTarget(
edmNavigationProperty,
edmNavigationSourceMap[binding.TargetNavigationSource.Name],
new EdmPathExpression(bindingPath));
}
//NavigationLinkBuilder linkBuilderFunc = navigationSourceConfiguration.GetNavigationPropertyLink(navigationProperty);
//if (linkBuilderFunc != null)
//{
// linkBuilder.AddNavigationPropertyLinkBuilder(edmNavigationProperty, linkBuilderFunc);
//}
}
}
public void GetTargetNavigationSource_Returns_Null_IfNoMatchingTargetNavigaitonSource()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration motorcycle = builder.AddEntityType(typeof(Motorcycle));
NavigationPropertyConfiguration navigationProperty = motorcycle.AddNavigationProperty(typeof(Motorcycle).GetProperty("Manufacturer"), EdmMultiplicity.ZeroOrOne);
// Act
NavigationSourceConfiguration targetNavigationSource = AssociationSetDiscoveryConvention.GetTargetNavigationSource(navigationProperty, builder);
// Assert
Assert.Null(targetNavigationSource);
}
public void Apply(NavigationSourceConfiguration configuration, ODataModelBuilder model)
{
if (configuration == null)
{
throw Error.ArgumentNull("configuration");
}
// Configure the self link for the feed
EntitySetConfiguration entitySet = configuration as EntitySetConfiguration;
if (entitySet != null && (entitySet.GetFeedSelfLink() == null))
{
entitySet.HasFeedSelfLink(feedContext =>
{
string selfLink = feedContext.InternalUrlHelper.CreateODataLink(new EntitySetSegment(feedContext.EntitySetBase as IEdmEntitySet));
if (selfLink == null)
{
return(null);
}
return(new Uri(selfLink));
});
}
if (configuration.GetIdLink() == null)
{
configuration.HasIdLink(new SelfLinkBuilder <Uri>((entityContext) => entityContext.GenerateSelfLink(includeCast: false), followsConventions: true));
}
if (configuration.GetEditLink() == null)
{
bool derivedTypesDefineNavigationProperty = model.DerivedTypes(configuration.EntityType)
.OfType <EntityTypeConfiguration>().Any(e => e.NavigationProperties.Any());
// generate links with cast if any of the derived types define a navigation property
if (derivedTypesDefineNavigationProperty)
{
configuration.HasEditLink(
new SelfLinkBuilder <Uri>(
entityContext => entityContext.GenerateSelfLink(includeCast: true),
followsConventions: true));
}
else
{
configuration.HasEditLink(
new SelfLinkBuilder <Uri>(
entityContext => entityContext.GenerateSelfLink(includeCast: false),
followsConventions: true));
}
}
}
public void Apply(INavigationSourceConfiguration configuration, ODataModelBuilder model)
{
foreach (EntityTypeConfiguration entity in model.ThisAndBaseAndDerivedTypes(configuration.EntityType))
{
foreach (NavigationPropertyConfiguration navigationProperty in entity.NavigationProperties)
{
NavigationSourceConfiguration targetNavigationSource = GetTargetNavigationSource(navigationProperty, model);
if (targetNavigationSource != null)
{
configuration.AddBinding(navigationProperty, targetNavigationSource);
}
}
}
}
public void GetTargetNavigationSource_Returns_TargetSingleton()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration companyType = builder.AddEntityType(typeof(Company));
EntityTypeConfiguration employeeType = builder.AddEntityType(typeof(Employee));
NavigationPropertyConfiguration navigationProperty = companyType.AddNavigationProperty(typeof(Company).GetProperty("CEO"), EdmMultiplicity.One);
SingletonConfiguration gazes = builder.AddSingleton("Gazes", employeeType);
// Act
NavigationSourceConfiguration targetNavigationSource = AssociationSetDiscoveryConvention.GetTargetNavigationSource(navigationProperty, builder);
// Assert
Assert.Same(gazes, targetNavigationSource);
}
public void GetTargetNavigationSource_Returns_TargetEntitySet()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration motorcycle = builder.AddEntityType(typeof(Motorcycle));
EntityTypeConfiguration manufacturer = builder.AddEntityType(typeof(MotorcycleManufacturer));
NavigationPropertyConfiguration navigationProperty = motorcycle.AddNavigationProperty(typeof(Motorcycle).GetProperty("Manufacturer"), EdmMultiplicity.ZeroOrOne);
EntitySetConfiguration manufacturers = builder.AddEntitySet("manufacturers", manufacturer);
// Act
NavigationSourceConfiguration targetNavigationSource = AssociationSetDiscoveryConvention.GetTargetNavigationSource(navigationProperty, builder);
// Assert
Assert.Same(manufacturers, targetNavigationSource);
}
private void ApplyNavigationSourceConventions(NavigationSourceConfiguration navigationSourceConfiguration)
{
if (!this._configuredNavigationSources.Contains(navigationSourceConfiguration))
{
this._configuredNavigationSources.Add(navigationSourceConfiguration);
foreach (INavigationSourceConvention convention in _conventions.OfType <INavigationSourceConvention>())
{
if (convention != null)
{
convention.Apply(navigationSourceConfiguration, this);
}
}
}
}
public void Apply(NavigationSourceConfiguration configuration, ODataModelBuilder model)
{
IList <Tuple <StructuralTypeConfiguration, IList <MemberInfo>, NavigationPropertyConfiguration> > navigations =
new List <Tuple <StructuralTypeConfiguration, IList <MemberInfo>, NavigationPropertyConfiguration> >();
Stack <MemberInfo> path = new Stack <MemberInfo>();
model.FindAllNavigationProperties(configuration.EntityType, navigations, path);
foreach (var navigation in navigations)
{
NavigationSourceConfiguration targetNavigationSource = GetTargetNavigationSource(
navigation.Item3, model);
if (targetNavigationSource != null)
{
configuration.AddBinding(navigation.Item3, targetNavigationSource, navigation.Item2);
}
}
}
public void Apply(NavigationSourceConfiguration configuration, ODataModelBuilder model)
{
if (configuration == null)
{
throw Error.ArgumentNull("configuration");
}
#if false
// generate links without cast for declared and inherited navigation properties
foreach (EntityTypeConfiguration entity in configuration.EntityType.ThisAndBaseTypes())
{
foreach (NavigationPropertyConfiguration property in entity.NavigationProperties)
{
if (configuration.GetNavigationPropertyLink(property) == null)
{
configuration.HasNavigationPropertyLink(
property,
new NavigationLinkBuilder(
(entityContext, navigationProperty) =>
entityContext.GenerateNavigationPropertyLink(navigationProperty, includeCast: false), followsConventions: true));
}
}
}
// generate links with cast for navigation properties in derived types.
foreach (EntityTypeConfiguration entity in model.DerivedTypes(configuration.EntityType))
{
foreach (NavigationPropertyConfiguration property in entity.NavigationProperties)
{
if (configuration.GetNavigationPropertyLink(property) == null)
{
configuration.HasNavigationPropertyLink(
property,
new NavigationLinkBuilder(
(entityContext, navigationProperty) =>
entityContext.GenerateNavigationPropertyLink(navigationProperty, includeCast: true), followsConventions: true));
}
}
}
#endif
}
private static void AddOptimisticConcurrencyAnnotation(this EdmModel model, IEdmVocabularyAnnotatable target,
NavigationSourceConfiguration navigationSourceConfiguration, EdmTypeMap edmTypeMap)
{
EntityTypeConfiguration entityTypeConfig = navigationSourceConfiguration.EntityType;
IEnumerable <StructuralPropertyConfiguration> concurrencyProperties =
entityTypeConfig.Properties.OfType <StructuralPropertyConfiguration>().Where(property => property.ConcurrencyToken);
foreach (var baseType in entityTypeConfig.BaseTypes())
{
concurrencyProperties = concurrencyProperties.Concat(
baseType.Properties.OfType <StructuralPropertyConfiguration>().Where(property => property.ConcurrencyToken));
}
IList <IEdmStructuralProperty> edmProperties = new List <IEdmStructuralProperty>();
foreach (StructuralPropertyConfiguration property in concurrencyProperties)
{
IEdmProperty value;
if (edmTypeMap.EdmProperties.TryGetValue(property.PropertyInfo, out value))
{
var item = value as IEdmStructuralProperty;
if (item != null)
{
edmProperties.Add(item);
}
}
}
if (edmProperties.Any())
{
IEdmCollectionExpression collectionExpression = new EdmCollectionExpression(edmProperties.Select(p => new EdmPropertyPathExpression(p.Name)).ToArray());
IEdmTerm term = Microsoft.OData.Edm.Vocabularies.V1.CoreVocabularyModel.ConcurrencyTerm;
EdmVocabularyAnnotation annotation = new EdmVocabularyAnnotation(target, term, collectionExpression);
annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline);
model.SetVocabularyAnnotation(annotation);
}
}
