internal MetadataProviderEdmModel(DataServiceProviderWrapper provider, DataServiceOperationContext operationContext, DataServiceStreamProviderWrapper streamProviderWrapper) { this.metadataProvider = provider; this.operationContext = operationContext; this.streamProviderWrapper = streamProviderWrapper; this.schemaTypeCache = new Dictionary <string, IEdmSchemaType>(StringComparer.Ordinal); this.resourceTypesPerNamespaceCache = new Dictionary <string, HashSet <ResourceType> >(StringComparer.Ordinal); this.entityContainerCache = new Dictionary <string, MetadataProviderEdmEntityContainer>(StringComparer.Ordinal); this.primitiveOrComplexCollectionTypeCache = new Dictionary <ResourceType, IEdmCollectionType>(EqualityComparer <ResourceType> .Default); this.entityPrimitiveOrComplexCollectionTypeCache = new Dictionary <ResourceType, IEdmCollectionType>(EqualityComparer <ResourceType> .Default); this.derivedTypeMappings = new Dictionary <IEdmStructuredType, List <IEdmStructuredType> >(EqualityComparer <IEdmStructuredType> .Default); this.associationSetByKeyCache = new Dictionary <string, string>(StringComparer.Ordinal); Version version = this.metadataProvider.Configuration.DataServiceBehavior.MaxProtocolVersion.ToVersion(); this.SetDataServiceVersion(version); Version version2 = null; if (!MetadataProviderUtils.DataServiceEdmVersionMap.TryGetValue(version, out version2)) { this.SetEdmVersion(Microsoft.Data.Edm.Library.EdmConstants.EdmVersionLatest); } else { this.SetEdmVersion(version2); } }
private ResourcePropertyCache InitializeResourcePropertyCache(DataServiceProviderWrapper provider, System.Data.Services.Providers.ResourceType type) { ResourcePropertyCache cache; if (!this.resourcePropertyCache.TryGetValue(type, out cache)) { cache = new ResourcePropertyCache { Properties = new List <ResourceProperty>() }; foreach (ResourceProperty property in type.Properties) { if ((property.TypeKind != ResourceTypeKind.EntityType) || (provider.GetContainer(this, type, property) != null)) { cache.Properties.Add(property); } } cache.PropertiesDeclaredOnTheType = new List <ResourceProperty>(); foreach (ResourceProperty property2 in type.PropertiesDeclaredOnThisType) { if ((property2.TypeKind != ResourceTypeKind.EntityType) || (provider.GetContainer(this, type, property2) != null)) { cache.PropertiesDeclaredOnTheType.Add(property2); } } this.resourcePropertyCache.Add(type, cache); } return(cache); }
public void ApplyConfiguration(DataServiceConfiguration configuration, DataServiceProviderWrapper provider) { if (this.Kind == OperationKind.ServiceOperation) { this.serviceOperationRights = configuration.GetServiceOperationRights(this.ServiceOperation); } else { this.serviceActionRights = configuration.GetServiceActionRights(this.ServiceAction); } if (((this.Kind == OperationKind.ServiceOperation) && ((this.serviceOperationRights & ~System.Data.Services.ServiceOperationRights.OverrideEntitySetRights) != System.Data.Services.ServiceOperationRights.None)) || ((this.Kind == OperationKind.Action) && (this.serviceActionRights != System.Data.Services.ServiceActionRights.None))) { if (this.operation.ResourceSet != null) { this.resourceSet = provider.TryResolveResourceSet(this.operation.ResourceSet.Name); if (this.resourceSet == null) { throw new InvalidOperationException(System.Data.Services.Strings.OperationWrapper_OperationResourceSetNotVisible(this.Name, this.operation.ResourceSet.Name)); } } else if (this.ResultSetPathExpression != null) { this.ResultSetPathExpression.InitializePathSegments(provider); } } }
/// <summary>Whether the types contained in the set has mappings for friendly feeds are V1 compatible or not</summary> /// <param name="provider">Data service provider instance.</param> /// <returns>False if there's any type in this set which has friendly feed mappings with KeepInContent=false. True otherwise.</returns> internal bool EpmIsV1Compatible(DataServiceProviderWrapper provider) { #if DEBUG Debug.Assert(provider != null, "provider != null"); Debug.Assert(this.resourceSet != null, "this.resourceSet != null"); Debug.Assert(this.isReadOnly, "EpmIsV1Compatible - entity set settings not initialized."); #endif if (!this.epmIsV1Compatible.HasValue) { // Go through all types contained in the set. If any one type is EpmIsV1Compatible == false, // the whole set is EpmIsV1Compatible=false. ResourceType baseType = this.resourceSet.ResourceType; bool isV1Compatible = baseType.EpmIsV1Compatible; // If the base type is not epm v1 compatible or it has no derived type, we need not look any further. if (isV1Compatible && provider.HasDerivedTypes(baseType)) { foreach (ResourceType derivedType in provider.GetDerivedTypes(baseType)) { if (!derivedType.EpmIsV1Compatible) { // We can stop as soon as we find the first type that is not epm v1 compatible. isV1Compatible = false; break; } } } this.epmIsV1Compatible = isV1Compatible; } return(this.epmIsV1Compatible.Value); }
internal ResourceSetWrapper GetTargetSet(DataServiceProviderWrapper provider, ResourceSetWrapper bindingSet) { ResourceSetWrapper sourceContainer = bindingSet; for (int i = 0; (sourceContainer != null) && (i < this.pathSegments.Length); i++) { PathSegment segment = this.pathSegments[i]; if (segment.Property != null) { sourceContainer = provider.GetContainer(sourceContainer, segment.SourceType, segment.Property); } } return(sourceContainer); }
public ResourceAssociationSetEnd(System.Data.Services.Providers.ResourceSet resourceSet, System.Data.Services.Providers.ResourceType resourceType, System.Data.Services.Providers.ResourceProperty resourceProperty) { WebUtil.CheckArgumentNull <System.Data.Services.Providers.ResourceSet>(resourceSet, "resourceSet"); WebUtil.CheckArgumentNull <System.Data.Services.Providers.ResourceType>(resourceType, "resourceType"); if ((resourceProperty != null) && ((resourceType.TryResolvePropertyName(resourceProperty.Name) == null) || (resourceProperty.TypeKind != ResourceTypeKind.EntityType))) { throw new ArgumentException(Strings.ResourceAssociationSetEnd_ResourcePropertyMustBeNavigationPropertyOnResourceType); } if (!resourceSet.ResourceType.IsAssignableFrom(resourceType) && !resourceType.IsAssignableFrom(resourceSet.ResourceType)) { throw new ArgumentException(Strings.ResourceAssociationSetEnd_ResourceTypeMustBeAssignableToResourceSet); } if ((resourceProperty != null) && (DataServiceProviderWrapper.GetDeclaringTypeForProperty(resourceType, resourceProperty, null) != resourceType)) { throw new ArgumentException(Strings.ResourceAssociationSetEnd_ResourceTypeMustBeTheDeclaringType(resourceType.FullName, resourceProperty.Name)); } this.resourceSet = resourceSet; this.resourceType = resourceType; this.resourceProperty = resourceProperty; }
public override ResourceAssociationSet GetResourceAssociationSet(ResourceSet resourceSet, ResourceType resourceType, ResourceProperty resourceProperty) { ResourceSet set; ResourceType type; string str; WebUtil.CheckArgumentNull <ResourceSet>(resourceSet, "resourceSet"); WebUtil.CheckArgumentNull <ResourceType>(resourceType, "resourceType"); WebUtil.CheckArgumentNull <ResourceProperty>(resourceProperty, "resourceProperty"); if (!base.TryResolveResourceSet(resourceSet.Name, out set) || (set != resourceSet)) { throw new InvalidOperationException(System.Data.Services.Strings.BadProvider_UnknownResourceSet(resourceSet.Name)); } if (!base.TryResolveResourceType(resourceType.FullName, out type) || (type != resourceType)) { throw new InvalidOperationException(System.Data.Services.Strings.BadProvider_UnknownResourceType(resourceType.FullName)); } if (resourceType != DataServiceProviderWrapper.GetDeclaringTypeForProperty(resourceType, resourceProperty, null)) { throw new InvalidOperationException(System.Data.Services.Strings.BadProvider_ResourceTypeMustBeDeclaringTypeForProperty(resourceType.FullName, resourceProperty.Name)); } ResourceType type2 = resourceProperty.ResourceType; if (type2.ResourceTypeKind != ResourceTypeKind.EntityType) { throw new InvalidOperationException(System.Data.Services.Strings.BadProvider_PropertyMustBeNavigationPropertyOnType(resourceProperty.Name, resourceType.FullName)); } ResourceSet containerForResourceType = InternalGetContainerForResourceType(type2.InstanceType, base.EntitySets.Values); if (base.Types.Count <ResourceType>(rt => (rt.Name == resourceType.Name)) > 1) { str = resourceType.FullName.Replace('.', '_') + '_' + resourceProperty.Name; } else { str = resourceType.Name + '_' + resourceProperty.Name; } ResourceAssociationSetEnd end = new ResourceAssociationSetEnd(resourceSet, resourceType, resourceProperty); return(new ResourceAssociationSet(str, end, new ResourceAssociationSetEnd(containerForResourceType, type2, null))); }
private void CheckHierarchy(DataServiceProviderWrapper provider) { if (!this.epmMinDSPV.HasValue) { System.Data.Services.Providers.ResourceType resourceType = this.resourceSet.ResourceType; bool hasEntityPropertyMappings = resourceType.HasEntityPropertyMappings; DataServiceProtocolVersion epmMinimumDataServiceProtocolVersion = resourceType.EpmMinimumDataServiceProtocolVersion; bool flag2 = false; bool flag3 = this.GetEntitySerializableProperties(provider, resourceType).Any <ResourceProperty>(p => p.TypeKind == ResourceTypeKind.EntityType); bool isOpenType = resourceType.IsOpenType; Version metadataVersion = resourceType.MetadataVersion; if (provider.HasDerivedTypes(resourceType)) { foreach (System.Data.Services.Providers.ResourceType type2 in provider.GetDerivedTypes(resourceType)) { if (type2.EpmMinimumDataServiceProtocolVersion > epmMinimumDataServiceProtocolVersion) { epmMinimumDataServiceProtocolVersion = type2.EpmMinimumDataServiceProtocolVersion; } hasEntityPropertyMappings |= type2.HasEntityPropertyMappings; bool flag5 = this.GetEntitySerializablePropertiesDeclaredOnTheResourceType(provider, type2).Any <ResourceProperty>(p => p.TypeKind == ResourceTypeKind.EntityType); flag3 |= flag5; flag2 |= type2.HasNamedStreamsDeclaredOnThisType | flag5; metadataVersion = WebUtil.RaiseVersion(metadataVersion, type2.MetadataVersion); isOpenType |= type2.IsOpenType; if (((epmMinimumDataServiceProtocolVersion == DataServiceProtocolVersion.V3) && (metadataVersion == RequestDescription.Version3Dot0)) && (flag2 && isOpenType)) { break; } } } this.hasEntityPropertyMappings = hasEntityPropertyMappings; this.epmMinDSPV = new DataServiceProtocolVersion?(epmMinimumDataServiceProtocolVersion); this.hasNavigationPropertyOrNamedStreamOnDerivedTypes = flag2; this.hasAccessibleNavigationProperty = flag3; this.hasOpenTypes = isOpenType; this.metadataVersion = metadataVersion; } }
internal ResourceSetWrapper GetResultSet(DataServiceProviderWrapper provider, ResourceSetWrapper bindingSet) { if (this.resourceSet != null) { return(this.resourceSet); } if (this.ResultSetPathExpression == null) { return(null); } if (bindingSet == null) { throw new InvalidOperationException(System.Data.Services.Strings.OperationWrapper_PathExpressionRequiresBindingSet(this.Name)); } ResourceSetWrapper targetSet = this.ResultSetPathExpression.GetTargetSet(provider, bindingSet); if (targetSet == null) { throw new InvalidOperationException(System.Data.Services.Strings.OperationWrapper_TargetSetFromPathExpressionNotNotVisible(this.Name, this.ResultSetPathExpression.PathExpression, bindingSet.Name)); } return(targetSet); }
/// <summary> /// Apply the given configuration to the resource set. /// </summary> /// <param name="configuration">data service configuration instance.</param> /// <param name="provider">data service provider wrapper instance for accessibility validation.</param> public void ApplyConfiguration(DataServiceConfiguration configuration, DataServiceProviderWrapper provider) { #if DEBUG Debug.Assert(!this.isReadOnly, "Can only apply the configuration once."); #endif this.rights = configuration.GetServiceOperationRights(this.serviceOperation); if ((this.rights & ~ServiceOperationRights.OverrideEntitySetRights) != ServiceOperationRights.None) { if (this.serviceOperation.ResourceSet != null) { // If the result type is an entity type, we need to make sure its entity set is visible. // If the entity set is hidden, we need to make sure that we throw an exception. this.resourceSet = provider.TryResolveResourceSet(this.serviceOperation.ResourceSet.Name); if (this.resourceSet == null) { throw new InvalidOperationException(Strings.BaseServiceProvider_ServiceOperationTypeHasNoContainer(this.serviceOperation.Name, this.serviceOperation.ResultType.FullName)); } } } #if DEBUG this.isReadOnly = true; #endif }
internal void InitializePathSegments(DataServiceProviderWrapper provider) { if (this.pathSegments == null) { string[] strArray = this.pathExpression.Split(new char[] { '/' }); ResourceType parameterType = this.bindingParameter.ParameterType; if (parameterType.ResourceTypeKind == ResourceTypeKind.EntityCollection) { parameterType = ((EntityCollectionResourceType)this.bindingParameter.ParameterType).ItemType; } List <PathSegment> list = new List <PathSegment>(); PathSegment item = new PathSegment { SourceType = parameterType }; bool flag = false; int length = strArray.Length; if (length == 1) { list.Add(item); } else { for (int i = 1; i < length; i++) { string str = strArray[i]; if (string.IsNullOrEmpty(str)) { throw new InvalidOperationException(Strings.ResourceSetPathExpression_EmptySegment(this.pathExpression)); } ResourceProperty property = item.SourceType.TryResolvePropertyName(str); if (property == null) { bool previousSegmentIsTypeSegment = flag; ResourceType type2 = WebUtil.ResolveTypeIdentifier(provider, str, item.SourceType, previousSegmentIsTypeSegment); if (type2 == null) { throw new InvalidOperationException(Strings.ResourceSetPathExpression_PropertyNotFound(this.pathExpression, str, item.SourceType.FullName)); } item.SourceType = type2; flag = true; if (i == (length - 1)) { throw new InvalidOperationException(Strings.ResourceSetPathExpression_PathCannotEndWithTypeIdentifier(this.pathExpression, strArray[length - 1])); } } else { flag = false; item.Property = property; list.Add(item); item = new PathSegment { SourceType = property.ResourceType }; } if (item.SourceType.ResourceTypeKind != ResourceTypeKind.EntityType) { throw new InvalidOperationException(Strings.ResourceSetPathExpression_PropertyMustBeEntityType(this.pathExpression, str, item.SourceType.FullName)); } } } this.pathSegments = list.ToArray(); } }
private static void AssertCacheNotPreloaded(DataServiceProviderWrapper wrapper) { }
internal void ApplyWildcardsAndSort(DataServiceProviderWrapper provider) { Func <ProjectionNode, bool> predicate = null; if (this.projectSubtree) { for (int i = this.nodes.Count - 1; i >= 0; i--) { ExpandedProjectionNode node = this.nodes[i] as ExpandedProjectionNode; if (node != null) { node.projectSubtree = true; node.ApplyWildcardsAndSort(provider); } else { this.nodes.RemoveAt(i); } } this.projectAllImmediateProperties = false; this.projectAllImmediateOperations = false; } else { for (int j = this.nodes.Count - 1; j >= 0; j--) { ExpandedProjectionNode node2 = this.nodes[j] as ExpandedProjectionNode; if (this.ProjectAllImmediateProperties && (node2 == null)) { this.nodes.RemoveAt(j); } else if (node2 != null) { node2.ApplyWildcardsAndSort(provider); } } if (this.nodes.Count > 0) { List <System.Data.Services.Providers.ResourceType> resourceTypesInMetadataOrder = new List <System.Data.Services.Providers.ResourceType> { this.ResourceType }; if (predicate == null) { predicate = n => !System.Data.Services.Providers.ResourceType.CompareReferences(n.TargetResourceType, this.ResourceType); } List <ProjectionNode> source = this.nodes.Where <ProjectionNode>(predicate).ToList <ProjectionNode>(); if (source.Count > 0) { using (IEnumerator <System.Data.Services.Providers.ResourceType> enumerator = provider.GetDerivedTypes(this.ResourceType).GetEnumerator()) { Func <ProjectionNode, bool> func = null; System.Data.Services.Providers.ResourceType rt; while (enumerator.MoveNext()) { rt = enumerator.Current; if (func == null) { func = node => node.TargetResourceType == rt; } if (source.FirstOrDefault <ProjectionNode>(func) != null) { resourceTypesInMetadataOrder.Add(rt); } } } } this.nodes = SortNodes(this.nodes, resourceTypesInMetadataOrder); } } }
internal static ResourceSetWrapper CreateResourceSetWrapper(System.Data.Services.Providers.ResourceSet resourceSet, DataServiceProviderWrapper provider, Func <System.Data.Services.Providers.ResourceType, System.Data.Services.Providers.ResourceType> resourceTypeValidator) { if (!resourceSet.IsReadOnly) { throw new DataServiceException(500, System.Data.Services.Strings.DataServiceProviderWrapper_ResourceContainerNotReadonly(resourceSet.Name)); } ResourceSetWrapper wrapper = new ResourceSetWrapper(resourceSet); wrapper.ApplyConfiguration(provider.Configuration); if (!wrapper.IsVisible) { return(null); } wrapper.resourceType = resourceTypeValidator(resourceSet.ResourceType); return(wrapper); }
internal IEnumerable <ResourceProperty> GetEntitySerializableProperties(DataServiceProviderWrapper provider, System.Data.Services.Providers.ResourceType entityType) { return(this.InitializeResourcePropertyCache(provider, entityType).Properties); }
private IEnumerable <ResourceProperty> GetEntitySerializablePropertiesDeclaredOnTheResourceType(DataServiceProviderWrapper provider, System.Data.Services.Providers.ResourceType entityType) { return(this.InitializeResourcePropertyCache(provider, entityType).PropertiesDeclaredOnTheType); }
internal DataServiceProtocolVersion VerifyEpmProtocolVersion(DataServiceProviderWrapper provider) { this.CheckHierarchy(provider); return(this.epmMinDSPV.Value); }
internal bool HasAccessibleNavigationProperty(DataServiceProviderWrapper provider) { this.CheckHierarchy(provider); return(this.hasAccessibleNavigationProperty); }
internal bool HasNavigationPropertyOrNamedStreamsOnDerivedTypes(DataServiceProviderWrapper provider) { this.CheckHierarchy(provider); return(this.hasNavigationPropertyOrNamedStreamOnDerivedTypes); }
internal bool HasEntityPropertyMappings(DataServiceProviderWrapper provider) { this.CheckHierarchy(provider); return(this.hasEntityPropertyMappings); }