/// <summary> /// Creates an instance of the AddCustomerViewModel /// that displays a customer /// </summary> /// <param name="customer">The customer that is to be edited.</param> public AddCustomerViewModel(Customer customer) { this.SelectedCustomer = customer; this.SaveCommand = new SaveCommand(this); this.CancelCommand = new CancelCommand(this); this.cancelSaveOperation = new CancellationTokenSource(); }
public void IfUserListEmptyShowStatsCommandDoesNotExecute() { Customer customer = new Customer(); MainViewModel viewModel = new MainViewModel(); Assert.IsFalse(viewModel.ShowStatsCommand.CanExecute(null)); viewModel.Customers = new List<Customer> { customer }; Assert.IsTrue(viewModel.ShowStatsCommand.CanExecute(null)); }
public void IfNoUserIsSelectedUpdateCommandDoesNotExecute() { Customer customer = new Customer(); MainViewModel viewModel = new MainViewModel(); Assert.IsFalse(viewModel.UpdateCustomerCommand.CanExecute(null)); viewModel.SelectedCustomer = customer; Assert.IsTrue(viewModel.UpdateCustomerCommand.CanExecute(null)); }
/// <summary> /// Helper method to get a sample customer /// </summary> /// <returns>A sample customer</returns> internal static Customer GetSampleCustomer() { Customer customer = new Customer() { Category = Category.A, DateOfBirth = new DateTime(1985, 7, 8), Gender = Gender.Unknown, HouseNumber = "323A", Name = "Tom", AddressLineOne = "Test address", State = "Alaska", Country = "United States", }; return customer; }
/// <summary> /// Sends the customer to the database and tries to update it with the newly created id. /// New customer is added to the local cache. /// </summary> /// <param name="customer">The customer to be saved in the database.</param> /// <param name="cancellationToken">Cancellation token to cancel save.</param> /// <returns>If successful returns datetime of the add operation, otherwise null.</returns> public async Task<Nullable<DateTime>> AddCustomer(Customer customer, CancellationToken cancellationToken) { // Successful if datetiem of the operation. // Failed if null. Nullable<DateTime> result = await this.dataAccess.AddCustomer(customer, cancellationToken); // Add customer to the cache if (result != null) { // Update time only if successful. // If failed cache will need an update. this.clientLastDbModification = (DateTime)result; if (cachedCustomers != null) { cachedCustomers.Add(customer); } } return result; }
/// <summary> /// Retries the customers data from the database. /// </summary> /// <returns>Collection of the customers.</returns> public async Task<List<Customer>> GetCustomers() { try { using (CustomersContext context = new CustomersContext()) { List<CustomerDb> customersDb = await context.CustomerDbs.ToListAsync(); List<Customer> customers = customersDb .Select(cdb => { Customer c = new Customer() { Id = cdb.Id, AddressLineOne = cdb.AddressLineOne, Category = cdb.Category, Country = cdb.Country, DateOfBirth = cdb.DateOfBirth, Gender = cdb.Gender, HouseNumber = cdb.HouseNumber, Name = cdb.Name, State = cdb.State, }; return c; } ).ToList(); return customers; } } catch (InvalidCastException e) { DbLog.LogException(e, "DataProxy.cs"); throw; } catch (InvalidOperationException e) { DbLog.LogException(e, "DataProxy.cs"); throw; } }
/// <summary> /// Removes the customer from the database. /// </summary> /// <param name="customer">The customer to be removed.</param> /// <returns>If successful returns datetime of the remove operation, otherwise null.</returns> public async Task<Nullable<DateTime>> RemoveCustomer(Customer customer) { try { if (customer == null) { throw new ArgumentNullException("Null Customer cannot be updated."); } using (CustomersContext context = new CustomersContext()) { CustomerDb customerDb = context.CustomerDbs.FirstOrDefault(c => c.Id == customer.Id); if (customerDb == null) { return null; } context.CustomerDbs.Remove(customerDb); await context.SaveChangesAsync(); await EnterModificationHistory(context, customer, ModificationType.Remove); this.lastDataBaseModificationTime = DateTime.Now; return this.lastDataBaseModificationTime; } } catch (InvalidOperationException e) { DbLog.LogException(e, "DataProxy.cs"); throw; } catch (NullReferenceException e) { DbLog.LogException(e, "DataProxy.cs"); throw; } }
/// <summary> /// Updates the customer in the database /// </summary> /// <param name="customer">The customer to be updated.</param> /// <param name="cancellationToken">Cancellation token to cancel save.</param> /// <returns>If successful returns datetime of the update operation, otherwise null.</returns> public async Task<Nullable<DateTime>> UpdateCustomer(Customer customer, CancellationToken cancellationToken = new CancellationToken()) { try { if (customer == null) { throw new ArgumentNullException("Null Customer cannot be updated."); } if (!customer.IsValid) { return null; } using (CustomersContext context = new CustomersContext()) { CustomerDb customerDb = context.CustomerDbs.Find(customer.Id); if (customerDb == null) { return null; } customerDb.AddressLineOne = customer.AddressLineOne; customerDb.Category = customer.Category; customerDb.Country = customer.Country; customerDb.DateOfBirth = customer.DateOfBirth; customerDb.Gender = customer.Gender; customerDb.HouseNumber = customer.HouseNumber; customerDb.Name = customer.Name; customerDb.State = customer.State; await context.SaveChangesAsync(cancellationToken); if (!cancellationToken.IsCancellationRequested) { await EnterModificationHistory(context, customer, ModificationType.Update); this.lastDataBaseModificationTime = DateTime.Now; return this.lastDataBaseModificationTime; } return null; } } catch (InvalidOperationException e) { DbLog.LogException(e, "DataProxy.cs"); throw; } catch (NullReferenceException e) { DbLog.LogException(e, "DataProxy.cs"); throw; } catch (OperationCanceledException) { throw; } catch (Exception) { // Cancelletion exception can be wrapped in several other exceptions. // Instead of unwrapping it check if cancellation requested. if (cancellationToken.IsCancellationRequested) { throw new OperationCanceledException(); } throw; } }
/// <summary> /// Makes a copy of all properties from the source customer to current customer /// </summary> /// <param name="sourceCustomer">The source customer to copy properties from</param> public void Copy(Customer sourceCustomer) { this.Id = sourceCustomer.Id; this.AddressLineOne = sourceCustomer.AddressLineOne; this.Category = sourceCustomer.Category; this.Country = sourceCustomer.Country; this.DateOfBirth = sourceCustomer.DateOfBirth; this.Gender = sourceCustomer.Gender; this.HouseNumber = sourceCustomer.HouseNumber; this.Name = sourceCustomer.Name; this.State = sourceCustomer.State; }
/// <summary> /// Removes the customer from the database. /// </summary> /// <param name="customer">The customer to be removed.</param> /// <returns>If successful returns datetime of the remove operation, otherwise null.</returns> public new async Task<DateTime?> RemoveCustomer(Customer customer) { return await base.RemoveCustomer(customer); }
/// <summary> /// Invokes the add new customer window . /// </summary> internal void AddCustomer() { try { AddCustomerView addCustomerView = new AddCustomerView(); // Set the date of birth to today, so it's not set to default 01/01/0001 Customer customer = new Customer() { DateOfBirth = DateTime.Now }; AddCustomerViewModel addCustomerViewModel = new AddCustomerViewModel(customer); addCustomerViewModel.SaveCompleted += (s, e) => { // Get latest data after save. this.SelectedCustomer = null; addCustomerView.Close(); this.GetData(); }; addCustomerViewModel.Cancelled += (s, e) => { this.SelectedCustomer = null; addCustomerView.Close(); }; addCustomerView.DataContext = addCustomerViewModel; addCustomerView.ShowDialog(); } catch (Exception ex) { InfoDialogViewModel.ShowDialog(ex.Message, "Unhandled Exception"); Log.LogException(ex, "MainViewModel.cs"); } }
/// <summary> /// Removes the customer from the database. /// </summary> /// <param name="customer">The customer to be removed.</param> /// <returns>If successful returns datetime of the remove operation, otherwise null.</returns> public async Task<Nullable<DateTime>> RemoveCustomer(Customer customer) { // Successful if datetiem of the operation. // Failed if null. Nullable<DateTime> result = await this.dataAccess.RemoveCustomer(customer); // If db remove successful, remove the customer from the local cache. if (result != null) { // Update time only if successful. // If failed cache will need an update. this.clientLastDbModification = (DateTime)result; if (cachedCustomers != null && cachedCustomers.Contains(customer)) { cachedCustomers.Remove(customer); } } return result; }
/// <summary> /// Request customer update on the database. /// </summary> /// <param name="customer">The customer to be updated.</param> /// <param name="cancellationToken">Cancellation token to cancel save.</param> /// <returns>If successful returns datetime of the update operation, otherwise null.</returns> public async Task<Nullable<DateTime>> UpdateCustomer(Customer customer, CancellationToken cancellationToken) { // Successful if datetiem of the operation. // Failed if null. Nullable<DateTime> result = await this.dataAccess.UpdateCustomer(customer, cancellationToken); // Update local cache. if (this.clientLastDbModification != null) { if (result != null) { // Update time only if successful. // If failed cache will need an update. this.clientLastDbModification = (DateTime)result; Customer cachedCustomer = cachedCustomers.FirstOrDefault(c => c.Id == customer.Id); if (cachedCustomer != null) { cachedCustomer.Copy(customer); } } } return result; }
public void SettingCustomerToMainViewModelTriggersPropertyChanged() { Customer customer = new Customer(); MainViewModel viewModel = new MainViewModel(); viewModel.PropertyChanged += (s, e) => { Assert.AreEqual("SelectedCustomer", e.PropertyName); Assert.AreEqual(customer, viewModel.SelectedCustomer); }; viewModel.SelectedCustomer = customer; }
/// <summary> /// Enteres a modification history entry based on the submitted customer and the modification type. /// </summary> /// <param name="context">The context in which the modification entry will be performed.</param> /// <param name="customer">The customer object that has been modified. Original details are saved in the history table.</param> /// <param name="modificationType">The modofication type: Add, Remove, Update, Other</param> /// <returns></returns> private async Task EnterModificationHistory(CustomersContext context, Customer customer, ModificationType modificationType) { CustomerDbHistory customerHistory = new CustomerDbHistory() { // log modification type ModificationType = modificationType, // and customer details so it's easier to reproduce changes Id = customer.Id, AddressLineOne = customer.AddressLineOne, Category = customer.Category, Country = customer.Country, DateOfBirth = customer.DateOfBirth, Gender = customer.Gender, HouseNumber = customer.HouseNumber, Name = customer.Name, State = customer.State, ChangedOn = DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt") }; try { context.CustomerDbHistories.Add(customerHistory); await context.SaveChangesAsync(); } catch (Exception e) { DbLog.LogException(e, "DataProxy.cs"); } }
/// <summary> /// Invokes the update customer window. /// </summary> internal void UpdateCustomer() { try { // Make a copy of the current customer to avoid directly editing the customer in the data grid. // The customer will be modified in the cache and in the database // and the grid view will be updated from the cache or the database. Customer c = new Customer(); c.Copy(this.SelectedCustomer); AddCustomerView addCustomerView = new AddCustomerView(); AddCustomerViewModel addCustomerViewModel = new AddCustomerViewModel(c); addCustomerViewModel.SaveCompleted += (s, e) => { // Get latest data after save. this.SelectedCustomer = null; addCustomerView.Close(); this.GetData(); }; addCustomerViewModel.Cancelled += (s, e) => { this.SelectedCustomer = null; addCustomerView.Close(); }; addCustomerView.DataContext = addCustomerViewModel; addCustomerView.ShowDialog(); this.SelectedCustomer = null; } catch (Exception ex) { InfoDialogViewModel.ShowDialog(ex.Message, "Unhandled Exception"); Log.LogException(ex, "MainViewModel.cs"); } }
/// <summary> /// Adds the customer to the database. /// </summary> /// <param name="customer">The customer to be added.</param> /// <param name="cancellationToken">Cancellation token to cancel save.</param> /// <returns>If successful returns datetime of the add operation, otherwise null.</returns> public async Task<Nullable<DateTime>> AddCustomer(Customer customer, CancellationToken cancellationToken = new CancellationToken()) { try { if (customer == null) { throw new ArgumentNullException("Null Customer cannot be added"); } if (!customer.IsValid) { return null; } using (CustomersContext context = new CustomersContext()) { CustomerDb customerDb = new CustomerDb() { AddressLineOne = customer.AddressLineOne, Category = customer.Category, Country = customer.Country, DateOfBirth = customer.DateOfBirth, Gender = customer.Gender, HouseNumber = customer.HouseNumber, Name = customer.Name, State = customer.State }; context.CustomerDbs.Add(customerDb); await context.SaveChangesAsync(cancellationToken); if (!cancellationToken.IsCancellationRequested) { // The Id is created by the database so before // logging modification history entry update the customer with the new Id. customer.Id = customerDb.Id; await EnterModificationHistory(context, customer, ModificationType.Add); this.lastDataBaseModificationTime = DateTime.Now; return this.lastDataBaseModificationTime; } return null; } } catch (InvalidOperationException e) { DbLog.LogException(e, "DataProxy.cs"); throw; } catch (NullReferenceException e) { DbLog.LogException(e, "DataProxy.cs"); throw; } catch (OperationCanceledException) { throw; } catch (Exception) { // Cancelletion exception can be wrapped in several other exceptions. // Instead of unwrapping it check if cancellation requested. if (cancellationToken.IsCancellationRequested) { throw new OperationCanceledException(); } throw; } }
/// <summary> /// Updates the customer in the database /// </summary> /// <param name="customer">The customer to be updated.</param> /// <param name="cancellationToken">Cancellation token to cancel update.</param> /// <returns>If successful returns datetime of the update operation, otherwise null.</returns> public new async Task<DateTime?> UpdateCustomer(Customer customer, CancellationToken cancellationToken) { return await base.UpdateCustomer(customer, cancellationToken); }