public ResourceAssociationSet GetResourceAssociationSet(
ResourceSet resourceSet,
ResourceType resourceType,
ResourceProperty resourceProperty)
{
// resourceProperty.GetAnnotation().ResourceAssociationSet;
return resourceProperty.CustomState as ResourceAssociationSet;
}
/// <summary>
/// Initializes a new <see cref="ServiceOperation"/> instance.
/// </summary>
/// <param name="name">name of the service operation.</param>
/// <param name="resultKind">Kind of result expected from this operation.</param>
/// <param name="resultType">Type of element of the method result.</param>
/// <param name="resultSet">EntitySet of the result expected from this operation.</param>
/// <param name="method">Protocol (for example HTTP) method the service operation responds to.</param>
/// <param name="parameters">In-order parameters for this operation.</param>
public ServiceOperation(
string name,
ServiceOperationResultKind resultKind,
ResourceType resultType,
ResourceSet resultSet,
string method,
IEnumerable<ServiceOperationParameter> parameters)
{
WebUtil.CheckStringArgumentNull(name, "name");
WebUtil.CheckServiceOperationResultKind(resultKind, "resultKind");
WebUtil.CheckStringArgumentNull(method, "method");
if ((resultKind == ServiceOperationResultKind.Void && resultType != null) ||
(resultKind != ServiceOperationResultKind.Void && resultType == null))
{
throw new ArgumentException(Strings.ServiceOperation_ResultTypeAndKindMustMatch("resultKind", "resultType", ServiceOperationResultKind.Void));
}
if ((resultType == null || resultType.ResourceTypeKind != ResourceTypeKind.EntityType) && resultSet != null)
{
throw new ArgumentException(Strings.ServiceOperation_ResultSetMustBeNull("resultSet", "resultType"));
}
if (resultType != null && resultType.ResourceTypeKind == ResourceTypeKind.EntityType && (resultSet == null || !resultSet.ResourceType.IsAssignableFrom(resultType)))
{
throw new ArgumentException(Strings.ServiceOperation_ResultTypeAndResultSetMustMatch("resultType", "resultSet"));
}
if (method != XmlConstants.HttpMethodGet && method != XmlConstants.HttpMethodPost)
{
throw new ArgumentException(Strings.ServiceOperation_NotSupportedProtocolMethod(method, name));
}
this.name = name;
this.resultKind = resultKind;
this.resultType = resultType;
this.resourceSet = resultSet;
this.method = method;
if (parameters == null)
{
this.parameters = ServiceOperation.emptyParameterCollection;
}
else
{
this.parameters = new ReadOnlyCollection<ServiceOperationParameter>(new List<ServiceOperationParameter>(parameters));
HashSet<string> paramNames = new HashSet<string>(StringComparer.Ordinal);
foreach (ServiceOperationParameter p in this.parameters)
{
if (!paramNames.Add(p.Name))
{
throw new ArgumentException(Strings.ServiceOperation_DuplicateParameterName(p.Name), "parameters");
}
}
}
}
private ServiceAction(string name, ResourceType returnType, ResourceSet resultSet, ResourceSetPathExpression resultSetPathExpression, IEnumerable<ServiceActionParameter> parameters, OperationParameterBindingKind operationParameterBindingKind) : base(name, Operation.GetResultKindFromReturnType(returnType, false), returnType, resultSet, resultSetPathExpression, "POST", parameters, operationParameterBindingKind, OperationKind.Action)
{
if (base.OperationParameters == OperationParameter.EmptyOperationParameterCollection)
{
this.parameters = ServiceActionParameter.EmptyServiceActionParameterCollection;
}
else
{
this.parameters = new ReadOnlyCollection<ServiceActionParameter>(base.OperationParameters.Cast<ServiceActionParameter>().ToList<ServiceActionParameter>());
}
}
public ServiceOperation(string name, ServiceOperationResultKind resultKind, ResourceType resultType, ResourceSet resultSet, string method, IEnumerable<ServiceOperationParameter> parameters) : base(name, resultKind, GetReturnTypeFromResultType(resultType, resultKind), resultSet, null, method, parameters, OperationParameterBindingKind.Never, OperationKind.ServiceOperation)
{
if (base.OperationParameters == OperationParameter.EmptyOperationParameterCollection)
{
this.parameters = ServiceOperationParameter.EmptyServiceOperationParameterCollection;
}
else
{
this.parameters = new ReadOnlyCollection<ServiceOperationParameter>(base.OperationParameters.Cast<ServiceOperationParameter>().ToList<ServiceOperationParameter>());
}
}
/// <summary>
/// Constructs a new ResourceSetWrapper instance using the ResourceSet instance to be enclosed.
/// </summary>
/// <param name="resourceSet">ResourceSet instance to be wrapped by the current instance</param>
/// <param name="resourceType">Resource type (normalized to a single instance by the caller).</param>
public ResourceSetWrapper(ResourceSet resourceSet, ResourceType resourceType)
{
Debug.Assert(resourceSet != null, "resourceSet != null");
if (!resourceSet.IsReadOnly)
{
throw new DataServiceException(500, Strings.DataServiceProviderWrapper_ResourceContainerNotReadonly(resourceSet.Name));
}
this.resourceSet = resourceSet;
this.resourceType = resourceType;
}
/// <summary>
/// Constructs a ResourceAssociationEnd instance.
/// </summary>
/// <param name="resourceSet">Resource set of the association end.</param>
/// <param name="resourceType">Resource type of the association end.</param>
/// <param name="resourceProperty">Resource property of the association end.</param>
public ResourceAssociationSetEnd(ResourceSet resourceSet, ResourceType resourceType, ResourceProperty resourceProperty)
{
WebUtil.CheckArgumentNull(resourceSet, "resourceSet");
WebUtil.CheckArgumentNull(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);
}
this.resourceSet = resourceSet;
this.resourceType = resourceType;
// Note that for the TargetEnd, resourceProperty can be null.
this.resourceProperty = resourceProperty;
}
/// <summary>
/// Gets the ResourceAssociationSet instance when given the source association end.
/// </summary>
/// <param name="resourceSet">Resource set of the source association end.</param>
/// <param name="resourceType">Resource type of the source association end.</param>
/// <param name="resourceProperty">Resource property of the source association end.</param>
/// <returns>ResourceAssociationSet instance.</returns>
public override ResourceAssociationSet GetResourceAssociationSet(ResourceSet resourceSet, ResourceType resourceType, ResourceProperty resourceProperty)
{
Debug.Assert(resourceSet != null, "resourceSet != null");
Debug.Assert(resourceType != null, "resourceType != null");
Debug.Assert(resourceProperty != null, "resourceProperty != null");
Debug.Assert(resourceType == DataServiceProviderWrapper.GetDeclaringTypeForProperty(resourceType, resourceProperty), "resourceType should be the declaring type for resourceProperty");
ResourceType targetType = resourceProperty.ResourceType;
Debug.Assert(targetType != null && targetType.ResourceTypeKind == ResourceTypeKind.EntityType, "targetType != null && targetType.ResourceTypeKind == ResourceTypeKind.EntityType");
ResourceSet targetSet = InternalGetContainerForResourceType(targetType.InstanceType, this.EntitySets.Values);
Debug.Assert(targetSet != null, "targetSet != null");
string associationName = resourceType.Name + '_' + resourceProperty.Name;
// EF associations are first-class, navigation properties come second. So you actually
// define the two-way association first, then say that the nav props "go through" them.
// For CLR, however, there is no such constraint - in fact, we're very happy with one-way (link) associations.
// For one-way associations, the target property is always null.
ResourceAssociationSetEnd sourceEnd = new ResourceAssociationSetEnd(resourceSet, resourceType, resourceProperty);
ResourceAssociationSetEnd targetEnd = new ResourceAssociationSetEnd(targetSet, targetType, null);
return new ResourceAssociationSet(associationName, sourceEnd, targetEnd);
}
/// <summary>
/// Returns the IQueryable that represents the container.
/// </summary>
/// <param name="container">resource set representing the entity set.</param>
/// <returns>
/// An IQueryable that represents the container; null if there is
/// no container for the specified name.
/// </returns>
public IQueryable GetQueryRootForResourceSet(ResourceSet container)
{
Debug.Assert(container != null, "resourceContainer != null");
return(this.GetResourceContainerInstance(container));
}
/// <summary>
/// Adds a new <see cref="ServiceOperation"/> based on the specified <paramref name="method"/>
/// instance.
/// </summary>
/// <param name="method">Method to expose as a service operation.</param>
/// <param name="protocolMethod">Protocol (for example HTTP) method the service operation responds to.</param>
private void AddServiceOperation(MethodInfo method, string protocolMethod)
{
Debug.Assert(method != null, "method != null");
Debug.Assert(!method.IsAbstract, "!method.IsAbstract - if method is abstract, the type is abstract - already checked");
// This method is only called for V1 providers, since in case of custom providers,
// they are suppose to load the metadata themselves.
if (this.metadata.ServiceOperations.ContainsKey(method.Name))
{
throw new InvalidOperationException(Strings.BaseServiceProvider_OverloadingNotSupported(this.Type, method));
}
bool hasSingleResult = SingleResultAttribute.MethodHasSingleResult(method);
ServiceOperationResultKind resultKind;
ResourceType resourceType = null;
if (method.ReturnType == typeof(void))
{
resultKind = ServiceOperationResultKind.Void;
this.UpdateEdmSchemaVersion(MetadataEdmSchemaVersion.Version1Dot1);
}
else
{
// Load the metadata of the resource type on the fly.
// For Edm provider, it might not mean anything, but for reflection service provider, we need to
// load the metadata of the type if its used only in service operation case
Type resultType = null;
if (WebUtil.IsPrimitiveType(method.ReturnType))
{
resultKind = ServiceOperationResultKind.DirectValue;
resultType = method.ReturnType;
resourceType = ResourceType.GetPrimitiveResourceType(resultType);
}
else
{
Type queryableElement = GetGenericInterfaceElementType(method.ReturnType, IQueryableTypeFilter);
if (queryableElement != null)
{
resultKind = hasSingleResult ?
ServiceOperationResultKind.QueryWithSingleResult :
ServiceOperationResultKind.QueryWithMultipleResults;
resultType = queryableElement;
}
else
{
Type enumerableElement = GetIEnumerableElement(method.ReturnType);
if (enumerableElement != null)
{
resultKind = ServiceOperationResultKind.Enumeration;
resultType = enumerableElement;
}
else
{
resultType = method.ReturnType;
resultKind = ServiceOperationResultKind.DirectValue;
this.UpdateEdmSchemaVersion(MetadataEdmSchemaVersion.Version1Dot1);
}
}
Debug.Assert(resultType != null, "resultType != null");
resourceType = ResourceType.GetPrimitiveResourceType(resultType);
if (resourceType == null)
{
resourceType = this.PopulateMetadataForType(resultType, this.TypeCache, this.ChildTypesCache, this.EntitySets.Values);
}
}
if (resourceType == null)
{
throw new InvalidOperationException(Strings.BaseServiceProvider_UnsupportedReturnType(method, method.ReturnType));
}
if (resultKind == ServiceOperationResultKind.Enumeration && hasSingleResult)
{
throw new InvalidOperationException(Strings.BaseServiceProvider_IEnumerableAlwaysMultiple(this.Type, method));
}
if (hasSingleResult ||
(!hasSingleResult &&
(resourceType.ResourceTypeKind == ResourceTypeKind.ComplexType ||
resourceType.ResourceTypeKind == ResourceTypeKind.Primitive)))
{
this.UpdateEdmSchemaVersion(MetadataEdmSchemaVersion.Version1Dot1);
}
}
ParameterInfo[] parametersInfo = method.GetParameters();
ServiceOperationParameter[] parameters = new ServiceOperationParameter[parametersInfo.Length];
for (int i = 0; i < parameters.Length; i++)
{
ParameterInfo parameterInfo = parametersInfo[i];
if (parameterInfo.IsOut || parameterInfo.IsRetval)
{
throw new InvalidOperationException(Strings.BaseServiceProvider_ParameterNotIn(method, parameterInfo));
}
ResourceType parameterType = ResourceType.GetPrimitiveResourceType(parameterInfo.ParameterType);
if (parameterType == null)
{
throw new InvalidOperationException(
Strings.BaseServiceProvider_ParameterTypeNotSupported(method, parameterInfo, parameterInfo.ParameterType));
}
string parameterName = parameterInfo.Name ?? "p" + i.ToString(CultureInfo.InvariantCulture);
parameters[i] = new ServiceOperationParameter(parameterName, parameterType);
}
ResourceSet container = null;
if (resourceType != null && resourceType.ResourceTypeKind == ResourceTypeKind.EntityType)
{
if (!this.TryFindAnyContainerForType(resourceType, out container))
{
throw new InvalidOperationException(
Strings.BaseServiceProvider_ServiceOperationMissingSingleEntitySet(method, resourceType.FullName));
}
}
ServiceOperation operation = new ServiceOperation(method.Name, resultKind, resourceType, container, protocolMethod, parameters);
operation.CustomState = method;
MimeTypeAttribute attribute = MimeTypeAttribute.GetMimeTypeAttribute(method);
if (attribute != null)
{
operation.MimeType = attribute.MimeType;
}
this.metadata.ServiceOperations.Add(method.Name, operation);
}
public abstract ResourceAssociationSet GetResourceAssociationSet(ResourceSet resourceSet, ResourceType resourceType, ResourceProperty resourceProperty);
/// <summary>
/// Looks for the first resource set that the specified <paramref name="type"/>
/// could belong to.
/// </summary>
/// <param name="type">Type to look for.</param>
/// <param name="container">After the method returns, the container to which the type could belong.</param>
/// <returns>true if a container was found; false otherwise.</returns>
private bool TryFindAnyContainerForType(ResourceType type, out ResourceSet container)
{
Debug.Assert(type != null, "type != null");
foreach (ResourceSet c in this.EntitySets.Values)
{
if (c.ResourceType.IsAssignableFrom(type))
{
container = c;
return true;
}
}
container = default(ResourceSet);
return false;
}
/// <summary>Given the specified name, tries to find a resource set.</summary>
/// <param name="name">Name of the resource set to resolve.</param>
/// <param name="resourceSet">Returns the resolved resource set, null if no resource set for the given name was found.</param>
/// <returns>True if resource set with the given name was found, false otherwise.</returns>
public bool TryResolveResourceSet(string name, out ResourceSet resourceSet)
{
Debug.Assert(!string.IsNullOrEmpty(name), "!string.IsNullOrEmpty(name)");
return this.EntitySets.TryGetValue(name, out resourceSet);
}
/// <summary> /// Gets the ResourceAssociationSet instance when given the source association end. /// </summary> /// <param name="resourceSet">Resource set of the source association end.</param> /// <param name="resourceType">Resource type of the source association end.</param> /// <param name="resourceProperty">Resource property of the source association end.</param> /// <returns>ResourceAssociationSet instance.</returns> public abstract ResourceAssociationSet GetResourceAssociationSet(ResourceSet resourceSet, ResourceType resourceType, ResourceProperty resourceProperty);
/// <summary>
/// Gets the ResourceAssociationSet instance when given the source association end.
/// </summary>
/// <param name="resourceSet">Resource set of the source association end.</param>
/// <param name="resourceType">Resource type of the source association end.</param>
/// <param name="resourceProperty">Resource property of the source association end.</param>
/// <returns>ResourceAssociationSet instance.</returns>
public ResourceAssociationSet GetResourceAssociationSet(ResourceSet resourceSet, ResourceType resourceType, ResourceProperty resourceProperty)
{
throw new NotImplementedException("Should never get here, reference properties are not yet supported.");
}
public ResourceAssociationSetEnd(ResourceSet resourceSet, ResourceType resourceType, ResourceProperty resourceProperty)
{
Contract.Requires(resourceSet != null);
Contract.Requires(resourceType != null);
}
public ServiceAction(string name, ResourceType returnType, ResourceSet resultSet, OperationParameterBindingKind operationParameterBindingKind, IEnumerable <ServiceActionParameter> parameters) : this(name, returnType, resultSet, null, parameters, operationParameterBindingKind)
{
}
internal IEdmEntitySet FindEntitySet(ResourceSet resourceSet)
{
string name = resourceSet.EntityContainerName ?? this.metadataProvider.ContainerName;
return(this.FindExistingEntityContainer(name).FindEntitySet(MetadataProviderUtils.GetEntitySetName(resourceSet)));
}
private void AddServiceOperation(MethodInfo method, string protocolMethod)
{
ServiceOperationResultKind @void;
if (this.metadata.ServiceOperations.ContainsKey(method.Name))
{
throw new InvalidOperationException(System.Data.Services.Strings.BaseServiceProvider_OverloadingNotSupported(this.Type, method));
}
bool flag = SingleResultAttribute.MethodHasSingleResult(method);
ResourceType primitive = null;
if (method.ReturnType == typeof(void))
{
@void = ServiceOperationResultKind.Void;
}
else
{
System.Type returnType;
if (WebUtil.IsPrimitiveType(method.ReturnType))
{
@void = ServiceOperationResultKind.DirectValue;
returnType = method.ReturnType;
primitive = ResourceType.PrimitiveResourceTypeMap.GetPrimitive(returnType);
}
else
{
System.Type genericInterfaceElementType = GetGenericInterfaceElementType(method.ReturnType, new TypeFilter(BaseServiceProvider.IQueryableTypeFilter));
if (genericInterfaceElementType != null)
{
@void = flag ? ServiceOperationResultKind.QueryWithSingleResult : ServiceOperationResultKind.QueryWithMultipleResults;
returnType = genericInterfaceElementType;
}
else
{
System.Type iEnumerableElement = GetIEnumerableElement(method.ReturnType);
if (iEnumerableElement != null)
{
@void = ServiceOperationResultKind.Enumeration;
returnType = iEnumerableElement;
}
else
{
returnType = method.ReturnType;
@void = ServiceOperationResultKind.DirectValue;
}
}
primitive = ResourceType.PrimitiveResourceTypeMap.GetPrimitive(returnType);
if (primitive == null)
{
primitive = this.PopulateMetadataForType(returnType, this.TypeCache, this.ChildTypesCache, this.EntitySets.Values);
}
}
if (primitive == null)
{
throw new InvalidOperationException(System.Data.Services.Strings.BaseServiceProvider_UnsupportedReturnType(method, method.ReturnType));
}
if ((@void == ServiceOperationResultKind.Enumeration) && flag)
{
throw new InvalidOperationException(System.Data.Services.Strings.BaseServiceProvider_IEnumerableAlwaysMultiple(this.Type, method));
}
}
ParameterInfo[] parameters = method.GetParameters();
ServiceOperationParameter[] parameterArray = new ServiceOperationParameter[parameters.Length];
for (int i = 0; i < parameterArray.Length; i++)
{
ParameterInfo info = parameters[i];
if (info.IsOut || info.IsRetval)
{
throw new InvalidOperationException(System.Data.Services.Strings.BaseServiceProvider_ParameterNotIn(method, info));
}
ResourceType parameterType = ResourceType.PrimitiveResourceTypeMap.GetPrimitive(info.ParameterType);
if (parameterType == null)
{
throw new InvalidOperationException(System.Data.Services.Strings.BaseServiceProvider_ParameterTypeNotSupported(method, info, info.ParameterType));
}
string name = info.Name ?? ("p" + i.ToString(CultureInfo.InvariantCulture));
parameterArray[i] = new ServiceOperationParameter(name, parameterType);
}
ResourceSet container = null;
if (((primitive != null) && (primitive.ResourceTypeKind == ResourceTypeKind.EntityType)) && !this.TryFindAnyContainerForType(primitive, out container))
{
throw new InvalidOperationException(System.Data.Services.Strings.BaseServiceProvider_ServiceOperationMissingSingleEntitySet(method, primitive.FullName));
}
ServiceOperation operation = new ServiceOperation(method.Name, @void, primitive, container, protocolMethod, parameterArray)
{
CustomState = method
};
MimeTypeAttribute mimeTypeAttribute = MimeTypeAttribute.GetMimeTypeAttribute(method);
if (mimeTypeAttribute != null)
{
operation.MimeType = mimeTypeAttribute.MimeType;
}
this.metadata.ServiceOperations.Add(method.Name, operation);
}
public bool TryResolveResourceSet(string name, out ResourceSet resourceSet)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
return(this.EntitySets.TryGetValue(name, out resourceSet));
}
protected abstract IQueryable GetResourceContainerInstance(ResourceSet resourceContainer);
private bool TryFindAnyContainerForType(ResourceType type, out ResourceSet container)
{
foreach (ResourceSet set in this.EntitySets.Values)
{
if (set.ResourceType.IsAssignableFrom(type))
{
container = set;
return true;
}
}
container = null;
return false;
}
/// <summary>Checks that the specified <paramref name="method"/> has a correct signature.</summary>
/// <param name="type">Service type.</param>
/// <param name="method">Method to check.</param>
/// <param name="container">Container associated with the interceptor.</param>
private static void CheckQueryInterceptorSignature(Type type, MethodInfo method, ResourceSet container)
{
Debug.Assert(type != null, "type != null");
Debug.Assert(method != null, "method != null");
Debug.Assert(container != null, "container != null");
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length != 0)
{
throw new InvalidOperationException(Strings.DataService_QueryInterceptorIncorrectParameterCount(method.Name, type.FullName, parameters.Length));
}
Type lambdaType = typeof(Func<,>).MakeGenericType(container.ResourceType.InstanceType, typeof(bool));
Type expectedReturnType = typeof(Expression<>).MakeGenericType(lambdaType);
Type returnType = method.ReturnType;
if (returnType == typeof(void))
{
throw new InvalidOperationException(Strings.DataService_AuthorizationMethodVoid(method.Name, type.FullName, expectedReturnType));
}
else if (!expectedReturnType.IsAssignableFrom(returnType))
{
Type nullableLambdaType = typeof(Func<,>).MakeGenericType(container.ResourceType.InstanceType, typeof(bool?));
if (!(typeof(Expression<>).MakeGenericType(nullableLambdaType).IsAssignableFrom(returnType)))
{
throw new InvalidOperationException(
Strings.DataService_AuthorizationReturnTypeNotAssignable(method.Name, type.FullName, returnType.FullName, expectedReturnType.FullName));
}
}
}
public bool TryResolveResourceSet(string name, out ResourceSet resourceSet)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
return this.EntitySets.TryGetValue(name, out resourceSet);
}
/// <summary>Adds a resource set to the metadata definition.</summary>
/// <param name="name">The name of the resource set to add.</param>
/// <param name="entityType">The type of entities in the resource set.</param>
/// <returns>The newly created resource set.</returns>
public ResourceSet AddResourceSet(string name, ResourceType entityType)
{
if (entityType.ResourceTypeKind != ResourceTypeKind.EntityType)
{
throw new ArgumentException("The resource type specified as the base type of a resource set is not an entity type.");
}
ResourceSet resourceSet = new ResourceSet(name, entityType);
entityType.GetAnnotation().ResourceSet = resourceSet;
this.resourceSets.Add(name, resourceSet);
return resourceSet;
}
/// <summary>Given the specified name, tries to find a resource set.</summary>
/// <param name="name">Name of the resource set to resolve.</param>
/// <param name="resourceSet">Returns the resolved resource set, null if no resource set for the given name was found.</param>
/// <returns>True if resource set with the given name was found, false otherwise.</returns>
public bool TryResolveResourceSet(string name, out ResourceSet resourceSet)
{
Debug.Assert(!string.IsNullOrEmpty(name), "!string.IsNullOrEmpty(name)");
return(this.EntitySets.TryGetValue(name, out resourceSet));
}
/// <summary>
/// Gets the ResourceAssociationSet instance when given the source association end.
/// </summary>
/// <param name="resourceSet">Resource set of the source association end.</param>
/// <param name="resourceType">Resource type of the source association end.</param>
/// <param name="resourceProperty">Resource property of the source association end.</param>
/// <returns>ResourceAssociationSet instance.</returns>
/// <remarks>This method returns a ResourceAssociationSet representing a reference which is specified
/// by the <paramref name="resourceProperty"/> on the <paramref name="resourceType"/> for instances in the <paramref name="resourceSet"/>.</remarks>
public ResourceAssociationSet GetResourceAssociationSet(ResourceSet resourceSet, ResourceType resourceType, ResourceProperty resourceProperty)
{
// We have the resource association set precreated on the property annotation, so no need to compute anything in here
ResourceAssociationSet resourceAssociationSet = resourceProperty.GetAnnotation().ResourceAssociationSet;
// Just few verification to show what is expected of the returned resource association set.
Debug.Assert(resourceAssociationSet.End1.ResourceSet == resourceSet, "The precreated resource association set doesn't match the specified resource set.");
Debug.Assert(resourceAssociationSet.End1.ResourceType == resourceType, "The precreated resource association set doesn't match the specified resource type.");
Debug.Assert(resourceAssociationSet.End1.ResourceProperty == resourceProperty, "The precreated resource association set doesn't match its resource property.");
return resourceAssociationSet;
}
/// <summary>
/// Returns the IQueryable that represents the container.
/// </summary>
/// <param name="container">resource set representing the entity set.</param>
/// <returns>
/// An IQueryable that represents the container; null if there is
/// no container for the specified name.
/// </returns>
public IQueryable GetQueryRootForResourceSet(ResourceSet container)
{
Debug.Assert(container != null, "resourceContainer != null");
return this.GetResourceContainerInstance(container);
}
/// <summary>Helper method to add a reference property.</summary>
/// <param name="resourceType">The resource type to add the property to.</param>
/// <param name="name">The name of the property to add.</param>
/// <param name="targetResourceSet">The resource set the resource reference property points to.</param>
/// <param name="resourceSetReference">true if the property should be a resource set reference, false if it should be resource reference.</param>
private void AddReferenceProperty(ResourceType resourceType, string name, ResourceSet targetResourceSet, bool resourceSetReference)
{
ResourceProperty property = new ResourceProperty(
name,
resourceSetReference ? ResourcePropertyKind.ResourceSetReference : ResourcePropertyKind.ResourceReference,
targetResourceSet.ResourceType);
property.CanReflectOnInstanceTypeProperty = false;
resourceType.AddProperty(property);
// We don't support type inheritance so the property can only point to the base resource type of the target resource set
// We also don't support MEST, that is having two resource sets with the same resource type, so we can determine
// the resource set from the resource type. That also means that the property can never point to different resource sets
// so we can precreate the ResourceAssociationSet for this property right here as we have all the information.
property.CustomState = new ResourcePropertyAnnotation()
{
ResourceAssociationSet = new ResourceAssociationSet(
resourceType.Name + "_" + name + "_" + targetResourceSet.Name,
new ResourceAssociationSetEnd(resourceType.GetAnnotation().ResourceSet, resourceType, property),
new ResourceAssociationSetEnd(targetResourceSet, targetResourceSet.ResourceType, null))
};
}
/// <summary> /// Creates the object query for the given resource set and returns it /// </summary> /// <param name="resourceContainer">resource set for which IQueryable instance needs to be created</param> /// <returns>returns the IQueryable instance for the given resource set</returns> protected abstract IQueryable GetResourceContainerInstance(ResourceSet resourceContainer);
private void PopulateMetadataFromCollection(MongoContext context, string collectionName, ResourceSet resourceSet)
{
var collection = context.Database.GetCollection<BsonDocument>(collectionName);
const string naturalSort = "$natural";
var sortBuilder = Builders<BsonDocument>.Sort;
var sort = this.Configuration.FetchPosition == MongoConfiguration.FetchPosition.End
? sortBuilder.Descending(naturalSort)
: sortBuilder.Ascending(naturalSort);
var documents = collection.Find(new BsonDocument()).Sort(sort).ToListAsync().GetAwaiter().GetResult();
int rowCount = 0;
foreach (var document in documents)
{
if (resourceSet == null)
{
resourceSet = AddResourceSet(context, collectionName, document);
}
else
{
UpdateResourceSet(context, resourceSet, document);
}
++rowCount;
if (this.Configuration.PrefetchRows >= 0 && rowCount >= this.Configuration.PrefetchRows)
break;
}
}
private static void CheckQueryInterceptorSignature(Type type, MethodInfo method, ResourceSet container)
{
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length != 0)
{
throw new InvalidOperationException(System.Data.Services.Strings.DataService_QueryInterceptorIncorrectParameterCount(method.Name, type.FullName, parameters.Length));
}
Type type2 = typeof(Func<,>).MakeGenericType(new Type[] { container.ResourceType.InstanceType, typeof(bool) });
Type type3 = typeof(Expression<>).MakeGenericType(new Type[] { type2 });
Type returnType = method.ReturnType;
if (returnType == typeof(void))
{
throw new InvalidOperationException(System.Data.Services.Strings.DataService_AuthorizationMethodVoid(method.Name, type.FullName, type3));
}
if (!type3.IsAssignableFrom(returnType))
{
Type type5 = typeof(Func<,>).MakeGenericType(new Type[] { container.ResourceType.InstanceType, typeof(bool?) });
if (!typeof(Expression<>).MakeGenericType(new Type[] { type5 }).IsAssignableFrom(returnType))
{
throw new InvalidOperationException(System.Data.Services.Strings.DataService_AuthorizationReturnTypeNotAssignable(method.Name, type.FullName, returnType.FullName, type3.FullName));
}
}
}
public IQueryable GetQueryRootForResourceSet(ResourceSet container)
{
WebUtil.CheckArgumentNull <ResourceSet>(container, "container");
return(this.GetResourceContainerInstance(container));
}
/// <summary>Adds a resource set reference property to the specified <paramref name="resourceType"/>.</summary>
/// <param name="resourceType">The resource type to add the property to.</param>
/// <param name="name">The name of the property to add.</param>
/// <param name="targetResourceSet">The resource set the resource reference property points to.</param>
/// <remarks>This creates a property pointing to multiple resources in the target resource set.</remarks>
public void AddResourceSetReferenceProperty(ResourceType resourceType, string name, ResourceSet targetResourceSet)
{
AddReferenceProperty(resourceType, name, targetResourceSet, true);
}
internal int GetResourceSetPageSize(ResourceSet container)
{
int defaultPageSize;
if (!this.pageSizes.TryGetValue(container.Name, out defaultPageSize))
{
defaultPageSize = this.defaultPageSize;
}
return defaultPageSize;
}
/// <summary>Returnes a resource set specified by its name.</summary>
/// <param name="name">The name of the resource set find.</param>
/// <param name="resourceSet">The resource set instance found.</param>
/// <returns>true if the resource set was found or false otherwise.</returns>
/// <remarks>The implementation of this method should be very fast as it will get called for almost every request. It should also be fast
/// for non-existing resource sets to avoid possible DoS attacks on the service.</remarks>
public bool TryResolveResourceSet(string name, out ResourceSet resourceSet)
{
return this.resourceSets.TryGetValue(name, out resourceSet); ;
}
internal EntitySetRights GetResourceSetRights(ResourceSet container)
{
EntitySetRights rightsForUnspecifiedResourceContainer;
if (!this.resourceRights.TryGetValue(container.Name, out rightsForUnspecifiedResourceContainer))
{
rightsForUnspecifiedResourceContainer = this.rightsForUnspecifiedResourceContainer;
}
return rightsForUnspecifiedResourceContainer;
}
/// <summary>Returns a query which can be used to retrive resource from the specified resource set.</summary>
/// <param name="resourceSet">The resource set to get the quqeyr for.</param>
/// <returns>An <see cref="IQueryable"/> which will be used to get resources from the specified resource set.</returns>
/// <remarks>The data service will use the LINQ to build the actual query required for the resource set. It's up to this provider
/// to return an <see cref="IQueryable"/> which can handle such queries. If the resource set is not recognized by the provider it should return null.</remarks>
public virtual IQueryable GetQueryRootForResourceSet(ResourceSet resourceSet)
{
return DSPLinqQueryProvider.CreateQuery(_dataSource.GetQueryable(resourceSet.Name), _expressionVisitor);
}
internal MethodInfo[] GetWriteAuthorizationMethods(ResourceSet resourceSet)
{
List<MethodInfo> list;
if (this.writeAuthorizationMethods.TryGetValue(resourceSet.Name, out list))
{
return list.ToArray();
}
return null;
}
private void UpdateResourceSet(MongoContext context, ResourceSet resourceSet, BsonDocument document)
{
foreach (var element in document.Elements)
{
RegisterDocumentProperty(context, resourceSet.ResourceType, element);
}
}
public IQueryable GetQueryRootForResourceSet(ResourceSet container)
{
WebUtil.CheckArgumentNull<ResourceSet>(container, "container");
return this.GetResourceContainerInstance(container);
}
internal IEdmEntitySet FindEntitySet(ResourceSet resourceSet)
{
string name = resourceSet.EntityContainerName ?? this.metadataProvider.ContainerName;
return this.FindExistingEntityContainer(name).FindEntitySet(MetadataProviderUtils.GetEntitySetName(resourceSet));
}
public ServiceOperation(string name, ServiceOperationResultKind resultKind, ResourceType resultType, ResourceSet resultSet, string method, IEnumerable <ServiceOperationParameter> parameters)
{
throw new NotImplementedException();
}