private static Uri ExecuteAssetDeleteRequest( AssetDeleteOptionsRequestAdapter adapter) { Uri uri = null; var context = new DataServiceContext(new Uri("http://127.0.0.1/" + Guid.NewGuid().ToString())); bool sendingRequestCalled = false; context.SendingRequest2 += delegate(object o, SendingRequest2EventArgs args) { sendingRequestCalled = true; uri = args.RequestMessage.Url; }; try { AssetData asset = new AssetData() {Id = Guid.NewGuid().ToString()}; context.AttachTo("Assets", asset); context.DeleteObject(asset); adapter.Adapt(context); context.SaveChanges(); } catch (DataServiceRequestException ex) { Debug.WriteLine(ex.Message); } Assert.IsTrue(sendingRequestCalled); return uri; }
public static Uri RegisterDataService(DataServiceContext ctx) { if (_behavior == null) Behavior = Activator.CreateInstance(OAuthConfiguration.Configuration.ClientSettings.WcfDSBehaviorType) as IOAuthBehavior; return Behavior.RegisterDataService(ctx); }
public void Init() { context = new DataServiceContext(new Uri(rootUrl)); this.sampleDateTimeOffset = new DateTime(2012, 12, 17, 9, 23, 31, DateTimeKind.Utc); this.sampleDate = XmlConvert.ToString(this.sampleDateTimeOffset); }
/// <summary> /// Translates resource bound expression tree to a URI. /// </summary> /// <param name='context'>Data context used to generate type names for types.</param> /// <param name="addTrailingParens">flag to indicate whether generated URI should include () if leaf is ResourceSet</param> /// <param name="e">The expression to translate</param> /// <param name="uri">uri</param> /// <param name="version">version for query</param> internal static void Translate(DataServiceContext context, bool addTrailingParens, Expression e, out Uri uri, out Version version) { var writer = new UriWriter(context); writer.Visit(e); string fullUri = writer.uriBuilder.ToString(); if (writer.alias.Any()) { if (fullUri.IndexOf(UriHelper.QUESTIONMARK) > -1) { fullUri += UriHelper.AMPERSAND; } else { fullUri += UriHelper.QUESTIONMARK; } foreach (var kv in writer.alias) { fullUri += kv.Key; fullUri += UriHelper.EQUALSSIGN; fullUri += kv.Value; fullUri += UriHelper.AMPERSAND; } fullUri = fullUri.Substring(0, fullUri.Length - 1); } uri = UriUtil.CreateUri(fullUri, UriKind.Absolute); version = writer.uriVersion; }
/// <summary> /// Instantiates a new Serializer class and calls WriteEntry method on it. /// </summary> /// <param name="dataServiceContext"></param> /// <returns></returns> private static Person SetupSerializerAndCallWriteEntry(DataServiceContext dataServiceContext) { Person person = new Person(); Address address = new Address(); Car car1 = new Car(); person.Cars.Add(car1); person.HomeAddress = address; dataServiceContext.AttachTo("Cars", car1); dataServiceContext.AttachTo("Addresses", address); var requestInfo = new RequestInfo(dataServiceContext); var serializer = new Serializer(requestInfo); var headers = new HeaderCollection(); var clientModel = new ClientEdmModel(ODataProtocolVersion.V4); var entityDescriptor = new EntityDescriptor(clientModel); entityDescriptor.State = EntityStates.Added; entityDescriptor.Entity = person; var requestMessageArgs = new BuildingRequestEventArgs("POST", new Uri("http://www.foo.com/Northwind"), headers, entityDescriptor, HttpStack.Auto); var linkDescriptors = new LinkDescriptor[] { new LinkDescriptor(person, "Cars", car1, clientModel), new LinkDescriptor(person, "HomeAddress", address, clientModel) }; var odataRequestMessageWrapper = ODataRequestMessageWrapper.CreateRequestMessageWrapper(requestMessageArgs, requestInfo); serializer.WriteEntry(entityDescriptor, linkDescriptors, odataRequestMessageWrapper); return person; }
public void EndToEndShortIntegrationWriteEntryEventTest() { List<KeyValuePair<string, object>> eventArgsCalled = new List<KeyValuePair<string, object>>(); var dataServiceContext = new DataServiceContext(new Uri("http://www.odata.org/Service.svc")); dataServiceContext.Configurations.RequestPipeline.OnEntityReferenceLink((args) => eventArgsCalled.Add(new KeyValuePair<string, object>("OnEntityReferenceLink", args))); dataServiceContext.Configurations.RequestPipeline.OnEntryEnding((args) => eventArgsCalled.Add(new KeyValuePair<string, object>("OnEntryEnded", args))); dataServiceContext.Configurations.RequestPipeline.OnEntryStarting((args) => eventArgsCalled.Add(new KeyValuePair<string, object>("OnEntryStarted", args))); dataServiceContext.Configurations.RequestPipeline.OnNavigationLinkEnding((args) => eventArgsCalled.Add(new KeyValuePair<string, object>("OnNavigationLinkEnded", args))); dataServiceContext.Configurations.RequestPipeline.OnNavigationLinkStarting((args) => eventArgsCalled.Add(new KeyValuePair<string, object>("OnNavigationLinkStarted", args))); Person person = SetupSerializerAndCallWriteEntry(dataServiceContext); eventArgsCalled.Should().HaveCount(8); eventArgsCalled[0].Key.Should().Be("OnEntryStarted"); eventArgsCalled[0].Value.Should().BeOfType<WritingEntryArgs>(); eventArgsCalled[0].Value.As<WritingEntryArgs>().Entity.Should().BeSameAs(person); eventArgsCalled[1].Key.Should().Be("OnNavigationLinkStarted"); eventArgsCalled[1].Value.Should().BeOfType<WritingNavigationLinkArgs>(); eventArgsCalled[2].Key.Should().Be("OnEntityReferenceLink"); eventArgsCalled[2].Value.Should().BeOfType<WritingEntityReferenceLinkArgs>(); eventArgsCalled[3].Key.Should().Be("OnNavigationLinkEnded"); eventArgsCalled[3].Value.Should().BeOfType<WritingNavigationLinkArgs>(); eventArgsCalled[4].Key.Should().Be("OnNavigationLinkStarted"); eventArgsCalled[4].Value.Should().BeOfType<WritingNavigationLinkArgs>(); eventArgsCalled[5].Key.Should().Be("OnEntityReferenceLink"); eventArgsCalled[5].Value.Should().BeOfType<WritingEntityReferenceLinkArgs>(); eventArgsCalled[6].Key.Should().Be("OnNavigationLinkEnded"); eventArgsCalled[6].Value.Should().BeOfType<WritingNavigationLinkArgs>(); eventArgsCalled[7].Key.Should().Be("OnEntryEnded"); eventArgsCalled[7].Value.Should().BeOfType<WritingEntryArgs>(); eventArgsCalled[7].Value.As<WritingEntryArgs>().Entity.Should().BeSameAs(person); }
//[TestMethod, Variation("One should not be able to get named streams via load property api")] public void NamedStreams_LoadPropertyTest() { // populate the context DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4); EntityWithNamedStreams1 entity = context.CreateQuery<EntityWithNamedStreams1>("MySet1").Take(1).Single(); try { context.LoadProperty(entity, "Stream1"); } catch (DataServiceClientException ex) { Assert.IsTrue(ex.Message.Contains(DataServicesResourceUtil.GetString("DataService_VersionTooLow", "1.0", "3", "0")), String.Format("The error message was not as expected: {0}", ex.Message)); } try { context.BeginLoadProperty( entity, "Stream1", (result) => { context.EndLoadProperty(result); }, null); } catch (DataServiceClientException ex) { Assert.IsTrue(ex.Message.Contains(DataServicesResourceUtil.GetString("DataService_VersionTooLow", "1.0", "3", "0")), String.Format("The error message was not as expected: {0}", ex.Message)); } }
public void WhenOrdering_ThenSucceeds() { var config = HttpHostConfiguration.Create(); config.Configuration.OperationHandlerFactory.Formatters.Insert(0, new JsonNetMediaTypeFormatter()); using (var ws = new HttpWebService<TestService>("http://localhost:20000", "products", config)) { var client = new HttpClient("http://localhost:20000"); client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("text/json")); var context = new DataServiceContext(new Uri("http://localhost:20000")); // We always specify how many to take, to be explicit. var query = context.CreateQuery<Product>("products") .Where(x => x.Owner.Name == "kzu") .OrderBy(x => x.Id) .ThenBy(x => x.Owner.Id) .Skip(1) .Take(1); //var uri = ((DataServiceQuery)query).RequestUri; var uri = new Uri(((DataServiceQuery)query).RequestUri.ToString().Replace("()?$", "?$")); Console.WriteLine(uri); var response = client.Get(uri); Assert.True(response.IsSuccessStatusCode, "Failed : " + response.StatusCode + " " + response.ReasonPhrase); var products = new JsonSerializer().Deserialize<List<Product>>(new JsonTextReader(new StreamReader(response.Content.ContentReadStream))); Assert.Equal(1, products.Count); } }
private UriWriter(DataServiceContext context) { Debug.Assert(context != null, "context != null"); this.context = context; this.uriBuilder = new StringBuilder(); this.uriVersion = Util.DataServiceVersion1; }
/// <summary> /// Unregisters this verifier from the context's event /// </summary> /// <param name="context">The context to stop verifing events on</param> /// <param name="inErrorState">A value indicating that we are recovering from an error</param> public void UnregisterEventHandler(DataServiceContext context, bool inErrorState) { ExceptionUtilities.CheckArgumentNotNull(context, "context"); #if !WINDOWS_PHONE this.HttpTracker.UnregisterHandler(context, this.HandleRequestResponsePair, !inErrorState); #endif }
/// <summary> /// constructor for SaveResult /// </summary> /// <param name="context">context</param> /// <param name="method">method</param> /// <param name="options">options</param> /// <param name="callback">user callback</param> /// <param name="state">user state object</param> internal SaveResult(DataServiceContext context, string method, SaveChangesOptions options, AsyncCallback callback, object state) : base(context, method, null, options, callback, state) { Debug.Assert(!Util.IsBatch(this.Options), "Util.IsBatch(this.Options) is not set"); this.cachedResponses = new List<CachedResponse>(); }
/// <summary> /// constructor for BatchSaveResult /// </summary> /// <param name="context">context</param> /// <param name="method">method</param> /// <param name="queries">queries</param> /// <param name="options">options</param> /// <param name="callback">user callback</param> /// <param name="state">user state object</param> internal BatchSaveResult(DataServiceContext context, string method, DataServiceRequest[] queries, SaveChangesOptions options, AsyncCallback callback, object state) : base(context, method, queries, options, callback, state) { Debug.Assert(Util.IsBatch(options), "the options must have batch flag set"); this.Queries = queries; this.streamCopyBuffer = new byte[StreamCopyBufferSize]; }
/// <summary> /// Creates a new instance of RequestInfo class which is used to build the request to send to the server /// </summary> /// <param name="context">wrapping context instance.</param> internal RequestInfo(DataServiceContext context) { Debug.Assert(context != null, "context != null"); this.Context = context; this.WriteHelper = new ODataMessageWritingHelper(this); this.typeResolver = new TypeResolver(context.Model, context.ResolveTypeFromName, context.ResolveNameFromTypeInternal, context.Format.ServiceModel); }
static public DataServiceState Save(DataServiceContext context, Dictionary<string,object> collections) { List<Type> knownTypes = GetKnownTypes(context); Dictionary<EntityDescriptor, Guid> entityDescriptorToId; ContextState contextState = context.SaveState(out entityDescriptorToId); string contextAsString = SerializeContextToString(contextState, knownTypes); var collectionsState = new Dictionary<string, CollectionState>(); if (collections != null) { foreach (KeyValuePair<string, object> kvp in collections) { IDataServiceCollection collection = (IDataServiceCollection) kvp.Value; CollectionState collectionState = collection.SaveState(context, entityDescriptorToId); collectionsState.Add(kvp.Key, collectionState); } } DataServiceState state = new DataServiceState() { CollectionsState = collectionsState, ContextAsString = contextAsString, ContextTypeName = context.GetType().AssemblyQualifiedName, KnownTypeNames = knownTypes.Select(t => t.AssemblyQualifiedName).ToList() }; return state; }
public void ClientSerializeGeographyTest_Update() { DataServiceContext ctx = new DataServiceContext(new Uri("http://localhost")); ctx.AttachTo("Entities", testEntity); ctx.UpdateObject(testEntity); ClientSerializeGeographyTest_Validate(ctx); }
/// <summary> /// Analyzes a lambda expression to check whether it can be satisfied with /// $select and client-side materialization. /// </summary> /// <param name="le">Lambda expression.</param> /// <param name="re">Resource expression in scope.</param> /// <param name="matchMembers">Whether member accesses are matched as top-level projections.</param> /// <param name="context">Context of expression to analyze.</param> /// <returns>true if the lambda is a client-side projection; false otherwise.</returns> internal static bool Analyze(LambdaExpression le, ResourceExpression re, bool matchMembers, DataServiceContext context) { Debug.Assert(le != null, "le != null"); if (le.Body.NodeType == ExpressionType.Constant) { if (ClientTypeUtil.TypeOrElementTypeIsEntity(le.Body.Type)) { throw new NotSupportedException(Strings.ALinq_CannotCreateConstantEntity); } re.Projection = new ProjectionQueryOptionExpression(le.Body.Type, le, new List<string>()); return true; } if (le.Body.NodeType == ExpressionType.MemberInit || le.Body.NodeType == ExpressionType.New) { AnalyzeResourceExpression(le, re, context); return true; } if (matchMembers) { // Members can be projected standalone or type-casted. Expression withoutConverts = SkipConverts(le.Body); if (withoutConverts.NodeType == ExpressionType.MemberAccess) { AnalyzeResourceExpression(le, re, context); return true; } } return false; }
public void ClientSerializeGeographyTest_BindingAddChangeShouldBeDetected() { DataServiceContext ctx = new DataServiceContext(new Uri("http://localhost")); DataServiceCollection<SpatialEntityType> dsc = new DataServiceCollection<SpatialEntityType>(ctx, null, TrackingMode.AutoChangeTracking, "Entities", null, null); dsc.Add(testEntity); ClientSerializeGeographyTest_Validate(ctx); }
private static void Analyze(LambdaExpression e, PathBox pb, DataServiceContext context) { bool flag = ClientTypeUtil.TypeOrElementTypeIsEntity(e.Body.Type); ParameterExpression pe = e.Parameters.Last<ParameterExpression>(); bool flag2 = ClientTypeUtil.TypeOrElementTypeIsEntity(pe.Type); if (flag2) { pb.PushParamExpression(pe); } if (!flag) { NonEntityProjectionAnalyzer.Analyze(e.Body, pb, context); } else { switch (e.Body.NodeType) { case ExpressionType.Constant: throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_CannotCreateConstantEntity); case ExpressionType.MemberInit: EntityProjectionAnalyzer.Analyze((MemberInitExpression) e.Body, pb, context); goto Label_0099; case ExpressionType.New: throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_CannotConstructKnownEntityTypes); } NonEntityProjectionAnalyzer.Analyze(e.Body, pb, context); } Label_0099: if (flag2) { pb.PopParamExpression(); } }
public SqlSampleDataPageViewModel(Dispatcher dispatcher, DataServiceContext odataServiceContext) { this.dispatcher = dispatcher; this.Context = odataServiceContext; this.Items = new DataServiceCollection<SqlSampleData>(odataServiceContext); this.Items.LoadCompleted += this.OnLoadCompleted; }
public void Initialize() { this.contextWithKeyAsSegment = new DataServiceContext(new Uri("http://myservice/", UriKind.Absolute), ODataProtocolVersion.V4) { UrlConventions = DataServiceUrlConventions.KeyAsSegment, }; }
public void ShortIntegrationTestToValidateEntryShouldBeRead() { var odataEntry = new ODataEntry() { Id = new Uri("http://services.odata.org/OData/OData.svc/Customers(0)") }; odataEntry.Properties = new ODataProperty[] { new ODataProperty() { Name = "ID", Value = 0 }, new ODataProperty() { Name = "Description", Value = "Simple Stuff" } }; var clientEdmModel = new ClientEdmModel(ODataProtocolVersion.V4); var context = new DataServiceContext(); MaterializerEntry.CreateEntry(odataEntry, ODataFormat.Atom, true, clientEdmModel); var materializerContext = new TestMaterializerContext() {Model = clientEdmModel, Context = context}; var adapter = new EntityTrackingAdapter(new TestEntityTracker(), MergeOption.OverwriteChanges, clientEdmModel, context); QueryComponents components = new QueryComponents(new Uri("http://foo.com/Service"), new Version(4, 0), typeof(Customer), null, new Dictionary<Expression, Expression>()); var entriesMaterializer = new ODataEntriesEntityMaterializer(new ODataEntry[] { odataEntry }, materializerContext, adapter, components, typeof(Customer), null, ODataFormat.Atom); var customersRead = new List<Customer>(); // This line will call ODataEntityMaterializer.ReadImplementation() which will reconstruct the entity, and will get non-public setter called. while (entriesMaterializer.Read()) { customersRead.Add(entriesMaterializer.CurrentValue as Customer); } customersRead.Should().HaveCount(1); customersRead[0].ID.Should().Be(0); customersRead[0].Description.Should().Be("Simple Stuff"); }
// // GET: /OData/ public ActionResult WebGrid(int page = 1, int rowsPerPage = 10, string sort = "ProductID", string sortDir = "ASC") { DataServiceContext nwd = new DataServiceContext(new Uri("http://services.odata.org/Northwind/Northwind.svc/")); var Products2 = (QueryOperationResponse<Product>)nwd.Execute<Product>( new Uri("http://services.odata.org/Northwind/Northwind.svc/Products()?$expand=Category,Supplier&$select=ProductID,ProductName,Category/CategoryName,Supplier/CompanyName,Supplier/Country")); var t = from p in Products2 select new JointProductModel { ProductID = p.ProductID, ProductName = p.ProductName, CategoryName = p.Category.CategoryName, CompanyName = p.Supplier.CompanyName, Country = p.Supplier.Country }; // ViewBag.count = t.Count(); ViewBag.page = page; ViewBag.rowsPerPage = rowsPerPage; ViewBag.sort = sort; ViewBag.sortDir = sortDir; var r2 = t.AsQueryable().OrderBy(sort + " " + sortDir).Skip((page - 1) * rowsPerPage).Take(rowsPerPage); return View(r2.ToList()); }
/// <summary>constructor</summary> /// <param name="entity">entity</param> /// <param name="propertyName">name of collection or reference property to load</param> /// <param name="context">Originating context</param> /// <param name="request">Originating WebRequest</param> /// <param name="callback">user callback</param> /// <param name="state">user state</param> /// <param name="dataServiceRequest">request object.</param> /// <param name="plan">Projection plan for materialization; possibly null.</param> /// <param name="isContinuation">Whether this request is a continuation request.</param> internal LoadPropertyResult(object entity, string propertyName, DataServiceContext context, ODataRequestMessageWrapper request, AsyncCallback callback, object state, DataServiceRequest dataServiceRequest, ProjectionPlan plan, bool isContinuation) : base(context, Util.LoadPropertyMethodName, dataServiceRequest, request, new RequestInfo(context, isContinuation), callback, state) { this.entity = entity; this.propertyName = propertyName; this.plan = plan; }
public DataServicePackageRepository(Uri uri) { _context = new DataServiceContext(uri); _context.SendingRequest += OnSendingRequest; _context.IgnoreMissingProperties = true; _context.Credentials = CredentialCache.DefaultCredentials; }
private ExpressionWriter(DataServiceContext context) { Debug.Assert(context != null, "context != null"); this.context = context; this.builder = new StringBuilder(); this.expressionStack = new Stack<Expression>(); this.expressionStack.Push(null); }
/// <summary> /// Initializes a new instance of the <see cref="EntityTrackingAdapter" /> class. /// </summary> /// <param name="entityTracker">The entity tracker.</param> /// <param name="mergeOption">The merge option.</param> /// <param name="model">The model.</param> /// <param name="context">The context.</param> internal EntityTrackingAdapter(EntityTrackerBase entityTracker, MergeOption mergeOption, ClientEdmModel model, DataServiceContext context) { this.MaterializationLog = new AtomMaterializerLog(mergeOption, model, entityTracker); this.MergeOption = mergeOption; this.EntityTracker = entityTracker; this.Model = model; this.Context = context; }
private static void AnalyzeResourceExpression(LambdaExpression lambda, ResourceExpression resource, DataServiceContext context) { PathBox pb = new PathBox(); Analyze(lambda, pb, context); resource.Projection = new ProjectionQueryOptionExpression(lambda.Body.Type, lambda, pb.ProjectionPaths.ToList<string>()); resource.ExpandPaths = pb.ExpandPaths.Union<string>(resource.ExpandPaths, StringComparer.Ordinal).ToList<string>(); resource.RaiseUriVersion(pb.UriVersion); }
/// <summary> /// Initializes a new instance of the <see cref="DataServiceClientFormat"/> class. /// </summary> /// <param name="context">DataServiceContext instance associated with this format.</param> internal DataServiceClientFormat(DataServiceContext context) { Debug.Assert(context != null, "Context cannot be null for DataServiceClientFormat"); // On V6.0.2, we change the default format to be json for the client this.ODataFormat = ODataFormat.Json; this.context = context; }
// Methods public ReportWatchViewModel() { this.context = new DataServiceContext(new Uri("http://localhost:55555/ReportWatchService.svc", UriKind.Absolute)); SymbolQueryBegin(); IndexQueryBegin("^DJI"); IndexQueryBegin("^GSPC"); IndexQueryBegin("^IXIC"); }
internal static void Translate(DataServiceContext context, bool addTrailingParens, Expression e, out Uri uri, out Version version) { var writer = new UriWriter(context); writer.leafResourceSet = addTrailingParens ? (e as ResourceSetExpression) : null; writer.Visit(e); uri = Util.CreateUri(context.BaseUriWithSlash, Util.CreateUri(writer.uriBuilder.ToString(), UriKind.Relative)); version = writer.uriVersion; }
public static EntityDescriptor GetEntityDescriptor(this DataServiceContext context, object entity) { ExceptionUtilities.CheckArgumentNotNull(context, "context"); return(context.Entities.Where(e => e.Entity == entity).SingleOrDefault()); }
public void SDPC_QORFullLoad() { using (Utils.ConfigurationCacheCleaner()) using (Utils.RestoreStaticValueOnDispose(typeof(SimpleDataServiceHelper), "PageSizeCustomizer")) { SimpleDataServiceHelper.PageSizeCustomizer = PageSizeCustomizerFast; SimpleWorkspace workspace = this.NorthwindWorkspacePaged; Uri baseUri = new Uri(workspace.ServiceEndPoint + workspace.ServiceContainer.Name + ".svc", UriKind.Absolute); DataServiceContext ctx = new DataServiceContext(baseUri); //ctx.EnableAtom = true; //ctx.Format.UseAtom(); var q = ctx.CreateQuery <northwindBinding.Customers>("Customers").Expand("Orders"); int totalCustomerCount = q.Count(); int totalOrdersCount = ctx.CreateQuery <northwindBinding.Orders>("Orders").Count(); var qor = q.Execute() as QueryOperationResponse <northwindBinding.Customers>; DataServiceQueryContinuation <northwindBinding.Customers> nextCustLink = null; int custCount = 0; int orderCount = 0; do { ICollection previousOrderCollection = null; foreach (var c in qor) { try { if (previousOrderCollection != null) { qor.GetContinuation(previousOrderCollection); Assert.Fail("Out of scope collection did not throw"); } } catch (ArgumentException) { } var nextOrderLink = qor.GetContinuation(c.Orders); while (nextOrderLink != null) { if (custCount % 2 == 0) { var innerQOR = ctx.Execute <northwindBinding.Orders>(nextOrderLink) as QueryOperationResponse <northwindBinding.Orders>; foreach (var innerOrder in innerQOR) { ctx.AttachLink(c, "Orders", innerOrder); c.Orders.Add(innerOrder); } nextOrderLink = innerQOR.GetContinuation(); } else { nextOrderLink = ctx.LoadProperty(c, "Orders", nextOrderLink).GetContinuation(); } } previousOrderCollection = c.Orders; orderCount += c.Orders.Count; custCount++; } nextCustLink = qor.GetContinuation(); if (nextCustLink != null) { qor = ctx.Execute <northwindBinding.Customers>(nextCustLink) as QueryOperationResponse <northwindBinding.Customers>; } } while (nextCustLink != null); Assert.AreEqual(totalCustomerCount, custCount); Assert.AreEqual(totalOrdersCount, orderCount); Assert.AreEqual(totalOrdersCount, ctx.Links.Count); Assert.AreEqual(totalCustomerCount + totalOrdersCount, ctx.Entities.Count); } }
/// <summary> /// Serialize the operation parameters and put them in a dictionary. /// </summary> /// <param name="context">The context.</param> /// <param name="parameters">The parameters.</param> /// <returns>A dictionary where the key is the parameter name, and the value is the serialized parameter value.</returns> internal static Dictionary <string, string> SerializeOperationParameters(this DataServiceContext context, UriOperationParameter[] parameters) { return(parameters.ToDictionary(parameter => parameter.Name, parameter => Serializer.GetParameterValue(context, parameter))); }
/// <summary>Creates a materializer for partial result sets.</summary> /// <param name="context">Context of expression to analyze.</param> /// <param name="results">The current page of results</param> /// <param name="continuation">The continuation for the results.</param> /// <returns>A new materializer.</returns> internal static MaterializeAtom CreateWrapper(DataServiceContext context, IEnumerable results, DataServiceQueryContinuation continuation) { return(new ResultsWrapper(context, results, continuation)); }
public void Init() { this.serviceEdmModel = new EdmModel(); // Enum type this.genreEnumTypeName = "ServiceNS.Genre"; this.genreEnumType = new EdmEnumType("ServiceNS", "Genre"); this.genreEnumType.AddMember(new EdmEnumMember(this.genreEnumType, "Thriller", new EdmEnumMemberValue(1))); this.genreEnumType.AddMember(new EdmEnumMember(this.genreEnumType, "SciFi", new EdmEnumMemberValue(2))); this.genreEnumType.AddMember(new EdmEnumMember(this.genreEnumType, "Epic", new EdmEnumMemberValue(3))); this.serviceEdmModel.AddElement(this.genreEnumType); // Complex type this.addressComplexTypeName = "ServiceNS.Address"; this.addressComplexType = new EdmComplexType("ServiceNS", "Address", null /* baseType */, false /* isAbstract */, true /* isOpen */); this.addressComplexType.AddStructuralProperty("AddressLine", EdmPrimitiveTypeKind.String); this.addressComplexType.AddStructuralProperty("City", EdmPrimitiveTypeKind.String); this.serviceEdmModel.AddElement(this.addressComplexType); // Nested complex type this.nextOfKinComplexTypeName = "ServiceNS.NextOfKin"; this.nextOfKinComplexType = new EdmComplexType("ServiceNS", "NextOfKin"); this.nextOfKinComplexType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); this.nextOfKinComplexType.AddStructuralProperty("HomeAddress", new EdmComplexTypeReference(this.addressComplexType, true)); this.serviceEdmModel.AddElement(this.nextOfKinComplexType); // Director entity type this.directorEntitySetName = "Directors"; this.directorEntityTypeName = "ServiceNS.Director"; this.directorEntityType = new EdmEntityType("ServiceNS", "Director", null /* baseType */, false /* isAbstract */, true /* isOpen */); // Open type this.directorEntityType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); this.directorEntityType.AddKeys(this.directorEntityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false)); this.serviceEdmModel.AddElement(directorEntityType); // Editor entity type this.editorEntitySetName = "Editors"; this.editorEntityTypeName = "ServiceNS.Editor"; this.editorEntityType = new EdmEntityType("ServiceNS", "Editor", null /* baseType */, false /* isAbstract */, true /* isOpen */); // Open type this.editorEntityType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); this.editorEntityType.AddKeys(this.editorEntityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false)); this.serviceEdmModel.AddElement(editorEntityType); // Producer entity type this.producerEntitySetName = "Producers"; this.producerEntityTypeName = "ServiceNS.Producer"; this.producerEntityType = new EdmEntityType("ServiceNS", "Producer"); // Not an open type this.producerEntityType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); this.producerEntityType.AddKeys(this.producerEntityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false)); this.serviceEdmModel.AddElement(producerEntityType); // Actor entity type this.actorEntitySetName = "Actors"; this.actorEntityTypeName = "ServiceNS.Actor"; this.actorEntityType = new EdmEntityType("ServiceNS", "Actor", null /* baseType */, false /* isAbstract */, true /* isOpen */); // Open type this.actorEntityType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); this.actorEntityType.AddKeys(this.actorEntityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false)); this.serviceEdmModel.AddElement(actorEntityType); // Award entity type this.awardEntitySetName = "Awards"; this.awardEntityTypeName = "ServiceNS.Award"; this.awardEntityType = new EdmEntityType("ServiceNS", "Award"); // Not an open type this.awardEntityType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); this.awardEntityType.AddKeys(this.awardEntityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false)); this.serviceEdmModel.AddElement(awardEntityType); // Entity container EdmEntityContainer container = new EdmEntityContainer("ServiceNS", "Container"); container.AddEntitySet(this.directorEntitySetName, this.directorEntityType, true); container.AddEntitySet(this.editorEntitySetName, this.editorEntityType, true); container.AddEntitySet(this.producerEntitySetName, this.producerEntityType, true); container.AddEntitySet(this.actorEntitySetName, this.actorEntityType, true); container.AddEntitySet(this.awardEntitySetName, this.awardEntityType, true); this.serviceEdmModel.AddElement(container); this.clientEdmModel = new ClientEdmModel(ODataProtocolVersion.V4); this.context = new DataServiceContext(new Uri("http://tempuri.org/"), ODataProtocolVersion.V4, this.clientEdmModel); this.context.UndeclaredPropertyBehavior = UndeclaredPropertyBehavior.Support; this.context.Format.UseJson(this.serviceEdmModel); var serverTypeNames = new[] { this.genreEnumTypeName, this.addressComplexTypeName, this.nextOfKinComplexTypeName, this.directorEntityTypeName, this.editorEntityTypeName, this.producerEntityTypeName, this.actorEntityTypeName, this.awardEntityTypeName }; this.context.ResolveName = type => { // Lazy approach to resolving server type names - alternative would be multiple if/else blocks return(serverTypeNames.FirstOrDefault(d => d.EndsWith(type.Name, StringComparison.Ordinal))); }; var serverTypeNameToClientTypeMapping = new Dictionary <string, Type> { { this.genreEnumTypeName, typeof(Genre) }, { this.addressComplexTypeName, typeof(Address) }, { this.nextOfKinComplexTypeName, typeof(NextOfKin) }, { this.directorEntityTypeName, typeof(Director) }, { this.producerEntityTypeName, typeof(Producer) }, { this.editorEntityTypeName, typeof(Editor) }, { this.actorEntityTypeName, typeof(Actor) }, { this.awardEntityTypeName, typeof(Award) } }; this.context.ResolveType = name => { if (!serverTypeNameToClientTypeMapping.ContainsKey(name)) { return(null); } // Lazy approach to resolving client types - alternative would be multiple if/else blocks return(serverTypeNameToClientTypeMapping[name]); }; this.typeNameToEntitySetMapping = new Dictionary <string, string> { { typeof(Director).Name, this.directorEntitySetName }, { typeof(Editor).Name, this.editorEntitySetName }, { typeof(Producer).Name, this.producerEntitySetName }, { typeof(Actor).Name, this.actorEntitySetName } }; }
public static DataServiceContext ReConfigureForNetworkLoadingTests(this DataServiceContext context) { context.Format.InjectMetadataHttpNetworkRequest = InjectFakeEdmxRequest; return(context); }
public static void AddObject <TEntity>(this DataServiceContext dataServiceContext, TEntity entity) { var entitySetName = new EnglishPluralizationService().Pluralize(typeof(TEntity).Name); dataServiceContext.AddObject(entitySetName, entity); }
/// <summary> /// A Factory class to use in selecting the implementation to use depending on the /// </summary> /// <param name="args"></param> /// <param name="dataServiceContext"></param> /// <returns></returns> public DataServiceClientRequestMessage CreateRequestMessage(DataServiceClientRequestMessageArgs args, DataServiceContext dataServiceContext) { if (dataServiceContext.HttpRequestTransportMode == HttpRequestTransportMode.HttpWebRequest) { return(new HttpWebRequestMessage(args)); } else { return(new HttpClientRequestMessage(args)); } }
/// <summary> /// Create a new instance of <see cref="ClientCreatedArgs"/> /// </summary> /// <param name="name">the logical name of the client.</param> /// <param name="container">the instance of data service context for client communication.</param> public ClientCreatedArgs(string name, DataServiceContext container) { this.Name = name; this.ODataClient = container; }
public static Task <DataServiceStreamResponse> GetReadStreamAsync(this DataServiceContext context, object entity, DataServiceRequestArgs args, object state) { return(Task.Factory.FromAsync <object, DataServiceRequestArgs, DataServiceStreamResponse>(context.BeginGetReadStream, context.EndGetReadStream, entity, args, state)); }
public static LinkDescriptor GetLinkDescriptor(this DataServiceContext context, object source, string sourceProperty, object target) { ExceptionUtilities.CheckArgumentNotNull(context, "context"); return(context.Links.Where(l => l.Source == source && l.Target == target && l.SourceProperty == sourceProperty).SingleOrDefault()); }
public void BlobStreamSaveChanges() { using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf()) using (PlaybackService.InspectRequestPayload.Restore()) using (PlaybackService.OverridingPlayback.Restore()) { request.ServiceType = typeof(PlaybackService); request.ForceVerboseErrors = true; request.StartService(); byte[] content = new byte[] { 1, 2, 3 }; DataServiceContext ctx = new DataServiceContext(new Uri(request.BaseUri, UriKind.RelativeOrAbsolute)); ctx.EnableAtom = true; ctx.Format.UseAtom(); Stream stream = new MemoryStream(content); ClientCSharpRegressionTests.CustomerWithStream customer = new ClientCSharpRegressionTests.CustomerWithStream() { ID = 1, Name = "Foo" }; ctx.AddObject("Customers", customer); ctx.SetSaveStream(customer, stream, true, new DataServiceRequestArgs() { ContentType = "application/jpeg" }); EntityDescriptor ed = ctx.Entities[0]; int i = 0; string id = "http://myidhost/somerandomIDUrl"; string selfLink = request.BaseUri + "/self-link/Customer(1)"; string editLink = request.BaseUri + "/edit-link/Customer(1)"; string etag = "someetagvalue"; string serverTypeName = "SomeRandomTypeName"; string editMediaLink = "http://myhost/somerandomeUrl/edit-media-link/v1"; string readMediaLink = "http://myedithost/somerandomUrl/foo/self-media-link/v1"; string streamETag = "somerandomeStreamETag"; string mediaType = "application/jpeg"; string locationHeader = "http://mylocationhost/somerandomUrl/location/"; PlaybackService.InspectRequestPayload.Value = (message) => { if (i == 0) { string xml = MediaEntry( id: id, selfLink: selfLink, editLink: editLink, etag: etag, properties: "<d:ID>5</d:ID>", serverTypeName: serverTypeName, readStreamUrl: readMediaLink, editStreamUrl: editMediaLink, mediaETag: streamETag, mediaType: mediaType); // The response payload has some random location header and no etag header. // Verify that the edit link, etag and type name are used from the payload. string responsePayload = "HTTP/1.1 201 Created" + Environment.NewLine + "Content-Type: application/atom+xml" + Environment.NewLine + "Location: " + locationHeader + Environment.NewLine + Environment.NewLine + xml; PlaybackService.OverridingPlayback.Value = responsePayload; } else if (i == 1) { // Make sure that no metadata from the payload is merged yet into the public entity descriptor // In V2, we already set the edit link and id to the location header. So that part cannot be changed now. Assert.AreEqual(ed.Identity, locationHeader, "id must be set to location header"); Assert.AreEqual(ed.EditLink.AbsoluteUri, locationHeader, "edit link value must be equal to the location header"); Assert.AreEqual(ed.SelfLink, null, "Self link must not be populated"); Assert.AreEqual(ed.ETag, null, "etag must be null"); Assert.AreEqual(ed.ServerTypeName, null, "server type name must be null"); Assert.AreEqual(ed.EditStreamUri, null, "edit media stream must be null"); Assert.AreEqual(ed.ReadStreamUri, null, "read media stream must be null"); Assert.AreEqual(ed.StreamETag, null, "stream etag must be null"); // no response for PUT string responsePayload = "HTTP/1.1 200 OK" + Environment.NewLine + "Content-Type: application/atom+xml" + Environment.NewLine + Environment.NewLine; PlaybackService.OverridingPlayback.Value = responsePayload; } i++; }; ctx.SaveChanges(); Assert.IsTrue(i == 2, "only 2 requests should be sent to the server)"); // Make sure the edit link from the payload is used, not the location header Assert.IsTrue(PlaybackService.LastPlayback.Contains("PATCH " + editLink), "should use edit link from the POST response payload"); // make sure the etag is used from the payload Assert.IsTrue(PlaybackService.LastPlayback.Contains("If-Match: W/\"" + etag + "\""), "should use the etag value from the POST response payload"); // make sure the type is used from the payload Assert.IsTrue(PlaybackService.LastPlayback.Contains("category term=\"#" + serverTypeName + "\" scheme=\"http://docs.oasis-open.org/odata/ns/scheme\""), "should use the server type name as specified in the POST response payload"); Assert.AreEqual(ed.Identity, id, "id must be set to location header"); Assert.AreEqual(ed.EditLink.AbsoluteUri, editLink, "edit link value must be equal to the location header"); Assert.AreEqual(ed.SelfLink, selfLink, "Self link should be populated"); Assert.AreEqual(ed.ETag, null, "etag must be null, since the PATCH response didn't send any etag in the response header"); Assert.AreEqual(ed.ServerTypeName, serverTypeName, "server type name must NOT be null"); Assert.AreEqual(ed.EditStreamUri, editMediaLink, "edit media stream must NOT be null"); Assert.AreEqual(ed.ReadStreamUri, readMediaLink, "read media stream must NOT be null"); Assert.AreEqual(ed.StreamETag, streamETag, "stream etag must NOT be null"); } }
protected BaseRepositoryReadOnly(DataServiceContext context) { _context = context; }
public TransportLayerThatRemembersIfMatchAndAlwaysSendsBack204(DataServiceContext context) : base(context) { // Do nothing }
public void Init() { this.testSubject = new DataServiceContext(new Uri("http://base.org/")); }
private SessionRow GetSession(string id) { DataServiceContext svc = CreateDataServiceContext(); return(GetSession(id, svc)); }
/// <summary> /// Creates materializer for results /// </summary> /// <param name="context">Context of expression to analyze.</param> /// <param name="results">the results to wrap</param> /// <returns>a new materializer</returns> internal static MaterializeAtom CreateWrapper(DataServiceContext context, IEnumerable results) { return(new ResultsWrapper(context, results, null)); }
/// <summary> /// Creates a wrapper for raw results /// </summary> /// <param name="context">Context of expression to analyze.</param> /// <param name="results">the results to wrap</param> /// <param name="continuation">The continuation for this query.</param> internal ResultsWrapper(DataServiceContext context, IEnumerable results, DataServiceQueryContinuation continuation) { this.context = context; this.results = results ?? new object[0]; this.continuation = continuation; }
public static Task <QueryOperationResponse> LoadPropertyAsync(this DataServiceContext context, object entity, string propertyName, Uri nextLinkUri, object state) { return(Task.Factory.FromAsync <object, string, Uri, QueryOperationResponse>(context.BeginLoadProperty, context.EndLoadProperty, entity, propertyName, nextLinkUri, state)); }
/// <summary>Constructs a query provider based on the context passed in </summary> /// <param name="context">The context for the query provider</param> internal DataServiceQueryProvider(DataServiceContext context) { this.Context = context; }
/// <summary> /// Private constructor for creating UriWriter /// </summary> /// <param name='context'>Data context used to generate type names for types.</param> private UriWriter(DataServiceContext context) { Debug.Assert(context != null, "context != null"); this.context = context; this.uriVersion = Util.ODataVersion4; }
public static Task <DataServiceResponse> SaveChangesAsync(this DataServiceContext context, SaveChangesOptions options, object state) { return(Task.Factory.FromAsync <SaveChangesOptions, DataServiceResponse>(context.BeginSaveChanges, context.EndSaveChanges, options, state)); }
public void Init() { this.v3Context = new DataServiceContext(new Uri("http://temp.org/"), ODataProtocolVersion.V4); this.v3TestSubject = this.v3Context.Format; }
public ODataPropertyConverterTests() { this.serverModel = new EdmModel(); this.serverEntityType = new EdmEntityType("Server.NS", "ServerEntityType"); this.serverEntityTypeName = "Server.NS.ServerEntityType"; this.serverModel.AddElement(this.serverEntityType); this.serverEntityType.AddKeys(this.serverEntityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32)); var addressType = new EdmComplexType("Server.NS", "Address"); addressType.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String); this.serverEntityType.AddStructuralProperty("Address", new EdmComplexTypeReference(addressType, true)); this.serverComplexTypeName = "Server.NS.Address"; var homeAddressType = new EdmComplexType("Server.NS", "HomeAddress", addressType); homeAddressType.AddStructuralProperty("FamilyName", EdmPrimitiveTypeKind.String); this.serverComplexTypeName = "Server.NS.HomeAddress"; var colorType = new EdmEnumType("Server.NS", "Color"); colorType.AddMember(new EdmEnumMember(colorType, "Red", new EdmEnumMemberValue(1))); colorType.AddMember(new EdmEnumMember(colorType, "Blue", new EdmEnumMemberValue(2))); colorType.AddMember(new EdmEnumMember(colorType, "Green", new EdmEnumMemberValue(3))); this.serverEntityType.AddStructuralProperty("Color", new EdmEnumTypeReference(colorType, false)); this.serverEntityType.AddStructuralProperty("Nicknames", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt32(false)))); this.serverEntityType.AddStructuralProperty("OtherAddresses", new EdmCollectionTypeReference(new EdmCollectionType(new EdmComplexTypeReference(addressType, false)))); this.clientModel = new ClientEdmModel(ODataProtocolVersion.V4); this.clientTypeAnnotation = this.clientModel.GetClientTypeAnnotation(typeof(TestClientEntityType)); this.context = new DataServiceContext(new Uri("http://temp/"), ODataProtocolVersion.V4, this.clientModel); this.context.Format.UseJson(this.serverModel); this.testSubject = new ODataPropertyConverter(new RequestInfo(this.context)); this.context.Format.UseJson(this.serverModel); this.context.ResolveName = t => { if (t == typeof(TestClientEntityType)) { return(this.serverEntityTypeName); } if (t == typeof(Address)) { return(this.serverComplexTypeName); } return(null); }; this.entity = new TestClientEntityType { Id = 1, Name = "foo", Number = 1.23f, Address = new Address(), OpenAddress = new Address(), Nicknames = new string[0], OtherAddresses = new[] { new Address() }, Color = 0 }; this.entityWithDerivedComplexProperty = new TestClientEntityType { Id = 1, Name = "foo", Number = 1.23f, Address = new HomeAddress(), OpenAddress = new Address(), Nicknames = new string[0], OtherAddresses = new[] { new Address() } }; this.entityWithDerivedComplexInCollection = new TestClientEntityType { Id = 1, Name = "foo", Number = 1.23f, Address = new HomeAddress(), OpenAddress = new Address(), Nicknames = new string[0], OtherAddresses = new[] { new Address(), new HomeAddress() } }; }
public void PerTestCleanup() { this.ctx = null; }
/// <summary> /// Initializes a new instance of the <see cref="AssetFileCollection"/> class. /// </summary> /// <param name="cloudMediaContext">The cloud media context.</param> internal AssetFileCollection(CloudMediaContext cloudMediaContext) { _cloudMediaContext = cloudMediaContext; this._dataContext = cloudMediaContext.DataContextFactory.CreateDataServiceContext(); this._assetFileQuery = new Lazy <IQueryable <IAssetFile> >(() => this._dataContext.CreateQuery <AssetFileData>(FileSet)); }
public static Task <IEnumerable <T> > ExecuteAsync <T>(this DataServiceContext context, Uri requestUri, object state) { return(Task.Factory.FromAsync <Uri, IEnumerable <T> >(context.BeginExecute <T>, context.EndExecute <T>, requestUri, state)); }
public void NamedStreams_NestedQuery_1() { // projecting out deep links to get stream url in DSSL property - both narrow type and anonymous type { // Querying url of the nested type - doing this makes the entity non-tracking, but populated the link property DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4); //context.EnableAtom = true; //context.Format.UseAtom(); var q = from s in context.CreateQuery <EntityWithNamedStreams1>("MySet1") select new EntityWithNamedStreams1 { ID = s.ID, Stream1 = s.Stream1, Ref = new EntityWithNamedStreams1 { ID = s.Ref.ID, RefStream1 = s.Ref.RefStream1 }, Collection = (from c in s.Collection select new EntityWithNamedStreams2() { ID = c.ID, ColStream = c.ColStream }).ToList() }; Assert.AreEqual(request.ServiceRoot.AbsoluteUri + "/MySet1?$expand=Ref($select=ID),Ref($select=RefStream1),Collection($select=ID),Collection($select=ColStream)&$select=ID,Stream1", q.ToString(), "make sure the right uri is produced by the linq translator"); foreach (var o in q) { Assert.IsNotNull(o.Stream1, "Stream11 must have some value"); Assert.AreEqual(o.Stream1.EditLink, context.GetReadStreamUri(o, "Stream1"), "the stream url for Stream1 must be populated correctly"); Assert.AreEqual(o.Ref.RefStream1.EditLink, context.GetReadStreamUri(o.Ref, "RefStream1"), "the stream url for RefStream1 must be populated correctly"); foreach (var c in o.Collection) { Assert.AreEqual(c.ColStream.EditLink, context.GetReadStreamUri(c, "ColStream"), "the url for the nested collection entity should match"); } } Assert.AreEqual(context.Entities.Count, 3, "there should be 3 entities tracked by the context"); Assert.AreEqual(context.Entities[0].EditLink.AbsoluteUri, request.ServiceRoot.AbsoluteUri + "/MySet1(1)", "top level entity must be tracked"); Assert.AreEqual(context.Entities[1].EditLink.AbsoluteUri, request.ServiceRoot.AbsoluteUri + "/MySet2(3)", "the nested entity must be tracked"); Assert.AreEqual(context.Entities[2].EditLink.AbsoluteUri, request.ServiceRoot.AbsoluteUri + "/MySet3('ABCDE')", "top level entity must be tracked"); } { // Querying url of the nested type - doing this makes the entity non-tracking, but populated the link property DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4); //context.EnableAtom = true; //context.Format.UseAtom(); var q = from s in context.CreateQuery <EntityWithNamedStreams1>("MySet1") select new { ID = s.ID, Stream1Url = s.Stream1, Ref = new { ID = s.Ref.ID, Stream1Url = s.Ref.RefStream1 }, Collection = (from c in s.Collection select new { Name = c.Name, Stream1Url = c.ColStream }) }; Assert.AreEqual(request.ServiceRoot.AbsoluteUri + "/MySet1?$expand=Ref($select=ID),Ref($select=RefStream1),Collection($select=Name),Collection($select=ColStream)&$select=ID,Stream1", q.ToString(), "make sure the right uri is produced by the linq translator"); foreach (var o in q) { Assert.AreEqual(o.Stream1Url.EditLink, request.ServiceRoot.AbsoluteUri + "/MySet1(1)/Stream1", "the stream url for Stream1 must be populated correctly"); Assert.AreEqual(o.Ref.Stream1Url.EditLink, request.ServiceRoot.AbsoluteUri + "/MySet2(3)/RefStream1", "the stream url for RefStream1 must be populated correctly"); Assert.AreEqual(o.Collection.First().Stream1Url.EditLink, request.ServiceRoot.AbsoluteUri + "/MySet3('ABCDE')/ColStream", "the stream url of the collection stream must be populated correctly - index 0"); } Assert.AreEqual(context.Entities.Count, 0, "there should be no entities tracked by the context"); } }
public void NamedStreams_NestedQuery_2() { // projecting out collection of collection properties - both narrow type and anonymous type { // Querying url of the nested type - doing this makes the entity non-tracking, but populated the link property DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4); //context.EnableAtom = true; //context.Format.UseAtom(); DataServiceQuery <EntityWithNamedStreams1> q = (DataServiceQuery <EntityWithNamedStreams1>) from s in context.CreateQuery <EntityWithNamedStreams1>("MySet1") select new EntityWithNamedStreams1 { ID = s.ID, Stream1 = s.Stream1, Collection = (from c in s.Collection select new EntityWithNamedStreams2() { ID = c.ID, ColStream = c.ColStream, Collection1 = (from c1 in c.Collection1 select new EntityWithNamedStreams1() { ID = c1.ID, RefStream1 = c1.RefStream1 }).ToList() }).ToList() }; Assert.AreEqual(request.ServiceRoot.AbsoluteUri + "/MySet1?$expand=Collection($select=ID),Collection($select=ColStream),Collection($expand=Collection1($select=ID)),Collection($expand=Collection1($select=RefStream1))&$select=ID,Stream1", q.ToString(), "make sure the right uri is produced by the linq translator"); var response = (QueryOperationResponse <EntityWithNamedStreams1>)q.Execute(); DataServiceQueryContinuation <EntityWithNamedStreams2> continuation = null; foreach (var o in response) { Assert.IsNotNull(o.Stream1.EditLink, "Stream1 should not be null"); Assert.AreEqual(o.Stream1.EditLink, context.GetReadStreamUri(o, "Stream1"), "the stream url for Stream1 must be populated correctly"); foreach (var c in o.Collection) { Assert.IsNotNull(c.ColStream.EditLink, "ColStream should not be null"); Assert.AreEqual(c.ColStream.EditLink, context.GetReadStreamUri(c, "ColStream"), "the url for the nested collection entity should match - Level 0"); foreach (var c1 in c.Collection1) { Assert.IsNotNull(c1.RefStream1.EditLink, "RefStream1 should not be null"); Assert.AreEqual(c1.RefStream1.EditLink, context.GetReadStreamUri(c1, "RefStream1"), "the url for the nested collection entity should match - Level 1"); } } // Make sure you get the continuation token for the collection and try and get the next page continuation = response.GetContinuation(o.Collection); } Assert.AreEqual(context.Entities.Count, 3, "there should be 3 entities tracked by the context"); Assert.AreEqual(context.Entities[0].EditLink.AbsoluteUri, request.ServiceRoot.AbsoluteUri + "/MySet1(1)", "top level entity must be tracked"); Assert.AreEqual(context.Entities[1].EditLink.AbsoluteUri, request.ServiceRoot.AbsoluteUri + "/MySet3('ABCDE')", "top level entity must be tracked"); Assert.AreEqual(context.Entities[2].EditLink.AbsoluteUri, request.ServiceRoot.AbsoluteUri + "/MySet2(3)", "the nested entity must be tracked"); Assert.IsNotNull(continuation, "since SDP is turned on, we should get the continuation token"); // Get the next page and make sure we get the right entity and the link is populated. foreach (var entity in context.Execute(continuation)) { Assert.IsNotNull(entity.ColStream.EditLink, "ColStream should not be null"); Assert.AreEqual(entity.ColStream.EditLink, context.GetReadStreamUri(entity, "ColStream"), "the url for the nested collection entity should match - Level 1"); foreach (var c1 in entity.Collection1) { Assert.IsNotNull(c1.RefStream1.EditLink, "RefStream1 should not be null"); Assert.AreEqual(c1.RefStream1.EditLink, context.GetReadStreamUri(c1, "RefStream1"), "the url for the nested collection entity should match - Level 1"); } } Assert.AreEqual(context.Entities.Count, 4, "there should be 4 entities tracked by the context"); } { // Querying url of the nested type - doing this makes the entity non-tracking, but populated the link property DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4); //context.EnableAtom = true; //context.Format.UseAtom(); var q = from s in context.CreateQuery <EntityWithNamedStreams1>("MySet1") select new { ID = s.ID, Stream1Url = s.Stream1, Collection = (from c in s.Collection select new { Name = c.Name, Stream1Url = c.ColStream, Collection1 = (from c1 in c.Collection1 select new { ID = c1.ID, Stream1Url = c1.RefStream1 }) }) }; Assert.AreEqual(request.ServiceRoot.AbsoluteUri + "/MySet1?$expand=Collection($select=Name),Collection($select=ColStream),Collection($expand=Collection1($select=ID)),Collection($expand=Collection1($select=RefStream1))&$select=ID,Stream1", q.ToString(), "make sure the right uri is produced by the linq translator"); foreach (var o in q) { Assert.AreEqual(o.Stream1Url.EditLink, request.ServiceRoot.AbsoluteUri + "/MySet1(1)/Stream1", "the stream url for Stream1 must be populated correctly"); Assert.AreEqual(o.Collection.First().Stream1Url.EditLink, request.ServiceRoot.AbsoluteUri + "/MySet3('ABCDE')/ColStream", "the stream url of the collection stream must be populated correctly - index 0"); Assert.AreEqual(o.Collection.First().Collection1.Single().Stream1Url.EditLink, request.ServiceRoot.AbsoluteUri + "/MySet2(3)/RefStream1", "the stream url of the collection stream must be populated correctly - index 0 - index 0"); } Assert.AreEqual(context.Entities.Count, 0, "there should be no entities tracked by the context"); } }