public async Task <IActionResult> Absent(int Month)
        {
            if (_signInManager.Context.User.Identity.IsAuthenticated)
            {
                if (HttpContext.User.IsInRole("Hr"))
                {
                    await Initializer.InitialLayout("Employees", ViewBag, _db, _signInManager, "Employee Attendance");

                    DateTime LastCheckDate;
                    if (Month == 0 || Month == DateTime.Now.Month)
                    {
                        Month         = DateTime.Now.Month;
                        LastCheckDate = DateTime.Now;
                    }
                    else
                    {
                        LastCheckDate = Convert.ToDateTime(Month + "/" + DateTime.DaysInMonth(DateTime.Now.Year, Convert.ToInt32(Month)) + "/" + DateTime.Now.Year);
                    }
                    List <Employee> employees = await _db.Employees.ToListAsync();

                    List <Absent> Absents = await _db.Absents.Where(a => a.From.Year == DateTime.Now.Year && a.From.Month == Month).ToListAsync();

                    List <Absent> annualAbsents = await _db.Absents.Where(a => a.From.Year == DateTime.Now.Year).ToListAsync();

                    AbsentModel model = new AbsentModel
                    {
                        Employees     = employees,
                        Absents       = Absents,
                        AnnualAbsents = annualAbsents,
                        LastCheckDate = LastCheckDate
                    };
                    return(View(model));
                }
            }
            return(RedirectToAction("Forbidden", "Error"));
        }
        public async Task <IActionResult> Absent(AbsentModel model)
        {
            if (_signInManager.Context.User.Identity.IsAuthenticated)
            {
                if (HttpContext.User.IsInRole("Hr"))
                {
                    await Initializer.InitialLayout("Employees", ViewBag, _db, _signInManager, "Employee Attendance");

                    List <Employee> employees = await _db.Employees.ToListAsync();

                    List <Absent> Absents = await _db.Absents.Where(wc => wc.From.Year == DateTime.Now.Year && wc.From.Month == DateTime.Now.Month && wc.EmployeeId == model.EmployeeId).ToListAsync();

                    List <Absent> annualAbsents = await _db.Absents.Where(a => a.From.Year == DateTime.Now.Year && a.EmployeeId == model.EmployeeId).ToListAsync();

                    Employee employee = await _db.Employees
                                        .Where(e => e.Id == model.EmployeeId)
                                        .FirstOrDefaultAsync();

                    AbsentModel wcm = new AbsentModel();
                    if (ModelState.IsValid)
                    {
                        bool IsExist = false;
                        if (model.From == model.To)
                        {
                            ModelState.AddModelError("", "From and To must not be equal");
                        }
                        else if (model.From < employee.LastCalculate)
                        {
                            ModelState.AddModelError("", "You can't add this time arrange");
                        }
                        else
                        {
                            foreach (Absent absent in Absents)
                            {
                                if (absent.From <= model.From && absent.To >= model.From)
                                {
                                    IsExist               = true;
                                    absent.From           = model.From;
                                    absent.To             = model.To;
                                    absent.PermissionRole = model.PermissionRole;
                                    absent.Reason         = model.Reason;
                                    absent.EmployeeId     = model.EmployeeId;
                                    if (absent.From.Day - absent.To.Day == 5)
                                    {
                                        Work work = await _db.Works
                                                    .Where(w => w.EmployeeId == absent.EmployeeId && w.LeaveTime == DateTime.MinValue)
                                                    .FirstOrDefaultAsync();

                                        work.LeaveTime = absent.To;
                                        work.Reason    = "5 gün və artıq işə gəlməməsi";
                                    }
                                    await _db.SaveChangesAsync();

                                    break;
                                }
                            }
                            if (!IsExist)
                            {
                                Absent absent = new Absent
                                {
                                    From           = model.From,
                                    To             = model.To,
                                    PermissionRole = model.PermissionRole,
                                    EmployeeId     = model.EmployeeId,
                                    Reason         = model.Reason
                                };
                                await _db.Absents.AddAsync(absent);

                                if (absent.From.Day - absent.To.Day == 5)
                                {
                                    Work work = await _db.Works
                                                .Where(w => w.EmployeeId == absent.EmployeeId && w.LeaveTime == DateTime.MinValue)
                                                .FirstOrDefaultAsync();

                                    work.LeaveTime = absent.To;
                                    work.Reason    = "5 gün və artıq işə gəlməməsi";
                                }
                                await _db.SaveChangesAsync();
                            }
                        }
                        Absents = await _db.Absents.Where(wc => wc.From.Year == DateTime.Now.Year && wc.From.Month == DateTime.Now.Month && wc.EmployeeId == model.EmployeeId).ToListAsync();
                    }
                    else
                    {
                        wcm.From           = model.From;
                        wcm.To             = model.To;
                        wcm.PermissionRole = model.PermissionRole;
                        wcm.Reason         = model.Reason;
                        wcm.EmployeeId     = model.EmployeeId;
                        Absents            = await _db.Absents.Where(wc => wc.From.Year == DateTime.Now.Year && wc.From.Month == DateTime.Now.Month && wc.EmployeeId == model.EmployeeId).ToListAsync();
                    }
                    wcm.Employees     = employees;
                    wcm.Absents       = Absents;
                    wcm.AnnualAbsents = annualAbsents;
                    wcm.LastCheckDate = DateTime.Now;
                    return(View(wcm));
                }
            }
            return(RedirectToAction("Forbidden", "Error"));
        }