public bool IsUserSignedUpForShiftDay(ShiftDay shiftDay, string userId)
{
var signups = GetShiftSignpsForShiftDay(shiftDay.ShiftDayId);
if (shiftDay.Shift.Personnel != null && shiftDay.Shift.Personnel.Any())
{
if (shiftDay.Shift.Personnel.Any(x => x.UserId == userId))
{
return(true);
}
}
if (signups == null || !signups.Any())
{
return(false);
}
foreach (var shiftSignup in signups)
{
if (shiftSignup.UserId == userId)
{
return(true);
}
if (shiftSignup.Trade != null && shiftSignup.Trade.TargetShiftSignup != null &&
shiftSignup.Trade.TargetShiftSignup.UserId == userId)
{
return(true);
}
}
return(false);
}
public ShiftDayDTO InsertShiftDayDetail(ShiftDayDTO detail)
{
ShiftDay dataToInsert = new ShiftDay();
dataToInsert = ShiftDayRequestFormatter.ConvertRespondentInfoFromDTO(detail);
return(ShiftDayRequestFormatter.ConvertRespondentInfoToDTO(_unitOfWork.ShiftDayRepository.Create(dataToInsert)));
// return null;
}
public int UpdateShiftDetail(ShiftDayDTO detail)
{
ShiftDay dataToUpdate = new ShiftDay();
dataToUpdate = ShiftDayRequestFormatter.ConvertRespondentInfoFromDTO(detail);
var res = _unitOfWork.ShiftDayRepository.Update(dataToUpdate);
_unitOfWork.Save();
return(res);
// return 0;
}
public static ShiftDayDTO ConvertRespondentInfoToDTO(ShiftDay shift)
{
Mapper.CreateMap <ShiftDay, ShiftDayDTO>().ConvertUsing(
m =>
{
return(new ShiftDayDTO
{
DayName = m.DayName,
DayNumber = m.DayNumber,
DayShiftId = m.DayShiftId,
DayStartTime = m.DayStartTime,
DayEndTime = m.DayEndTime,
DayWeekend = m.DayWeekend,
DayWorkingMinute = m.DayWorkingMinute,
DayDual = m.DayDual
});
});
return(Mapper.Map <ShiftDay, ShiftDayDTO>(shift));
}
public async Task <bool> IsShiftDayFilledWithObjAsync(Shift shift, ShiftDay shiftDay)
{
bool isFilled = true;
var shiftGroups = await GetShiftDayNeedsObjAsync(shift, shiftDay);
if (shiftGroups == null)
{
return(true);
}
foreach (var group in shiftGroups)
{
foreach (var role in group.Value)
{
if (role.Value > 0)
{
isFilled = false;
}
}
}
return(isFilled);
}
public async Task <Dictionary <int, Dictionary <int, int> > > GetShiftDayNeedsObjAsync(Shift shift, ShiftDay shiftDay)
{
//var shiftDay = await _shiftDaysRepository.GetShiftDayByIdAsync(shiftDayId);
var shiftGroups = new Dictionary <int, Dictionary <int, int> >();
if (shiftDay != null)
{
if (shiftDay.Shift.AssignmentType == (int)ShiftAssignmentTypes.Assigned)
{
return(null);
}
//shiftDay.Shift.Groups = (await _shiftGroupsRepository.GetShiftGroupsByShiftIdAsync(shiftDay.ShiftId)).ToList();
if (shiftDay.Shift.Groups == null || shiftDay.Shift.Groups.Count() <= 0)
{
return(null);
}
var shiftSignups =
(await _shiftSignupRepository.GetAllShiftSignupsByShiftIdAndDateAsync(shiftDay.ShiftId,
shiftDay.Day)).ToList();
foreach (var group in shiftDay.Shift.Groups)
{
var roleRequirements = new Dictionary <int, int>();
if (group.Roles != null && group.Roles.Any())
{
foreach (var role in group.Roles)
{
roleRequirements.Add(role.PersonnelRoleId, role.Required);
}
}
if (shiftSignups != null && shiftSignups.Any())
{
var groupSignups = shiftSignups.Where(x => x.DepartmentGroupId == group.DepartmentGroupId);
foreach (var signup in groupSignups)
{
var roles = await _personnelRolesService.GetRolesForUserAsync(signup.UserId, shiftDay.Shift.DepartmentId);
foreach (var personnelRole in roles)
{
if (roleRequirements.ContainsKey(personnelRole.PersonnelRoleId))
{
roleRequirements[personnelRole.PersonnelRoleId]--;
}
}
}
}
shiftGroups.Add(group.DepartmentGroupId, roleRequirements);
}
}
return(shiftGroups);
}
public ShiftDayService(IUnitOfWork unitOfWork = null)
{
_unitOfWork = unitOfWork ?? new UnitOfWork();
_shiftDay = new ShiftDay();
}
public ActionResult ShiftMapping(ShiftMapViewModel model)
{
if (ModelState.ContainsKey("AssignedDayData[0].ShiftType"))
{
ModelState["AssignedDayData[0].ShiftType"].Errors.Clear();
}
if (ModelState.ContainsKey("AssignedDayData[1].ShiftType"))
{
ModelState["AssignedDayData[1].ShiftType"].Errors.Clear();
}
if (ModelState.ContainsKey("AssignedDayData[2].ShiftType"))
{
ModelState["AssignedDayData[2].ShiftType"].Errors.Clear();
}
if (ModelState.ContainsKey("AssignedDayData[3].ShiftType"))
{
ModelState["AssignedDayData[3].ShiftType"].Errors.Clear();
}
if (ModelState.ContainsKey("AssignedDayData[4].ShiftType"))
{
ModelState["AssignedDayData[4].ShiftType"].Errors.Clear();
}
if (ModelState.ContainsKey("AssignedDayData[5].ShiftType"))
{
ModelState["AssignedDayData[5].ShiftType"].Errors.Clear();
}
if (ModelState.ContainsKey("AssignedDayData[6].ShiftType"))
{
ModelState["AssignedDayData[6].ShiftType"].Errors.Clear();
}
if (ModelState.ContainsKey("AssignedDateData.ShiftType"))
{
ModelState["AssignedDateData.ShiftType"].Errors.Clear();
}
if (ModelState.IsValid)
{
if (model.Doctor.Daywise)
{
foreach (var item in model.AssignedDayData)
{
if (item.IsSelected)
{
var shiftType = db.ShiftDays.Where(m => m.Doctor_ID == model.Doctor.ID && m.WeekDays_ID == item.Day ).FirstOrDefault();
if(shiftType != null)
{
if(item.ShiftType != 0)
{
shiftType.ShiftType_ID = item.ShiftType;
}
if (item.StartTime != "")
{
shiftType.StartTime = item.StartTime;
}
if (item.EndTime != "")
{
shiftType.EndTime = item.EndTime;
}
shiftType.Status = true;
db.Entry(shiftType).State = EntityState.Modified;
}
else
{
ShiftDay dayShift = new ShiftDay
{
WeekDays_ID = item.Day,
StartTime = item.StartTime,
EndTime = item.EndTime,
ShiftType_ID = item.ShiftType,
Doctor_ID = model.Doctor.ID,
Status = true
};
db.ShiftDays.Add(dayShift);
}
db.SaveChanges();
}
else
{
var shiftType = db.ShiftDays.Where(m => m.Doctor_ID == model.Doctor.ID && m.WeekDays_ID == item.Day).FirstOrDefault();
if(shiftType != null)
{
shiftType.Status = false;
db.Entry(shiftType).State = EntityState.Modified;
db.SaveChanges();
}
}
}
return RedirectToAction("Index", "Doctors");
}
else
{
foreach (var item in model.AssignedDateData)
{
ShiftDate dateShift = new ShiftDate { DayAvailable = item.DateAvailable, StartTime = item.StartTime, EndTime = item.EndTime, Doctor_ID = model.Doctor.ID, ShiftType_ID = item.ShiftType, Status = true };
db.ShiftDates.Add(dateShift);
db.SaveChanges();
}
return RedirectToAction("Index", "Doctors");
}
}
ViewBag.Shifts = new SelectList(db.ShiftTypes, "ID", "Name");
return View(model);
}
