internal static Deserializer CreateDeserializer(System.Data.Services.RequestDescription description, IDataService dataService, bool update, UpdateTracker tracker)
{
string str;
Encoding encoding;
HttpProcessUtility.ReadContentType(dataService.OperationContext.Host.RequestContentType, out str, out encoding);
if (DataServiceActionProviderWrapper.IsServiceActionRequest(description))
{
return(new ParameterDeserializer(update, dataService, tracker, description));
}
if ((description.TargetKind == RequestTargetKind.OpenPropertyValue) || (description.TargetKind == RequestTargetKind.PrimitiveValue))
{
return(new RawValueDeserializer(update, dataService, tracker, description));
}
if (description.TargetKind == RequestTargetKind.MediaResource)
{
return(new MediaResourceDeserializer(update, dataService, tracker, description));
}
if (((description.TargetKind == RequestTargetKind.Primitive) || (description.TargetKind == RequestTargetKind.ComplexObject)) || ((description.TargetKind == RequestTargetKind.Collection) || (description.TargetKind == RequestTargetKind.OpenProperty)))
{
return(new PropertyDeserializer(update, dataService, tracker, description));
}
if (description.LinkUri)
{
return(new EntityReferenceLinkDeserializer(update, dataService, tracker, description));
}
if (description.TargetKind != RequestTargetKind.Resource)
{
throw new DataServiceException(0x19f, System.Data.Services.Strings.RequestUriProcessor_MethodNotAllowed);
}
return(new EntityDeserializer(update, dataService, tracker, description));
}
protected bool NeedNextPageLink(IEnumerator enumerator)
{
if (((this.CurrentContainer != null) && !DataServiceActionProviderWrapper.IsServiceActionRequest(this.RequestDescription)) && !this.RequestDescription.IsRequestForEnumServiceOperation)
{
if (this.IsCustomPaged)
{
this.currentSkipTokenForCustomPaging = this.service.PagingProvider.PagingProviderInterface.GetContinuationToken(BasicExpandProvider.ExpandedEnumeratorEx.UnwrapEnumerator(enumerator));
return((this.currentSkipTokenForCustomPaging != null) && (this.currentSkipTokenForCustomPaging.Length > 0));
}
int pageSize = this.CurrentContainer.PageSize;
if ((pageSize != 0) && (this.RequestDescription.ResponseVersion != System.Data.Services.RequestDescription.DataServiceDefaultResponseVersion))
{
if (this.segmentInfo.Count == 1)
{
int?topQueryParameter = this.GetTopQueryParameter();
if (topQueryParameter.HasValue && (topQueryParameter.Value <= pageSize))
{
return(false);
}
}
return(this.segmentInfo.CurrentResultCount == pageSize);
}
}
return(false);
}
public void Init()
{
this.entityType = new ResourceType(typeof(object), ResourceTypeKind.EntityType, null, "Fake.NS", "Type", false)
{
CanReflectOnInstanceType = false
};
this.entityType.AddProperty(new ResourceProperty("Id", ResourcePropertyKind.Key | ResourcePropertyKind.Primitive, ResourceType.GetPrimitiveResourceType(typeof(int)))
{
CanReflectOnInstanceTypeProperty = false
});
this.entityType.SetReadOnly();
var resourceSet = new ResourceSet("Set", this.entityType);
resourceSet.SetReadOnly();
this.resourceSetWrapper = ResourceSetWrapper.CreateForTests(resourceSet);
this.action = new ServiceAction("Fake", ResourceType.GetPrimitiveResourceType(typeof(int)), OperationParameterBindingKind.Sometimes, new[] { new ServiceActionParameter("p1", this.entityType) }, null);
this.action.SetReadOnly();
this.provider = new TestDataServiceProvider();
this.actionProvider = DataServiceActionProviderWrapper.Create(this.provider, ODataProtocolVersion.V4, () => this.operationContext);
var host = new DataServiceHostSimulator();
this.operationContext = new DataServiceOperationContext(host);
this.operationContext.InitializeAndCacheHeaders(new DataServiceSimulator());
}
private string ComputeContainerName()
{
if (DataServiceActionProviderWrapper.IsServiceActionSegment(base.RequestDescription.LastSegmentInfo))
{
bool flag2;
return(base.Provider.GetNameFromContainerQualifiedName(base.RequestDescription.ContainerName, out flag2));
}
return(base.RequestDescription.ContainerName);
}
internal static RequestDescription ProcessQuery(IDataService service, RequestDescription description)
{
if ((service.OperationContext.Host.HttpVerb != HttpVerbs.GET) && (description.SegmentInfos[0].TargetSource != RequestTargetSource.ServiceOperation))
{
CheckV2EmptyQueryArguments(service);
}
if (((description.RequestExpression == null) || DataServiceActionProviderWrapper.IsServiceActionRequest(description)) || !typeof(IQueryable).IsAssignableFrom(description.RequestExpression.Type))
{
CheckEmptyQueryArguments(service, false);
return(description);
}
RequestQueryProcessor processor = new RequestQueryProcessor(service, description);
return(processor.ProcessQuery());
}
private static DataServiceProviderWrapper CreateProviderWrapper(TestActionProvider actionProvider = null, Action <DataServiceProviderSimulator> addMetadata = null)
{
var provider = new DataServiceProviderSimulator();
if (addMetadata != null)
{
addMetadata(provider);
}
var dataService = new DataServiceSimulatorWithGetService();
dataService.Configuration = new DataServiceConfiguration(provider);
dataService.ProcessingPipeline = new DataServiceProcessingPipeline();
dataService.Configuration.SetServiceActionAccessRule("*", ServiceActionRights.Invoke);
dataService.Configuration.SetEntitySetAccessRule("*", EntitySetRights.All);
dataService.Configuration.SetServiceOperationAccessRule("*", ServiceOperationRights.All);
dataService.Configuration.DataServiceBehavior.MaxProtocolVersion = ODataProtocolVersion.V4;
dataService.OperationContext = new DataServiceOperationContext(false, new DataServiceHost2Simulator {
AbsoluteRequestUri = new Uri("http://fake.org/$metadata")
});
dataService.OperationContext.InitializeAndCacheHeaders(dataService);
DataServiceStaticConfiguration staticConfiguration = new DataServiceStaticConfiguration(dataService.Instance.GetType(), provider);
IDataServiceProviderBehavior providerBehavior = DataServiceProviderBehavior.CustomDataServiceProviderBehavior;
var providerWrapper = new DataServiceProviderWrapper(
new DataServiceCacheItem(
dataService.Configuration,
staticConfiguration),
provider,
provider,
dataService,
false);
dataService.Provider = providerWrapper;
providerWrapper.ProviderBehavior = providerBehavior;
dataService.ActionProvider = DataServiceActionProviderWrapper.Create(dataService);
if (actionProvider != null)
{
dataService.Providers.Add(typeof(IDataServiceActionProvider), actionProvider);
}
return(providerWrapper);
}
protected void IncrementSegmentResultCount()
{
if (this.segmentInfo != null)
{
int maxResultsPerCollection = this.service.Configuration.MaxResultsPerCollection;
if ((!this.IsCustomPaged && (this.CurrentContainer != null)) && (this.CurrentContainer.PageSize != 0))
{
maxResultsPerCollection = this.CurrentContainer.PageSize;
}
if ((maxResultsPerCollection != 0x7fffffff) || this.IsCustomPaged)
{
int num2 = this.segmentInfo.CurrentResultCount + 1;
if ((num2 > maxResultsPerCollection) && !DataServiceActionProviderWrapper.IsServiceActionRequest(this.RequestDescription))
{
throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.Serializer_ResultsExceedMax(maxResultsPerCollection));
}
this.segmentInfo.CurrentResultCount = num2;
}
}
}
/// <summary>Constructs a <see cref="MetadataProviderEdmModel"/> which wraps the given <see cref="DataServiceProviderWrapper"/> instance.</summary>
/// <param name="provider"><see cref="DataServiceProviderWrapper"/> instance.</param>
/// <param name="streamProviderWrapper">The stream provider wrapper instance.</param>
/// <param name="actionProviderWrapper">The action provider wrapper instance.</param>
internal MetadataProviderEdmModel(DataServiceProviderWrapper provider, DataServiceStreamProviderWrapper streamProviderWrapper, DataServiceActionProviderWrapper actionProviderWrapper)
{
Debug.Assert(provider != null, "provider != null");
this.metadataProvider = provider;
this.streamProviderWrapper = streamProviderWrapper;
this.actionProviderWrapper = actionProviderWrapper;
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);
this.operationsQualifiedNameCache = new Dictionary<string, List<MetadataProviderEdmOperation>>(StringComparer.Ordinal);
this.operationWrapperOperationLookUp = new Dictionary<OperationWrapper, IEdmOperation>(EqualityComparer<OperationWrapper>.Default);
// In the model, set the data service version and the edm version based on the MPV (this is the best estimate we have at this time).
// This helps to set the nullability facet correctly when resolving type references. Note that, when the model is serialized for $metadata requests
// in MetadataSerializer.WriteMetadataDocument, the DSV and the edm version on the model will be overwritten with the value computed by walking the
// resource model.
Version odataVersion = this.metadataProvider.Configuration.DataServiceBehavior.MaxProtocolVersion.ToVersion();
Version edmVersion = null;
if (!MetadataProviderUtils.DataServiceEdmVersionMap.TryGetValue(odataVersion, out edmVersion))
{
this.SetEdmVersion(Microsoft.OData.Edm.Library.EdmConstants.EdmVersionLatest);
}
else
{
this.SetEdmVersion(edmVersion);
}
// Initialize the minimum Edm Metadata Version to 4.0.
this.MinMetadataEdmSchemaVersion = Microsoft.OData.Edm.Library.EdmConstants.EdmVersion4;
this.AnnotationsCache = new VocabularyAnnotationCache(this);
}
private static IEdmEntityType CreateModelAndGetEdmType(ResourceType resourceType)
{
var provider = new DataServiceProviderSimulator();
DataServiceSimulator dataService = new DataServiceSimulator();
DataServiceStaticConfiguration staticConfiguration = new DataServiceStaticConfiguration(dataService.Instance.GetType(), provider);
IDataServiceProviderBehavior providerBehavior = DataServiceProviderBehavior.CustomDataServiceProviderBehavior;
DataServiceProviderWrapper providerWrapper = new DataServiceProviderWrapper(
new DataServiceCacheItem(
new DataServiceConfiguration(provider),
staticConfiguration),
provider,
provider,
dataService,
false);
dataService.Provider = providerWrapper;
var model = new MetadataProviderEdmModel(providerWrapper, new DataServiceStreamProviderWrapper(dataService), DataServiceActionProviderWrapper.Create(dataService));
dataService.ProcessingPipeline = new DataServiceProcessingPipeline();
model.MetadataProvider.ProviderBehavior = providerBehavior;
var edmType = model.EnsureSchemaType(resourceType) as IEdmEntityType;
return(edmType);
}
private static MetadataProviderEdmModel CreateMetadataProviderEdmModel(DataServiceProviderSimulator metadataProvider, IDataServiceActionProvider actionProvider = null)
{
var dataServiceSimulator = new DataServiceSimulatorWithGetService {
OperationContext = new DataServiceOperationContext(false, new DataServiceHost2Simulator()), ProcessingPipeline = new DataServiceProcessingPipeline()
};
dataServiceSimulator.OperationContext.InitializeAndCacheHeaders(dataServiceSimulator);
var dataServiceConfiguration = new DataServiceConfiguration(metadataProvider);
dataServiceConfiguration.SetEntitySetAccessRule("*", EntitySetRights.AllRead);
dataServiceConfiguration.SetServiceActionAccessRule("*", ServiceActionRights.Invoke);
dataServiceConfiguration.DataServiceBehavior.MaxProtocolVersion = ODataProtocolVersion.V4;
if (actionProvider != null)
{
dataServiceSimulator.Providers.Add(typeof(IDataServiceActionProvider), actionProvider);
}
DataServiceStaticConfiguration staticConfiguration = new DataServiceStaticConfiguration(dataServiceSimulator.Instance.GetType(), metadataProvider);
IDataServiceProviderBehavior providerBehavior = DataServiceProviderBehavior.CustomDataServiceProviderBehavior;
DataServiceProviderWrapper providerWrapper = new DataServiceProviderWrapper(
new DataServiceCacheItem(
dataServiceConfiguration,
staticConfiguration),
metadataProvider,
metadataProvider,
dataServiceSimulator,
false);
dataServiceSimulator.Provider = providerWrapper;
var model = new MetadataProviderEdmModel(providerWrapper, new DataServiceStreamProviderWrapper(dataServiceSimulator), DataServiceActionProviderWrapper.Create(dataServiceSimulator));
model.MetadataProvider.ProviderBehavior = providerBehavior;
return(model);
}
private void InitWithQueryOptions(string selectQueryOption, string expandQueryOption)
{
string queryOption = string.Empty;
if (selectQueryOption != null && expandQueryOption != null)
{
queryOption = "?$select=" + selectQueryOption + "&$expand=" + expandQueryOption;
}
else if (selectQueryOption != null)
{
queryOption = "?$select=" + selectQueryOption;
}
else
{
queryOption = "?$expand=" + expandQueryOption;
}
this.host = new DataServiceHostSimulator
{
AbsoluteRequestUri = new Uri("http://fake.org/FakeSet" + queryOption),
AbsoluteServiceUri = new Uri("http://fake.org/"),
RequestHttpMethod = "GET",
RequestVersion = "2.0",
};
if (selectQueryOption != null)
{
this.host.SetQueryStringItem("$select", selectQueryOption);
}
if (expandQueryOption != null)
{
this.host.SetQueryStringItem("$expand", expandQueryOption);
}
DataServiceProviderSimulator provider = new DataServiceProviderSimulator
{
ContainerName = "SelectTestContainer",
ContainerNamespace = "SelectTestNamespace"
};
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();
provider.AddResourceSet(resourceSet);
DataServiceConfiguration configuration = new DataServiceConfiguration(provider);
configuration.SetEntitySetAccessRule("*", EntitySetRights.All);
this.service = new DataServiceSimulator
{
OperationContext = new DataServiceOperationContext(this.host),
Configuration = configuration,
};
DataServiceStaticConfiguration staticConfiguration = new DataServiceStaticConfiguration(this.service.Instance.GetType(), provider);
IDataServiceProviderBehavior providerBehavior = DataServiceProviderBehavior.CustomDataServiceProviderBehavior;
this.service.Provider = new DataServiceProviderWrapper(
new DataServiceCacheItem(
configuration,
staticConfiguration),
provider,
provider,
this.service,
false);
this.service.ProcessingPipeline = new DataServiceProcessingPipeline();
this.service.Provider.ProviderBehavior = providerBehavior;
this.service.ActionProvider = DataServiceActionProviderWrapper.Create(this.service);
this.service.OperationContext.InitializeAndCacheHeaders(service);
}
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>
/// TODO: Refactor this into a factory pattern, if needed
/// </summary>
/// <returns>IDataService</returns>
public IDataService CreateService <T>() where T : DataServiceSimulator, new()
{
T dataService = new T();
//
// Operation Context
//
DataServiceOperationContext operationContext = new DataServiceOperationContext(host);
operationContext.InitializeAndCacheHeaders(dataService);
//
// Configuration
//
DataServiceConfiguration config = new DataServiceConfiguration(provider);
config.SetEntitySetAccessRule("*", EntitySetRights.All);
config.SetServiceOperationAccessRule("*", ServiceOperationRights.All);
config.SetServiceActionAccessRule("*", ServiceActionRights.Invoke);
config.DataServiceBehavior.AcceptAnyAllRequests = this.behavior.AcceptAnyAllRequests;
config.DataServiceBehavior.AcceptCountRequests = this.behavior.AcceptCountRequests;
config.DataServiceBehavior.AcceptProjectionRequests = this.behavior.AcceptProjectionRequests;
config.DataServiceBehavior.AcceptSpatialLiteralsInQuery = this.behavior.AcceptSpatialLiteralsInQuery;
config.DataServiceBehavior.IncludeAssociationLinksInResponse = this.behavior.IncludeAssociationLinksInResponse;
config.DataServiceBehavior.InvokeInterceptorsOnLinkDelete = this.behavior.InvokeInterceptorsOnLinkDelete;
config.DataServiceBehavior.MaxProtocolVersion = this.behavior.MaxProtocolVersion;
config.DataServiceBehavior.UseMetadataKeyOrderForBuiltInProviders = this.behavior.UseMetadataKeyOrderForBuiltInProviders;
DataServiceStaticConfiguration staticConfiguration = new DataServiceStaticConfiguration(dataService.Instance.GetType(), provider);
IDataServiceProviderBehavior providerBehavior = DataServiceProviderBehavior.CustomDataServiceProviderBehavior;
var providerWrapper = new DataServiceProviderWrapper(
new DataServiceCacheItem(
config,
staticConfiguration),
provider,
provider,
dataService,
false);
dataService.ProcessingPipeline = new DataServiceProcessingPipeline();
dataService.Provider = providerWrapper;
providerWrapper.ProviderBehavior = providerBehavior;
//
// Service
//
operationContext.RequestMessage.InitializeRequestVersionHeaders(config.DataServiceBehavior.MaxProtocolVersion.ToVersion());
var pipeline = new DataServiceProcessingPipeline();
#if DEBUG
pipeline.SkipDebugAssert = true;
#endif
dataService.OperationContext = operationContext;
dataService.Provider = providerWrapper;
dataService.ProcessingPipeline = pipeline;
dataService.Configuration = config;
dataService.StreamProvider = new DataServiceStreamProviderWrapper(dataService);
dataService.ActionProvider = DataServiceActionProviderWrapper.Create(dataService);
return(dataService);
}
