public async Task <IHttpActionResult> PutOrder(Order order) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _dbContext.ApplyChanges(order); try { await _dbContext.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!_dbContext.Orders.Any(o => o.OrderId == order.OrderId)) { return(Conflict()); } throw; } await _dbContext.LoadRelatedEntitiesAsync(order); order.AcceptChanges(); return(Ok(order)); }
public async Task <IHttpActionResult> PutOrder(Order order) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } // Update order _unitOfWork.OrderRepository.Update(order); try { await _unitOfWork.SaveChangesAsync(); } catch (UpdateConcurrencyException) { if (_unitOfWork.OrderRepository.Find(order.OrderId) == null) { return(Conflict()); } throw; } // Load related entities and accept changes await _unitOfWork.OrderRepository.LoadRelatedEntitiesAsync(order); order.AcceptChanges(); return(Ok(order)); }
public async Task <IHttpActionResult> PostOrder(Order entity) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } entity.TrackingState = TrackingState.Added; _dbContext.ApplyChanges(entity); try { await _dbContext.SaveChangesAsync(); } catch (DbUpdateException) { if (_dbContext.Orders.Any(e => e.OrderId == entity.OrderId)) { return(Conflict()); } throw; } await _dbContext.LoadRelatedEntitiesAsync(entity); entity.AcceptChanges(); return(CreatedAtRoute("DefaultApi", new { id = entity.OrderId }, entity)); }
public async Task <IHttpActionResult> PostOrder(Order order) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } // Insert order _unitOfWork.OrderRepository.Insert(order); try { // Save and accept changes await _unitOfWork.SaveChangesAsync(); } catch (UpdateException) { if (_unitOfWork.OrderRepository.Find(order.OrderId) == null) { return(Conflict()); } throw; } // Load related entities and accept changes await _unitOfWork.OrderRepository.LoadRelatedEntitiesAsync(order); order.AcceptChanges(); return(CreatedAtRoute("DefaultApi", new { id = order.OrderId }, order)); }
public async Task <IHttpActionResult> PutOrder(Order entity) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _unitOfWork.OrderRepository.Update(entity); try { await _unitOfWork.SaveChangesAsync(); } catch (UpdateConcurrencyException) { if (_unitOfWork.OrderRepository.Find(entity.OrderId) == null) { return(Conflict()); } throw; } await _unitOfWork.OrderRepository.LoadRelatedEntitiesAsync(entity); entity.AcceptChanges(); return(Ok(entity)); }
public async Task <IHttpActionResult> PostOrder(Order entity) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _unitOfWork.OrderRepository.Insert(entity); try { await _unitOfWork.SaveChangesAsync(); } catch (UpdateException) { if (_unitOfWork.OrderRepository.Find(entity.OrderId) == null) { return(Conflict()); } throw; } await _unitOfWork.OrderRepository.LoadRelatedEntitiesAsync(entity); entity.AcceptChanges(); return(CreatedAtRoute("DefaultApi", new { id = entity.OrderId }, entity)); }
// PUT api/Orders public HttpResponseMessage PutOrder(Order order) { if (!ModelState.IsValid) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } _dbContext.ApplyChanges(order); try { _dbContext.SaveChanges(); } catch (DbUpdateConcurrencyException ex) { if (!_dbContext.Orders.Any(o => o.OrderId == order.OrderId)) { return(Request.CreateErrorResponse(HttpStatusCode.Conflict, ex)); } throw; } _dbContext.LoadRelatedEntities(order); order.AcceptChanges(); HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, order); return(response); }
// POST api/Orders public HttpResponseMessage PostOrder(Order order) { if (!ModelState.IsValid) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } order.TrackingState = TrackingState.Added; _dbContext.ApplyChanges(order); try { _dbContext.SaveChanges(); } catch (DbUpdateException ex) { if (_dbContext.Orders.Any(o => o.OrderId == order.OrderId)) { return(Request.CreateErrorResponse(HttpStatusCode.Conflict, ex)); } throw; } _dbContext.LoadRelatedEntities(order); order.AcceptChanges(); HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, order); response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = order.OrderId })); return(response); }
private void DoSave() { event_aggregator.GetEvent <GeneralMessageEvent>().Publish(ApplicationStrings.BeginningSave); ExecuteFaultHandledOperation(() => { var order_service = service_factory.CreateClient <IOrderService>(); using (var scope = new TransactionScope()) { using (order_service) { if (Order.OrderKey == 0) { var account_service = service_factory.CreateClient <IAccountService>(); Order.OrderNumber = account_service.GetAccountNextNumber(Order.Account.Model, QIQOEntityNumberType.OrderNumber); account_service.Dispose(); } //TODO: Do something to make sure the order items are in the object properly var new_order_line = Order.OrderItems.Where(item => item.ProductKey == 0).FirstOrDefault(); if (new_order_line != null) { Order.OrderItems.Remove(new_order_line); } // For some reason, these don't seem to get set properly when I add the account object to the Order object Order.Model.OrderItems.ForEach(item => item.OrderItemBillToAddress = DefaultBillingAddress.Model); Order.Model.OrderItems.ForEach(item => item.OrderItemShipToAddress = DefaultShippingAddress.Model); var order_key = order_service.CreateOrder(Order.Model); if (Order.OrderKey == 0) { Order.OrderKey = order_key; } Order.AcceptChanges(); ViewTitle = Order.OrderNumber; //event_aggregator.GetEvent<OrderUpdatedEvent>().Publish($"Order {Order.OrderNumber} updated successfully"); } scope.Complete(); } }); if (Order.OrderKey > 0) { GetOrder(Order.OrderKey); event_aggregator.GetEvent <OrderUpdatedEvent>().Publish($"Order {Order.OrderNumber} updated successfully"); } }
public async Task <IHttpActionResult> PostOrder(Order order) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } order.TrackingState = TrackingState.Added; _dbContext.ApplyChanges(order); await _dbContext.SaveChangesAsync(); await _dbContext.LoadRelatedEntitiesAsync(order); order.AcceptChanges(); return(CreatedAtRoute("DefaultApi", new { id = order.OrderId }, order)); }
public async Task <ObjectResult> PostOrder([FromBody] Order order) { if (!ModelState.IsValid) { return(HttpBadRequest(ModelState)); } order.TrackingState = TrackingState.Added; _dbContext.ApplyChanges(order); await _dbContext.SaveChangesAsync(); await _dbContext.LoadRelatedEntitiesAsync(order); order.AcceptChanges(); return(CreatedAtRoute(new { id = order.OrderId }, order)); }
public async Task <Order> UpdateOrder(Order order) { // Update entity state _dbContext.ApplyChanges(order); try { await _dbContext.SaveChangesAsync(); } catch (DbUpdateConcurrencyException updateEx) { throw new FaultException(updateEx.Message); } // Load related entities, accept changes and return updated order await _dbContext.LoadRelatedEntitiesAsync(order); order.AcceptChanges(); return(order); }
public async Task <Order> CreateOrder(Order order) { // Mark order as added order.TrackingState = TrackingState.Added; _dbContext.ApplyChanges(order); try { await _dbContext.SaveChangesAsync(); } catch (DbUpdateException updateEx) { throw new FaultException(updateEx.Message); } // Load related entities and accept changes await _dbContext.LoadRelatedEntitiesAsync(order); order.AcceptChanges(); return(order); }
private static void ManyToOneRelation(HttpClient client) { Console.WriteLine("\nPress Enter to create a new order for an existing customer"); Console.ReadLine(); // Create a new order for an existing customer var order = new Order { CustomerId = "ALFKI", OrderDate = DateTime.Today, ShippedDate = DateTime.Today.AddDays(1) }; // Add to change tracker to mark as Added var orderChangeTracker = new ChangeTrackingCollection <Order>(true) { order }; // Insert order and merge Order updatedOrder = CreateEntity(client, order); orderChangeTracker.MergeChanges(updatedOrder); PrintOrder(order); Console.WriteLine("\nPress Enter to add a new customer to the order"); Console.ReadLine(); // Create a new customer // NOTE: Marking customer as Added will create a NEW customer const string customerId = "WXYZ"; var customer = new Customer { CustomerId = customerId, CompanyName = "Widget Company", ContactName = "Jane Doe", City = "New York", Country = "USA", TrackingState = TrackingState.Added // Mark as added }; order.Customer = customer; // new customer will be created order.CustomerId = customerId; // cust will be assigned to order // Update order, then accept changes updatedOrder = UpdateEntity(client, order); Console.WriteLine("\tOrder's customer added: {0}", updatedOrder.Customer != null); order.AcceptChanges(); PrintOrder(order); PrintCustomer(order.Customer); Console.WriteLine("\nPress Enter to modify order's customer"); Console.ReadLine(); // Modify order customer var newCompanyName = order.Customer.CompanyName += " - Changed"; // Update order, then accept changes UpdateEntity(client, order); var updatedCustomer = GetEntity <Customer, string>(client, customerId); Console.WriteLine("\tOrder customer's name modified: {0}", updatedCustomer.CompanyName == newCompanyName); customer.AcceptChanges(); PrintCustomer(customer); // Delete the order and customer Console.WriteLine("\nPress Enter to delete the order and customer"); Console.ReadLine(); // Delete order and verify DeleteEntity <Order, int>(client, order.OrderId); var orderDeleted = VerifyEntityDeleted <Order, int>(client, order.OrderId); Console.WriteLine(orderDeleted ? "Order was successfully deleted" : "Order was NOT deleted"); // Delete order and verify DeleteEntity <Customer, string>(client, customer.CustomerId); var customerDeleted = VerifyEntityDeleted <Customer, string>(client, customer.CustomerId); Console.WriteLine(customerDeleted ? "Customer was successfully deleted" : "Customer was NOT deleted"); }