BeWoPlaner/BeWoPlanerMobil/Controllers/EmployeeController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;
using BeWoPlanerMobil.Models;
using BeWoPlanerMobil.Service;
using BeWoPlanerMobil.Util;
using Bogus.DataSets;
using BS.Shared;
using BS.Shared.DataContracts;
using Newtonsoft.Json;

namespace BeWoPlanerMobil.Controllers
{
    public class EmployeeController : AbstractBaseController, IAbsenceTimeController
    {
        public EmployeeController() { }

        [Authorize]
        public override string SaveCollapsibleStatus(bool isOpen, string identifier)
        {
            return SaveCollapsibleStatusToModel(Model, isOpen, identifier);
        }

        private EmployeeModel _Model;

        public EmployeeModel Model
        {
            get
            {
                if(false == MobileSessionFacade.IsUserLoggedIn())
                {
                    Logout();
                    return null;
                }

                if(_Model != null)
                {
                    return _Model;
                }

                _Model = new EmployeeModel();

                InitModel(_Model);
                InitViewModel();

                return _Model;
            }
        }

        [Authorize]
        public ActionResult Employee(long? id)
        {
            
            if(!MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer"))
            {
                return Logout();
            }

            if(id.HasValue)
            {
                LoadEmployeeToModel(id);
            }

            return View(Model);
        }

        private void InitViewModel()
        {
            if(!MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer"))
            {
                Logout();
                return;
            }

            Model.AllAbsenceReasons = CustomerService.GetAllAbsenceReasons()
                .Where(ar => ar.Sichtbarkeit is null || 
                             ar.Sichtbarkeit == AbsenceReasonVisibilityType.Employee ||
                             ar.Sichtbarkeit == AbsenceReasonVisibilityType.All)
                .ToList();

            if(Model.EmployeeSessionModel.SelectedAbsenceTimeObjectOid != null)
            {
                Model.SelectedEmployee = EmployeeService.LoadEmployee(Model.EmployeeSessionModel.SelectedAbsenceTimeObjectOid.Value);
                Model.AbsenceTimeObject = Model.SelectedEmployee;
            }

            var selectedAbsenceTimeOid = Model.EmployeeSessionModel.SelectedAbsenceTimeOid;

            if(selectedAbsenceTimeOid.HasValue && Model.SelectedEmployee != null)
            {
                Model.SelectedAbsenceTime = Model.SelectedEmployee.AbsenceTimes.FirstOrDefault(absenceTime => absenceTime.AbsenceTimeOid?.Equals(selectedAbsenceTimeOid.Value) ?? false);
            }
        }

        private void LoadEmployeeToModel(long? employeeOid)
        {
            if(employeeOid == -1)
            {
                Model.EmployeeSessionModel.ResetValues();
                return;
            }

            if(Model.SelectedEmployeeOid.HasValue && Model.SelectedEmployeeOid != employeeOid)
            {
                Model.EmployeeSessionModel.ResetValues();
            }

            Model.SelectedEmployeeOid = employeeOid;

            if(employeeOid != null)
            {
                Model.SelectedEmployee = EmployeeService.LoadEmployee(Model.EmployeeSessionModel.SelectedAbsenceTimeObjectOid.Value);
                Model.AbsenceTimeObject = Model.SelectedEmployee;
            }
        }

        [Authorize]
        [HttpPost]
        public ActionResult CreateOrUpdateAbsenceTime(FormCollection formCollection)
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return Logout();
            }

            var selectedAbsenceTime = Model.SelectedAbsenceTime;
            var oid = selectedAbsenceTime?.AbsenceTimeOid;

            var isNew = oid is null;

            var startDateString = formCollection["employee-absence-time-start-date"];
            var startTimeString = formCollection["employee-absence-time-start-time"];
            var endDateString = formCollection["employee-absence-time-end-date"];
            var endTimeString = formCollection["employee-absence-time-end-time"];
            var category = formCollection["employee-absence-time-category"];
            var notice = formCollection["employee-absence-time-notice"];
            var allDay = "on" == formCollection["employee-absence-time-allday-cb"];

            if(allDay)
            {
                startTimeString = null;
                endTimeString = null;
            }

            var startString = $"{startDateString} {startTimeString ?? "00:00"}";
            var endString = $"{endDateString} {endTimeString ?? "00:00"}";

            var start = DateTime.Parse(startString);
            var end = string.IsNullOrWhiteSpace(endDateString) && string.IsNullOrWhiteSpace(endTimeString) ? null : (DateTime?) DateTime.Parse(endString);

            var categoryOid = long.Parse(category);

            var absenceReason = Model.AllAbsenceReasons.FirstOrDefault(ar => ar.AbsenceReasonOid.HasValue && ar.AbsenceReasonOid.Value.Equals(categoryOid));

            var employee = Model.SelectedEmployee;

            if(isNew)
            {
                var absenceTime = new AbsenceTimeDC
                {
                    EmployeeOid = employee.EmployeeOid,
                    Reason = absenceReason,
                    Start = start,
                    End = end,
                    Notice = notice
                };

                OperationsService.InsertNewEmployeeAbsenceTime(employee.EmployeeOid.Value, absenceTime);
            }
            else
            {
                selectedAbsenceTime.Start = start;
                selectedAbsenceTime.End = end;
                selectedAbsenceTime.Reason = absenceReason;
                selectedAbsenceTime.Notice = notice;

                OperationsService.UpdateAbsenceTime(selectedAbsenceTime);
            }

            LoadEmployeeToModel(employee.EmployeeOid);

            Model.SelectedAbsenceTime = null;
            Model.SelectedAbsenceTimeOid = null;
            Model.SelectedAbsenceReasonOid = -1;

            return RedirectToActionPermanent("Employee");
        }

        [Authorize]
        [HttpPost]
        public ActionResult SelectAbsenceTime(long absenceTimeOid)
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return Logout();
            }

            if(absenceTimeOid == 0)
            {
                return RedirectToActionPermanent("Employee", Model);
            }

            var selectedAbsenceTime = Model.SelectedEmployee.AbsenceTimes.FirstOrDefault(absenceTime => absenceTime.EmployeeOid?.Equals(absenceTimeOid) ?? false);

            if(selectedAbsenceTime is null)
            {
                return RedirectToActionPermanent("Employee", Model);
            }

            Model.SelectedAbsenceTimeOid = absenceTimeOid;
            Model.SelectedAbsenceReasonOid = selectedAbsenceTime.Reason.AbsenceReasonOid;

            return RedirectToActionPermanent("Employee", Model);
        }

        [Authorize]
        public string SetSelectedAbsenceTimeOid(long absenceTimeOid)
        {
            var selectedAbsenceTime = Model.SelectedEmployee.AbsenceTimes.FirstOrDefault(absenceTime => absenceTime.AbsenceTimeOid?.Equals(absenceTimeOid) ?? false);

            if(selectedAbsenceTime is null)
            {
                return "Es ist ein Fehler bei der Auswahl der zu bearbeitenden Abwesenheit aufgetreten.<br />Bitte wenden Sie sich an Ihren Systemadministrator";
            }

            Model.SelectedAbsenceTimeOid = absenceTimeOid;
            Model.SelectedAbsenceReasonOid = selectedAbsenceTime.Reason.AbsenceReasonOid;

            return LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public ActionResult LoadAbsenceTimeToForm()
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
            }

            return PartialView("AbsenceTimeFormPartial", Model);
        }

        [Authorize]
        public string DeselectAbsenceTime()
        {
            Model.SelectedAbsenceTimeOid = null;
            Model.SelectedAbsenceReasonOid = -1;

            return LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public ActionResult DeleteAbsenceTime(long absenceTimeOid)
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("AbsenceTimePartial");
            }

            var absenceTime2Delete = Model.SelectedEmployee.AbsenceTimes.FirstOrDefault(absenceTime => absenceTime.AbsenceTimeOid?.Equals(absenceTimeOid) ?? false);

            if(absenceTime2Delete is null)
            {
                ViewData["AbsenceTimeError"] = "Beim Löschen der Abwesenheit ist ein Fehler aufgetreten!<br/><br/>Bitte wenden Sie sich an Ihren Administrator.";
            }

            if(absenceTime2Delete != null && !Model.CanDeleteAbsenceTime(absenceTime2Delete))
            {
                ViewData["AbsenceTimeError"] = "Sie haben nicht das Benutzerrecht, bereits vergangene Mitarbeiter-Abwesenheiten zu löschen.";
                return PartialView("AbsenceTimePartial", Model);
            }

            var employee = Model.SelectedEmployee;

            employee.AbsenceTimes.Remove(absenceTime2Delete);

            EmployeeService.UpdateEmployee(employee);

            LoadEmployeeToModel(employee.EmployeeOid);

            return PartialView("AbsenceTimePartial", Model);
        }

        [Authorize]
        public string CheckForOverlappingAbsenceTimes(string startStr, string endStr, long oid)
        {
            var hasNoEnd = false;

            if(false == DateTime.TryParse(startStr, out var start))
            {
                start = DateTime.MinValue;
            }

            if(false == DateTime.TryParse(endStr, out var end))
            {
                hasNoEnd = true;

                end = DateTime.MaxValue;
            }

            var messages = new List<string>();

            var hasOverlappingAbsenceTimes = false;

            foreach(var absenceTime in Model.SelectedEmployee.AbsenceTimes)
            {
                var alpha = absenceTime.Start ?? DateTime.MinValue;
                var omega = absenceTime.End ?? DateTime.MaxValue;

                if(start >= alpha && start <= omega ||
                   alpha >= start && alpha <= end ||
                   end >= alpha && end <= omega ||
                   omega >= start && omega <= end)
                {
                    hasOverlappingAbsenceTimes = true;
                    break;
                }
            }

            if(hasOverlappingAbsenceTimes)
            {
                messages.Add($"Die Abwesenheit überschneidet sich mit mindestens einer bereits vorhandenen Abwesenheit.{(hasNoEnd ? "<br/><br/>" : "<br/>")}");
            }

            if(hasNoEnd)
            {
                messages.Add("Die Abwesenheit hat kein Enddatum.<br/>Beachten Sie, dass Abwesenheiten ohne Enddatum unbegrenzt weiterlaufen und es dadurch zu Fehlberechnungen im Stunden- und Urlaubskonto kommen kann.");
            }

            if(messages.Any())
            {
                messages.Add("<br/><br/>Möchten Sie trotzdem fortfahren?<br/>");
            }

            return JsonConvert.SerializeObject(messages);
        }
    }
}