public async Task <IHttpActionResult> PostCustomer(Customer customer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_unitOfWork.CustomerRepository.Insert(customer);
try
{
// Save and accept changes
await _unitOfWork.SaveChangesAsync();
}
catch (UpdateException)
{
if (_unitOfWork.CustomerRepository.Find(customer.CustomerId) == null)
{
return(Conflict());
}
throw;
}
// Load related entities and accept changes
await _unitOfWork.CustomerRepository.LoadRelatedEntitiesAsync(customer);
customer.AcceptChanges();
return(CreatedAtRoute("DefaultApi", new { id = customer.CustomerId }, customer));
}
public async Task <IHttpActionResult> PutCustomer(Customer customer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_unitOfWork.CustomerRepository.Update(customer);
try
{
await _unitOfWork.SaveChangesAsync();
}
catch (UpdateConcurrencyException)
{
if (_unitOfWork.CustomerRepository.Find(customer.CustomerId) == null)
{
return(Conflict());
}
throw;
}
await _unitOfWork.CustomerRepository.LoadRelatedEntitiesAsync(customer);
customer.AcceptChanges();
return(Ok(customer));
}
public async Task <IHttpActionResult> PutCustomer(Customer customer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_dbContext.ApplyChanges(customer);
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!_dbContext.Customers.Any(c => c.CustomerId == customer.CustomerId))
{
return(Conflict());
}
throw;
}
await _dbContext.LoadRelatedEntitiesAsync(customer);
customer.AcceptChanges();
return(Ok(customer));
}
private void RemoveInactive(Customer customer)
{
try
{
for (int i = customer.Projects.Count() - 1; i >= 0; i--)
{
if (customer.Projects[i].Inactive)
{
customer.Projects.RemoveAt(i);
}
else
{
for (int y = customer.Projects[i].Tasks.Count() - 1; y >= 0; y--)
{
if (customer.Projects[i].Tasks[y].Inactive)
{
customer.Projects[i].Tasks.RemoveAt(y);
}
}
customer.Projects[i].MarkAsUnchanged();
customer.Projects[i].AcceptChanges();
}
}
customer.MarkAsUnchanged();
customer.AcceptChanges();
}
catch (Exception ex)
{
LogError(ex);
throw;
}
}
private void SaveExecute()
{
try
{
if (this.Photo != null)
{
this.Customer.CustomerPicture = new CustomerPicture()
{
Photo = this.Photo
}
}
;
else
{
this.Customer.CustomerPicture = new CustomerPicture();
}
this.Customer.MarkAsAdded();
MainModuleServiceClient client = new MainModuleServiceClient();
client.AddCustomerCompleted += delegate
{
_currentCustomer.AcceptChanges();
((VMCustomerListView)((MainPage)App.Current.RootVisual).viewListCustomers.DataContext).GetCustomers();
((MainPage)App.Current.RootVisual).GoBackAddCustomer.Begin();
Customer = null;
};
client.AddCustomerAsync(this._currentCustomer);
}
catch (FaultException <ServiceError> ex)
{
MessageBox.Show(ex.Detail.ErrorMessage);
}
}
public async Task <IHttpActionResult> PostCustomer(Customer customer)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
customer.TrackingState = TrackingState.Added;
_dbContext.ApplyChanges(customer);
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (_dbContext.Customers.Any(c => c.CustomerId == customer.CustomerId))
{
return(Conflict());
}
throw;
}
await _dbContext.LoadRelatedEntitiesAsync(customer);
customer.AcceptChanges();
return(CreatedAtRoute("DefaultApi", new { id = customer.CustomerId }, customer));
}
private void SaveExecute(string isValidData)
{
try
{
if (this.Photo == null)
{
this.Customer.CustomerPicture = new CustomerPicture();
}
this.Customer.MarkAsModified();
MainModuleServiceClient client = new MainModuleServiceClient();
client.ChangeCustomerCompleted += delegate(object sender, AsyncCompletedEventArgs e)
{
if (e.Error == null)
{
Customer.AcceptChanges();
((VMCustomer)((MainPage)App.Current.RootVisual).viewCustomer.DataContext).Customer = Customer;
((VMCustomerListView)((MainPage)App.Current.RootVisual).viewListCustomers.DataContext).GetCustomers();
}
((MainPage)App.Current.RootVisual).GoBackEditCustomer.Begin();
};
client.ChangeCustomerAsync(this.Customer);
}
catch (FaultException <ServiceError> ex)
{
MessageBox.Show(ex.Detail.ErrorMessage);
}
}
// PUT api/Customer
public HttpResponseMessage PutCustomer(Customer customer)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
_dbContext.ApplyChanges(customer);
try
{
_dbContext.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
if (!_dbContext.Customers.Any(c => c.CustomerId == customer.CustomerId))
{
return(Request.CreateErrorResponse(HttpStatusCode.Conflict, ex));
}
throw;
}
_dbContext.LoadRelatedEntities(customer);
customer.AcceptChanges();
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, customer);
return(response);
}
// POST api/Customer
public HttpResponseMessage PostCustomer(Customer customer)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
customer.TrackingState = TrackingState.Added;
_dbContext.ApplyChanges(customer);
try
{
_dbContext.SaveChanges();
}
catch (DbUpdateException ex)
{
if (_dbContext.Customers.Any(c => c.CustomerId == customer.CustomerId))
{
return(Request.CreateErrorResponse(HttpStatusCode.Conflict, ex));
}
throw;
}
_dbContext.LoadRelatedEntities(customer);
customer.AcceptChanges();
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, customer);
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = customer.CustomerId }));
return(response);
}
public async Task <Customer> UpdateCustomer(Customer customer)
{
_dbContext.ApplyChanges(customer);
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException updateEx)
{
throw new FaultException(updateEx.Message);
}
await _dbContext.LoadRelatedEntitiesAsync(customer);
customer.AcceptChanges();
return(customer);
}
public async Task <Customer> CreateCustomer(Customer customer)
{
customer.TrackingState = TrackingState.Added;
_dbContext.ApplyChanges(customer);
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateException updateEx)
{
throw new FaultException(updateEx.Message);
}
await _dbContext.LoadRelatedEntitiesAsync(customer);
customer.AcceptChanges();
return(customer);
}
private void ExecuteSave(object obj)
{
_dataService.SaveCustomer(Customer).Subscribe(
customer =>
{
if (_isNew)
{
Customer = Customer;
Customer.CustomerID = customer.CustomerID;
Customer.AcceptChanges();
OverwriteCig(Customer);
InternalCommands.CustomerAddCompleted.Execute(Customer);
}
else
{
Customer = Customer;
Customer.AcceptChanges();
OverwriteCig(Customer);
InternalCommands.CustomerEditCompleted.Execute(Customer);
}
});
}
private void CustomerDeleteStart(Customer obj)
{
var confirmBox = MessageBox.Show(TextResources.ConfirmDeleteCustomerLabel,
TextResources.ConfirmDeleteBoxTitle,
MessageBoxButton.OKCancel);
if (confirmBox == MessageBoxResult.OK)
{
obj.MarkAsDeleted();
_dataService.DeleteCustomer(obj).Subscribe(
success =>
{
if (success)
{
obj.AcceptChanges();
InternalCommands.CustomerDeleteCompleted.Execute(obj.CustomerID);
}
else
{
obj.CancelChanges();
}
});
}
}
private static void OneToOneRelation(HttpClient client)
{
Console.WriteLine("\nPress Enter to create a new customer");
Console.ReadLine();
// Create a new customer
var customer = new Customer
{
CustomerId = "ABCDE",
CompanyName = "Acme Company",
ContactName = "John Doe",
City = "Dallas",
Country = "USA"
};
// Add to change tracker to mark as Added
var customerChangeTracker = new ChangeTrackingCollection <Customer>(true)
{
customer
};
// Insert customer and merge
Customer updatedCustomer = CreateEntity(client, customer);
customerChangeTracker.MergeChanges(updatedCustomer);
PrintCustomer(customer);
Console.WriteLine("\nPress Enter to add a new setting");
Console.ReadLine();
// Add a new customer setting
// NOTE: To add a 1-1 property, you must manually mark it as Added.
customer.CustomerSetting = new CustomerSetting
{
CustomerId = customer.CustomerId,
Setting = " Test Setting",
TrackingState = TrackingState.Added // Mark as added
};
// Update customer, then accept changes
updatedCustomer = UpdateEntity(client, customer);
Console.WriteLine("\tCustomer setting added: {0}",
updatedCustomer.CustomerSetting != null);
customer.AcceptChanges();
PrintCustomer(customer);
// Add new customer setting
Console.WriteLine("\nPress Enter to modify the setting");
Console.ReadLine();
// Modify customer setting
var newSetting = customer.CustomerSetting.Setting += " - Changed";
// Update customer, then accept changes
updatedCustomer = UpdateEntity(client, customer);
Console.WriteLine("\tCustomer setting modified: {0}",
updatedCustomer.CustomerSetting.Setting == newSetting);
customer.AcceptChanges();
PrintCustomer(customer);
// Remove existing customer setting
Console.WriteLine("\nPress Enter to remove the existing setting");
Console.ReadLine();
// Delete existing customer setting
// NOTE: To remove a 1-1 property, you must manually mark it as Deleted.
customer.CustomerSetting.TrackingState = TrackingState.Deleted;
// Update customer, then set 1-1 property to null
updatedCustomer = UpdateEntity(client, customer);
Console.WriteLine("\tCustomer setting removed: {0}",
updatedCustomer.CustomerSetting == null);
customer.CustomerSetting = null;
PrintCustomer(customer);
// Delete the customer
Console.WriteLine("\nPress Enter to delete the customer");
Console.ReadLine();
DeleteEntity <Customer, string>(client, customer.CustomerId);
// Verify order was deleted
var deleted = VerifyEntityDeleted <Customer, string>(client, customer.CustomerId);
Console.WriteLine(deleted ?
"Customer was successfully deleted" :
"Customer was NOT deleted");
}
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");
}
