/// <summary>
/// Persists Employee model-wrapper object data to the data source.
/// </summary>
/// <param name="employee">Employee model-wrapper object</param>
/// <returns>Primary key of newly persisted employee model-wrapper data</returns>
public async Task SaveEmployeeAsync(EmployeeWrapper employee)
{
if (!employee.IsChanged)
{
return;
}
if (await _databaseService.ExistsAsync("employee", new Dictionary <string, dynamic>
{
{ "employee_id", employee.Id }
}))
{
await _databaseService.UpdateRowAsync("employee", new Dictionary <string, dynamic>
{
{ "first_name", employee.FirstName },
{ "last_name", employee.LastName }
}, new Dictionary <string, dynamic>
{
{ "employee_id", employee.Id }
});
}
else
{
employee.Id = Convert.ToInt32(await _databaseService.InsertRowAsync("employee", new Dictionary <string, dynamic>()
{
{ "first_name", employee.FirstName },
{ "last_name", employee.LastName }
}));
}
await SaveAddressAsync(employee);
await SaveEmailAsync(employee);
}
private async Task SaveAddressAsync(EmployeeWrapper employee)
{
if (!employee.Address.IsChanged)
{
return;
}
if (await _databaseService.ExistsAsync(tableName: "address", whereConditions: new Dictionary <string, dynamic>
{
{ "address_id", employee.Address.Id }
}))
{
await _databaseService.UpdateRowAsync(tableName : "address", columnValuePairs : new Dictionary <string, dynamic>
{
{ "number", employee.Address.Number },
{ "street", employee.Address.Street },
{ "city", employee.Address.City }
}, whereConditions : new Dictionary <string, dynamic>
{
{ "address_id", employee.Address.Id }
});
}
else
{
employee.Id = Convert.ToInt32(await _databaseService.InsertRowAsync(tableName: "address", columnValuePairs: new Dictionary <string, dynamic>()
{
{ "number", employee.Address.Number },
{ "street", employee.Address.Street },
{ "city", employee.Address.City },
{ "employee_id", employee.Id }
}));
}
}
private void LoadEmployee(int employeeId)
{
var employee = employeeId != 0 ? _employeeRepository.GetById(employeeId) : new Employee();
Employee = new EmployeeWrapper(employee);
if (employeeId == 0)
{
_employeeRepository.Add(employee);
}
Employee.PropertyChanged += (s, e) =>
{
if (!IsDirty)
{
IsDirty = _companyRepository.HasChanges();
SaveCommand.RaiseCanExecuteChanged();
}
if (e.PropertyName == nameof(Employee.FirstName) ||
e.PropertyName == nameof(Employee.LastName) ||
e.PropertyName == nameof(Employee.CompanyId))
{
IsDirty = _employeeRepository.HasChanges();
SaveCommand.RaiseCanExecuteChanged();
}
};
}
public void ShouldInitializeEmailsProperty()
{
var wrapper = new EmployeeWrapper(_employee);
Assert.IsNotNull(wrapper.Emails);
CheckIfModelEmailsCollectionIsInSync(wrapper);
}
public void ShouldBeInSyncAfterClearingEmails()
{
var wrapper = new EmployeeWrapper(_employee);
wrapper.Emails.Clear();
CheckIfModelEmailsCollectionIsInSync(wrapper);
}
public void ShouldInitializeAddressProperty()
{
var wrapper = new EmployeeWrapper(_employee);
Assert.IsNotNull(wrapper.Address);
Assert.AreEqual(_employee.Address, wrapper.Address.Model);
}
public void ShouldSetValueOfUnderlyingModelProperty()
{
var wrapper = new EmployeeWrapper(_employee);
const string firstName = "gHwo3";
wrapper.FirstName = firstName;
Assert.AreEqual(firstName, _employee.FirstName);
}
public void ShouldBeInSyncAfterAddingEmail()
{
_employee.Emails.Remove(_email);
var wrapper = new EmployeeWrapper(_employee);
wrapper.Emails.Add(new EmailWrapper(_email));
CheckIfModelEmailsCollectionIsInSync(wrapper);
}
public void ShouldBeInSyncAfterRemovingEmail()
{
var wrapper = new EmployeeWrapper(_employee);
var emailToRemove = wrapper.Emails.Single(ew => ew.Model == _email);
wrapper.Emails.Remove(emailToRemove);
CheckIfModelEmailsCollectionIsInSync(wrapper);
}
public void ShouldStoreOriginalValue()
{
var employeeWrapper = new EmployeeWrapper(_employee);
Assert.AreEqual(ChangeTrackingSimpleProperties.FirstName, employeeWrapper.FirstNameOriginalValue);
employeeWrapper.FirstName = "different first name";
Assert.AreEqual(ChangeTrackingSimpleProperties.FirstName, employeeWrapper.FirstNameOriginalValue);
}
public void ShouldStoreOriginalValue()
{
var wrapper = new EmployeeWrapper(_employee);
Assert.AreEqual("Van", wrapper.FirstNameOriginalValue);
wrapper.FirstName = "Thien";
Assert.AreEqual("Van", wrapper.FirstNameOriginalValue);
}
public void ShouldSetIsChanged()
{
var wrapper = new EmployeeWrapper(_employee);
wrapper.Address.City = "different city";
Assert.IsTrue(wrapper.IsChanged);
wrapper.Address.City = ChangeTrackingComplexProperties.City;
Assert.IsFalse(wrapper.IsChanged);
}
public void ShouldThrowArgumentNullExceptionIfModelIsNull()
{
try
{
var wrapper = new EmployeeWrapper(null);
}
catch (ArgumentNullException ex)
{
Assert.AreEqual("model", ex.ParamName);
throw;
}
}
public void ShouldSetIsChanged()
{
var wrapper = new EmployeeWrapper(_employee);
Assert.IsFalse(wrapper.FirstNameIsChanged);
Assert.IsFalse(wrapper.IsChanged);
wrapper.FirstName = "different first name";
Assert.IsTrue(wrapper.FirstNameIsChanged);
Assert.IsTrue(wrapper.IsChanged);
wrapper.FirstName = ChangeTrackingSimpleProperties.FirstName;
Assert.IsFalse(wrapper.FirstNameIsChanged);
Assert.IsFalse(wrapper.IsChanged);
}
public void ShouldThrowArgumentNullExceptionIfModelIsNull()
{
_employee = null;
try
{
var wrapper = new EmployeeWrapper(_employee);
}
catch (ArgumentNullException ex)
{
Assert.AreEqual("model", ex.ParamName);
throw;
}
}
public void ShouldRejectChanges()
{
var wrapper = new EmployeeWrapper(_employee);
wrapper.Address.City = "different city";
Assert.AreEqual(ChangeTrackingComplexProperties.City, wrapper.Address.CityOriginalValue);
wrapper.RejectChanges();
Assert.IsFalse(wrapper.IsChanged);
Assert.AreEqual(ChangeTrackingComplexProperties.City, wrapper.Address.City);
Assert.AreEqual(ChangeTrackingComplexProperties.City, wrapper.Address.CityOriginalValue);
}
void ExecuteAddEmployeeCommand()
{
var employee = new Employee
{
FirstName = FirstName,
LastName = LastName
};
var employeeWrapper = new EmployeeWrapper(employee);
Employees.Add(employeeWrapper);
_dataService.AddEmploee(employeeWrapper.Model);
}
public void ShouldNotRaisePropertyChangedEventIfPropertyIsSetToSameValue()
{
var fired = false;
var wrapper = new EmployeeWrapper(_employee);
wrapper.PropertyChanged += (s, e) =>
{
if (e.PropertyName == "FirstName")
{
fired = true;
}
};
wrapper.FirstName = "Ahmed";
Assert.IsFalse(fired);
}
private void SetSelectedItem(EmployeeWrapper employeeWrapper)
{
SelectedItem = employeeWrapper;
SelectedItem.PropertyChanged += (s, e) =>
{
if (e.PropertyName == nameof(SelectedItem.IsChanged) ||
e.PropertyName == nameof(SelectedItem.IsValid))
{
SaveCommand.RaiseCanExecuteChanged();
ResetCommand.RaiseCanExecuteChanged();
_eventAggregator.GetEvent <ModelIsChangedEvent>().Publish(SelectedItem.IsChanged);//Notify the mainwindow that there are changes, to prompt user not to close window.
}
};
}
public void ShouldRaisePropertyChangedEventOnPropertyChange()
{
var fired = false;
var wrapper = new EmployeeWrapper(_employee);
wrapper.PropertyChanged += (s, e) =>
{
if (e.PropertyName == "FirstName")
{
fired = true;
}
};
wrapper.FirstName = "Julia";
Assert.IsTrue(fired);
}
public void ShouldSetIsChanged()
{
var wrapper = new EmployeeWrapper(_employee);
Assert.IsFalse(wrapper.FirstNameIsChanged);
Assert.IsFalse(wrapper.IsChanged);
wrapper.FirstName = "Thien";
Assert.IsTrue(wrapper.FirstNameIsChanged);
Assert.IsTrue(wrapper.IsChanged);
wrapper.FirstName = "Van";
Assert.IsFalse(wrapper.FirstNameIsChanged);
Assert.IsFalse(wrapper.IsChanged);
}
public void ShouldNotRaisePropertyChangedEventIfPropertyIsSetToSameValue()
{
var fired = false;
var wrapper = new EmployeeWrapper(_employee);
wrapper.PropertyChanged += (s, e) =>
{
if (e.PropertyName == "FirstName")
{
fired = true;
}
};
wrapper.FirstName = "Van";
Assert.IsFalse(fired);
}
private void OnLogin(object sender, EmployeeWrapper user)
{
_loggedIn = user.EmployeeToWrap;
LoginControl.Visibility = Visibility.Hidden;
if (_loggedIn.Role == 1)
{
CashierControl.Initialize(Services, _loggedIn);
CashierControl.Visibility = Visibility.Visible;
}
else
{
ManagerControl.Initialize(Services, _loggedIn);
ManagerControl.Visibility = Visibility.Visible;
}
}
public void ShouldRaisePropertyChangedEventForIsChanged()
{
var fired = false;
var wrapper = new EmployeeWrapper(_employee);
wrapper.PropertyChanged += (s, e) =>
{
if (e.PropertyName == nameof(wrapper.IsChanged))
{
fired = true;
}
};
wrapper.FirstName = "Thien";
Assert.IsTrue(fired);
}
public void ShouldNotRaisePropertyChangedEventOnPropertySetToOriginalValue()
{
var eventFired = false;
var wrapper = new EmployeeWrapper(_employee);
wrapper.PropertyChanged += (sender, args) =>
{
if (args.PropertyName.Equals(nameof(wrapper.FirstName)))
{
eventFired = true;
}
};
wrapper.FirstName = FirstName;
Assert.IsFalse(eventFired);
}
public void ShouldRaisePropertyChangedEventOnPropertyChange()
{
var eventFired = false;
var wrapper = new EmployeeWrapper(_employee);
wrapper.PropertyChanged += (sender, args) =>
{
if (args.PropertyName.Equals(nameof(wrapper.FirstName)))
{
eventFired = true;
}
};
wrapper.FirstName = "something different";
Assert.IsTrue(eventFired);
}
public async Task DeleteEmployeeAsync(EmployeeWrapper employee)
{
if (await _databaseService.ExistsAsync("employee", new Dictionary <string, dynamic>
{
{ "employee_id", employee.Id }
}))
{
await _databaseService.UpdateRowAsync("employee", new Dictionary <string, dynamic>
{
{ "is_deleted", 1 }
}, new Dictionary <string, dynamic>
{
{ "employee_id", employee.Id }
});
}
}
public void ShouldRaisePropertyChangedEventForIsChanged()
{
var eventFired = false;
var wrapper = new EmployeeWrapper(_employee);
wrapper.PropertyChanged += (sender, args) =>
{
if (args.PropertyName.Equals(nameof(wrapper.IsChanged)))
{
eventFired = true;
}
};
wrapper.Address.City = "different city";
Assert.IsTrue(eventFired);
}
private void InitializeEmployee(Employee employee)
{
Employee = new EmployeeWrapper(employee);
Employee.PropertyChanged += (s, e) =>
{
if (!HasChanges)
{
HasChanges = _personRepository.HasChanges();
}
if (e.PropertyName == nameof(Employee.HasErrors))
{
((DelegateCommand <PasswordBox>)SaveCommand).RaiseCanExecuteChanged();
}
};
((DelegateCommand <PasswordBox>)SaveCommand).RaiseCanExecuteChanged();
}
public void ShouldBeValidAgainWhenFirstNameChanged()
{
var wrapper = new EmployeeWrapper(_employee);
wrapper.FirstName = "";
Assert.IsFalse(wrapper.IsValid);
wrapper.FirstName = "ab";
Assert.IsFalse(wrapper.IsValid);
wrapper.FirstName = "Ahmed";
Assert.IsTrue(wrapper.IsValid);
var emailsErrors = wrapper.GetErrors("FirstName").Cast<string>().ToList();
Assert.AreEqual(0, emailsErrors.Count);
}
private void WrapEmployee(Employee emp)
{
if (emp.EntityPersonKey == 0)
{
GetNewEmployeeAttributes(emp);
}
CurrentEmployee = new EmployeeWrapper(emp);
CurrentEmployee.PropertyChanged += Context_PropertyChanged;
if (emp.Addresses.Count > 0)
{
DefaultAddress = new AddressWrapper(emp.Addresses[0]);
}
else
{
DefaultAddress = new AddressWrapper(new Address());
}
}
public void ShouldAcceptChanges()
{
var wrapper = new EmployeeWrapper(_employee);
wrapper.FirstName = "something different";
Assert.AreEqual("something different", wrapper.FirstName);
Assert.AreEqual(ChangeTrackingSimpleProperties.FirstName, wrapper.FirstNameOriginalValue);
Assert.IsTrue(wrapper.FirstNameIsChanged);
Assert.IsTrue(wrapper.IsChanged);
wrapper.AcceptChanges();
Assert.AreEqual("something different", wrapper.FirstName);
Assert.AreEqual("something different", wrapper.FirstNameOriginalValue);
Assert.IsFalse(wrapper.FirstNameIsChanged);
Assert.IsFalse(wrapper.IsChanged);
}
public void ShouldRejectChanges()
{
var wrapper = new EmployeeWrapper(_employee);
wrapper.FirstName = "Thien";
Assert.AreEqual("Thien", wrapper.FirstName);
Assert.AreEqual("Van", wrapper.FirstNameOriginalValue);
Assert.IsTrue(wrapper.FirstNameIsChanged);
Assert.IsTrue(wrapper.IsChanged);
wrapper.RejectChanges();
Assert.AreEqual("Van", wrapper.FirstName);
Assert.AreEqual("Van", wrapper.FirstNameOriginalValue);
Assert.IsFalse(wrapper.FirstNameIsChanged);
Assert.IsFalse(wrapper.IsChanged);
}
public void ShouldAcceptChanges()
{
var wrapper = new EmployeeWrapper(_employee);
wrapper.FirstName = "Thien";
Assert.AreEqual("Thien", wrapper.FirstName);
Assert.AreEqual("Van", wrapper.FirstNameOriginalValue);
Assert.IsTrue(wrapper.FirstNameIsChanged);
Assert.IsTrue(wrapper.IsChanged);
wrapper.AcceptChanges();
Assert.AreEqual("Thien", wrapper.FirstName);
Assert.AreEqual("Thien", wrapper.FirstNameOriginalValue); //Once accept everything is wiped out, so FirstNameOriginalValue points to FirstName current value.
Assert.IsFalse(wrapper.FirstNameIsChanged); //Once changes has been accepted, reset the IsChanges for all property.
Assert.IsFalse(wrapper.IsChanged); //Reset the model IsChange to false, but once AcceptChanges() run, all model property has been updated.
}
public EmployeeViewModel Load(int? employeeId = null)
{
var employee = employeeId.HasValue
? _employeeService.GetEmployeeById(employeeId.Value)
: new Employee();
Employee = new EmployeeWrapper(employee);
Employee.PropertyChanged += (s, e) =>
{
if (e.PropertyName == "IsChanged"
|| e.PropertyName == "IsValid")
{
InvalidateCommands();
}
};
InvalidateCommands();
return this;
}
public void ShouldIntializeWithoutProblems()
{
var wrapper = new EmployeeWrapper(_employee);
Assert.IsTrue(wrapper.IsValid);
}
public void ShouldContainModelInModelProperty()
{
var wrapper = new EmployeeWrapper(_employee);
Assert.AreEqual(_employee, wrapper.Model);
}
public void ShouldSetValueOfUnderlyingModelProperty()
{
var wrapper = new EmployeeWrapper(_employee);
wrapper.FirstName = "Ragheb";
Assert.AreEqual("Ragheb", _employee.FirstName);
}
public void ShouldGetValueOfUnderlyingModelProperty()
{
var wrapper = new EmployeeWrapper(_employee);
Assert.AreEqual(_employee.FirstName, wrapper.FirstName);
}
