public async Task DataServiceActionQueryExecuteAsyncCancellationTokenTest() { var source = new CancellationTokenSource(); var context = this.CreateWrappedContext <DefaultContainer>().Context; Customer c1 = new Customer { CustomerId = 11, Name = "customerOne" }; context.AddToCustomer(c1); Customer c2 = new Customer { CustomerId = 22, Name = "customerTwo" }; context.AddToCustomer(c2); await context.SaveChangesAsync(); AuditInfo auditInfo = new AuditInfo() { ModifiedDate = new DateTimeOffset() }; DataServiceQuerySingle <Customer> customer = context.Customer.ByKey(11); DataServiceActionQuery getComputerAction = customer.ChangeCustomerAuditInfo(auditInfo); Task response() => getComputerAction.ExecuteAsync(source.Token); source.Cancel(); var exception = await Assert.ThrowsAsync <OperationCanceledException>(response); Assert.Equal("The operation was canceled.", exception.Message); this.EnqueueTestComplete(); }
/// <summary>Create a query of a single item based on another one.</summary> /// <param name="query">The query.</param> public DataServiceQuerySingle(DataServiceQuerySingle <TElement> query) { this.Context = query.Context; this.Query = query.Query; this.IsComposable = query.IsComposable; this.isFunction = query.isFunction; }
/// <summary> /// Gets the value. /// </summary> /// <typeparam name="T">The type.</typeparam> /// <param name="query">The query.</param> /// <returns>A value</returns> public static T GetValue <T>(DataServiceQuerySingle <T> query) { var tries = 0; var maxTries = 3; var watch = new Stopwatch(); watch.Start(); while (tries < maxTries) { try { var result = query.GetValueAsync().Result; watch.Stop(); LogInfo($" <.><.> GetValue<T>: {query.RequestUri}: {watch.ElapsedMilliseconds}ms"); return(result); } catch (DataServiceQueryException ex) { LogError($"Exception {ex.InnerException.Message} on GetValue:{ex.Response.Query}", typeof(Proxy)); return(default(T)); } catch (AggregateException ex) { foreach (var e in ex.InnerExceptions) { if (e is DataServiceQueryException dataserviceQueryException) { switch (dataserviceQueryException.Response.StatusCode) { case 404: // If the item is not found, we return a null. // That is easier to code for than throwing an exception LogError($"Entity Not Found Exception (404) - Query: {dataserviceQueryException.Response.Query} - Message:{dataserviceQueryException.Message}", typeof(Proxy)); return(default(T)); default: LogError($"Query Exception - Query:{dataserviceQueryException.Response.Query} - Message:{dataserviceQueryException.Message}", typeof(Proxy)); throw dataserviceQueryException; } } LogError($"Exception {e.GetType()}: {e.Message} on GetValue:{query.RequestUri}", typeof(Proxy)); throw e; } } catch (Exception ex) { LogError($"Exception {ex.GetType()}: {ex.Message} GetValue:{query.RequestUri}", typeof(Proxy)); throw; } tries++; Thread.Sleep(100); } throw new CommerceServiceQuerySingleException(query.RequestUri.ToString()); }
/// <summary> /// Gets the value. /// </summary> /// <typeparam name="T">The type.</typeparam> /// <param name="query">The query.</param> /// <returns>A value</returns> public static T GetValue <T>(DataServiceQuerySingle <T> query) { var tries = 0; var maxTries = 3; var watch = new Stopwatch(); watch.Start(); while (tries < maxTries) { try { var result = query.GetValueAsync().Result; watch.Stop(); Console.WriteLine($" <.><.> GetValue<T>: {query.RequestUri}: {watch.ElapsedMilliseconds}ms"); return(result); } catch (DataServiceQueryException ex) { WriteColoredLine(ConsoleColor.Red, $"Exception {ex.InnerException.Message} on GetValue:{ex.Response.Query}"); } catch (AggregateException ex) { WriteColoredLine(ConsoleColor.Red, $"Aggregate Exception {ex.InnerException.Message}"); var exception = ex.InnerException as DataServiceQueryException; if (exception != null) { var dataserviceQueryException = exception; switch (dataserviceQueryException.Response.StatusCode) { case 404: // If the item is not found, we return a null. // That is easier to code for than throwing an exception WriteColoredLine(ConsoleColor.Red, $"Entity Not Found Exception (404) - Query: {dataserviceQueryException.Response.Query}"); return(default(T)); default: WriteColoredLine(ConsoleColor.Red, $"Query Exception - Query:{dataserviceQueryException.Response.Query} - Message:{dataserviceQueryException.Message}"); throw dataserviceQueryException; } } } catch (Exception ex) { WriteColoredLine(ConsoleColor.Red, $"Unknown Exception {ex.Message} GetValue:{query.RequestUri}"); } tries++; Thread.Sleep(100); } throw new CommerceServiceQuerySingleException(query.RequestUri.ToString()); }
public void FunctionOfEntityTakeCollectionReturnEntities() { var customerQuery = new DataServiceQuerySingle <Customer>(this.TestClientContext, "Customers(3)"); var functionQuery = customerQuery.CreateFunctionQuery <Order>("Microsoft.Test.OData.Services.ODataOperationService.GetOrdersFromCustomerByNotes", true, new UriOperationParameter("notes", new Collection <string> { "1111", "2222" })); var orders = functionQuery.Execute(); Assert.AreEqual(1, orders.Count()); }
static async Task Main(string[] args) { var context = new DataContainer(new Uri("http://localhost:5001/")); context.MergeOption = MergeOption.NoTracking; // go through the accounts foreach (var account in context.Accounts) { Console.WriteLine("Account: {0}", account.Name); } // project the ID of an account var accountId = ( from a in context.Accounts where a.Name == "Customer 1" select new { Id = a.Id, }).FirstOrDefault(); // get a query to the GetUsers() for the account we chose var keyPath = context.Accounts.GetKeyPath(accountId.Id.ToString()); var accountObj = new DataServiceQuerySingle <Account>(context.Accounts.Context, keyPath); var query = accountObj.CreateFunctionQuery <User>("GetUsers", true); // project on GetUsers() var users = from u in query select new { Name = u.Name, }; // output the result foreach (var user in users) { Console.WriteLine(user.Name); } Console.WriteLine("Done. Press a key to close."); Console.ReadKey(); }
public static async Task PatchPropertyAsync <TEntity>(this DataServiceQuerySingle <TEntity> singleQuery, ExpandoObject patchDelta) where TEntity : BaseEntityType { using (var client = new HttpClient()) { var stringPayload = JsonConvert.SerializeObject(patchDelta); var httpContent = new StringContent(stringPayload, Encoding.UTF8, "application/json"); var request = new HttpRequestMessage(new HttpMethod("PATCH"), $"{singleQuery.RequestUri.AbsoluteUri}") { Content = httpContent }; var response = await client.SendAsync(request); if (!response.IsSuccessStatusCode) { throw new ServerException(response); } } }
/// <summary> /// Creates a data object with change tracking /// that can be used to PATCH an existing entity with /// just the data that was set or modified in the data object. /// </summary> /// <typeparam name="T">Type of the entity to create.</typeparam> /// <param name="entity">The entity to be patched.</param> /// <returns> /// A data object with change tracking enabled. /// </returns> /// <remarks> /// Operation is persisted when <see cref="DataServiceContext.SaveChangesAsync()"/> is invoked. /// </remarks> public static T PatchEntityWithChangeTracking <T>(this DataServiceQuerySingle <T> entity) { return(new DataServiceCollection <T>(entity)[0]); }
/// <summary>Initializes a new instance of the <see cref="Microsoft.OData.Client.DataServiceCollection{T}" /> class based on query execution and with the specified tracking mode.</summary> /// <param name="trackingMode">A <see cref="Microsoft.OData.Client.TrackingMode" /> value that indicated whether or not changes made to items in the collection are automatically tracked.</param> /// <param name="item">A <see cref="Microsoft.OData.Client.DataServiceQuerySingle{T}" /> or LINQ query that returns an object that are used to initialize the collection.</param> public DataServiceCollection(TrackingMode trackingMode, DataServiceQuerySingle <T> item) : this(null, item.Query, trackingMode, null, null, null) { }
/// <summary>Initializes a new instance of the <see cref="Microsoft.OData.Client.DataServiceCollection{T}" /> class based on query execution.</summary> /// <param name="item">A <see cref="Microsoft.OData.Client.DataServiceQuerySingle{T}" /> or LINQ query that returns an object that are used to initialize the collection.</param> public DataServiceCollection(DataServiceQuerySingle <T> item) : this(null, item.Query, TrackingMode.AutoChangeTracking, null, null, null) { }