BeWoPlaner/BeWoPlanerMobil/Controllers/CustomerController.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Web.Mvc;
using BeWo.Report.DefaultReports;
using BeWo.View.Navigation.Filter;
using BeWoPlanerMobil.Models;
using BeWoPlanerMobil.Service;
using BeWoPlanerMobil.Util;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using BS.Shared.Extensions;
using DevExpress.XtraReports.UI;

namespace BeWoPlanerMobil.Controllers
{
    public class CustomerController : ReportBaseController
    {
        private CustomerModel _Model;
        public CustomerModel Model
        {
            get
            {
                if (!MobileSessionFacade.IsUserLoggedIn())
                {
                    Logout();
                    return null;
                }

                if (((CustomerModel) Session[ModelSessionConstants.CustomerModelKey])?.Employee is null)
                {
                    _Model = new CustomerModel{Employee = MobileSessionFacade.LoggedInEmployee};
                    Session[ModelSessionConstants.CustomerModelKey] = _Model;
                }
                else
                {
                    _Model = (CustomerModel)Session[ModelSessionConstants.CustomerModelKey];
                }

                return _Model;
            }
        }

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

                var customerFilter = MobileUserSettingsUtils.GetSettingValueAsEnum(AbstractModel.UserSettings, SettingsKeys.CustomerFilterCustomers, CustomerFilterEnum.MyCustomer);
                
                Model.SelectedCustomerFilter = customerFilter;

                InitViewModel();

                if(id.HasValue)
                {
                    LoadCustomerToModel(id);
                }
            }
            catch (Exception e)
            {
                Log.Info("Exception: " + e.Message + "\n" + e.StackTrace);
                if (e.InnerException != null)
                {
                    Log.Info("\n\nInnerException: " + e.InnerException.Message + "\n" + e.InnerException.StackTrace);
                }

                throw;
            }
            
            return View(Model);
        }

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

            if(Model.Employee?.EmployeeOid.HasValue ?? false)
            {
                Model.Customers = EmployeeService.GetActiveCustomersForEmployee(Model.Employee.EmployeeOid.Value, Model.SelectedCustomerFilter).OrderBy(customer => customer.LastName).ToList();
            }
            else
            {
                Model.Customers = new List<CompactCustomerDC>();
            }

            if(AbstractModel.IsAllowedToSeeMedikamentenliste)
            {
                Model.ReportTypes = new List<CustomerReportType> { CustomerReportType.Medikamentenliste, CustomerReportType.Bedarfsmedikation, CustomerReportType.Historie };
            }

            Model.AllAbsenceReasons = AbstractModel.HasRightToViewCustomerAbsenceTimes ? CustomerService.GetAllAbsenceReasons() : new List<AbsenceReasonDC>();
        }

        private void LoadCustomerToModel(long? customerOid)
        {
            if(!(customerOid > 0) || !Model.Customers.Any(c => c.CustomerOid.Equals(customerOid.Value))) return;
            
            Model.FolderTree = OperationsService.GetFolderTree(TableID.Customer, customerOid.Value);
            Model.SelectedCustomerOid = customerOid;
            var customer = CustomerService.LoadCustomer(customerOid.Value);

            if(!(customer is null))
            {
                Model.ICD10Diagnosen = OperationsService.GetDiagiosisStringsForICD10Codes(customer.ICD10DiagnosisCodes);
            }

            Model.SelectedCustomer = customer;

            ReloadBargeldkassen();
        }

        [Authorize]
        [HttpPost]
        public ActionResult SelectCustomer(FormCollection formCollection)
        {
            try
            {
                if(Model is null || !MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer"))
                {
                    TempData[TempDataConstants.DoLogoutKey] = true;
                    return Logout();
                }

                var selectedCustomerOidString = formCollection[FormCollectionConstants.SelectedCustomerOidKey];
                if (long.TryParse(selectedCustomerOidString, out var selectedCustomerOid))
                {
                    LoadCustomerToModel(selectedCustomerOid);
                }

                return RedirectToActionPermanent("Customer");
            }
            catch (Exception exception)
            {
                Log.Error(exception.Message, exception);
            }

            return RedirectToActionPermanent("Customer");
        }

        [HttpPost]
        [Authorize]
        public ActionResult SetCustomerFilter(FormCollection formCollection)
        {
            if(Model is null || !MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer"))
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return Logout();
            }

            var selectedCustomerFilter = formCollection[nameof(Model.SelectedCustomerFilter)];

            if(!Enum.TryParse(selectedCustomerFilter, out CustomerFilterEnum customerFilter))
            {
                customerFilter = CustomerFilterEnum.MyCustomer;
            }
            
            UpdateApplicationSettings(SettingsKeys.CustomerFilterCustomers, customerFilter.ToString());

            return RedirectToActionPermanent("Customer");
        }

        [Authorize]
        public FileResult DownloadFile(long fileOid)
        {
            if (Model is null || !MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer"))
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return null;
            }
            
            var fileAttachment = DownloadService.GetFileAttachmentForMobile(fileOid, MobileSessionFacade.Tenant);

            return File(fileAttachment.BinaryData, "application/octet-stream", fileAttachment.FileName);
        }

        [Authorize]
        public string SaveEditedNotice(string newNotice)
        {
            if(Model is null || !MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer"))
            {
                Logout();
                return LeerzeichenFuerGetMethoden;
            }

            var isAllowedToEdit = MobileSessionFacade.LoggedInUser.CheckForAtLeastOneRight(new List<UserRightType> { UserRightType.CustomerView_Edit, UserRightType.EditAll });

            if(isAllowedToEdit && Model.SelectedCustomer != null)
            {
                Model.SelectedCustomer.Notice = newNotice?.RemoveUppercaseEsszett();

                var customerOid = CustomerService.UpdateCustomer(Model.SelectedCustomer);
                Model.SelectedCustomer = CustomerService.LoadCustomer(customerOid);
            }

            return LeerzeichenFuerGetMethoden;
        }

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

            var firstname   = formCollection["vorname"]?.RemoveUppercaseEsszett();
            var lastname    = formCollection["nachname"]?.RemoveUppercaseEsszett();
            var alias       = formCollection["alias"]?.RemoveUppercaseEsszett();
            var geburtdatum = formCollection["geburtstag"]?.RemoveUppercaseEsszett();
            var geschlecht  = formCollection["geschlecht"]?.RemoveUppercaseEsszett();

            var adresszusatz = formCollection["adresszusatz"]?.RemoveUppercaseEsszett();
            var street       = formCollection["strasse"]?.RemoveUppercaseEsszett();
            var postalCode   = formCollection["plz"]?.RemoveUppercaseEsszett();
            var city         = formCollection["ort"]?.RemoveUppercaseEsszett();

            var nameInvoiceAddress       = formCollection["name-rechnungsadresse"]?.RemoveUppercaseEsszett();
            var streetInvoiceAddress     = formCollection["strasse-rechnungsadresse"]?.RemoveUppercaseEsszett();
            var postalCodeInvoiceAddress = formCollection["plz-rechnungsadresse"]?.RemoveUppercaseEsszett();
            var cityInvoiceAddress       = formCollection["ort-rechnungsadresse"]?.RemoveUppercaseEsszett();

            var mobile       = formCollection["handy"]?.RemoveUppercaseEsszett();
            var phone        = formCollection["telefon"]?.RemoveUppercaseEsszett();
            var fax          = formCollection["fax"]?.RemoveUppercaseEsszett();
            var eMailAddress = formCollection["mail"]?.RemoveUppercaseEsszett();

            var notice = formCollection["notiz"]?.RemoveUppercaseEsszett();

            var krankenkasse = formCollection["krankenkasse"];
            var versichertennummer = formCollection["versichertennummer"];
            var versichertenstatus = formCollection["versichertenstatus"];

            var customer = Model.SelectedCustomer;

            if(customer is null)
            {
                return RedirectToActionPermanent("Customer");
            }

            customer.FirstName     = firstname;
            customer.LastName      = lastname;
            customer.CustomerAlias = alias;

            if(DateTime.TryParse(geburtdatum, out var dateOfBirth))
            {
                customer.DateOfBirth = dateOfBirth;
            }

            if(int.TryParse(geschlecht, out var sexIndex))
            {
                var castSex = sexIndex >= 0 ? (Sex?)sexIndex : null;

                customer.Sex = castSex;
            }

            customer.HealthInsurance = krankenkasse;
            customer.InsuranceNumber = versichertennummer;
            customer.VersichertenStatus = versichertenstatus;

            customer.AddressLine1 = adresszusatz;
            customer.Street       = street;
            customer.PostalCode   = postalCode;
            customer.Town         = city;

            customer.InvoiceAddressLine1      = nameInvoiceAddress;
            customer.InvoiceAddressStreet     = streetInvoiceAddress;
            customer.InvoiceAddressPostalCode = postalCodeInvoiceAddress;
            customer.InvoiceAddressTown       = cityInvoiceAddress;

            var mobileContactInfo = customer.ContactInformations.FirstOrDefault(contactInformation => contactInformation.ContactType == ContactType.business_MobilePhone) ?? new ContactDC { ContactType = ContactType.business_MobilePhone };
            mobileContactInfo.ContactValue = mobile;

            if(customer.ContactInformations.All(a => a.ContactType != ContactType.business_MobilePhone))
            {
                customer.ContactInformations.Add(mobileContactInfo);
            }

            var phoneContactInfo = customer.ContactInformations.FirstOrDefault(contactInformation => contactInformation.ContactType == ContactType.business_Phone) ?? new ContactDC { ContactType = ContactType.business_Phone };
            phoneContactInfo.ContactValue = phone;

            if(customer.ContactInformations.All(a => a.ContactType != ContactType.business_Phone))
            {
                customer.ContactInformations.Add(phoneContactInfo);
            }

            var faxContactInfo = customer.ContactInformations.FirstOrDefault(contactInformation => contactInformation.ContactType == ContactType.business_Fax) ?? new ContactDC { ContactType = ContactType.business_Fax };
            faxContactInfo.ContactValue = fax;

            if(customer.ContactInformations.All(a => a.ContactType != ContactType.business_Fax))
            {
                customer.ContactInformations.Add(faxContactInfo);
            }

            var eMailContactInfo = customer.ContactInformations.FirstOrDefault(contactInformation => contactInformation.ContactType == ContactType.business_Mail) ?? new ContactDC { ContactType = ContactType.business_Mail };
            eMailContactInfo.ContactValue = eMailAddress;

            if(customer.ContactInformations.All(a => a.ContactType != ContactType.business_Mail))
            {
                customer.ContactInformations.Add(eMailContactInfo);
            }

            customer.Notice = notice;

            CustomerService.UpdateCustomer(customer);

            LoadCustomerToModel(customer.CustomerOid);

            return RedirectToActionPermanent("Customer", new { id = customer.CustomerOid });
        }


        [Authorize]
        public override string ResetReport()
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return LeerzeichenFuerGetMethoden;
            }

            Model.Report = null;
            Model.ReportName = null;

            return LeerzeichenFuerGetMethoden;
        }


        #region Medikamentenverordnungen
        [Authorize]
        public ActionResult ShowMedList(int reportType)
        {
            if(Model is null || !MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer") || !AbstractModel.IsAllowedToSeeMedikamentenliste)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("BeWoReportPartial", Model);
            }

            var selectedReportType = (CustomerReportType)reportType;

            SelectReport(selectedReportType);

            return PartialView("BeWoReportPartial", Model);
        }

        [Authorize]
        public ActionResult ShowHistoricalMedList(long medListOid)
        {
            if(Model is null || !MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer") || !AbstractModel.IsAllowedToSeeMedikamentenliste)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("BeWoReportPartial", Model);
            }

            Model.SelectedReportType = CustomerReportType.Historie;

            GenerateMobileMedListForSelectedCustomer(medListOid);

            return PartialView("BeWoReportPartial", Model);
        }

        [Authorize]
        public ActionResult DeleteHistoricalMedList(long medListOid)
        {
            if(Model is null || !MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer") || !AbstractModel.IsAllowedToSeeMedikamentenliste)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("CustomerMedListPartial", Model);
            }

            Model.SelectedReportType = CustomerReportType.Historie;

            CustomerService.DeleteMedikamentenverordnungsliste(medListOid);

            LoadCustomerToModel(Model.SelectedCustomerOid);

            return PartialView("CustomerMedListPartial", Model);
        }

        private void SelectReport(CustomerReportType selectedReportType)
        {
            Model.SelectedReportType = selectedReportType;

            GenerateMobileMedListForSelectedCustomer();
        }

        private void GenerateMobileMedListForSelectedCustomer(long? selectedMedListOid = null)
        {
            if(Model.SelectedCustomerOid is null)
            {
                return;
            }

            long? medListOid = null;
            var customerOid = Model.SelectedCustomerOid.Value;

            switch(Model.SelectedReportType)
            {
                case CustomerReportType.Medikamentenliste:
                    medListOid = CustomerService.GetActiveMedListByTypeForCustomer(customerOid, false);
                    break;
                case CustomerReportType.Bedarfsmedikation:
                    medListOid = CustomerService.GetActiveMedListByTypeForCustomer(customerOid, true);
                    break;
                case CustomerReportType.Historie:
                    medListOid = selectedMedListOid;
                    break;
            }

            var medList = Model.SelectedCustomer.Medikamentenverordnungslisten.FirstOrDefault(f => f.MedikamentenverordnungslistenOid == medListOid);

            if(medList?.MedikamentenverordnungslistenOid is null || Request?.Url is null)
            {
                return;
            }

            Model.ReportName = $"Medikamentenverordnung vom {medList.ErstellDatum}";

            using(var memoryStream = ReportService.CreateMedikamentenlistenReport(medList.MedikamentenverordnungslistenOid.Value, MobileSessionFacade.Tenant))
            {
                var medikamentenverordnungslistenReport = new MedikamentenverordnungslistenReport();
                medikamentenverordnungslistenReport.PrintingSystem.LoadDocument(memoryStream);

                Model.Report = medikamentenverordnungslistenReport;
                Model.BargeldkassenReportName = null;
                Model.BargeldkassenReportObject = null;
                Model.ZahlungsbelegsReportObject = null;
            }
        }
        #endregion

        #region Bargeldkassen

        [Authorize]
        private void ReloadBargeldkassen()
        {
            if(Model?.SelectedCustomer?.CustomerOid is null)
            {
                return;
            }

            Model.Bargeldkassen = OperationsService.LoadBargeldkassenForObject(TableID.Customer, Model.SelectedCustomer.CustomerOid.Value);

            // ToDo: alle Transaktionen durchgehen und schauen, ob es HistoryEntries gibt und in Model.TransaktionsOids2HasHistoryEntries speichern

            // ToDo: Funktion für das Laden aller Transaktionen durch BargeldkassenOids implementieren im SearchDAO-Objekt
            var transactions = new List<BargeldtransaktionDC>();

            Model.Bargeldkassen.DoForEach(bargeldkasse =>
            {
                transactions.AddRangeIfElementsNotIn(bargeldkasse.Bargeldtransaktionen.Where(t => t.BargeldtransaktionOid.HasValue));
            });

            var historyEntries = OperationsService.LoadBargeldtransaktionshistoryEntriesByTransaktionsOids(transactions.Where(t => t.BargeldtransaktionOid.HasValue).Select(t => t.BargeldtransaktionOid.Value).ToList());

            Model.TransaktionsOid2HasHistoryEntries = new Dictionary<long, bool>();

            transactions.DoForEach(transaction =>
            {
                if(transaction.BargeldtransaktionOid is null)
                {
                    return;
                }

                Model.TransaktionsOid2HasHistoryEntries.AddOrUpdate(transaction.BargeldtransaktionOid.Value, historyEntries.Any(a => a.BargeldtransaktionOid.HasValue && a.BargeldtransaktionOid.Value.Equals(transaction.BargeldtransaktionOid.Value)));
            });
        }

        [Authorize]
        public string SelectBargeldkasse(long oid)
        {
            if(Model is null)
            {
                Logout();
                return LeerzeichenFuerGetMethoden;
            }

            var selectedBargeldkasse = Model.Bargeldkassen.FirstOrDefault(bargeldkasse => bargeldkasse.BargeldkassenOid.HasValue && bargeldkasse.BargeldkassenOid.Value.Equals(oid));

            Model.SelectedBargeldkasse = selectedBargeldkasse;

            return LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public string DeselectBargeldkasse()
        {
            if(Model is null)
            {
                Logout();
                return LeerzeichenFuerGetMethoden;
            }

            Model.SelectedBargeldkasse = null;

            return LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public ActionResult LoadFormPartial()
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("CustomerBargeldkassenFormPartial", Model);
            }

            Model.SelectedBargeldkasse = null;
            Model.SelectedAuszahlungsintervall = 0;

            return PartialView("CustomerBargeldkassenFormPartial", Model);
        }

        [Authorize]
        public ActionResult LoadEditFormPartial(long bargeldkassenOid)
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("CustomerBargeldkassenFormPartial", Model);
            }

            Model.SelectedBargeldkasse = Model.Bargeldkassen.FirstOrDefault(bargeldkasse => bargeldkasse.BargeldkassenOid.HasValue && bargeldkasse.BargeldkassenOid.Value.Equals(bargeldkassenOid));

            if(Model.SelectedBargeldkasse != null)
            {
                Model.SelectedAuszahlungsintervall = (int) Model.SelectedBargeldkasse.Auszahlungsintervall;
            }

            return PartialView("CustomerBargeldkassenFormPartial", Model);
        }

        [Authorize]
        [HttpPost]
        public ActionResult DeleteBargeldkasse(FormCollection formCollection) 
        {
            if(Model is null || !long.TryParse(formCollection["bk-to-delete-oid"], out var bargeldkassenOid) || Model.SelectedCustomerOid is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return Logout();
            }

            var bargeldkasse = Model.Bargeldkassen.FirstOrDefault(f => f.BargeldkassenOid.HasValue && f.BargeldkassenOid.Value.Equals(bargeldkassenOid));
                
            if(bargeldkasse?.BargeldkassenVersion is null)
            {
                return RedirectToActionPermanent("Customer");
            }

            var bargeldkassenVersion = bargeldkasse.BargeldkassenVersion.Value;

            OperationsService.DeactivateBargeldkasse(bargeldkassenOid, bargeldkassenVersion);

            ReloadBargeldkassen();

            return RedirectToActionPermanent("Customer");
        }

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

            var name = formCollection["bargeldkassenname"];
            var rawAnfangsbestand = formCollection["bargeldkassenanfangsbestand"];

            decimal.TryParse(rawAnfangsbestand, out var anfangsbestand);

            var auszahlungsintervall = (Auszahlungsintervall) Model.SelectedAuszahlungsintervall;

            if(Model.SelectedBargeldkasse is null)
            {
                var newBargeldkasse = new BargeldkassenDC
                {
                    Anfangsbestand = anfangsbestand,
                    Kassenname = name,
                    Auszahlungsintervall = auszahlungsintervall,
                    ObjectOid = Model.SelectedCustomerOid,
                    ObjectTid = TableID.Customer
                };

                OperationsService.InsertNewBargeldkasse(newBargeldkasse);

                LoadCustomerToModel(Model.SelectedCustomerOid);
            }
            else
            {
                var bargeldkasse = Model.SelectedBargeldkasse;

                if(!string.IsNullOrWhiteSpace(name))
                {
                    bargeldkasse.Kassenname = name;
                }

                bargeldkasse.Auszahlungsintervall = auszahlungsintervall;

                bargeldkasse.Anfangsbestand = anfangsbestand;

                OperationsService.UpdateBargeldkasse(bargeldkasse);

                LoadCustomerToModel(Model.SelectedCustomerOid);
            }

            Model.SelectedBargeldkasse = null;

            return RedirectToActionPermanent("Customer");
        }

        [Authorize]
        public ActionResult PrintBargeldkasse(long kassenbuchOid, string reportStartDate, string reportEndDate)
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("BeWoReportPartial", Model);
            }

            var bargeldkasse = Model.Bargeldkassen.FirstOrDefault(f => f.BargeldkassenOid.HasValue && f.BargeldkassenOid.Value.Equals(kassenbuchOid));

            var startDate = DateTime.TryParse(reportStartDate, out var parsedStartDate) ? parsedStartDate : DateTime.Today.GetFirstOfMonth();
            var endDate = DateTime.TryParse(reportEndDate, out var parsedEndDate) ? parsedEndDate : DateTime.Today.GetLastOfMonth();

            if(bargeldkasse?.ObjectOid is null)
            {
                return PartialView("BeWoReportPartial", Model);
            }

            var bargeldkassenReportZeitraum = startDate.Equals(startDate.GetFirstOfMonth()) && endDate.Equals(startDate.GetLastOfMonth()) ? 
                $"{startDate:MMMM} {startDate:yyyy}" : 
                $"{startDate:dd.MM.yyyy} bis {endDate:dd.MM.yyyy}";

            var name = $"Kassenbuch \"{bargeldkasse.Kassenname}\" {bargeldkassenReportZeitraum} von {Model.SelectedCustomer.FirstName} {Model.SelectedCustomer.LastName}";

            var memoryStream = ReportService.CreateKassenbuchReportImZeitraum(startDate, endDate, bargeldkasse, bargeldkasse.ObjectOid.Value, bargeldkasse.ObjectTid);

            var report = new XtraReport();

            report.PrintingSystem.LoadDocument(memoryStream);

            Model.Report = report;
            Model.ReportName = name;

            return PartialView("BeWoReportPartial", Model);
        }

        [Authorize]
        public string SetSelectedAuszahlungsintervall(int auszahlungsintervall)
        {
            Model.SelectedAuszahlungsintervall = auszahlungsintervall < 4 && auszahlungsintervall >= 0 ? auszahlungsintervall : 0;

            return LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public ActionResult DownloadZahlungsbeleg(long transaktionsOid)
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("BeWoReportPartial", Model);
            }

            var kassenbuch = Model.Bargeldkassen.FirstOrDefault(bargeldkasse => bargeldkasse.Bargeldtransaktionen.Any(transaktion => transaktion.BargeldtransaktionOid.Equals(transaktionsOid)));

            var zahlung = kassenbuch?.Bargeldtransaktionen.FirstOrDefault(bargeldtransaktion => bargeldtransaktion.BargeldtransaktionOid.Equals(transaktionsOid));

            if(zahlung != null && kassenbuch.ObjectOid.HasValue)
            {
                var memoryStream = ReportService.CreateKassenbelegReport(zahlung, kassenbuch.ObjectOid.Value, kassenbuch.ObjectTid);

                var report = new XtraReport();

                report.PrintingSystem.LoadDocument(memoryStream);

                Model.Report                     = report;
                Model.ReportName                 = "Zahlungsbeleg";
            }

            return PartialView("BeWoReportPartial", Model);
        }

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

            var kassenbuch = GetBargeldkasseByTransaktionsOid(transaktionsOid);

            var zahlung = kassenbuch?.Bargeldtransaktionen.FirstOrDefault(bargeldtransaktion => bargeldtransaktion.BargeldtransaktionOid.Equals(transaktionsOid));

            Model.SelectedBargeldtransaktion = zahlung;

            if(zahlung != null)
            {
                Model.SelectedTransaktionsart = (int) zahlung.Zahlungstyp;
            }
            
            Model.SelectedBargeldkasse = kassenbuch;

            return PartialView("CustomerBargeldtransaktionenFormPartial", Model);
        }

        private BargeldkassenDC GetBargeldkasseByTransaktionsOid(long transaktionsOid)
        {
            return Model.Bargeldkassen.FirstOrDefault(bargeldkasse => bargeldkasse.Bargeldtransaktionen.Any(transaktion => transaktion.BargeldtransaktionOid.Equals(transaktionsOid)));
        }

        [Authorize]
        public string SetTransaktionsart(int transaktionsart)
        {
            Model.SelectedTransaktionsart = transaktionsart < 2 && transaktionsart >= 0 ? transaktionsart : 0;

            return LeerzeichenFuerGetMethoden;
        }

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

            Model.SelectedBargeldtransaktion = null;
            Model.SelectedTransaktionsart = 0;

            Model.SelectedBargeldkasse = Model.Bargeldkassen.FirstOrDefault(bk => bk.BargeldkassenOid.HasValue && bk.BargeldkassenOid.Equals(bargeldkassenOid));

            return PartialView("CustomerBargeldtransaktionenFormPartial", Model);
        }

        [Authorize]
        public ActionResult CreateOrUpdateBargeldTransaktion2(string rawDate, string rawArt, string rawBetrag, string belegnummer, string notice)
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("CustomerBargeldkassen");
            }

            var transaktion2Edit = Model.SelectedBargeldtransaktion;
            var bargeldkasse = Model.SelectedBargeldkasse;

            var isNew = transaktion2Edit is null;

            var isArtValid = Enum.TryParse(rawArt, out Zahlungstyp art);

            var isDateValid = DateTime.TryParse(rawDate, out var datum);
            var isBetragValid = decimal.TryParse(rawBetrag.Replace('.', ','), NumberStyles.AllowDecimalPoint, new CultureInfo("DE-de"), out var betrag);

            if(!isDateValid || !isBetragValid || betrag <= 0)
            {
                TempData[TempDataConstants.CustomerBargeldkassenErrorMessageKey] = "Datum oder Betrag sind ungültig!";
                return PartialView("CustomerBargeldkassen", Model);
            }

            if(bargeldkasse is null)
            {
                TempData[TempDataConstants.CustomerBargeldkassenErrorMessageKey] = "Beim Speichern der Transaktion ist ein Fehler aufgetreten. Bitte wenden Sie sich an Ihren Administrator.";
                return PartialView("CustomerBargeldkassen", Model);
            }
            
            if(isNew)
            {
                bargeldkasse.Bargeldtransaktionen.Add(new BargeldtransaktionDC
                {
                    Belegnummer = belegnummer,
                    Betrag = betrag,
                    Notice = notice,
                    Zahlungsdatum = datum,
                    Zahlungstyp = art
                });
            }
            else 
            {
                foreach(var bargeldtransaktion in bargeldkasse.Bargeldtransaktionen)
                {
                    if(transaktion2Edit.BargeldtransaktionOid.HasValue && (bargeldtransaktion.BargeldtransaktionOid?.Equals(transaktion2Edit.BargeldtransaktionOid.Value) ?? false))
                    {
                        bargeldtransaktion.Belegnummer   = belegnummer;
                        bargeldtransaktion.Betrag        = betrag;
                        bargeldtransaktion.Notice        = notice;
                        bargeldtransaktion.Zahlungsdatum = datum;
                        bargeldtransaktion.Zahlungstyp   = art;

                        break;
                    }
                }
            }

            OperationsService.UpdateBargeldkasse(bargeldkasse);

            Model.SelectedBargeldkasse = null;

            ReloadBargeldkassen();

            return PartialView("CustomerBargeldkassen", Model);
        }

        [Authorize]
        public ActionResult DeleteBargeldtransaktion(long? bargeldtransaktionsOid)
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("CustomerBargeldkassen");
            }

            if(bargeldtransaktionsOid is null)
            {
                TempData[TempDataConstants.CustomerBargeldkassenErrorMessageKey] = "Es ist ein Fehler beim Löschen der Bargeldtransaktion aufgetreten. Bitte wenden Sie sich an Ihren Administrator.";
                return PartialView("CustomerBargeldkassen", Model);
            }

            var bargeldkasse = GetBargeldkasseByTransaktionsOid(bargeldtransaktionsOid.Value);

            var bargeldtransaktion = bargeldkasse.Bargeldtransaktionen.FirstOrDefault(f => f.BargeldtransaktionOid.HasValue && f.BargeldtransaktionOid.Value.Equals(bargeldtransaktionsOid));

            if(bargeldtransaktion is null)
            {
                TempData[TempDataConstants.CustomerBargeldkassenErrorMessageKey] = "Es ist ein Fehler beim Löschen der Bargeldtransaktion aufgetreten. Bitte wenden Sie sich an Ihren Administrator.";
                return PartialView("CustomerBargeldkassen", Model);
            }

            bargeldkasse.Bargeldtransaktionen.Remove(bargeldtransaktion);

            OperationsService.UpdateBargeldkasse(bargeldkasse);

            if(Model.SelectedCustomer?.CustomerOid is null)
            {
                TempData[TempDataConstants.CustomerBargeldkassenErrorMessageKey] = "Es ist ein Fehler beim Laden der Bargeldkassen aufgetreten. Bitte wenden Sie sich an Ihren Administrator.";
                return PartialView("CustomerBargeldkassen", Model);
            }

            ReloadBargeldkassen();

            return PartialView("CustomerBargeldkassen", Model);
        }

        [Authorize]
        public ActionResult SaveTransaktionsunterschrift(long transaktionsOid, string signatureAsBase64)
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("CustomerBargeldkassen");
            }

            var bargeldkasse = GetBargeldkasseByTransaktionsOid(transaktionsOid);

            var transaktion = bargeldkasse?.Bargeldtransaktionen.FirstOrDefault(f => f.BargeldtransaktionOid.HasValue && f.BargeldtransaktionOid.Value.Equals(transaktionsOid));

            if(transaktion is null)
            {
                TempData[TempDataConstants.CustomerBargeldkassenErrorMessageKey] = "Beim Speichern der Transaktionsunterschrift ist ein Fehler aufgetreten. Bitte wenden Sie sich an Ihren Administrator.";
                return PartialView("CustomerBargeldkassen", Model);
            }

            long? signatureOid;

            using(var signatureBitmap = SignatureUtils.Base64StringToBitmap(signatureAsBase64.Split(',')[1]))
            {
                var isValid = SignatureUtils.ValidateSignature(signatureBitmap);

                if(!isValid)
                {
                    TempData[TempDataConstants.CustomerBargeldkassenErrorMessageKey] = "Das Unterschriftenfeld darf nicht leer sein.";
                }

                signatureOid = OperationsService.InsertSignature(new SignatureDC
                {
                    DataBild = signatureAsBase64,
                    BargeldtransaktionsOid = transaktionsOid,
                    Zeitstempel = DateTime.Now
                }).SignatureOid;
            }

            if(signatureOid.HasValue)
            {
                foreach(var bargeldtransaktion in bargeldkasse.Bargeldtransaktionen)
                {
                    if(bargeldtransaktion.BargeldtransaktionOid.HasValue && bargeldtransaktion.BargeldtransaktionOid.Value.Equals(transaktionsOid))
                    {
                        bargeldtransaktion.SignatureOid = signatureOid;
                    }
                }

                OperationsService.UpdateBargeldkasse(bargeldkasse);
            }

            ReloadBargeldkassen();

            return PartialView("CustomerBargeldkassen", Model);
        }

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

            BargeldkassenDC bargeldkasse = null;
            BargeldtransaktionDC transaction = null;

            foreach(var item in Model.Bargeldkassen)
            {
                transaction = item.Bargeldtransaktionen.FirstOrDefault(t => t.BargeldtransaktionOid.Equals(transactionOid));

                if(transaction == null)
                {
                    continue;
                }

                bargeldkasse = item;
                break;
            }

            var signatureOid = transaction?.SignatureOid;

            if(signatureOid.HasValue)
            {
                bargeldkasse.Bargeldtransaktionen.DoForEach(t =>
                {
                    if(t.BargeldtransaktionOid.Equals(transactionOid))
                    {
                        t.SignatureOid = null;
                    }
                });

                OperationsService.DeleteBargeldtransaktionSignature(signatureOid.Value);
                OperationsService.UpdateBargeldkasse(bargeldkasse);

                ReloadBargeldkassen();
            }

            return PartialView("CustomerBargeldkassen", Model);
        }

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

            var historyEntries = OperationsService.LoadBargeldtransaktionshistoryEntries(transactionOid);

            Model.BargeldtransaktionshistoryEntries = historyEntries.OrderByDescending(he => he.InsertedOn).ToList();

            return PartialView("CustomerBargeldtransaktionshistorienPartial", Model);
        }

        [Authorize]
        public string ClearHistoryEntries()
        {
            Model?.BargeldtransaktionshistoryEntries.Clear();

            return LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public string CheckForExistingSignature()
        {
            return (Model?.SelectedBargeldtransaktion?.SignatureOid.HasValue ?? false) ? "1" : "0";
        }
        #endregion

        #region Abwesenheiten

        [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["customer-absence-time-start-date"];
            var startTimeString = formCollection["customer-absence-time-start-time"];
            var endDateString   = formCollection["customer-absence-time-end-date"];
            var endTimeString   = formCollection["customer-absence-time-end-time"];
            var category        = formCollection["customer-absence-time-category"];
            var notice          = formCollection["customer-absence-time-notice"];
            var allDay          = "on" == formCollection["customer-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 customer = Model.SelectedCustomer;

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

                OperationsService.InsertNewCustomerAbsenceTime(customer.CustomerOid.Value, absenceTime);
            }
            else
            {
                selectedAbsenceTime.Start  = start;
                selectedAbsenceTime.End    = end;
                selectedAbsenceTime.Reason = absenceReason;
                selectedAbsenceTime.Notice = notice;

                OperationsService.UpdateAbsenceTime(selectedAbsenceTime);
            }

            LoadCustomerToModel(customer.CustomerOid);

            Model.SelectedAbsenceTime = null;
            Model.SelectedAbsenceReason = -1;

            return RedirectToActionPermanent("Customer", new { id = customer.CustomerOid });
        }

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

            if(absenceTimeOid == 0)
            {
                return RedirectToActionPermanent("Customer", Model);
                //return "Es ist ein Fehler bei der Auswahl der zu bearbeitenden Abwesenheit aufgetreten.<br />Bitte wenden Sie sich an Ihren Systemadministrator.";
            }

            var selectedAbsenceTime = Model.SelectedCustomer.AbsenceTimes.FirstOrDefault(absenceTime => absenceTime.AbsenceTimeOid.HasValue && absenceTime.AbsenceTimeOid.Value.Equals(absenceTimeOid));

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

            Model.SelectedAbsenceTime = selectedAbsenceTime;
            Model.SelectedAbsenceReason = selectedAbsenceTime.Reason.AbsenceReasonOid;

            //return LeerzeichenFuerGetMethoden;
            return RedirectToActionPermanent("Customer", Model);
        }

        [Authorize]
        public string SetSelectedAbsenceTimeOid(long absenceTimeOid)
        {
            var selectedAbsenceTime = Model.SelectedCustomer.AbsenceTimes.FirstOrDefault(absenceTime => absenceTime.AbsenceTimeOid.HasValue && absenceTime.AbsenceTimeOid.Value.Equals(absenceTimeOid));

            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.SelectedAbsenceTime = selectedAbsenceTime;
            Model.SelectedAbsenceReason = selectedAbsenceTime.Reason.AbsenceReasonOid;

            return LeerzeichenFuerGetMethoden;
        }

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

            return PartialView("CustomerAbsenceTimeFormPartial", Model);
        }

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

            return LeerzeichenFuerGetMethoden;
        }

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

            var absenceTime2Delete = Model.SelectedCustomer.AbsenceTimes.FirstOrDefault(absenceTime => absenceTime.AbsenceTimeOid.HasValue && absenceTime.AbsenceTimeOid.Equals(absenceTimeOid));

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

            var customer = Model.SelectedCustomer;

            customer.AbsenceTimes.Remove(absenceTime2Delete);

            CustomerService.UpdateCustomer(customer);

            LoadCustomerToModel(customer.CustomerOid);

            return PartialView("CustomerAbsenceTimePartial", Model);
        }
        #endregion
    }

    public enum CustomerReportType
    {
        Medikamentenliste = 0,
        Bedarfsmedikation = 1,
        Historie = 2
    }
}