/// <summary>
 /// Initializes a new instance of the TestDataServiceInvokable class
 /// </summary>
 /// <param name="dataServiceInstance">Data Service Instance</param>
 /// <param name="dataServiceOperationContext">Data Service Operation Context</param>
 /// <param name="serviceAction">Service Action</param>
 /// <param name="parameters">Parameters to use</param>
 public TestDataServiceInvokable(object dataServiceInstance, DataServiceOperationContext dataServiceOperationContext, ServiceAction serviceAction, object[] parameters)
 {
     this.dataServiceOperationContext = dataServiceOperationContext;
     this.dataServiceInstance = dataServiceInstance;
     this.serviceAction = serviceAction;
     this.parameters = parameters;
 }
 public void GetQueryStringItemAsksHost()
 {
     var host = new DataServiceHost2Simulator();
     host.SetQueryStringItem("some-key", "test-value");
     DataServiceOperationContext context = new DataServiceOperationContext(host);
     context.GetQueryStringValue("some-key").Should().Be("test-value");
 }
 /// <summary>
 /// Creates a new instance of DataServiceODataWriterEntryArgs
 /// </summary>
 /// <param name="entry">ODataEntry instance.</param>
 /// <param name="entityInstance">Entity instance that is getting serialized.</param>
 /// <param name="operationContext">DataServiceOperationContext instance.</param>
 public DataServiceODataWriterEntryArgs(ODataEntry entry, object entityInstance, DataServiceOperationContext operationContext)
 {
     Debug.Assert(operationContext != null, "operationContext != null");
     this.Entry = entry;
     this.Instance = entityInstance;
     this.OperationContext = operationContext;
 }
 /// <summary>
 /// Creates a new instance of DataServiceODataWriterNavigationLinkArgs.
 /// </summary>
 /// <param name="navigationLink">Instance of ODataNavigationLink.</param>
 /// <param name="operationContext">Instance of DataServiceOperationContext.</param>
 public DataServiceODataWriterNavigationLinkArgs(
     ODataNavigationLink navigationLink,
     DataServiceOperationContext operationContext)
 {
     WebUtil.CheckArgumentNull(navigationLink, "navigationLink != null");
     Debug.Assert(operationContext != null, "navigationLink != null");
     this.NavigationLink   = navigationLink;
     this.OperationContext = operationContext;
 }
        public bool TryResolveServiceAction(DataServiceOperationContext operationContext, string serviceActionName, out ServiceAction serviceAction)
        {
            if (this.TryResolveServiceActionCallback != null)
            {
                return this.TryResolveServiceActionCallback(operationContext, serviceActionName, out serviceAction);
            }

            throw new NotImplementedException();
        }
 /// <summary>
 /// Creates a new instance of DataServiceODataWriterFeedArgs
 /// </summary>
 /// <param name="feed">ODataFeed instance.</param>
 /// <param name="results">IEnumerable instance that is getting serialized.</param>
 /// <param name="operationContext">DataServiceOperationContext instance.</param>
 public DataServiceODataWriterFeedArgs(ODataFeed feed, IEnumerable results, DataServiceOperationContext operationContext)
 {
     WebUtil.CheckArgumentNull(feed, "feed");
     Debug.Assert(results != null, "results != null");
     Debug.Assert(operationContext != null, "operationContext != null");
     this.Feed             = feed;
     this.Results          = results;
     this.OperationContext = operationContext;
 }
 /// <summary>
 /// Creates a new instance of DataServiceODataWriterNavigationLinkArgs.
 /// </summary>
 /// <param name="navigationLink">Instance of ODataNavigationLink.</param>
 /// <param name="operationContext">Instance of DataServiceOperationContext.</param>
 public DataServiceODataWriterNavigationLinkArgs(
     ODataNavigationLink navigationLink,
     DataServiceOperationContext operationContext)
 {
     WebUtil.CheckArgumentNull(navigationLink, "navigationLink != null");
     Debug.Assert(operationContext != null, "navigationLink != null");
     this.NavigationLink = navigationLink;
     this.OperationContext = operationContext;
 }
        /// <summary>
        /// Builds up an instance oz <see cref="IDataServiceInvokable"/> for the given <paramref name="serviceAction"/> with the provided <paramref name="parameterTokens"/>.
        /// </summary>
        /// <param name="operationContext">The data service operation context instance.</param>
        /// <param name="serviceAction">The service action to invoke.</param>
        /// <param name="parameterTokens">The parameter tokens required to invoke the service action.</param>
        /// <returns>An instance of <see cref="IDataServiceInvokable"/> to invoke the action with.</returns>
        public IDataServiceInvokable CreateInvokable(DataServiceOperationContext operationContext, ServiceAction serviceAction, object[] parameterTokens)
        {
            if (DataServiceOverrides.ActionProvider.CreateInvokableFunc != null)
            {
                return DataServiceOverrides.ActionProvider.CreateInvokableFunc(operationContext, serviceAction, parameterTokens);
            }

            return new TestDataServiceInvokable(this.dataServiceInstance, operationContext, serviceAction, parameterTokens);
        }
        /// <summary>
        /// Returns all service actions in the provider.
        /// </summary>
        /// <param name="operationContext">operation Context</param>
        /// <returns>An enumeration of all service actions.</returns>
        public IEnumerable<ServiceAction> GetServiceActions(DataServiceOperationContext operationContext)
        {
            if (DataServiceOverrides.ActionProvider.GetServiceActionsFunc != null)
            {
                return DataServiceOverrides.ActionProvider.GetServiceActionsFunc(operationContext);
            }

            return this.GetServiceActionsInternal(operationContext);
        }
 /// <summary>
 /// Creates a new instance of DataServiceODataWriterFeedArgs
 /// </summary>
 /// <param name="feed">ODataFeed instance.</param>
 /// <param name="results">IEnumerable instance that is getting serialized.</param>
 /// <param name="operationContext">DataServiceOperationContext instance.</param>
 public DataServiceODataWriterFeedArgs(ODataFeed feed, IEnumerable results, DataServiceOperationContext operationContext)
 {
     WebUtil.CheckArgumentNull(feed, "feed");
     Debug.Assert(results != null, "results != null");
     Debug.Assert(operationContext != null, "operationContext != null");
     this.Feed = feed;
     this.Results = results;
     this.OperationContext = operationContext;
 }
Example #11
0
        public IEnumerable<ServiceAction> GetServiceActionsByBindingParameterType(DataServiceOperationContext operationContext, ResourceType bindingParameterType)
        {
            if (this.GetByBindingTypeCallback != null)
            {
                return this.GetByBindingTypeCallback(operationContext, bindingParameterType);
            }

            throw new NotImplementedException();
        }
Example #12
0
        public IEnumerable<ServiceAction> GetServiceActions(DataServiceOperationContext operationContext)
        {
            if (this.GetServiceActionsCallback != null)
            {
                return this.GetServiceActionsCallback(operationContext);
            }

            throw new NotImplementedException();
        }
Example #13
0
 public string ResolveType(string entitySetName, DataServiceOperationContext operationContext)
 {
     if (entitySetName == "CustomerBlobs")
     {
         return typeof(CustomerBlob).Name;
     }
     else
     {
         throw new ArgumentException("Unrecognized entity set name", "entitySetName");
     }
 }
        /// <summary>
        /// Tries to find the <see cref="ServiceAction"/> for the given <paramref name="sericeActionName"/>.
        /// </summary>
        /// <param name="operationContext">operation Context</param>
        /// <param name="serviceActionName">The name of the service action to resolve.</param>
        /// <param name="serviceAction">Returns the service action instance if the resolution is successful; null otherwise.</param>
        /// <returns>true if the resolution is successful; false otherwise.</returns>
        public bool TryResolveServiceAction(DataServiceOperationContext operationContext, string serviceActionName, out ServiceAction serviceAction)
        {
            if (DataServiceOverrides.ActionProvider.TryResolveServiceActionFunc != null)
            {
                DataServiceOverrides.ActionProvider.TryResolveServiceActionFunc(operationContext, serviceActionName);
                serviceAction = DataServiceOverrides.ActionProvider.OutServiceActionTryResolveServiceActionFunc();

                return DataServiceOverrides.ActionProvider.OutReturnTryResolveServiceActionFunc();
            }

            serviceAction = this.GetServiceActionsInternal(operationContext).SingleOrDefault(sa => sa.Name == serviceActionName);

            return serviceAction != null;
        }
        internal void AssertDebugStateDuringRequestProcessing(DataServiceOperationContext operationContext)
        {
#if DEBUG
            // If the current request encounters an exception, there is no guarantee that all the
            // events will be fired, we skip the debug asserts when that happens.
            if (!this.SkipDebugAssert)
            {
                Debug.Assert(!this.HasDisposedProviderInterfaces, "!this.HasDisposedProviderInterfaces");
                Debug.Assert(this.OnStartProcessingRequestInvokeCount > 0, "this.OnStartProcessingRequestInvokeCount > 0");
                Debug.Assert(this.ProcessingRequestInvokeCount == 1, "this.ProcessingRequestInvokeCount == 1");
                Debug.Assert(this.ProcessedRequestInvokeCount == 0, "this.ProcessedRequestInvokeCount == 0");
                Debug.Assert(
                    (this.ProcessingChangesetInvokeCount == 0) ||
                    (this.ProcessingChangesetInvokeCount == 1 && operationContext.RequestMessage.HttpVerb.IsChange()),
                    "ProcessingChangesetInvokeCount must be 1 during a CUD request.");
            }
#endif
        }
        public bool TryResolveServiceAction(DataServiceOperationContext context, ServiceActionResolverArgs resolverArgs, out ServiceAction serviceAction)
        {
            string actionName = resolverArgs.ServiceActionName;
            IEnumerable<ServiceAction> possibleMatches = this.GetServiceActions(context).Where(a => a.Name == actionName);
            if (possibleMatches.Count() == 1)
            {
                serviceAction = possibleMatches.Single();
            }
            else if (resolverArgs.BindingType == null)
            {
                // unbound action
                serviceAction = possibleMatches.SingleOrDefault(a => a.BindingParameter == null);
            }
            else
            {
                serviceAction = possibleMatches.SingleOrDefault(a => a.BindingParameter != null && a.BindingParameter.ParameterType.FullName == resolverArgs.BindingType.FullName);
            }

            return serviceAction != null;
        }
        public void Initialize()
        {
            this.host = new DataServiceHost2Simulator();

            var context = new DataServiceOperationContext(this.host);
            this.dataServiceSimulator = new DataServiceSimulator { OperationContext = context };

            var providerSimulator = new DataServiceProviderSimulator();

            DataServiceStaticConfiguration staticConfiguration = new DataServiceStaticConfiguration(this.dataServiceSimulator.Instance.GetType(), providerSimulator);
            IDataServiceProviderBehavior providerBehavior = DataServiceProviderBehavior.CustomDataServiceProviderBehavior;

            var resourceType = new ResourceType(typeof(object), ResourceTypeKind.EntityType, null, "SelectTestNamespace", "Fake", false) { CanReflectOnInstanceType = false, IsOpenType = true };
            resourceType.AddProperty(new ResourceProperty("Id", ResourcePropertyKind.Key | ResourcePropertyKind.Primitive, ResourceType.GetPrimitiveResourceType(typeof(int))) { CanReflectOnInstanceTypeProperty = false });
            var resourceSet = new ResourceSet("FakeSet", resourceType);
            resourceSet.SetReadOnly();

            providerSimulator.AddResourceSet(resourceSet);

            var configuration = new DataServiceConfiguration(providerSimulator);
            configuration.SetEntitySetAccessRule("*", EntitySetRights.All);

            var provider = new DataServiceProviderWrapper(
                new DataServiceCacheItem(
                    configuration,
                    staticConfiguration), 
                providerSimulator, 
                providerSimulator, 
                this.dataServiceSimulator,
                false);

            this.dataServiceSimulator.ProcessingPipeline = new DataServiceProcessingPipeline();
            this.dataServiceSimulator.Provider = provider;
            provider.ProviderBehavior = providerBehavior;
            this.dataServiceSimulator.Configuration = new DataServiceConfiguration(providerSimulator);
            this.dataServiceSimulator.Configuration.DataServiceBehavior.MaxProtocolVersion = ODataProtocolVersion.V4;

            this.responseMessageSimulator = new ODataResponseMessageSimulator();
        }
 public MyDSPInvokableAction(DataServiceOperationContext operationContext, Provider.ServiceAction action, object[] parameters)
 {
     this.action = action;
     this.parameters = parameters;
 }
            /// <summary>
            /// Determines whether a given <paramref name="serviceAction"/> should be advertised as bindable to the given <paramref name="resourceInstance"/>.
            /// </summary>
            /// <param name="operationContext">The data service operation context instance.</param>
            /// <param name="serviceAction">Service action to be advertised.</param>
            /// <param name="resourceInstance">Instance of the resource to which the service action is bound.</param>
            /// <param name="resourceInstanceInFeed">true if the resource instance to be serialized is inside a feed; false otherwise. The value true
            /// suggests that this method might be called many times during serialization since it will get called once for every resource instance inside
            /// the feed. If it is an expensive operation to determine whether to advertise the service action for the <paramref name="resourceInstance"/>,
            /// the provider may choose to always advertise in order to optimize for performance.</param>
            /// <param name="actionToSerialize">The <see cref="ODataAction"/> to be serialized. The server constructs 
            /// the version passed into this call, which may be replaced by an implementation of this interface.
            /// This should never be set to null unless returning false.</param>
            /// <returns>true if the service action should be advertised; false otherwise.</returns>
            public override bool AdvertiseServiceAction(DataServiceOperationContext operationContext, ServiceAction serviceAction, object resourceInstance, bool resourceInstanceInFeed, ref ODataAction actionToSerialize)
            {
                if (SubstituteAdvertiseServiceAction != null)
                {
                    return SubstituteAdvertiseServiceAction(operationContext, serviceAction, resourceInstance, resourceInstanceInFeed, ref actionToSerialize);
                }

                return base.AdvertiseServiceAction(operationContext, serviceAction, resourceInstance, resourceInstanceInFeed, ref actionToSerialize);
            }
Example #20
0
 /// <summary>
 /// Forms an instance of DataServiceODataWriterFeedArgs that contains results.
 /// </summary>
 /// <param name="feed">ODataFeed instance.</param>
 /// <param name="operationContext">DataServicesOperationContext instance.</param>
 /// <returns>DataServiceODataWriterFeedArgs instance</returns>
 internal DataServiceODataWriterFeedArgs GetDataServiceODataWriterFeedArgs(ODataFeed feed, DataServiceOperationContext operationContext)
 {
     return(new DataServiceODataWriterFeedArgs(feed, this.results, operationContext));
 }
Example #21
0
 public string GetStreamETag(object entity, DataServiceOperationContext operationContext)
 {
     return null;
 }
Example #22
0
 public Uri GetReadStreamUri(object entity, DataServiceOperationContext operationContext)
 {
     return DummyReadStreamUri;
 }
Example #23
0
 public string GetStreamContentType(object entity, DataServiceOperationContext operationContext)
 {
     return DummyContentType;
 }
Example #24
0
 public void DeleteStream(object entity, DataServiceOperationContext operationContext)
 {
     throw new NotImplementedException();
 }
 /// <summary>
 /// Creates a new instance of DataServiceODataWriterEntryArgs
 /// </summary>
 /// <param name="entry">ODataResource instance.</param>
 /// <param name="entityInstance">Entity instance that is getting serialized.</param>
 /// <param name="operationContext">DataServiceOperationContext instance.</param>
 public DataServiceODataWriterEntryArgs(ODataResource entry, object entityInstance, DataServiceOperationContext operationContext)
 {
     Debug.Assert(operationContext != null, "operationContext != null");
     this.Entry            = entry;
     this.Instance         = entityInstance;
     this.OperationContext = operationContext;
 }
 public override Provider.IDataServiceInvokable CreateInvokable(DataServiceOperationContext operationContext, Provider.ServiceAction serviceAction, object[] parameterTokens)
 {
     return new MyDSPInvokableAction(operationContext, serviceAction, parameterTokens);
 }
Example #27
0
 public bool AdvertiseServiceAction(DataServiceOperationContext operationContext, ServiceAction serviceAction, object resourceInstance, bool resourceInstanceInFeed, ref ODataAction actionToSerialize)
 {
     throw new NotImplementedException();
 }
 public object Execute(Expression requestExpression, DataServiceOperationContext context)
 {
     return CUSTOM_EXE_PROVIDER_INVOKE_RETURN;
 }
Example #29
0
 /// <summary>
 /// Constructs a new instance of DataServicePipelineEventArgs object
 /// </summary>
 /// <param name="operationContext">Context for the operation which the current event is fired for.</param>
 internal DataServiceProcessingPipelineEventArgs(DataServiceOperationContext operationContext)
 {
     Debug.Assert(operationContext != null, "operationContext != null");
     this.operationContext = operationContext;
 }
Example #30
0
        private static DataServiceProviderWrapper CreateProvider(out DataServiceConfiguration config, out DataServiceOperationContext operationContext)
        {
            var baseUri = new Uri("http://localhost");
            var host = new DataServiceHostSimulator()
            {
                AbsoluteServiceUri = baseUri,
                AbsoluteRequestUri = new Uri(baseUri.AbsoluteUri + "/$metadata", UriKind.Absolute),
                RequestHttpMethod = "GET",
                RequestAccept = "application/xml+atom",
                RequestVersion = "4.0",
                RequestMaxVersion = "4.0",
            };

            operationContext = new DataServiceOperationContext(host);
            var dataService = new DataServiceSimulator() { OperationContext = operationContext };
            operationContext.InitializeAndCacheHeaders(dataService);

            DataServiceProviderSimulator providerSimulator = new DataServiceProviderSimulator();
            providerSimulator.ContainerNamespace = "MyModel";
            providerSimulator.ContainerName = "CustomersContainer";

            ResourceType customerEntityType = new ResourceType(
                typeof(object), ResourceTypeKind.EntityType, null, "MyModel", "Customer", false)
            { 
                CanReflectOnInstanceType = false 
            };

            ResourcePropertyKind idPropertyKind = ResourcePropertyKind.Primitive | ResourcePropertyKind.Key;
            ResourceProperty idProperty = new ResourceProperty(
                "Id", idPropertyKind, ResourceType.GetPrimitiveResourceType(typeof(int)))
            { 
                CanReflectOnInstanceTypeProperty = false 
            };
            customerEntityType.AddProperty(idProperty);

            ResourcePropertyKind firstNamePropertyKind = ResourcePropertyKind.Primitive | ResourcePropertyKind.Key;
            ResourceProperty firstNameProperty = new ResourceProperty(
                "FirstName", firstNamePropertyKind, ResourceType.GetPrimitiveResourceType(typeof(string)))
            {
                CanReflectOnInstanceTypeProperty = false
            };
            customerEntityType.AddProperty(firstNameProperty);            
            
            customerEntityType.SetReadOnly();
            providerSimulator.AddResourceType(customerEntityType);

            ResourceSet customerSet = new ResourceSet("Customers", customerEntityType);
            customerSet.SetReadOnly();
            providerSimulator.AddResourceSet(customerSet);

            config = new DataServiceConfiguration(providerSimulator);
            config.SetEntitySetAccessRule("*", EntitySetRights.All);
            config.DataServiceBehavior.MaxProtocolVersion = ODataProtocolVersion.V4;

            IDataServiceProviderBehavior providerBehavior = DataServiceProviderBehavior.CustomDataServiceProviderBehavior;
            DataServiceStaticConfiguration staticConfig = new DataServiceStaticConfiguration(dataService.Instance.GetType(), providerSimulator);

            DataServiceProviderWrapper provider = new DataServiceProviderWrapper(
                new DataServiceCacheItem(config, staticConfig), providerSimulator, providerSimulator, dataService, false);

            dataService.ProcessingPipeline = new DataServiceProcessingPipeline();
            dataService.Provider = provider;
            provider.ProviderBehavior = providerBehavior;
            dataService.ActionProvider = DataServiceActionProviderWrapper.Create(dataService);
#if DEBUG
            dataService.ProcessingPipeline.SkipDebugAssert = true;
#endif
            operationContext.RequestMessage.InitializeRequestVersionHeaders(VersionUtil.ToVersion(config.DataServiceBehavior.MaxProtocolVersion));
            return provider;
        }
 /// <summary>
 /// Creates a new instance of DataServiceODataWriterFeedArgs
 /// </summary>
 /// <param name="feed">ODataResourceSet instance.</param>
 /// <param name="results">IEnumerable instance that is getting serialized.</param>
 /// <param name="operationContext">DataServiceOperationContext instance.</param>
 public DataServiceODataWriterFeedArgs(ODataResourceSet resourceCollection, IEnumerable results, DataServiceOperationContext operationContext)
 {
     WebUtil.CheckArgumentNull(resourceCollection, "feed");
     Debug.Assert(results != null, "results != null");
     Debug.Assert(operationContext != null, "operationContext != null");
     this.Feed             = resourceCollection;
     this.Results          = results;
     this.OperationContext = operationContext;
 }
Example #32
0
 public IDataServiceInvokable CreateInvokable(DataServiceOperationContext operationContext, ServiceAction serviceAction, object[] parameterTokens)
 {
     throw new NotImplementedException();
 }
        private void ValidateArguments(object entity, DataServiceOperationContext operationContext)
        {
            if (!SkipValidation)
            {
                Type projectedWrapperType = typeof(DataService<>).Assembly.GetType("Microsoft.OData.Service.Internal.ProjectedWrapper");

                if (projectedWrapperType.IsAssignableFrom(entity.GetType()))
                {
                    throw new DataServiceException("Expected ResourceType but received ProjectedWrapper");
                }

                Type entityType = entity.GetType();
                if (!typeof(Photo).IsAssignableFrom(entityType) && entityType != typeof(NorthwindModel.Customers) && entityType != typeof(NorthwindModel.Orders) &&
                    (entityType != typeof(RowEntityTypeWithIDAsKey) || (((RowEntityTypeWithIDAsKey)entity).TypeName != CustomRowBasedContext.CustomerFullName && ((RowEntityTypeWithIDAsKey)entity).TypeName != CustomRowBasedContext.CustomerWithBirthdayFullName)) &&
                    (entityType != typeof(RowComplexType) || (((RowComplexType)entity).TypeName != "AstoriaUnitTests.Stubs.Customer" && ((RowComplexType)entity).TypeName != "AstoriaUnitTests.Stubs.CustomerWithBirthday")))
                {
                    throw new DataServiceException(String.Format("Unsupported streaming type '{0}'", entity.GetType().FullName));
                }

                // For PUT to $value or POST requests, the content type of the MR should match
                if (((operationContext.AbsoluteRequestUri.OriginalString.Contains("$value") && operationContext.RequestMethod.Equals("PUT", StringComparison.OrdinalIgnoreCase)) ||
                      operationContext.RequestMethod.Equals("POST", StringComparison.OrdinalIgnoreCase))
                    && operationContext.RequestHeaders[HttpRequestHeader.ContentType] != GetContentType(entity))
                {
                    throw new DataServiceException(String.Format("Incorrect Content-Type header value '{0}', expected '{1}'.", operationContext.RequestHeaders["Content-Type"], GetContentType(entity)));
                }

                if (!ValidateCustomRequestHeaders(operationContext))
                {
                    throw new DataServiceException("Expected custom request headers not found!");
                }
            }
        }
Example #34
0
 /// <summary>
 /// Forms an instance of DataServiceODataWriterFeedArgs that contains results.
 /// </summary>
 /// <param name="feed">ODataResourceSet instance.</param>
 /// <param name="operationContext">DataServicesOperationContext instance.</param>
 /// <returns>DataServiceODataWriterFeedArgs instance</returns>
 internal DataServiceODataWriterFeedArgs GetDataServiceODataWriterFeedArgs(ODataResourceSet resourceCollection, DataServiceOperationContext operationContext)
 {
     return(new DataServiceODataWriterFeedArgs(resourceCollection, this.results, operationContext));
 }
        private static bool ValidateCustomRequestHeaders(DataServiceOperationContext operationContext)
        {
            string customHeader1 = operationContext.RequestHeaders["CustomRequestHeader1"];
            string customHeader2 = operationContext.RequestHeaders["CustomRequestHeader2"];
            if (customHeader1 == "CustomRequestHeaderValue1" && customHeader2 == "CustomRequestHeaderValue2")
            {
                return true;
            }

            return false;
        }
Example #36
0
        /// <summary>
        /// Resolves the entity type for a POST MR operation.
        /// </summary>
        /// <param name="entitySetName">named of the entity set for the POST operation</param>
        /// <param name="operationContext">operation context instance</param>
        /// <returns>fully qualified entity type name to be created. May be null if the type hierarchy only contains 1 type or does not contain any MLE type</returns>
        protected override string ResolveTypeInternal(string entitySetName, DataServiceOperationContext operationContext)
        {
            string typeName = operationContext.RequestHeaders[ResolveTypeHeaderName];
            if (!string.IsNullOrEmpty(typeName))
            {
                return typeName;
            }

            ResourceSet resourceSet;
            if (!DSPServiceDefinition.Current.Metadata.TryResolveResourceSet(entitySetName, out resourceSet))
            {
                throw new InvalidOperationException("Invalid set name: '" + entitySetName + "'");
            }

            ResourceType rootType = resourceSet.ResourceType;
            List<ResourceType> typeHierarchy = new List<ResourceType>();
            typeHierarchy.Add(rootType);
            typeHierarchy.AddRange(DSPServiceDefinition.Current.Metadata.GetDerivedTypes(rootType));
            return typeHierarchy.Single(t => t.IsMediaLinkEntry).FullName;
        }
        private void SetCustomResponseHeaders(DataServiceOperationContext operationContext)
        {
            operationContext.ResponseHeaders["CustomResponseHeader1"] = "CustomResponseHeaderValue1";
            operationContext.ResponseHeaders["CustomResponseHeader2"] = "CustomResponseHeaderValue2";

            bool seenHeader1 = false;
            bool seenHeader2 = false;

            foreach (string responseHeader in operationContext.ResponseHeaders.AllKeys)
            {
                if (responseHeader == "CustomResponseHeader1")
                {
                    seenHeader1 = true;
                    if (operationContext.ResponseHeaders[responseHeader] != "CustomResponseHeaderValue1")
                    {
                        throw new DataServiceException("Invalid value for CustomResponseHeader1.");
                    }
                }
                else if (responseHeader == "CustomResponseHeader2")
                {
                    seenHeader2 = true;
                    if (operationContext.ResponseHeaders[responseHeader] != "CustomResponseHeaderValue2")
                    {
                        throw new DataServiceException("Invalid value for CustomResponseHeader2.");
                    }
                }
            }

            if (!seenHeader1 || !seenHeader2)
            {
                throw new DataServiceException("CustomResponseHeader1 or CustomResponseHeader2 is not set.");
            }
        }
Example #38
0
 public Stream GetWriteStream(object entity, string etag, bool? checkETagForEquality, DataServiceOperationContext operationContext)
 {
     throw new NotImplementedException();
 }
Example #39
0
 /// <summary>Initalizes a new <see cref="ProcessRequestArgs"/> instance.</summary>
 /// <param name="operationContext">Context about the current operation being processed.</param>
 internal ProcessRequestArgs(DataServiceOperationContext operationContext)
 {
     this.OperationContext = operationContext;
 }