public async Task ShouldCreateOneDeptHistoryRecord()
{
ResetDatabase();
var deptHistory = new EmployeeDepartmentHistory
{
BusinessEntityID = 14,
DepartmentID = 10,
ShiftID = 3,
StartDate = new DateTime(2019, 9, 2),
EndDate = new DateTime(2020, 9, 2)
};
string jsonDeptHistory = JsonConvert.SerializeObject(deptHistory);
HttpContent content = new StringContent(jsonDeptHistory, Encoding.UTF8, "application/json");
var response = await _client.PostAsync($"{serviceAddress}{rootAddress}/depthistory", content);
Assert.True(response.IsSuccessStatusCode);
var jsonResponse = await response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <EmployeeDepartmentHistory>(jsonResponse);
Assert.Equal(deptHistory.EndDate, result.EndDate);
}
public async Task Update(History history, History oldHistory)
{
var record = await context.EmployeeDepartmentHistory
.SingleAsync(x => x.BusinessEntityID == history.Id && x.StartDate == oldHistory.StartDate && x.Department.Name == oldHistory.Department);
if (record == null)
{
return;
}
//can't modify StartDate - primary key so I remove original record and add new one updated
context.EmployeeDepartmentHistory.Remove(record);
var newRecord = new EmployeeDepartmentHistory
{
BusinessEntityID = record.BusinessEntityID,
ShiftID = record.ShiftID,
StartDate = history.StartDate,
EndDate = history.EndDate,
ModifiedDate = DateTime.Now,
Employee = context.Employee.Single(e => e.BusinessEntityID == record.BusinessEntityID),
Department = context.Department.Where(e => e.Name == history.Department).First(),
Shift = record.Shift
};
newRecord.Employee.Person.FirstName = history.FirstName;
newRecord.Employee.Person.LastName = history.LastName;
context.EmployeeDepartmentHistory.Add(newRecord);
await context.SaveChangesAsync();
}
/// <summary>
/// Test Find using the Query class
/// </summary>
private void Step_30_TestFindByQuery_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
//Insert Mock Instance
EmployeeDepartmentHistory mock = CreateMockInstance(tm);
bool result = DataRepository.EmployeeDepartmentHistoryProvider.Insert(tm, mock);
Assert.IsTrue(result, "Could Not Test FindByQuery, Insert Failed");
EmployeeDepartmentHistoryQuery query = new EmployeeDepartmentHistoryQuery();
query.AppendEquals(EmployeeDepartmentHistoryColumn.EmployeeId, mock.EmployeeId.ToString());
query.AppendEquals(EmployeeDepartmentHistoryColumn.DepartmentId, mock.DepartmentId.ToString());
query.AppendEquals(EmployeeDepartmentHistoryColumn.ShiftId, mock.ShiftId.ToString());
query.AppendEquals(EmployeeDepartmentHistoryColumn.StartDate, mock.StartDate.ToString());
if (mock.EndDate != null)
{
query.AppendEquals(EmployeeDepartmentHistoryColumn.EndDate, mock.EndDate.ToString());
}
query.AppendEquals(EmployeeDepartmentHistoryColumn.ModifiedDate, mock.ModifiedDate.ToString());
TList <EmployeeDepartmentHistory> results = DataRepository.EmployeeDepartmentHistoryProvider.Find(tm, query);
Assert.IsTrue(results.Count == 1, "Find is not working correctly. Failed to find the mock instance");
}
}
private void SaveHistoryEntry()
{
if (Closed != null)
{
EmployeeDepartmentHistory newEntry = new EmployeeDepartmentHistory();
{
newEntry.BusinessEntityID = BusinessEntityID;
newEntry.DepartmentID = DepartmentID;
newEntry.StartDate = StartDate;
newEntry.ShiftID = ShiftID;
newEntry.EndDate = EndDate;
newEntry.ModifiedDate = DateTime.Now;
}
try
{
DataService.AddEmployeeDepartmentHistoryEntity(newEntry);
NotifyPropertyChanged("EmployeeDepartmentHistory");
HumanResourcesViewModel.Instance.RefreshEmployeeDepartmentHistoryList();
Closed(newEntry);
}
catch (Exception e)
{
ErrorMessage = e.Message;
NotifyPropertyChanged("ErrorMessage");
}
}
}
///<summary>
/// Returns a Typed EmployeeDepartmentHistory Entity with mock values.
///</summary>
static public EmployeeDepartmentHistory CreateMockInstance_Generated(TransactionManager tm)
{
EmployeeDepartmentHistory mock = new EmployeeDepartmentHistory();
mock.StartDate = TestUtility.Instance.RandomDateTime();
mock.EndDate = TestUtility.Instance.RandomDateTime();
mock.ModifiedDate = TestUtility.Instance.RandomDateTime();
//OneToOneRelationship
Department mockDepartmentByDepartmentId = DepartmentTest.CreateMockInstance(tm);
DataRepository.DepartmentProvider.Insert(tm, mockDepartmentByDepartmentId);
mock.DepartmentId = mockDepartmentByDepartmentId.DepartmentId;
//OneToOneRelationship
Employee mockEmployeeByEmployeeId = EmployeeTest.CreateMockInstance(tm);
DataRepository.EmployeeProvider.Insert(tm, mockEmployeeByEmployeeId);
mock.EmployeeId = mockEmployeeByEmployeeId.EmployeeId;
//OneToOneRelationship
Shift mockShiftByShiftId = ShiftTest.CreateMockInstance(tm);
DataRepository.ShiftProvider.Insert(tm, mockShiftByShiftId);
mock.ShiftId = mockShiftByShiftId.ShiftId;
// create a temporary collection and add the item to it
TList <EmployeeDepartmentHistory> tempMockCollection = new TList <EmployeeDepartmentHistory>();
tempMockCollection.Add(mock);
tempMockCollection.Remove(mock);
return((EmployeeDepartmentHistory)mock);
}
public EditRecordViewModel(EmployeeDepartmentHistory selectedRecord)
{
this.selectedRecord = selectedRecord;
saveCommand = new RelayCommand(() => SaveHistoryEntry());
cancelCommand = new RelayCommand(() => CloseWindow());
UpdateProperties();
}
/// <summary>
/// Deep load all EmployeeDepartmentHistory children.
/// </summary>
private void Step_03_DeepLoad_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
int count = -1;
mock = CreateMockInstance(tm);
mockCollection = DataRepository.EmployeeDepartmentHistoryProvider.GetPaged(tm, 0, 10, out count);
DataRepository.EmployeeDepartmentHistoryProvider.DeepLoading += new EntityProviderBaseCore <EmployeeDepartmentHistory, EmployeeDepartmentHistoryKey> .DeepLoadingEventHandler(
delegate(object sender, DeepSessionEventArgs e)
{
if (e.DeepSession.Count > 3)
{
e.Cancel = true;
}
}
);
if (mockCollection.Count > 0)
{
DataRepository.EmployeeDepartmentHistoryProvider.DeepLoad(tm, mockCollection[0]);
System.Console.WriteLine("EmployeeDepartmentHistory instance correctly deep loaded at 1 level.");
mockCollection.Add(mock);
// DataRepository.EmployeeDepartmentHistoryProvider.DeepSave(tm, mockCollection);
}
//normally one would commit here
//tm.Commit();
//IDisposable will Rollback Transaction since it's left uncommitted
}
}
public static void Map(this EmployeeDepartmentHistory destination, EmployeeDepartmentHistory source)
{
destination.BusinessEntityID = source.BusinessEntityID;
destination.DepartmentID = source.DepartmentID;
destination.ShiftID = source.ShiftID;
destination.StartDate = source.StartDate;
destination.EndDate = source.EndDate;
}
void ChildWindow_Closed(EmployeeDepartmentHistory employeeDepartmentHistory)
{
if (Closed != null)
{
Closed(employeeDepartmentHistory);
}
ChildWindowManager.Instance.CloseChildWindow();
}
///<summary>
/// Update the Typed EmployeeDepartmentHistory Entity with modified mock values.
///</summary>
static public void UpdateMockInstance(TransactionManager tm, EmployeeDepartmentHistory mock)
{
EmployeeDepartmentHistoryTest.UpdateMockInstance_Generated(tm, mock);
// make any alterations necessary
// (i.e. for DB check constraints, special test cases, etc.)
SetSpecialTestData(mock);
}
public ViewEmployeeDepartmentHistory(EmployeeDepartmentHistory employee)
{
this.BusinessEntityID = employee.BusinessEntityID;
this.DepartmentID = employee.DepartmentID;
this.ShiftID = employee.ShiftID;
this.StartDate = employee.StartDate;
this.EndDate = employee.EndDate;
this.ModifiedDate = employee.ModifiedDate;
}
public EmployeeDepartmentHistoryModel Create(EmployeeDepartmentHistory edh)
{
return(new EmployeeDepartmentHistoryModel()
{
DepartmentID = edh.DepartmentID,
ShiftID = edh.ShiftID,
StartDate = edh.StartDate,
EndDate = edh.EndDate
});
}
private void DeleteRecord()
{
EmployeeDepartmentHistory selectedRecord = HumanResourcesViewModel.Instance.SelectedDepartmentHistory;
if (selectedRecord != null)
{
DataService.DeleteEmployeeDepartmentHistoryEntity(selectedRecord);
HumanResourcesViewModel.Instance.RefreshEmployeeDepartmentHistoryList();
}
}
private void ShowEditRecordWindow()
{
EmployeeDepartmentHistory selectedRecord = HumanResourcesViewModel.Instance.SelectedDepartmentHistory;
if (selectedRecord != null)
{
EditRecordWindowViewModel editRecordWindow = new EditRecordWindowViewModel();
editRecordWindow.Show(selectedRecord);
}
}
public void Show(EmployeeDepartmentHistory selectedRecord)
{
EditRecordViewModel vm = new EditRecordViewModel(selectedRecord);
vm.Closed += ChildWindow_Closed;
ChildWindowManager.Instance.ShowChildWindow(new EditRecordView()
{
DataContext = vm
});
}
/// <summary>
/// Test methods exposed by the EntityHelper class.
/// </summary>
private void Step_20_TestEntityHelper_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
mock = CreateMockInstance(tm);
EmployeeDepartmentHistory entity = mock.Copy() as EmployeeDepartmentHistory;
entity = (EmployeeDepartmentHistory)mock.Clone();
Assert.IsTrue(EmployeeDepartmentHistory.ValueEquals(entity, mock), "Clone is not working");
}
}
///<summary>
/// Returns a Typed EmployeeDepartmentHistory Entity with mock values.
///</summary>
static public EmployeeDepartmentHistory CreateMockInstance(TransactionManager tm)
{
// get the default mock instance
EmployeeDepartmentHistory mock = EmployeeDepartmentHistoryTest.CreateMockInstance_Generated(tm);
// make any alterations necessary
// (i.e. for DB check constraints, special test cases, etc.)
SetSpecialTestData(mock);
// return the modified object
return(mock);
}
/// <summary>
/// Check the foreign key dal methods.
/// </summary>
private void Step_10_FK_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
EmployeeDepartmentHistory entity = CreateMockInstance(tm);
bool result = DataRepository.EmployeeDepartmentHistoryProvider.Insert(tm, entity);
Assert.IsTrue(result, "Could Not Test FK, Insert Failed");
TList <EmployeeDepartmentHistory> t1 = DataRepository.EmployeeDepartmentHistoryProvider.GetByEmployeeId(tm, entity.EmployeeId, 0, 10);
}
}
// PUT api/awbuildversion/5
public void Put(EmployeeDepartmentHistory value)
{
var GetActionType = Request.Headers.Where(x => x.Key.Equals("ActionType")).FirstOrDefault();
if (GetActionType.Key != null)
{
if (GetActionType.Value.ToList()[0].Equals("DELETE"))
adventureWorks_BC.EmployeeDepartmentHistoryDelete(value);
if (GetActionType.Value.ToList()[0].Equals("UPDATE"))
adventureWorks_BC.EmployeeDepartmentHistoryUpdate(value);
}
}
/// <summary>
/// Serialize the mock EmployeeDepartmentHistory entity into a temporary file.
/// </summary>
private void Step_06_SerializeEntity_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
mock = CreateMockInstance(tm);
string fileName = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "temp_EmployeeDepartmentHistory.xml");
EntityHelper.SerializeXml(mock, fileName);
Assert.IsTrue(System.IO.File.Exists(fileName), "Serialized mock not found");
System.Console.WriteLine("mock correctly serialized to a temporary file.");
}
}
public ActionResult Edit([Bind(Include = "BusinessEntityID,DepartmentID,ShiftID,StartDate,EndDate,ModifiedDate,isDelete")] EmployeeDepartmentHistory employeeDepartmentHistory)
{
if (ModelState.IsValid)
{
db.Entry(employeeDepartmentHistory).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.DepartmentID = new SelectList(db.Departments, "DepartmentID", "Name", employeeDepartmentHistory.DepartmentID);
ViewBag.BusinessEntityID = new SelectList(db.Employees, "BusinessEntityID", "NationalIDNumber", employeeDepartmentHistory.BusinessEntityID);
ViewBag.ShiftID = new SelectList(db.Shifts, "ShiftID", "Name", employeeDepartmentHistory.ShiftID);
return(View(employeeDepartmentHistory));
}
public virtual EmployeeDepartmentHistory MapBOToEF(
BOEmployeeDepartmentHistory bo)
{
EmployeeDepartmentHistory efEmployeeDepartmentHistory = new EmployeeDepartmentHistory();
efEmployeeDepartmentHistory.SetProperties(
bo.BusinessEntityID,
bo.DepartmentID,
bo.EndDate,
bo.ModifiedDate,
bo.ShiftID,
bo.StartDate);
return(efEmployeeDepartmentHistory);
}
public virtual BOEmployeeDepartmentHistory MapEFToBO(
EmployeeDepartmentHistory ef)
{
var bo = new BOEmployeeDepartmentHistory();
bo.SetProperties(
ef.BusinessEntityID,
ef.DepartmentID,
ef.EndDate,
ef.ModifiedDate,
ef.ShiftID,
ef.StartDate);
return(bo);
}
public async Task <IActionResult> CreateDeptHistory([FromBody] EmployeeDepartmentHistory deptHistory)
{
await _repository.DepartmentHistory.CreateDepartmentHistory(deptHistory);
return(CreatedAtRoute(nameof(GetDeptHistoryByID),
new
{
employeeID = deptHistory.BusinessEntityID,
deptID = deptHistory.DepartmentID,
shiftID = deptHistory.ShiftID,
startDate = deptHistory.StartDate
},
deptHistory));
}
public bool EmployeeDepartmentHistoryDelete(EmployeeDepartmentHistory employeedepartmenthistory)
{
return(Execute <bool>(dal =>
{
EmployeeDepartmentHistory employeedepartmenthistoryDelete = dal.EmployeeDepartmentHistory.Where(x => x.BusinessEntityID == employeedepartmenthistory.BusinessEntityID).FirstOrDefault();
if (employeedepartmenthistoryDelete != null)
{
dal.EmployeeDepartmentHistory.DeleteOnSubmit(employeedepartmenthistoryDelete);
dal.SubmitChanges();
return true;
}
return false;
}));
}
// GET: EmployeeDepartmentHistories/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EmployeeDepartmentHistory employeeDepartmentHistory = db.EmployeeDepartmentHistories.Find(id);
if (employeeDepartmentHistory == null)
{
return(HttpNotFound());
}
return(View(employeeDepartmentHistory));
}
public void MapEFToBOList()
{
var mapper = new DALEmployeeDepartmentHistoryMapper();
EmployeeDepartmentHistory entity = new EmployeeDepartmentHistory();
entity.SetProperties(1, 1, DateTime.Parse("1/1/1987 12:00:00 AM"), DateTime.Parse("1/1/1987 12:00:00 AM"), 1, DateTime.Parse("1/1/1987 12:00:00 AM"));
List <BOEmployeeDepartmentHistory> response = mapper.MapEFToBO(new List <EmployeeDepartmentHistory>()
{
entity
});
response.Count.Should().Be(1);
}
/// <summary>
/// Check the indexes dal methods.
/// </summary>
private void Step_11_IX_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
EmployeeDepartmentHistory entity = CreateMockInstance(tm);
bool result = DataRepository.EmployeeDepartmentHistoryProvider.Insert(tm, entity);
Assert.IsTrue(result, "Could Not Test IX, Insert Failed");
TList <EmployeeDepartmentHistory> t0 = DataRepository.EmployeeDepartmentHistoryProvider.GetByDepartmentId(tm, entity.DepartmentId);
TList <EmployeeDepartmentHistory> t1 = DataRepository.EmployeeDepartmentHistoryProvider.GetByShiftId(tm, entity.ShiftId);
EmployeeDepartmentHistory t2 = DataRepository.EmployeeDepartmentHistoryProvider.GetByEmployeeIdStartDateDepartmentIdShiftId(tm, entity.EmployeeId, entity.StartDate, entity.DepartmentId, entity.ShiftId);
}
}
/// <summary>
/// Inserts a mock EmployeeDepartmentHistory entity into the database.
/// </summary>
private void Step_01_Insert_Generated()
{
using (TransactionManager tm = CreateTransaction())
{
mock = CreateMockInstance(tm);
Assert.IsTrue(DataRepository.EmployeeDepartmentHistoryProvider.Insert(tm, mock), "Insert failed");
System.Console.WriteLine("DataRepository.EmployeeDepartmentHistoryProvider.Insert(mock):");
System.Console.WriteLine(mock);
//normally one would commit here
//tm.Commit();
//IDisposable will Rollback Transaction since it's left uncommitted
}
}
public async Task ShouldRaiseExceptionDuplicateEmployeeDepartmentHistory()
{
var deptHistory = new EmployeeDepartmentHistory
{
BusinessEntityID = 1,
DepartmentID = 10,
ShiftID = 3,
StartDate = new DateTime(2009, 1, 14),
EndDate = new DateTime(2009, 1, 15)
};
var exception = await Assert.ThrowsAsync <AdventureWorksUniqueIndexException>(() => _deptHistoryRepo.CreateDepartmentHistory(deptHistory));
Assert.Equal("Error: This operation would result in a duplicate employee department history record.", exception.Message);
}
// PUT api/awbuildversion/5
public void Put(EmployeeDepartmentHistory value)
{
var GetActionType = Request.Headers.Where(x => x.Key.Equals("ActionType")).FirstOrDefault();
if (GetActionType.Key != null)
{
if (GetActionType.Value.ToList()[0].Equals("DELETE"))
{
adventureWorks_BC.EmployeeDepartmentHistoryDelete(value);
}
if (GetActionType.Value.ToList()[0].Equals("UPDATE"))
{
adventureWorks_BC.EmployeeDepartmentHistoryUpdate(value);
}
}
}
// POST api/awbuildversion
public void Post(EmployeeDepartmentHistory value)
{
adventureWorks_BC.EmployeeDepartmentHistoryAdd(value);
}
/// <summary>
/// There are no comments for EmployeeDepartmentHistory in the schema.
/// </summary>
public void AddToEmployeeDepartmentHistory(EmployeeDepartmentHistory employeeDepartmentHistory)
{
base.AddObject("EmployeeDepartmentHistory", employeeDepartmentHistory);
}
/// <summary>
/// Create a new EmployeeDepartmentHistory object.
/// </summary>
/// <param name="employeeID">Initial value of EmployeeID.</param>
/// <param name="departmentID">Initial value of DepartmentID.</param>
/// <param name="shiftID">Initial value of ShiftID.</param>
/// <param name="startDate">Initial value of StartDate.</param>
/// <param name="modifiedDate">Initial value of ModifiedDate.</param>
public static EmployeeDepartmentHistory CreateEmployeeDepartmentHistory(int employeeID, short departmentID, byte shiftID, global::System.DateTime startDate, global::System.DateTime modifiedDate)
{
EmployeeDepartmentHistory employeeDepartmentHistory = new EmployeeDepartmentHistory();
employeeDepartmentHistory.EmployeeID = employeeID;
employeeDepartmentHistory.DepartmentID = departmentID;
employeeDepartmentHistory.ShiftID = shiftID;
employeeDepartmentHistory.StartDate = startDate;
employeeDepartmentHistory.ModifiedDate = modifiedDate;
return employeeDepartmentHistory;
}
