// GET: Absence
public ActionResult Index(AbsenceViewModel avm)
{
try
{
ViewData["sessionData"] = new int?[] { HttpContext.Session.GetInt32("admin"), HttpContext.Session.GetInt32("language") };
avm.ActiveUser = userBll.GetUserById((long)HttpContext.Session.GetInt32("userId"));
avm.Dictionary = new Dictionary(HttpContext.Session.GetInt32("language"));
User user = new User();
if (avm.UserCode != null && avm.UserCode != "")
{
user = userBll.ShowAllUsers().FirstOrDefault(u => u.Login == avm.UserCode);
}
else
{
user = avm.ActiveUser;
avm.UserCode = avm.ActiveUser.Login;
}
avm.User = user;
avm.UserId = user.UserId;
avm.Absences = new AbsenceFE().GetAbsensesFE(absenceBll.ShowAllAbsences().Where(a => a.UserId == avm.UserId && a.EndDate >= DateTime.Today));
if (avm.ConflictReservatie)
{
ViewData["message"] = avm.Dictionary.Label21;
}
return(View(avm));
}
catch (Exception)
{
return(RedirectToAction("Index", "Home"));
}
}
/// <summary>
/// Converti une liste d'entités <see cref="Absence"/> en liste de ViewModel <see cref="AbsenceViewModel"/>
/// </summary>
/// <param name="notes">Liste d'entités <see cref="Absence"/></param>
/// <returns>Liste d'objets ViewModel <see cref="AbsenceViewModel"/></returns>
public List <AbsenceViewModel> ConvertToViewModels(List <Absence> absences)
{
EleveAdapter eleveAdapter = new EleveAdapter();
var vms = new List <AbsenceViewModel>();
if (absences == null || absences.Count == 0)
{
return(vms);
}
foreach (Absence absence in absences)
{
var vm = new AbsenceViewModel
{
AbsenceId = absence.AbsenceId,
Motif = absence.Motif,
DateAbsence = absence.DateAbsence,
EleveId = absence.EleveId,
};
vms.Add(vm);
}
return(vms);
}
public ActionResult Edit(int personnelId, AbsenceViewModel absenceViewModel)
{
var organisationId = UserOrganisationId;
absenceViewModel.Absence.OrganisationId = organisationId;
if (ModelState.IsValid)
{
absenceViewModel.Absence.AbsenceStatusByUser = ApplicationUser.Id;
absenceViewModel.Absence.AbsenceStatusDateTimeUtc = DateTime.UtcNow;
var result = HRBusinessService.UpdateAbsence(organisationId, absenceViewModel.Absence);
if (result.Succeeded)
{
return(RedirectToAction("Profile", "Personnel", new { id = absenceViewModel.Absence.PersonnelId }));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
var personnelAbsenceEntitlement = HRBusinessService.RetrievePersonnelAbsenceEntitlement(organisationId, absenceViewModel.Absence.PersonnelId, absenceViewModel.Absence.PersonnelAbsenceEntitlementId);
var employmentStartDate = HRBusinessService.RetrievePersonnelEmployments(organisationId, absenceViewModel.Absence.PersonnelId).Min(e => e.StartDate);
var employmentEndDate = HRBusinessService.RetrievePersonnelAbsencePeriods(organisationId, absenceViewModel.Absence.PersonnelId).Max(e => e.EndDate);
absenceViewModel.Period = personnelAbsenceEntitlement.Period;
absenceViewModel.AbsenceTypes = new SelectList(HRBusinessService.RetrieveAbsencePolicyEntitlements(organisationId, personnelAbsenceEntitlement.AbsencePolicyPeriod.AbsencePolicyId).Items.Select(s => s.AbsenceType).ToList(), "AbsenceTypeId", "Name", absenceViewModel.Absence.AbsenceTypeId);
absenceViewModel.PersonnelAbsenceEntitlement = personnelAbsenceEntitlement;
absenceViewModel.Permissions = HRBusinessService.RetrievePersonnelPermissions(User.IsInRole("Admin"), organisationId, UserPersonnelId, personnelId);
absenceViewModel.EmploymentBeginDate = employmentStartDate;
absenceViewModel.EmploymentEndDate = employmentEndDate;
return(View(absenceViewModel));
}
//[ValidateAntiForgeryToken]
///<summary>
/// Retrieves form for the given absence selected
/// </summary>
public ActionResult UpdateAbsenceEntry(IAbsenceDO iAbsence, int pointBankID)
{
ActionResult oResponse = null;
var userPO = (IUserPO)Session["UserModel"];
if (userPO.Email != null && userPO.RoleID_FK >= (int)RoleEnum.Administrator && userPO.RoleID_FK <= (int)RoleEnum.Team_Lead)
{
var absenceVM = new AbsenceViewModel();
// Retrieve selected absence
var absenceDO = PointsDataAccess.GetAbsenceByID(pointBankID);
ViewBag.Name = "Modify Employee Absence";
// Maps absence DO to PO
absenceVM.Absence = AbsenceMapper.MapAbsenceDOtoPO(absenceDO);
oResponse = View(absenceVM);
}
else
{
// User doesn't have priveleges redirect home
oResponse = RedirectToAction("Index", "Home");
}
return(oResponse);
}
public async Task <IActionResult> Add()
{
User user = await userManager.GetUserAsync(User);
if (user != null)
{
AbsenceViewModel model = new AbsenceViewModel
{
AbsenceRequest = new AbsenceRequest
{
UserId = user.Id,
DateSubmitted = DateTime.Now,
AbsenceStatusId = data.AbsenceStatusTypes.List().Where(s => s.Name == "Submitted").FirstOrDefault().AbsenceStatusId
},
AbsenceTypes = data.AbsenceTypes.List(),
DurationTypes = data.DurationTypes.List(),
SelectablePeriods = new List <SelectablePeriodViewModel>()
};
//Populate Period Check List
model.SelectablePeriods = PopulateSelectablePeriodCheckList(model.SelectablePeriods);
return(View("Absence", model));
}
//If user is not logged on. Redirect to log in screen.
return(RedirectToAction("LogIn", "Account"));
}
//[ValidateAntiForgeryToken]
///<summary>
/// Views all absences for all teams under a Service Manager -- Check to see if this already exists
/// </summary>
public ActionResult ViewAllAbsencesForSMTeams(int userID)
{
ActionResult oResponse = null;
var selectedTeamAbsences = new AbsenceViewModel();
var userPO = (IUserPO)Session["UserModel"];
if (userPO.Email != null && userPO.RoleID_FK <= (int)RoleEnum.Service_Manager && userPO.RoleID_FK >= (int)RoleEnum.Administrator)
{
if (ModelState.IsValid)
{
try
{
var absences = new List <IAbsenceDO>();
// Stores list of absences by UserID
absences = PointsDataAccess.ViewAbsencesByUserID(userID);
InitializeViewData(selectedTeamAbsences, (UserPO)userPO, absences);
oResponse = View(selectedTeamAbsences);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex, "ViewAbsenceByTeamID", "Maint");
selectedTeamAbsences.ErrorMessage = "Something went wrong retrieving the list of absences. Please try again.";
oResponse = View(selectedTeamAbsences);
}
}
else
{
oResponse = View(selectedTeamAbsences);
}
}
return(oResponse);
}
/// <summary>
/// Modifie ou crée une absence
/// </summary>
/// <param name="vm">Objet ViewModel <see cref="AbsenceViewModel"/></param>
/// <returns></returns>
public ActionResult EditAbsence(AbsenceViewModel vm)
{
if (!ModelState.IsValid)
{
return(View("EditAbsence", vm));
}
AbsenceAdapter absenceAdapter = new AbsenceAdapter();
EleveAdapter eleveAdapter = new EleveAdapter();
if (vm.AbsenceId == 0) //Création
{
Absence absence = new Absence();
absenceAdapter.ConvertToEntity(absence, vm);
Manager.Instance.AddAbsence(absence);
}
else //Modification
{
Absence absence = Manager.Instance.GetAbsenceById(vm.AbsenceId);
absenceAdapter.ConvertToEntity(absence, vm);
Manager.Instance.EditAbsence(absence);
}
Eleve eleve = Manager.Instance.GetEleveById(vm.EleveId);
EleveViewModel eleveVM = eleveAdapter.ConvertToViewModel(eleve);
return(RedirectToAction("DetailEleve", "Eleve", new { eleveId = vm.EleveId }));
}
///<summary>
/// Sends the form to the database to be modified for an absence
/// </summary>
public ActionResult UpdateAbsenceEntry(AbsenceViewModel iViewModel, int userID)
{
ActionResult oResponse = null;
var userPO = (IUserPO)Session["UserModel"];
// Ensure user has priveleges
if (userPO.Email != null && userPO.RoleID_FK >= (int)RoleEnum.Administrator && userPO.RoleID_FK <= (int)RoleEnum.Team_Lead)
{
if (ModelState.IsValid)
{
try
{
// Map absence from PO to DO
IAbsenceDO lAbsenceForm = AbsenceMapper.MapAbsencePOtoDO(iViewModel.Absence);
// Passes form to data access to update the database
PointsDataAccess.UpdateAbsenceInformation(lAbsenceForm, userPO.UserID);
// Determine redirect based off role
switch (userPO.RoleID_FK)
{
case 1:
oResponse = RedirectToAction("ViewAllAbsenceEntries", "Maint");
break;
case 2:
oResponse = RedirectToAction("ViewAllAbsencesForSMTeam", "Maint");
break;
case 3:
oResponse = RedirectToAction("ViewAbsencesByTeamID", "Maint");
break;
default:
oResponse = RedirectToAction("Index", "Home");
break;
}
}
catch (Exception ex)
{
ErrorLogger.LogError(ex, "UpdateAbsenceEntry", "Maint");
iViewModel.ErrorMessage = "Something went wrong updating the absence entry. Please try again.";
oResponse = View(iViewModel);
}
}
else
{
oResponse = View(iViewModel);
}
}
else
{
oResponse = RedirectToAction("Index", "Home");
}
return(oResponse);
}
public ActionResult Create(long id)
{
ViewData["sessionData"] = new int?[] { HttpContext.Session.GetInt32("admin"), HttpContext.Session.GetInt32("language") };
AbsenceViewModel avm = new AbsenceViewModel
{
Dictionary = new Dictionary(HttpContext.Session.GetInt32("language")),
UserId = id
};
return(View(avm));
}
private void InitializeViewData(AbsenceViewModel selectedTeamAbsences, UserPO userPO, List <IAbsenceDO> absences)
{
var smName = new StringBuilder(selectedTeamAbsences.User.FirstName, 25);
ViewBag.Name = smName.Append(" " + selectedTeamAbsences.User.LastName);
// Maps list of absences from DO to PO
foreach (IAbsenceDO absence in absences)
{
selectedTeamAbsences.Absence = AbsenceMapper.MapAbsenceDOtoPO(absence);
}
}
public ActionResult CreateAbsence(AbsenceViewModel avm)
{
try
{
if (HttpContext.Session.GetInt32("userId") > 0)
{
if (avm.StartDate == null)
{
avm.StartDate = DateTime.Today;
}
if (avm.EndDate == null)
{
avm.StartDate = avm.StartDate;
}
avm.Dictionary = new Dictionary(HttpContext.Session.GetInt32("language"));
if (reservationBll.ShowAllReservations().Where(r1 => r1.UserId == avm.UserId).FirstOrDefault(r => (r.StartDate >= avm.StartDate && r.StartDate <= avm.EndDate) || (r.EndDate >= avm.StartDate && r.EndDate <= avm.EndDate)) == null &&
reservationBll.ShowAllReservations().Where(r1 => r1.UserId == avm.UserId).FirstOrDefault(r => (avm.StartDate >= r.StartDate && avm.StartDate <= r.EndDate) || (avm.EndDate >= r.StartDate && avm.EndDate <= r.EndDate)) == null)
{
Absence absence = new Absence
{
UserId = avm.UserId,
StartDate = avm.StartDate,
EndDate = avm.EndDate,
Description = avm.Description,
CreationDate = DateTime.Now,
Creator = HttpContext.Session.GetInt32("userId"),
Status = 0,
StatusDate = DateTime.Now
};
if (HttpContext.Session.GetInt32("admin") > 0 || avm.UserId == absence.Creator)
{
absenceBll.CreateAbsence(absence);
}
}
else
{
avm.ConflictReservatie = true;
}
}
avm.Absences = new AbsenceFE().GetAbsensesFE(absenceBll.ShowAllAbsences().Where(a => a.UserId == avm.UserId && a.EndDate >= DateTime.Today));
avm.UserCode = userBll.GetUserById(avm.UserId).Login;
ViewData["sessionData"] = new int?[] { HttpContext.Session.GetInt32("admin"), HttpContext.Session.GetInt32("language") };
return(RedirectToAction(nameof(Index), avm));
}
catch
{
ViewData["sessionData"] = new int?[] { HttpContext.Session.GetInt32("admin"), HttpContext.Session.GetInt32("language") };
return(RedirectToAction(nameof(Index), avm));
}
}
public void StringifyCalendarItems_NoItems_EmptyString()
{
//Arrange
List <CalendarItem> calendarItems = new List <CalendarItem>();
//Act
string result = AbsenceViewModel.StringifyCalendarItems(calendarItems);
//Assert
Assert.AreEqual(result, "");
}
public ActionResult AjouterAbsence(AbsenceViewModel absenceVM, int idEleve)
{
if (!ModelState.IsValid)
{
return(View(absenceVM));
}
Absence absence = new Absence {
DateAbsence = absenceVM.Date, Motif = absenceVM.Motif, EleveId = idEleve
};
manager.AjouterAbsence(absence);
return(Redirect("/"));
}
private void MapAdminObjects(AbsenceViewModel selectedTeamAbsences, List <ITeamDO> allTeams, List <IAbsenceDO> absences)
{
// Map values to correct properties for view
foreach (IAbsenceDO absence in absences)
{
selectedTeamAbsences.Absence = AbsenceMapper.MapAbsenceDOtoPO(absence);
selectedTeamAbsences.ListOfPos.Add(selectedTeamAbsences.Absence);
}
foreach (ITeamDO team in allTeams)
{
selectedTeamAbsences.Team = TeamMapper.MapTeamDOtoPO(team);
}
}
public void AppendLocationData_DataAppendedCorrectly()
{
//Arrange
StringBuilder stringBuilder = new StringBuilder();
CalendarItem calendarItem = new CalendarItem {
Location = "abc"
};
//Act
AbsenceViewModel.AppendLocationData(stringBuilder, calendarItem);
//Assert
Assert.AreEqual(stringBuilder.ToString(), " (abc)");
}
/// <summary>
/// Retourne la vue de création/modification d'une absence
/// </summary>
/// <param name="absenceId">Identifiant de l'absence</param>
/// <param name="eleveId">Identifiant de l'élève</param>
/// <returns></returns>
public ActionResult OpenViewEditAbsence(int absenceId, int eleveId)
{
if (absenceId == 0) //CREATION
{
return(View("EditAbsence", new AbsenceViewModel {
EleveId = eleveId
}));
}
AbsenceAdapter absenceAdapter = new AbsenceAdapter();
Absence absence = Manager.Instance.GetAbsenceById(absenceId);
AbsenceViewModel absenceViewModel = absenceAdapter.ConvertToViewModel(absence);
return(View("EditAbsence", absenceViewModel));
}
//[ValidateAntiForgeryToken]
///<summary>
/// Admin view all absences by all employees
/// </summary>
/// <returns></returns>
public ActionResult ViewAllAbsenceEntries()
{
ActionResult oResponse = null;
var userPO = (IUserPO)Session["UserModel"];
var viewAllAbsenceEntries = new AbsenceViewModel();
// User can view all absences if Admin
if (userPO.Email != null && userPO.RoleID_FK == (int)RoleEnum.Administrator)
{
try
{
// Calls to retrieve all absences from data access
var allAbsences = PointsDataAccess.ViewAllAbsences();
var allTeams = _TeamDataAccess.GetAllTeams();
// Retrieve widget values
var bestStandingTeam = _TeamBusinessLogic.QueryBestStandingTeam(TeamMapper.MapListOfDOsToListOfBOs(allTeams), allAbsences);
var bottomStandingTeam = _TeamBusinessLogic.QueryWorstStandingTeam(TeamMapper.MapListOfDOsToListOfBOs(allTeams), allAbsences);
var teamRanker = _TeamBusinessLogic.QueryTeamRanker(TeamMapper.MapListOfDOsToListOfBOs(allTeams), allAbsences);
foreach (var item in teamRanker)
{
viewAllAbsenceEntries.TeamRanker.Team.Name = item.Item1;
viewAllAbsenceEntries.TeamRanker.Absence.RunningTotal = item.Item2;
}
AssociateAdminValues(viewAllAbsenceEntries, bestStandingTeam, bottomStandingTeam, allAbsences);
viewAllAbsenceEntries.User.RoleID_FK = userPO.RoleID_FK;
viewAllAbsenceEntries.User.Email = userPO.Email;
oResponse = View(viewAllAbsenceEntries);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex, "ViewAllAbsenceEntries", "Maint");
viewAllAbsenceEntries.ErrorMessage = "Something went wrong retrieving the list of absences. Please try again.";
oResponse = View(viewAllAbsenceEntries);
}
}
else
{
// State was invalid redirect home
oResponse = RedirectToAction("Index", "Home");
}
return(oResponse);
}
// TODO: Rename and add switch/case for role decisions
private void AssociateAdminValues(AbsenceViewModel selectedTeamAbsences, List <Tuple <string, decimal> > teamRanker, ITeamDO teamName,
Tuple <string, decimal> bestStandingTeam, Tuple <string, decimal> bottomStandingTeam, Tuple <string, decimal> topEmployee)
{
foreach (var item in teamRanker)
{
selectedTeamAbsences.TeamRanker.Team.Name = item.Item1;
selectedTeamAbsences.TeamRanker.Absence.Point = item.Item2;
}
selectedTeamAbsences.Team.Name = teamName.Name;
selectedTeamAbsences.TopTeam.Team.Name = bestStandingTeam.Item1;
selectedTeamAbsences.TopTeam.Absence.RunningTotal = bestStandingTeam.Item2;
selectedTeamAbsences.BottomTeam.Team.Name = bottomStandingTeam.Item1;
selectedTeamAbsences.BottomTeam.Absence.RunningTotal = bottomStandingTeam.Item2;
selectedTeamAbsences.TopEmployee.User.Employee = topEmployee.Item1;
selectedTeamAbsences.TopEmployee.Absence.Point = topEmployee.Item2;
}
// TODO: Rename and refactor to handle all role types
private void AssociateAdminValues(AbsenceViewModel viewAllAbsenceEntries, Tuple <string, decimal> bestStandingTeam, Tuple <string, decimal> bottomStandingTeam, List <IAbsenceDO> allAbsences)
{
// Assign values to model for widgets
viewAllAbsenceEntries.TopTeam.Team.Name = bestStandingTeam.Item1;
viewAllAbsenceEntries.TopTeam.Absence.RunningTotal = bestStandingTeam.Item2;
viewAllAbsenceEntries.BottomTeam.Team.Name = bottomStandingTeam.Item1;
viewAllAbsenceEntries.BottomTeam.Absence.RunningTotal = bottomStandingTeam.Item2;
// Map absences from DO to PO for displaying to the user
viewAllAbsenceEntries.ListOfPos = AbsenceMapper.MapListOfDOsToListOfPOs(allAbsences);
//foreach (var absence in allAbsences)
//{
// viewAllAbsenceEntries.Absences.Add(new SelectListItem() { Text = absence.Name, Value = absence.Name });
//}
}
public ActionResult Index(int id)
{
AbsenceViewModel absenceViewModel = new AbsenceViewModel();
Student student = Student.GetByID(Convert.ToUInt32(id));
absenceViewModel.Student = student;
foreach (Course course in student.Courses)
{
absenceViewModel.TotalNumberOfLessons += course.Lessons.Count;
absenceViewModel.TotalNumberOfAssignments += course.AssignmentDescriptions.Count;
absenceViewModel.CurrentTotalNumberOfLessons += course.CurrentLessons.Count;
absenceViewModel.CurrentTotalNumberOfAssignments += course.CurrentAssignmentDescriptions.Count;
absenceViewModel.Courses.Add(course);
}
return(View(absenceViewModel));
}
public async Task <IActionResult> SaveAbsence(AbsenceViewModel absenceForm, Dictionary <string, object> de)
{
var baseUrl = $"{this.Request.Scheme}://{this.Request.Host}{this.Request.PathBase}";
var result = await _sheduleService.SaveAbsence(absenceForm.IsPresent,
absenceForm.CalendarSheduleTimeSpendingId, baseUrl);
if (result.StatusCode == 200)
{
return(RedirectToAction("Index"));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
public void AppendStringifiedCalendarItem_BT_ItemAppendedCorrectly()
{
//Arrange
DateTime from = new DateTime(2014, 01, 01);
DateTime to = new DateTime(2014, 02, 02);
StringBuilder stringBuilder = new StringBuilder();
CalendarItem calendarItem = new CalendarItem {
Location = "abc", From = from, To = to, Type = CalendarItemType.BT
};
//Act
AbsenceViewModel.AppendStringifiedCalendarItem(stringBuilder, calendarItem);
//Assert
Assert.AreEqual(stringBuilder.ToString(), from.ToString(String.Format("dd.MM.yyyy") + " - " + to.ToString(String.Format("dd.MM.yyyy"))) + " (abc)");
}
/// <summary>
/// Converti une entité <see cref="Absence"/> en ViewModel <see cref="AbsenceViewModel"/>
/// </summary>
/// <param name="note">Entité <see cref="Absence"/></param>
/// <returns>Objet ViewModel <see cref="AbsenceViewModel"/></returns>
public AbsenceViewModel ConvertToViewModel(Absence absence)
{
if (absence == null)
{
return(null);
}
var vm = new AbsenceViewModel
{
AbsenceId = absence.AbsenceId,
Motif = absence.Motif,
DateAbsence = absence.DateAbsence,
EleveId = absence.EleveId
};
return(vm);
}
public async Task <IActionResult> Summary(string id)
{
var availableAbsence = await _context.AvailableAbsence
.Where(a => a.IdEmployee == id)
.ToListAsync();
var absenceType = await _context.AbsenceType
.ToListAsync();
var model = new AbsenceViewModel
{
AvailableAbsence = availableAbsence,
AbsenceType = absenceType
};
return(View(model));
}
public IActionResult Edit(AbsenceViewModel model)
{
if (ModelState.IsValid)
{
//Check to make sure Need Coverage and Periods input match.
List <SelectablePeriodViewModel> checkedPeriods = model.SelectablePeriods.Where(p => p.Checked == true).ToList();
if (model.NeedCoverageInput == "true" && checkedPeriods.Count == 0)
{
ModelState.AddModelError("", "If coverage is needed, please check the periods that you will need coverage for.");
}
else if (model.NeedCoverageInput == "false" && checkedPeriods.Count != 0)
{
ModelState.AddModelError("", "If no coverage is needed, checked periods are not allowed.");
}
else
{
//Initialize the bool value for Need Coverage in Absence Request.
model.AbsenceRequest.NeedCoverage = model.NeedCoverageInput == "true" ? true : false;
//Delete Old AbsenceRequestPeriod records from Joint Entity(Many-To-Many)
data.DeleteAbsenceRequestPeriods(model.AbsenceRequest);
//Create a new list of AbsenceRequestPeriods in the AbsenceRequest (Many-To-Many)
model.AbsenceRequest.AbsenceRequestPeriods = new List <AbsenceRequestPeriod>();
//Add the new periods checked to the joint entity AbsenceRequestPeriod (Many-to-Many), by using the method in Unit of Work.
data.AddNewAbsenceRequestPeriods(model.AbsenceRequest, model.SelectablePeriods);
//Inser the new record.
data.AbsenceRequests.Update(model.AbsenceRequest);
//Save the changes to the database.
data.Save();
TempData["SucessMessage"] = "The Absence Request # " + model.AbsenceRequest.AbsenceRequestId + ", was successfully updated.";
return(RedirectToAction("List"));
}
}
//If fail re-populate the lists
model.AbsenceTypes = data.AbsenceTypes.List();
model.DurationTypes = data.DurationTypes.List();
return(View("Absence", model));
}
public ActionResult AbsenceAction(int absenceID, int eleveID)
{
if (absenceID == 0)
{
AbsenceViewModel absenceVM = new AbsenceViewModel {
EleveId = eleveID, DateAbsence = DateTime.Now.Date
};
return(View("AjoutAbsence", absenceVM));
}
else
{
Absence a = BusinessManager.Instance.GetAbsenceById(absenceID);
AbsenceViewModel absenceVM = new AbsenceViewModel {
Motif = a.Motif, DateAbsence = a.DateAbsence, EleveId = a.EleveId, AbsenceId = a.AbsenceId
};
return(View("ModifierAbsence", absenceVM));
}
}
public ActionResult Add(AbsenceViewModel model, int EleveId = 0)
{
if (EleveId == 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (ModelState.IsValid)
{
Absence a = new Absence()
{
Motif = model.Motif, DateAbsence = model.DateAbsence, EleveId = EleveId
};
BusinessManager.Manager.Instance.AjouterAbsence(a);
return(RedirectToAction("Info", "Eleve", new { id = a.EleveId }));
}
return(View(model));
}
// GET: Absence/Edit/5
//[AuthorizePersonnel(Roles = "Admin,User")]
public ActionResult Edit(int personnelId, int id)
{
var organisationId = UserOrganisationId;
var personnel = HRBusinessService.RetrievePersonnel(organisationId, personnelId);
var absence = HRBusinessService.RetrieveAbsenceRange(organisationId, id);
bool canApproveAbsence = HRBusinessService.CanApproveAbsence(organisationId, id, User.IsInRole("Admin"), ApplicationUser.Id);
absence.CanApproveAbsence = canApproveAbsence;
if (absence == null)
{
return(HttpNotFound());
}
var personnelAbsenceEntitlement = HRBusinessService.RetrievePersonnelAbsenceEntitlement(organisationId, personnelId, absence.PersonnelAbsenceEntitlementId);
if (personnelAbsenceEntitlement == null)
{
throw new Exception("Absence entitlements may not been correctly configured, please contact your HR administrator.");
}
personnelAbsenceEntitlement.Personnel = personnel;
var periodDates = HRBusinessService.RetrieveAbsencePolicyAbsencePeriods(organisationId,
personnelAbsenceEntitlement.AbsencePolicyPeriod.AbsencePolicyId, null, null);
var periodsBeginDate = periodDates.Items.Min(a => a.AbsencePeriod.StartDate).Date;
var periodsEndDate = periodDates.Items.Max(a => a.AbsencePeriod.EndDate).Date;
var employmentStartDate = HRBusinessService.RetrievePersonnelEmployments(organisationId, personnelId).Min(e => e.StartDate);
var employmentEndDate = HRBusinessService.RetrievePersonnelAbsencePeriods(organisationId, personnelId).Max(e => e.EndDate);
var viewModel = new AbsenceViewModel
{
BeginDate = periodsBeginDate,
EndDate = periodsEndDate,
Period = personnelAbsenceEntitlement.Period,
Absence = absence,
AbsenceTypes = new SelectList(HRBusinessService.RetrieveAbsencePolicyEntitlements(organisationId, personnelAbsenceEntitlement.AbsencePolicyPeriod.AbsencePolicyId).Items.Select(s => s.AbsenceType).ToList(), "AbsenceTypeId", "Name", absence.AbsenceTypeId),
PersonnelAbsenceEntitlement = personnelAbsenceEntitlement,
Permissions = HRBusinessService.RetrievePersonnelPermissions(User.IsInRole("Admin"), organisationId, UserPersonnelId, personnelId),
EmploymentBeginDate = employmentStartDate,
EmploymentEndDate = employmentEndDate,
PersonnelId = personnelId,
};
return(View(viewModel));
}
//[ValidateAntiForgeryToken]
///<summary>
/// Retrieves form for creating a new absence entry
/// </summary>
public ActionResult AddAbsenceEntry()
{
ActionResult oResponse = null;
var userPO = (IUserPO)Session["UserModel"];
if (userPO.Email != null && userPO.RoleID_FK == (int)RoleEnum.Administrator)
{
var absenceVM = new AbsenceViewModel();
var absenceTypes = _AbsenceDataAccess.GetAllAbsenceTypes();
var absencePOs = AbsenceMapper.MapListOfDOsToListOfPOs(absenceTypes);
var users = _UserDataAccess.GetAllUsers();
var userPOs = UserMapper.MapListOfDOsToListOfPOs(users);
absenceVM.Users = userPOs.ConvertAll(a =>
{
return(new SelectListItem()
{
Text = a.UserID.ToString(),
Value = a.FirstName + " " + a.LastName,
Selected = false
});
});
absenceVM.AbsenceTypes = absencePOs.ConvertAll(a =>
{
return(new SelectListItem()
{
Text = a.AbsenceTypeID.ToString(),
Value = a.Name,
Selected = false
});
});
oResponse = View(absenceVM);
}
else
{
// User doesn't have access to create, redirect home
oResponse = RedirectToAction("Index", "Home");
}
return(oResponse);
}
///<summary>
/// Sends the absence form to the database to be added
/// </summary>
/// <returns></returns>
public ActionResult AddAbsenceEntry(AbsenceViewModel iViewModel)
{
ActionResult oResponse = null;
var userPO = (IUserPO)Session["UserModel"];
// User is authenticated(Admin, Service Manager or Team Lead)
if (userPO.Email != null && userPO.RoleID_FK < (int)RoleEnum.Service_Desk_Employee && userPO.RoleID_FK >= (int)RoleEnum.Administrator)
{
if (ModelState.IsValid)
{
try
{
var absenceTypes = _AbsenceDataAccess.GetAllAbsenceTypes();
var absenceTypePOs = AbsenceMapper.MapListOfDOsToListOfPOs(absenceTypes);
// Maps absence PO to DO during creation
IAbsenceDO lAbsenceForm = AbsenceMapper.MapAbsencePOtoDO(iViewModel.Absence);
var absenceType = absenceTypePOs.Where(at => at.AbsenceTypeID == iViewModel.Absence.AbsenceTypeID);
// Passes form to data access to add event to db
PointsDataAccess.AddAbsence(lAbsenceForm, userPO.UserID);
oResponse = RedirectToAction("ViewAllAbsence", "Maint");
}
catch (Exception ex)
{
ErrorLogger.LogError(ex, "AddAbsenceEntry", "Maint");
iViewModel.ErrorMessage = "Something went wrong when creating the absence to the system. Please try again.";
}
}
else
{
oResponse = View(iViewModel);
}
}
else
{
// User doesn't have privileges to create an absense entry, redirect to home.
oResponse = RedirectToAction("Index", "Home");
}
return(oResponse);
}
