/// Creator: Chase Schulte
/// Created: 2020/03/28
/// Approver: Kaleb Bachert
///
/// Method for Inserting Availability
/// </summary>
///
/// <remarks>
/// Updater
/// Updated:
/// Update:
/// </remarks>
/// <param name="availability"></param>
/// <returns></returns>
public int InsertAvailability(EmployeeAvailability availability)
{
int nonQueryResults;
//Conn
var conn = DBConnection.GetConnection();
//Cmd
var cmd = new SqlCommand("sp_insert_availability", conn);
cmd.CommandType = CommandType.StoredProcedure;
//Param
cmd.Parameters.AddWithValue("@DayOfWeek", availability.DayOfWeek);
cmd.Parameters.AddWithValue("@StartTime", availability.StartTime);
cmd.Parameters.AddWithValue("@EndTime", availability.EndTime);
cmd.Parameters.AddWithValue("@UserID", availability.EmployeeID);
//Execute Command
try
{
//Open conn
conn.Open();
nonQueryResults = cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
throw ex;
}
finally
{
conn.Close();
}
return(nonQueryResults);
}
/// <summary>
/// Creator: Chase Schulte
/// Created: 2020/04/09
/// Approver: Kaleb Bachert:
///
/// Get Fake method Inserting Availability
/// </summary>
///
/// <remarks>
/// Updater
/// Updated:
/// Update:
/// </remarks>
/// <param name="availability"></param>
/// <returns></returns>
public int InsertAvailability(EmployeeAvailability availability)
{
int result = 0;
if (availability.EndTime.Length > 20)
{
throw new Exception();
}
if (availability.StartTime.Length > 20)
{
throw new Exception();
}
if (availabilities.Find(av => av.AvailabilityID == availability.AvailabilityID) != null)
{
throw new Exception();
}
//Make sure user ID is in list
if (petUniverseUsers.Find(av => av.PUUserID == availability.EmployeeID) != null)
{
result = 1;
}
if (result != 1)
{
throw new Exception();
}
if (availability.DayOfWeek == "Monday" || availability.DayOfWeek == "Tuesday" || availability.DayOfWeek == "Wednesday" || availability.DayOfWeek == "Thursday" || availability.DayOfWeek == "Friday" || availability.DayOfWeek == "Saturday" || availability.DayOfWeek == "Sunday")
{
return(1);
}
return(0);
}
public void TestUpdateAvailabilitySuccess()
{
//Arrange
EmployeeAvailability oldAvailability = new EmployeeAvailability()
{
AvailabilityID = 1,
EmployeeID = 100000,
DayOfWeek = "Monday",
StartTime = new DateTime(2020, 4, 21, 10, 0, 0).ToString(),
EndTime = new DateTime(2020, 4, 21, 23, 0, 0).ToString()
};
EmployeeAvailability availability = new EmployeeAvailability()
{
AvailabilityID = 1,
EmployeeID = 100000,
DayOfWeek = "Tuesday",
StartTime = new DateTime(2020, 4, 21, 10, 0, 0).ToShortTimeString(),
EndTime = new DateTime(2020, 4, 21, 23, 0, 0).ToShortTimeString()
};
IAvailabilityManager _availabilityManager = new AvailabilityManager(_availabilityAccessor);
bool expectResult = true;
//Act
bool actualResult = _availabilityManager.EditAvailability(availability, oldAvailability);
//Assert
Assert.AreEqual(expectResult, actualResult);
}
public ActionResult Edit(int id, EmployeeAvailability employeeAvailability)
{
try
{
if (!ModelState.IsValid)
{
var viewModel = new EmployeeAvailabilityViewModel
{
EmployeeAvailability = employeeAvailability,
UserVenues = _context.UserVenues.ToList(),
Days = _context.Days.ToList()
};
//return View("CustomerForm", viewModel);
}
// TODO: Add update logic here
var EmpAvailinDb = _context.EmployeeAvailabilities.Single(v => v.Id == employeeAvailability.Id);
EmpAvailinDb.UserVenuesId = employeeAvailability.UserVenuesId;
EmpAvailinDb.DayID = employeeAvailability.DayID;
EmpAvailinDb.StartTime = employeeAvailability.StartTime;
EmpAvailinDb.EndTime = employeeAvailability.EndTime;
_context.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
/// <summary>
/// CREATOR: Lane Sandburg
/// DATE: 4/2/2020
/// APPROVER: Jordan Lindo
///
/// method for inserting a New Employee Availability
/// </summary>
/// <remarks>
/// Updater: NA
/// Updated: NA
/// Update: NA
/// </remarks>
/// <param name="employeeAvailability">The availability the will be inserted</param>
/// <returns>returns true if insertion of availability was successful else returns false</returns>
public bool InsertNewEmployeeAvailability(EmployeeAvailability employeeAvailability)
{
bool Created = false;
var conn = DBConnection.GetConnection();
var cmd = new SqlCommand("sp_insert_availability", conn)
{
CommandType = CommandType.StoredProcedure
};
cmd.Parameters.AddWithValue("@UserID", employeeAvailability.EmployeeID);
cmd.Parameters.AddWithValue("@DayOfWeek", employeeAvailability.DayOfWeek);
cmd.Parameters.AddWithValue("@StartTime", employeeAvailability.StartTime);
cmd.Parameters.AddWithValue("@EndTime", employeeAvailability.EndTime);
try
{
conn.Open();
Created = 1 == cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
throw ex;
}
finally
{
conn.Close();
}
return(Created);
}
public ActionResult Create(EmployeeAvailability employeeAvailability, string PostMethod)
{
try
{
if (!ModelState.IsValid)
{
var viewModel = new EmployeeAvailabilityViewModel
{
EmployeeAvailability = employeeAvailability,
UserVenues = _context.UserVenues.ToList(),
Days = _context.Days.ToList()
};
}
employeeAvailability.ApplicationUserCreatedById = "4af95f1c-0f73-4df9-bb6d-166a07b6e5f4";
employeeAvailability.ApplicationUserCreatedDate = DateTime.Now;
employeeAvailability.ApplicationUserLastUpdatedById = employeeAvailability.ApplicationUserCreatedById;
employeeAvailability.ApplicationUserLastUpdatedDate = DateTime.Now;
// TODO: Add insert logic here
_context.EmployeeAvailabilities.Add(employeeAvailability);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
/// <summary>
/// Creator: Chase Schulte
/// Created: 2020/04/11
/// Approver: Kaleb Bachert:
///
/// Get Fake method for updating Availabilites
/// </summary>
///
/// <remarks>
/// Updater
/// Updated:
/// Update:
/// </remarks>
/// <param name="newAvailability"></param>
/// <param name="oldAvailability"></param>
/// <returns></returns>
public int UpdateAvailability(EmployeeAvailability newAvailability, EmployeeAvailability oldAvailability)
{
int result = 0;
//check old availability
if (availabilities.Find(av => av.AvailabilityID == oldAvailability.AvailabilityID && av.DayOfWeek == oldAvailability.DayOfWeek && av.EndTime == oldAvailability.EndTime && av.StartTime == oldAvailability.StartTime && av.EmployeeID == oldAvailability.EmployeeID) != null)
{
result = 1;
}
if (result != 1)
{
throw new Exception();
}
if (newAvailability.EndTime.Length > 20)
{
throw new Exception();
}
if (newAvailability.StartTime.Length > 20)
{
throw new Exception();
}
result = 0;
//Make sure id match
if (petUniverseUsers.Find(pu => pu.PUUserID == newAvailability.EmployeeID) != null)
{
result = 1;
}
if (result == 0)
{
throw new Exception();
}
result = 0;
if (oldAvailability.AvailabilityID == newAvailability.AvailabilityID)
{
result = 1;
}
result = 0;
//Make sure id match
if (oldAvailability.AvailabilityID == newAvailability.AvailabilityID)
{
result = 1;
}
if (result == 0)
{
throw new Exception();
}
result = 0;
if (newAvailability.DayOfWeek == "Monday" || newAvailability.DayOfWeek == "Tuesday" || newAvailability.DayOfWeek == "Wednesday" || newAvailability.DayOfWeek == "Thursday" || newAvailability.DayOfWeek == "Friday" || newAvailability.DayOfWeek == "Saturday" || newAvailability.DayOfWeek == "Sunday")
{
result = 1;
}
if (result == 0)
{
return(0);
}
return(1);
}
/// <summary>
/// Creator: Lane Sandburg
/// Created: 4/2/2020
/// Approver: Jordan Lindo
///
/// Creates a new employee Availability
/// </summary>
/// <remarks>
/// Updater: NA
/// Update: NA
/// Approver: NA
/// </remarks>
/// <param name="employeeAvailability"></param>
/// <returns>Boolean value to tell if new user was created</returns>
public bool CreateNewEmployeeAvailability(EmployeeAvailability employeeAvailability)
{
try
{
return(_employeeAvailabilityAccessor.InsertNewEmployeeAvailability(employeeAvailability));
}
catch (Exception ex)
{
throw new ApplicationException("Unable to create new availability", ex);;
}
}
public void TestInsertAvailabilityInvalidAvailabilityEndTimeTooLong()
{
//Arrange
EmployeeAvailability availability = new EmployeeAvailability()
{
AvailabilityID = 4, DayOfWeek = "Monday", StartTime = "22:00", EndTime = "12345677889132456789132", EmployeeID = 1
};
IAvailabilityManager _availabilityManager = new AvailabilityManager(_availabilityAccessor);
//Act
bool actualResult = _availabilityManager.AddAvailability(availability);
}
public void TestInsertAvailabilityInvalidUserID()
{
//Arrange
EmployeeAvailability availability = new EmployeeAvailability()
{
AvailabilityID = 4, DayOfWeek = "Monday", StartTime = "22:00", EndTime = "24:00", EmployeeID = 0
};
IAvailabilityManager _availabilityManager = new AvailabilityManager(_availabilityAccessor);
//Act
bool actualResult = _availabilityManager.AddAvailability(availability);
}
/// <summary>
/// Creator: Chase Schulte
/// Created: 2020/04/09
/// Approver: Kaleb Bachert
///
/// method for updating availability
/// </summary>
///
/// <remarks>
/// Updater
/// Updated:
/// Update:
/// </remarks>
/// <param name="newAvailability"></param>
/// <param name="oldAvailability"></param>
/// <returns></returns>
public bool EditAvailability(EmployeeAvailability newAvailability, EmployeeAvailability oldAvailability)
{
bool result = true;
try
{
result = _availabilityAccessor.UpdateAvailability(newAvailability, oldAvailability) > 0;
}
catch (Exception ex)
{
throw new ApplicationException("Availability not updated", ex);
}
return(result);
}
/// <summary>
/// Creator: Chase Schulte
/// Created: 2020/04/09
/// Approver: Kaleb Bachert
///
/// method for adding availability
/// </summary>
///
/// <remarks>
/// Updater
/// Updated:
/// Update:
/// </remarks>
/// <param name="availability"></param>
/// <returns></returns>
public bool AddAvailability(EmployeeAvailability availability)
{
bool result = true;
try
{
result = _availabilityAccessor.InsertAvailability(availability) > 0;
}
catch (Exception ex)
{
throw new ApplicationException("Availability not inserted", ex);
}
return(result);
}
public void TestUpdateOldAvailabilityNotReal()
{
//Arrange
EmployeeAvailability oldAvailability = new EmployeeAvailability()
{
AvailabilityID = 1, DayOfWeek = "NoDay", StartTime = "10:00", EndTime = "18:00", EmployeeID = 1
};
EmployeeAvailability availability = new EmployeeAvailability()
{
AvailabilityID = 1, DayOfWeek = "Monday", StartTime = "10:00", EndTime = "18:00", EmployeeID = 1
};
IAvailabilityManager _availabilityManager = new AvailabilityManager(_availabilityAccessor);
bool actualResult = _availabilityManager.EditAvailability(availability, oldAvailability);
}
public ActionResult Delete(int id, EmployeeAvailability employeeAvailability)
{
try
{
// TODO: Add delete logic here
var EmpAvailinDb = _context.EmployeeAvailabilities.Single(c => c.Id == employeeAvailability.Id);
_context.EmployeeAvailabilities.Remove(EmpAvailinDb);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public void TestInsertAvailabilitySuccess()
{
//Arrange
EmployeeAvailability availability = new EmployeeAvailability()
{
AvailabilityID = 5, DayOfWeek = "Monday", StartTime = "22:00", EndTime = "24:00", EmployeeID = 100001
};
IAvailabilityManager _availabilityManager = new AvailabilityManager(_availabilityAccessor);
bool expectResult = true;
//Act
bool actualResult = _availabilityManager.AddAvailability(availability);
//Assert
Assert.AreEqual(expectResult, actualResult);
}
public void TestUpdateNewAvailabilityInvalidAvailabilityStartTimeTooLong()
{
//Arrange
EmployeeAvailability oldAvailability = new EmployeeAvailability()
{
AvailabilityID = 1, DayOfWeek = "Monday", StartTime = "10:00", EndTime = "18:00", EmployeeID = 1
};
EmployeeAvailability availability = new EmployeeAvailability()
{
AvailabilityID = 1, DayOfWeek = "Monday", StartTime = "12345678913245678789132", EndTime = "24:00", EmployeeID = 1
};
IAvailabilityManager _availabilityManager = new AvailabilityManager(_availabilityAccessor);
//Act
bool actualResult = _availabilityManager.EditAvailability(availability, oldAvailability);
}
/// <summary>
/// Creator: Lane Sandburg
/// Created:4/2/2020
/// Approver: Jordan Lindo
///
/// Data Access Fake for Inserting a new employee Availability
/// </summary>
/// <remarks>
/// Updater: NA
/// Updated: NA
/// Update: NA
/// </remarks>
/// <param name="employeeAvailability">Test availability being created</param>
/// <returns>True if fakeemployeeAvailability and employeeAvailability are equal</returns>
public bool InsertNewEmployeeAvailability(EmployeeAvailability employeeAvailability)
{
bool employeeID = employeeAvailability.EmployeeID.Equals(100000);
bool dayOfTheWeek = employeeAvailability.DayOfWeek.Equals("Monday");
bool startTime = employeeAvailability.StartTime.Equals("10:50:06");
bool endTime = employeeAvailability.EndTime.Equals("11:50:06");
if (employeeID && dayOfTheWeek && startTime && endTime)
{
return(true);
}
else
{
throw new ApplicationException("Unable to add availability");
}
}
// GET: EmployeeAvailability/Create
public ActionResult Create(EmployeeAvailability employeeAvailability)
{
if (!ModelState.IsValid)
{
var viewModel = new EmployeeAvailabilityViewModel
{
EmployeeAvailability = employeeAvailability,
UserVenues = _context.UserVenues.ToList(),
Days = _context.Days.ToList()
};
return(View("Create", viewModel));
}
else
{
return(RedirectToAction("Index"));
}
}
public void TestCreateNewEmployeeAvailability()
{
// arrange
EmployeeAvailability employeeAvailability = new EmployeeAvailability()
{
EmployeeID = 100000,
DayOfWeek = "Monday",
StartTime = "10:50:06",
EndTime = "11:50:06"
};
bool created = false;
bool expectedResult = true;
// act
created = _employeeAvailabilityAccessor.InsertNewEmployeeAvailability(employeeAvailability);
// assert
Assert.AreEqual(expectedResult, created);
}
/// <summary>
/// CREATOR: Kaleb Bachert
/// CREATED: 2020/4/15
/// APPROVER: Lane Sandburg
///
/// This method retrieves all Users' Avilabilities
/// </summary>
/// <remarks>
/// UPDATER: NA
/// UPDATED: NA
/// UPDATE: NA
///
/// </remarks>
public List <EmployeeAvailability> SelectAllUsersAvailability()
{
List <EmployeeAvailability> availabilities = new List <EmployeeAvailability>();
var conn = DBConnection.GetConnection();
var cmd = new SqlCommand("sp_select_all_users_availabilities", conn);
cmd.CommandType = CommandType.StoredProcedure;
try
{
conn.Open();
var reader = cmd.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
EmployeeAvailability availability = new EmployeeAvailability();
availability.EmployeeID = reader.GetInt32(0);
availability.DayOfWeek = reader.GetString(1);
availability.StartTime = reader.GetString(2);
availability.EndTime = reader.GetString(3);
availabilities.Add(availability);
}
reader.Close();
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
conn.Close();
}
return(availabilities);
}
/// Creator: Chase Schulte
/// Created: 2020/03/28
/// Approver: Kaleb Bachert
///
/// Method for Updating Availability
/// </summary>
///
/// <remarks>
/// Updater
/// Updated:
/// Update:
/// </remarks>
public int UpdateAvailability(EmployeeAvailability newAvailability, EmployeeAvailability oldAvailability)
{
int nonQueryResults;
//Conn
var conn = DBConnection.GetConnection();
//Cmd
var cmd = new SqlCommand("sp_update_availablity_by_id", conn);
cmd.CommandType = CommandType.StoredProcedure;
//Vals
cmd.Parameters.AddWithValue("OldAvailabilityID", oldAvailability.AvailabilityID);
cmd.Parameters.AddWithValue("OldUserID", oldAvailability.EmployeeID);
cmd.Parameters.AddWithValue("OldStartTime", oldAvailability.StartTime);
cmd.Parameters.AddWithValue("OldEndTime", oldAvailability.EndTime);
cmd.Parameters.AddWithValue("OldDayOfWeek", oldAvailability.DayOfWeek);
cmd.Parameters.AddWithValue("NewUserID", newAvailability.EmployeeID);
cmd.Parameters.AddWithValue("NewStartTime", newAvailability.StartTime);
cmd.Parameters.AddWithValue("NewEndTime", newAvailability.EndTime);
cmd.Parameters.AddWithValue("NewDayOfWeek", newAvailability.DayOfWeek);
//Execute Command
try
{
//Open conn
conn.Open();
nonQueryResults = cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
throw ex;
}
finally
{
conn.Close();
}
return(nonQueryResults);
}
public List <EmployeeAvailability> SetEmployeeAvailabilities(ApplicationDbContext context)
{
employees = context.EmployeeModel.ToList();
availabilities = context.Availabilities.ToList();
foreach (EmployeeModel employee in employees)
{
int t = 20;
int range = availabilities.Count() - 1;
for (int i = 0; i < t; i++)
{
int id = RandomID(range) + 1;
EmployeeAvailability ea = new EmployeeAvailability {
AvailabilityID = id, EmployeeID = employee.ID
};
employeeAvailabilities.Add(ea);
}
counts.Clear();
}
return(employeeAvailabilities);
}
private static List <EmployeeAvailability> SetEmployeeAvailabilities()
{
int c = 1;
foreach (EmployeeModel employee in employees)
{
int t = 20;
int range = availabilities.Count() - 1;
Availability availabilty = new Availability();
for (int i = 0; i < t; i++)
{
int id = RandomID(range) + 1;
availabilty = availabilities.FirstOrDefault(a => a.AvailabilityID == id);
EmployeeAvailability ea = new EmployeeAvailability {
EmployeeAvailabilityID = c, Employee = employee, Availability = availabilty, AvailabilityID = id, EmployeeID = employee.ID
};
employeeAvailabilities.Add(ea);
c++;
}
counts.Clear();
}
return(employeeAvailabilities);
}
public async Task <IActionResult> Create([Bind("AvailabilityID,Start, End, Weekly")] Availability availability)
{
if (ModelState.IsValid)
{
EmployeeModel employee = _context.EmployeeModel
.Single(e => e.EMail == User.Identity.Name);
_context.Add(availability);
_context.SaveChanges();
EmployeeAvailability employeeAvailability = new EmployeeAvailability
{
AvailabilityID = availability.AvailabilityID,
EmployeeID = employee.ID,
Availability = availability,
Employee = employee
};
_context.Add(employeeAvailability);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(availability));
}
/// <summary>
/// Creator: Lane Sandburg
/// Created: 04/09/2020
/// Approver: Jordan Lindo
///
/// populates list and datagrid with created availabilities.
/// </summary>
/// <remarks>
/// Updater:
/// Updated:
/// Update:
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnAddToDataGrid_Click(object sender, RoutedEventArgs e)
{
EmployeeAvailability availability = new EmployeeAvailability();
try
{
if (cboDayOfWeek.SelectedItem == null)
{
WPFErrorHandler.ErrorMessage("Day cannot be blank", "Validation");
cboDayOfWeek.Focus();
return;
}
else
{
availability.DayOfWeek = cboDayOfWeek.SelectedItem.ToString();
}
}
catch (Exception ex)
{
WPFErrorHandler.ErrorMessage(ex.Message, "Validation");
}
try
{
if (TPStartTime.Value == null || TPStartTime.Value.ToString().Equals(""))
{
WPFErrorHandler.ErrorMessage("StartTime cannot be blank", "Validation");
TPStartTime.Focus();
return;
}
else
{
DateTime time = (DateTime)TPStartTime.Value;
availability.StartTime = time.ToString("HH:mm:ss");;
}
}
catch (Exception ex)
{
WPFErrorHandler.ErrorMessage(ex.Message, "Validation");
}
try
{
if (TPEndTime.Value == null || TPEndTime.Value.ToString().Equals(""))
{
WPFErrorHandler.ErrorMessage("EndTime cannot be blank", "Validation");
TPEndTime.Focus();
return;
}
else
{
DateTime time = (DateTime)TPEndTime.Value;
availability.EndTime = time.ToString("HH:mm:ss");
}
}
catch (Exception ex)
{
WPFErrorHandler.ErrorMessage(ex.Message, "Validation");
}
try
{
DateTime startTime = (DateTime)TPStartTime.Value;
DateTime endTime = (DateTime)TPEndTime.Value;
if (endTime <= startTime.AddMinutes(59))
{
MessageBox.Show("Shifts must be at least 1Hour.");
TPStartTime.Focus();
return;
}
}
catch (Exception ex)
{
WPFErrorHandler.ErrorMessage(ex.Message, "Validation");
}
try
{
availability.EmployeeID = _employeeAvailabilityManager.RetrieveLastEmployeeID();
}
catch (Exception ex)
{
WPFErrorHandler.ErrorMessage(ex.Message, "Validation");
}
try
{
List <EmployeeAvailability> newAvailabilities = new List <EmployeeAvailability>();
bool failed = false;
if (availabilities.Count != 0)
{
foreach (EmployeeAvailability addedAvailability in availabilities)
{
if (availability.DayOfWeek == addedAvailability.DayOfWeek &&
availability.StartTime == addedAvailability.StartTime &&
availability.EndTime == addedAvailability.EndTime)
{
WPFErrorHandler.ErrorMessage("availability " + availability.DayOfWeek.ToString() + " " + availability.StartTime.ToString() + " " + availability.EndTime.ToString() + " was a duplicate entry", "Validation");
failed = true;
}
else if (availability.DayOfWeek == addedAvailability.DayOfWeek)
{
DateTime newStartTime = DateTime.Parse(availability.StartTime);
DateTime newEndTime = DateTime.Parse(availability.EndTime);
DateTime addedEndTime = DateTime.Parse(addedAvailability.EndTime);
DateTime addedStartTime = DateTime.Parse(addedAvailability.StartTime);
if (newStartTime < addedEndTime)
{
if (newEndTime < addedStartTime != true)
{
WPFErrorHandler.ErrorMessage("current availability " + availability.DayOfWeek.ToString() + " " + availability.StartTime.ToString() + " " + availability.EndTime.ToString() + " overlaps with "
+ addedAvailability.DayOfWeek.ToString() + " " + addedAvailability.StartTime.ToString() + " " + addedAvailability.EndTime.ToString(), "Validation");
failed = true;
}
else
{
newAvailabilities.Add(availability);
}
}
else
{
newAvailabilities.Add(availability);
}
}
else
{
newAvailabilities.Add(availability);
}
}
}
else
{
newAvailabilities.Add(availability);
}
if (failed == false)
{
availabilities.Add(newAvailabilities[0]);
}
}
catch (Exception ex)
{
WPFErrorHandler.ErrorMessage(ex.Message, "Validation");
}
dgAvailability.Items.Refresh();
if (btnSaveAvail.IsEnabled != true)
{
btnSaveAvail.IsEnabled = true;
}
}
public async static Task Initialize(IServiceProvider services)
{
var database = services.GetRequiredService <ApplicationDbContext>();
var userManager = services.GetRequiredService <UserManager <ApplicationUser> >();
var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >();
// Avoids data re-entry
if (!database.Offices.Any())
{
// Gets data
List <Office> officeList = Office.PopulateOffices();
database.Offices.AddRange(officeList);
database.SaveChanges();
}
// sets up list for data population
List <Employee> employeeList = Employee.PopulateEmployees();
List <ApplicationUser> appUserList = ApplicationUser.PopulateUsers();
List <Manager> managerList = Manager.PopulateManager();
// Setting up roles
string roleEmployee = "Employee";
string roleExecutive = "Executive";
string roleManagement = "Manager";
if (!database.Roles.Any())
{
IdentityRole role = new IdentityRole(roleExecutive);
await roleManager.CreateAsync(role);
role = new IdentityRole(roleEmployee);
await roleManager.CreateAsync(role);
role = new IdentityRole(roleManagement);
await roleManager.CreateAsync(role);
}
if (!database.Users.Any())
{
foreach (ApplicationUser eachExecutive in appUserList)
{
await userManager.CreateAsync(eachExecutive);
await userManager.AddToRoleAsync(eachExecutive, roleExecutive);
}
}
if (!database.Managers.Any())
{
foreach (Manager eachManager in managerList)
{
await userManager.CreateAsync(eachManager);
await userManager.AddToRoleAsync(eachManager, roleManagement);
}
}
if (!database.Employees.Any())
{
// filling employees into roleEmployee
foreach (Employee eachEmployee in employeeList)
{
// userManager = services.GetRequiredService<UserManager<ApplicationUser>>();
await userManager.CreateAsync(eachEmployee);
// userManager = services.GetRequiredService<UserManager<ApplicationUser>>();
await userManager.AddToRoleAsync(eachEmployee, roleEmployee);
}
}
// employee availability population
if (!database.EmployeeAvailabilities.Any())
{
DateTime startTime = DateTime.Parse("10:00 AM");
DateTime endTime = DateTime.Parse("10:00 PM");
//List to get all employees from db for data population
List <Employee> employees = database.Employees.ToList <Employee>();
EmployeeAvailability employeeAvailability = new EmployeeAvailability("Monday", startTime, endTime, employees[0].EmployeeID);
List <EmployeeAvailability> availabilityList = new List <EmployeeAvailability>();
availabilityList.Add(employeeAvailability);
startTime = DateTime.Parse("9:30 AM");
endTime = DateTime.Parse("8:30 PM");
employeeAvailability = new EmployeeAvailability("Tuesday", startTime, endTime, employees[0].EmployeeID);
availabilityList.Add(employeeAvailability);
startTime = DateTime.Parse("8:30 AM");
endTime = DateTime.Parse("10:00 PM");
employeeAvailability = new EmployeeAvailability("Tuesday", startTime, endTime, employees[1].EmployeeID);
availabilityList.Add(employeeAvailability);
startTime = DateTime.Parse("9:30 AM");
employeeAvailability = new EmployeeAvailability("Wednesday", startTime, endTime, employees[1].EmployeeID);
availabilityList.Add(employeeAvailability);
endTime = DateTime.Parse("6:00 PM");
employeeAvailability = new EmployeeAvailability("Thursday", startTime, endTime, employees[2].EmployeeID);
availabilityList.Add(employeeAvailability);
database.EmployeeAvailabilities.AddRange(availabilityList);
database.SaveChanges();
}
// hospital role population
if (!database.HospitalRoles.Any())
{
List <HospitalRole> hospitalRoleList = HospitalRole.PopulateHospitalRoles();
database.HospitalRoles.AddRange(hospitalRoleList);
database.SaveChanges();
}
// operating hour population
if (!database.OperatingHours.Any())
{
List <OperatingHour> operatingHoursList = OperatingHour.PopulateOperatingHours();
database.OperatingHours.AddRange(operatingHoursList);
database.SaveChanges();
}
if (!database.OperatingHourExceptions.Any())
{
List <OperatingHourException> operatingHourExceptionList = OperatingHourException.PopulateOfficeHourExecption();
database.OperatingHourExceptions.AddRange(operatingHourExceptionList);
database.SaveChanges();
}
if (!database.Office_OperatingHourExceptions.Any())
{
List <Office_OperatingHourException> office_OperatingsList = Office_OperatingHourException.PopulateOffice_Operating();
database.Office_OperatingHourExceptions.AddRange(office_OperatingsList);
database.SaveChanges();
}
if (!database.TimeClocks.Any())
{
List <Employee> employees = database.Employees.ToList <Employee>();
DateTime timeClockIn = DateTime.Parse("8:00 AM");
DateTime timeClockOut = DateTime.Parse("5:00 PM");
TimeClock clock = new TimeClock(timeClockIn, timeClockOut, employees[0].EmployeeID);
List <TimeClock> clocks = new List <TimeClock>();
clocks.Add(clock);
clock = new TimeClock(timeClockIn, timeClockOut, employees[1].EmployeeID);
clocks.Add(clock);
clock = new TimeClock(timeClockIn, timeClockOut, employees[2].EmployeeID);
clocks.Add(clock);
database.TimeClocks.AddRange(clocks);
database.SaveChanges();
if (clocks[0].EmployeeID == null)
{
clocks[0].EmployeeID = employees[0].EmployeeID;
database.TimeClocks.Update(clocks[0]);
clocks[1].EmployeeID = employees[1].EmployeeID;
database.TimeClocks.Update(clocks[1]);
clocks[2].EmployeeID = employees[2].EmployeeID;
database.TimeClocks.Update(clocks[2]);
clocks[3].EmployeeID = employees[3].EmployeeID;
database.TimeClocks.Update(clocks[3]);
clocks[0].EmployeeID = employees[1].EmployeeID;
database.TimeClocks.Update(clocks[0]);
clocks[2].EmployeeID = employees[3].EmployeeID;
database.TimeClocks.Update(clocks[2]);
database.SaveChanges();
}
}
//if (!database.TimeClock_Employees.Any())
//{
// //List to get all employees from db for data population
// List<Employee> employees = database.Employees.ToList<Employee>();
// List<TimeClock_Employee> clock_employeeList = new List<TimeClock_Employee>();
// TimeClock_Employee clock_employee = new TimeClock_Employee(1, employees[0].EmployeeID);
// clock_employeeList.Add(clock_employee);
// clock_employee = new TimeClock_Employee(1, employees[1].EmployeeID);
// clock_employeeList.Add(clock_employee);
// clock_employee = new TimeClock_Employee(2, employees[2].EmployeeID);
// clock_employeeList.Add(clock_employee);
// clock_employee = new TimeClock_Employee(3, employees[1].EmployeeID);
// clock_employeeList.Add(clock_employee);
// clock_employee = new TimeClock_Employee(2, employees[0].EmployeeID);
// clock_employeeList.Add(clock_employee);
// database.TimeClock_Employees.AddRange(clock_employeeList);
// database.SaveChanges();
//}
if (!database.StaffRequirements.Any())
{
List <StaffRequirement> staffRequirementList = StaffRequirement.PopulateStaffRequirement();
database.StaffRequirements.AddRange(staffRequirementList);
database.SaveChanges();
}
if (!database.ScheduledToWorks.Any())
{
List <ScheduledToWork> scheduledToWorkList = ScheduledToWork.PopulateScheduledToWork();
database.ScheduledToWorks.AddRange(scheduledToWorkList);
database.SaveChanges();
}
if (!database.Staff_Scheduleds.Any())
{
List <Staff_Scheduled> staff_ScheduledsList = Staff_Scheduled.PopulateStaff_Scheduled();
database.Staff_Scheduleds.AddRange(staff_ScheduledsList);
database.SaveChanges();
}
if (!database.RequestTypes.Any())
{
List <RequestType> requestTypesList = RequestType.PopulateRequestType();
database.RequestTypes.AddRange(requestTypesList);
database.SaveChanges();
}
if (!database.Requests.Any())
{
List <Employee> employees = database.Employees.ToList <Employee>();
List <Manager> managers = database.Managers.ToList <Manager>();
List <Request> requestList = Request.PopulateRequest();
foreach (Request eachRequest in requestList)
{
eachRequest.EmployeeID = employees[0].EmployeeID;
eachRequest.ManagerID = managers[0].ManagerID;
database.Requests.Update(eachRequest);
database.SaveChanges();
}
database.Requests.AddRange(requestList);
database.SaveChanges();
}
if (!database.RequestResponses.Any())
{
List <RequestResponse> requestResponsesList = RequestResponse.PopulateRequestResponse();
database.RequestResponses.AddRange(requestResponsesList);
database.SaveChanges();
}
if (!database.Employee_HospitalRoles.Any())
{
//List to get all employees from db for data population
List <Employee> employees = database.Employees.ToList <Employee>();
List <Employee_HospitalRole> employee_HospitalRoleList = Employee_HospitalRole.PopulateEmployee_HospitalRoles();
Employee_HospitalRole employee_hospitalrole = new Employee_HospitalRole(1, employees[0].EmployeeID);
employee_HospitalRoleList.Add(employee_hospitalrole);
employee_hospitalrole = new Employee_HospitalRole(1, employees[1].EmployeeID);
employee_HospitalRoleList.Add(employee_hospitalrole);
employee_hospitalrole = new Employee_HospitalRole(2, employees[2].EmployeeID);
employee_HospitalRoleList.Add(employee_hospitalrole);
database.Employee_HospitalRoles.AddRange(employee_HospitalRoleList);
database.SaveChanges();
}
if (!database.Employee_ScheduledToWorks.Any())
{
//List to get all employees from db for data population
List <Employee> employees = database.Employees.ToList <Employee>();
List <Employee_ScheduledToWork> employee_ScheduledToWorkList = Employee_ScheduledToWork.PopulateEmployee_ScheduledToWorks();
Employee_ScheduledToWork employee_ScheduledToWork = new Employee_ScheduledToWork(1, employees[0].EmployeeID);
employee_ScheduledToWorkList.Add(employee_ScheduledToWork);
employee_ScheduledToWork = new Employee_ScheduledToWork(1, employees[0].EmployeeID);
employee_ScheduledToWorkList.Add(employee_ScheduledToWork);
employee_ScheduledToWork = new Employee_ScheduledToWork(2, employees[0].EmployeeID);
employee_ScheduledToWorkList.Add(employee_ScheduledToWork);
employee_ScheduledToWork = new Employee_ScheduledToWork(3, employees[0].EmployeeID);
employee_ScheduledToWorkList.Add(employee_ScheduledToWork);
employee_ScheduledToWork = new Employee_ScheduledToWork(1, employees[0].EmployeeID);
employee_ScheduledToWorkList.Add(employee_ScheduledToWork);
database.Employee_ScheduledToWorks.AddRange(employee_ScheduledToWorkList);
database.SaveChanges();
}
}
