/// <summary>Registers a data type with the data service runtime so that it can be used by a custom data service provider.</summary>
/// <param name="typeName">The namespace-qualified name of the type that is enabled for use with the custom data service provider.</param>
/// <remarks>
/// This method is used to register a type with the Astoria runtime which may be returned in the �open properties� of
/// an open type such that the type is visible in $metadata output and usable with CRUD operations.
///
/// The typename parameter must be a namespace qualified type name (format: <namespace>.<typename>).
/// The name provided must be as it would show up in a CSDL document (ie. model types, not CLR types)
///
/// The types registered via calls to EnableAccess will be additive to those implicitly made accessible via
/// DSC.SetEntitySetAccessRule(�) invocations
/// � Note: The Astoria runtime layer won�t be able to determine if a typename specified maps to an Entity Type,
/// Complex Type, etc until it actually obtains type info (entity types, complex types, etc) from the underlying provider
/// � �*� can be used as the value of �typename�, which will be interpreted as matching all types
///
/// When Astoria enumerates types or needs to obtain a type (Complex Types, Entity Types) from the underlying provider
/// it will first determine if the type should be visible (show in $metadata and accessible via operations exposed by the
/// service) as per the standard v1 checks (ie. driven by SetEntitySetAccessRule calls). If the type is not visible via V1
/// rules, then we consult the set of types registered via EnableAccess(<typename>) invocations. If the type was
/// included in such a call then the type is visible via $metadata and can be accessed via CRUD ops, etc.
///
/// If a type is not made visible via one of the mechanisms above, then:
/// � That type must not be included a response to a $metadata request
/// � Instances of the type must not be returned to the client as the response of a request to the data service.
/// If such a type instance would be required the service MUST fail the request. Failure semantics are covered
/// in the area of the specification which covers request/response semantics with respect to open types.
///
/// Invoking this method multiple times with the same type name is allowed and considered a �NO OP�.
/// </remarks>
public void EnableTypeAccess(string typeName)
{
WebUtil.CheckStringArgumentNullOrEmpty(typeName, "typeName");
this.CheckNotSealed();
if (typeName == "*")
{
this.accessEnabledForAllResourceTypes = true;
}
else
{
ResourceType resourceType;
if (!this.provider.TryResolveResourceType(typeName, out resourceType) || resourceType == null)
{
throw new ArgumentException(Strings.DataServiceConfiguration_ResourceTypeNameNotFound(typeName), "typeName");
}
if (resourceType.ResourceTypeKind != ResourceTypeKind.ComplexType)
{
throw new ArgumentException(Strings.DataServiceConfiguration_NotComplexType(typeName), "typeName");
}
Debug.Assert(resourceType.FullName == typeName, "resourceType.FullName == typeName");
this.accessEnabledResourceTypes.Add(typeName);
}
}
/// <summary>
/// Initializes a new instance of <see cref="ServiceActionResolverArgs"/>.
/// </summary>
/// <param name="serviceActionName"> The service action name taken from the URI.</param>
/// <param name="bindingType">The binding type based on interpreting the URI preceeding the action, or null if the action is being invoked from the root of the service.</param>
public ServiceActionResolverArgs(string serviceActionName, ResourceType bindingType)
{
WebUtil.CheckStringArgumentNullOrEmpty(serviceActionName, "serviceActionName");
this.ServiceActionName = serviceActionName;
// binding type is explicitly allowed to be null.
this.BindingType = bindingType;
}
public ResourceProperty(string name, ResourcePropertyKind kind, System.Data.Services.Providers.ResourceType propertyResourceType)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
WebUtil.CheckArgumentNull <System.Data.Services.Providers.ResourceType>(propertyResourceType, "propertyResourceType");
ValidatePropertyParameters(kind, propertyResourceType);
this.kind = kind;
this.name = name;
this.propertyResourceType = propertyResourceType;
this.canReflectOnInstanceTypeProperty = !kind.HasFlag(ResourcePropertyKind.Stream);
}
public IEdmEntitySet FindEntitySet(string name)
{
IEdmEntitySet set;
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
if (!this.entitySetCache.TryGetValue(name, out set))
{
return(null);
}
return(set);
}
protected internal OperationParameter(string name, ResourceType parameterType)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
WebUtil.CheckArgumentNull <ResourceType>(parameterType, "parameterType");
if ((parameterType.ResourceTypeKind == ResourceTypeKind.Primitive) && (parameterType == ResourceType.GetPrimitiveResourceType(typeof(Stream))))
{
throw new ArgumentException(Strings.ServiceOperationParameter_TypeNotSupported(name, parameterType.FullName), "parameterType");
}
this.name = name;
this.type = parameterType;
}
public IEnumerable <IEdmFunctionImport> FindFunctionImports(string name)
{
List <MetadataProviderEdmFunctionImport> list;
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
if (!this.functionImportCache.TryGetValue(name, out list))
{
return(Enumerable.Empty <IEdmFunctionImport>());
}
return((IEnumerable <IEdmFunctionImport>)list.AsReadOnly());
}
public ResourceSet(string name, System.Data.Services.Providers.ResourceType elementType)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
WebUtil.CheckArgumentNull <System.Data.Services.Providers.ResourceType>(elementType, "elementType");
if (elementType.ResourceTypeKind != ResourceTypeKind.EntityType)
{
throw new ArgumentException(System.Data.Services.Strings.ResourceContainer_ContainerMustBeAssociatedWithEntityType);
}
this.name = name;
this.elementType = elementType;
this.queryRootType = typeof(IQueryable <>).MakeGenericType(new Type[] { elementType.InstanceType });
}
public bool TryResolveResourceType(string name, out ResourceType resourceType)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
foreach (ResourceType type in this.TypeCache.Values)
{
if (type.FullName == name)
{
resourceType = type;
return(true);
}
}
resourceType = null;
return(false);
}
/// <summary>
/// Searches for an entity set with the given name in this entity container and returns null if no such set exists.
/// </summary>
/// <param name="name">The name of the element being found.</param>
/// <returns>The requested entity set, or null if the entity set does not exist.</returns>
/// <remarks>
/// Cache state: EntityContainers required. We only support looking up entity sets once
/// all entity containers have been completely populated and cached.
/// </remarks>
public IEdmEntitySet FindEntitySet(string name)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
// NOTE: for the query parser we might want to allow incremental lookup
// of entity sets in the future.
IEdmEntitySet entitySet;
if (this.entitySetCache.TryGetValue(name, out entitySet))
{
return(entitySet);
}
return(this.LazyLoadEntitySet(name));
}
/// <summary>
/// Searches for operation imports with the given name in this entity container and returns an empty enumerable
/// if no such operation import exists.
/// </summary>
/// <param name="operationName">The name of the operation import being found.</param>
/// <returns>A group of the requested operation imports, or an empty enumerable if no such operation import exists.</returns>
/// <remarks>
/// Cache state: EntityContainers required. We only support looking up an operation imports once
/// all entity containers have been completely populated and cached.
/// </remarks>
public IEnumerable <IEdmOperationImport> FindOperationImports(string operationName)
{
WebUtil.CheckStringArgumentNullOrEmpty(operationName, "operationName");
List <IEdmOperationImport> operationImports;
// NOTE: for the query parser we might want to allow incremental lookup
// of operation imports in the future.
if (this.operationImportCache.TryGetValue(operationName, out operationImports))
{
return(operationImports.AsReadOnly());
}
return(this.LazyLoadServiceOperationImports(operationName));
}
/// <summary>Initializes a new <see cref="T:Microsoft.OData.Service.Providers.ResourceProperty" /> for an open property.</summary>
/// <param name="name">Property name for the property as string.</param>
/// <param name="kind">
/// <see cref="T:Microsoft.OData.Service.Providers.ResourcePropertyKind" />.</param>
/// <param name="propertyResourceType">The <see cref="T:Microsoft.OData.Service.Providers.ResourceType" /> of the resource to which the property refers.</param>
public ResourceProperty(
string name,
ResourcePropertyKind kind,
ResourceType propertyResourceType)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
WebUtil.CheckArgumentNull(propertyResourceType, "propertyResourceType");
ValidatePropertyParameters(kind, propertyResourceType);
this.kind = kind;
this.name = name;
this.propertyResourceType = propertyResourceType;
this.canReflectOnInstanceTypeProperty = kind.HasFlag(ResourcePropertyKind.Stream) ? false : true;
}
/// <summary>Given the specified name, tries to find a type.</summary>
/// <param name="name">Name of the type to resolve.</param>
/// <param name="resourceType">Returns the resolved resource type, null if no resource type for the given name was found.</param>
/// <returns>True if we found the resource type for the given name, false otherwise.</returns>
public virtual bool TryResolveResourceType(string name, out ResourceType resourceType)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
Debug.Assert(this.metadata != null, "this.metadata != null");
foreach (var cacheItem in this.metadata.ResourceTypeCacheItems)
{
if (cacheItem.ResourceType.FullName == name)
{
resourceType = cacheItem.ResourceType;
return(true);
}
}
resourceType = null;
return(false);
}
public ResourceAssociationSet(string name, ResourceAssociationSetEnd end1, ResourceAssociationSetEnd end2)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
WebUtil.CheckArgumentNull <ResourceAssociationSetEnd>(end1, "end1");
WebUtil.CheckArgumentNull <ResourceAssociationSetEnd>(end2, "end2");
if ((end1.ResourceProperty == null) && (end2.ResourceProperty == null))
{
throw new ArgumentException(Strings.ResourceAssociationSet_ResourcePropertyCannotBeBothNull);
}
if ((end1.ResourceType == end2.ResourceType) && (end1.ResourceProperty == end2.ResourceProperty))
{
throw new ArgumentException(Strings.ResourceAssociationSet_SelfReferencingAssociationCannotBeBiDirectional);
}
this.name = name;
this.end1 = end1;
this.end2 = end2;
}
/// <summary>Sets the permissions for the specified service action.</summary>
/// <param name="name">The name of the service action for which to set permissions.</param>
/// <param name="rights">The access rights to be granted to this action, passed as a <see cref="T:Microsoft.OData.Service.ServiceActionRights" /> value.</param>
public void SetServiceActionAccessRule(string name, ServiceActionRights rights)
{
this.CheckNotSealed();
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
WebUtil.CheckServiceActionRights(rights, "rights");
if (name == "*")
{
this.rightsForUnspecifiedServiceAction = rights;
}
else
{
// We initialize the service configuration before the action provider can be
// loaded. We will not validate the service action names to make sure they
// actually exist in the action provider.
this.serviceActionRights[name] = rights;
}
}
public ResourceType(Type instanceType, System.Data.Services.Providers.ResourceTypeKind resourceTypeKind, ResourceType baseType, string namespaceName, string name, bool isAbstract) : this(instanceType, baseType, namespaceName, name, isAbstract)
{
WebUtil.CheckArgumentNull <Type>(instanceType, "instanceType");
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
WebUtil.CheckResourceTypeKind(resourceTypeKind, "resourceTypeKind");
if (((resourceTypeKind == System.Data.Services.Providers.ResourceTypeKind.Primitive) || (resourceTypeKind == System.Data.Services.Providers.ResourceTypeKind.Collection)) || (resourceTypeKind == System.Data.Services.Providers.ResourceTypeKind.EntityCollection))
{
throw new ArgumentException(System.Data.Services.Strings.ResourceType_InvalidValueForResourceTypeKind("resourceTypeKind"), "resourceTypeKind");
}
if ((baseType != null) && (baseType.ResourceTypeKind != resourceTypeKind))
{
throw new ArgumentException(System.Data.Services.Strings.ResourceType_InvalidResourceTypeKindInheritance(resourceTypeKind.ToString(), baseType.ResourceTypeKind.ToString()), "resourceTypeKind");
}
if (instanceType.IsValueType)
{
throw new ArgumentException(System.Data.Services.Strings.ResourceType_TypeCannotBeValueType, "instanceType");
}
this.resourceTypeKind = resourceTypeKind;
}
public IEdmSchemaType FindDeclaredType(string qualifiedName)
{
IEdmSchemaType type;
WebUtil.CheckStringArgumentNullOrEmpty(qualifiedName, "qualifiedName");
if (this.schemaTypeCache.TryGetValue(qualifiedName, out type))
{
return(type);
}
if (this.coreModel.FindDeclaredType(qualifiedName) == null)
{
if (this.cacheState == MetadataProviderState.Full)
{
return(null);
}
ResourceType resourceType = this.metadataProvider.TryResolveResourceType(qualifiedName);
if (resourceType != null)
{
return(this.EnsureSchemaType(resourceType));
}
}
return(null);
}
internal Operation(string name, ServiceOperationResultKind resultKind, ResourceType returnType, System.Data.Services.Providers.ResourceSet resultSet, ResourceSetPathExpression resultSetPathExpression, string method, IEnumerable <OperationParameter> parameters, System.Data.Services.Providers.OperationParameterBindingKind operationParameterBindingKind, OperationKind kind)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
WebUtil.CheckServiceOperationResultKind(resultKind, "resultKind");
WebUtil.CheckStringArgumentNullOrEmpty(method, "method");
ValidateConstructorArguments(name, returnType, resultSet, resultSetPathExpression, method, operationParameterBindingKind, kind);
this.name = name;
this.resultKind = resultKind;
this.returnType = returnType;
this.resourceSet = resultSet;
this.resultSetPathExpression = resultSetPathExpression;
this.method = method;
this.kind = kind;
this.operationParameterBindingKind = operationParameterBindingKind;
this.operationParameters = ValidateParameters(this.operationParameterBindingKind, parameters);
if (this.operationParameterBindingKind != System.Data.Services.Providers.OperationParameterBindingKind.Never)
{
this.bindingParameter = this.operationParameters.FirstOrDefault <OperationParameter>();
if (this.bindingParameter == null)
{
throw new ArgumentException(System.Data.Services.Strings.ServiceOperation_BindableOperationMustHaveAtLeastOneParameter, "operationParameterBindingKind");
}
if (((resultSetPathExpression != null) && (this.bindingParameter.ParameterType.ResourceTypeKind != ResourceTypeKind.EntityType)) && (this.bindingParameter.ParameterType.ResourceTypeKind != ResourceTypeKind.EntityCollection))
{
throw new ArgumentException(System.Data.Services.Strings.ServiceOperation_BindingParameterMustBeEntityToUsePathExpression("resultSetPathExpression"));
}
if (((this.kind == OperationKind.Action) && (this.bindingParameter.ParameterType.ResourceTypeKind != ResourceTypeKind.EntityType)) && (this.bindingParameter.ParameterType.ResourceTypeKind != ResourceTypeKind.EntityCollection))
{
throw new ArgumentException(System.Data.Services.Strings.ServiceOperation_ActionBindingMustBeEntityOrEntityCollection, "parameters");
}
if (this.resultSetPathExpression != null)
{
this.resultSetPathExpression.SetBindingParameter(this.bindingParameter);
}
}
}
/// <summary>
/// Initializes a new <see cref="Operation"/> instance.
/// </summary>
/// <param name="name">name of the operation.</param>
/// <param name="resultKind">Kind of result expected from this operation.</param>
/// <param name="returnType">Return type of the operation.</param>
/// <param name="resultSet">EntitySet of the result expected from this operation, must be null if <paramref name="resultSetPathExpression"/> is not null.</param>
/// <param name="resultSetPathExpression">Path expression to calculate the result set of the operation, must be null if <paramref name="resultSet"/> is not null.</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>
/// <param name="operationParameterBindingKind">the kind of the operation parameter binding (Never, Sometimes, Always).</param>
/// <param name="kind">The kind of the current service operation.</param>
internal Operation(
string name,
ServiceOperationResultKind resultKind,
ResourceType returnType,
ResourceSet resultSet,
ResourceSetPathExpression resultSetPathExpression,
string method,
IEnumerable <OperationParameter> parameters,
OperationParameterBindingKind operationParameterBindingKind,
OperationKind kind)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
WebUtil.CheckServiceOperationResultKind(resultKind, "resultKind");
WebUtil.CheckStringArgumentNullOrEmpty(method, "method");
Debug.Assert(
this.GetType() == typeof(ServiceOperation) && kind == OperationKind.ServiceOperation ||
this.GetType() == typeof(ServiceAction) && kind == OperationKind.Action,
"OperationKind and the current type doesn't match.");
ValidateConstructorArguments(name, returnType, resultSet, resultSetPathExpression, method, operationParameterBindingKind, kind);
this.name = name;
this.resultKind = resultKind;
this.returnType = returnType;
this.resourceSet = resultSet;
this.resultSetPathExpression = resultSetPathExpression;
this.method = method;
this.kind = kind;
this.operationParameterBindingKind = operationParameterBindingKind;
this.operationParameters = Operation.ValidateParameters(this.operationParameterBindingKind, parameters);
if (this.operationParameterBindingKind != OperationParameterBindingKind.Never)
{
Debug.Assert(
this.operationParameterBindingKind == OperationParameterBindingKind.Always || this.operationParameterBindingKind == OperationParameterBindingKind.Sometimes,
"Value of operationParameterBindingKind was expected to be 'always' or 'sometimes'.");
Debug.Assert(this.kind != OperationKind.ServiceOperation, "ServiceOperations should never be bindable.");
this.bindingParameter = this.operationParameters.FirstOrDefault();
if (this.bindingParameter == null)
{
throw new ArgumentException(Strings.ServiceOperation_BindableOperationMustHaveAtLeastOneParameter, "operationParameterBindingKind");
}
if (resourceSet != null)
{
throw new ArgumentException(Strings.Opereration_BoundOperationsMustNotSpecifyEntitySetOnlyEntitySetPath(this.name), "resourceSet");
}
if (resultSetPathExpression != null &&
this.bindingParameter.ParameterType.ResourceTypeKind != ResourceTypeKind.EntityType &&
this.bindingParameter.ParameterType.ResourceTypeKind != ResourceTypeKind.EntityCollection)
{
throw new ArgumentException(Strings.ServiceOperation_BindingParameterMustBeEntityToUsePathExpression("resultSetPathExpression"));
}
if (this.kind == OperationKind.Action &&
!(this.bindingParameter.ParameterType.ResourceTypeKind == ResourceTypeKind.EntityType ||
this.bindingParameter.ParameterType.ResourceTypeKind == ResourceTypeKind.EntityCollection))
{
throw new ArgumentException(Strings.ServiceOperation_ActionBindingMustBeEntityOrEntityCollection, "parameters");
}
if (this.resultSetPathExpression != null)
{
this.resultSetPathExpression.SetBindingParameter(this.bindingParameter);
}
}
Debug.Assert(this.kind != OperationKind.Action || string.CompareOrdinal(XmlConstants.HttpMethodPost, this.method) == 0, "HttpMethod must be POST for Actions.");
Debug.Assert(this.resourceSet == null || this.resultSetPathExpression == null, "'resultSet' and 'resultSetPathExpression' cannot be both set by the constructor.");
}
public bool TryResolveResourceSet(string name, out ResourceSet resourceSet)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
return(this.EntitySets.TryGetValue(name, out resourceSet));
}
public bool TryResolveServiceOperation(string name, out ServiceOperation serviceOperation)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
return(this.metadata.ServiceOperations.TryGetValue(name, out serviceOperation));
}
public IEdmEntityContainer FindDeclaredEntityContainer(string name)
{
WebUtil.CheckStringArgumentNullOrEmpty(name, "name");
this.RunInState(new Action(this.EnsureEntityContainers), MetadataProviderState.EntityContainers);
return(this.FindExistingEntityContainer(name));
}
/// <summary> Creates a new instance of the <see cref="T:Microsoft.OData.Service.Providers.ResourceSetPathExpression" /> class. </summary>
/// <param name="pathExpression">Path expression to calculate the target resource set of a function or procedure.</param>
/// <remarks>The <paramref name="pathExpression"/> must start with the binding parameter name followed by navigation properties that are separated by "/".
/// For example, if the binding parameter is customer, a valid path can be "customer/Orders/OrderDetails".</remarks>
public ResourceSetPathExpression(string pathExpression)
{
WebUtil.CheckStringArgumentNullOrEmpty(pathExpression, "pathExpression");
this.pathExpression = pathExpression;
}
