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");
}
