using BeWo.Report;
using BeWo.Report.ReportObjects;
using BeWoPlanerMobil.Models;
using BeWoPlanerMobil.Service;
using BeWoPlanerMobil.Util;
using BeWoPlanerMobil.Util.ReportUtils;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.Mvc;

namespace BeWoPlanerMobil.Controllers
{
    public class ReportController : AbstractBaseController
    {
        private ReportModel _Model;

        public ReportModel Model
        {
            get
            {
                if(!MobileSessionFacade.IsUserLoggedIn())
                {
                    RedirectToActionPermanent("Index", "Login");
                    return null;
                }

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

                return _Model;
            }
        }

        [Authorize]
        public ActionResult Report()
        {
            if(!MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer") || !AbstractModel.IsAllowedToSeeScheduler)
            {
                return Logout();
            }

            if(!AbstractModel.IsAllowedToSeeBills)
            {
                return RedirectToActionPermanent("Main", "Main");
            }

            CreateServiceOverview(null);

            return View(Model);
        }

        [Authorize]
        public ActionResult InitReports()
        {
            if(!MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer") || !AbstractModel.IsAllowedToSeeScheduler)
            {
                return Logout();
            }

            if(!AbstractModel.IsAllowedToSeeBills)
            {
                return RedirectToActionPermanent("Main", "Main");
            }

            var month = DateTime.Today.Month;
            var year = DateTime.Today.Year;

            var first = new DateTime(year, month, 1).AddMonths(-1);
            var last = first.AddMonths(1).AddDays(-1);

            Model.SelectedYear     = first.Year;
            Model.SelectedMonth    = first.Month;
            Model.SelectedStartDay = first.Day;
            Model.SelectedEndDay   = last.Day;

            var filterEnums = Enum.GetValues(typeof(QBFilterEnum)).Cast<QBFilterEnum>();

            Model.QbFilters.Clear();
            foreach(var filterEnum in filterEnums)
            {
                Model.QbFilters.AddIfNotIn(new QbFilterItem(filterEnum));
            }

            Model.Customers = EmployeeService.GetActiveCompactCustomersForEmployee(null).OrderBy(d => d.ToString()).ToList();

            Model.Employees = EmployeeService.GetActiveCompactEmployeesForEmployee(MobileSessionFacade.LoggedInCompactEmployee.EmployeeOid);

            Model.ServiceCategories = OperationsService.GetAllServiceCategories();

            Model.Organisations = CustomerService.GetAllCostBearerCompact();
            Model.Organisations.Sort((x, y) => x.Name.CompareTo(y.Name));
            
            Model.AllTeams = EmployeeService.GetAllActiveCompactTeamsForEmployee(MobileSessionFacade.LoggedInEmployee.EmployeeOid);

            return View("Report", Model);
        }

        [Authorize]
        [HttpPost]
        public ActionResult CreateServiceOverview(FormCollection formCollection)
        {
            if(Model?.Employee?.EmployeeOid == null)
            {
                return Logout();
            }

            if(Model.SelectedFilterItem == null)
            {
                return RedirectToActionPermanent("Report");
            }

            if(Model.SelectedFilterItem.FilterEnum == QBFilterEnum.KlientenAuswahl)
            {
                var customerOidString = formCollection == null ? Model.SelectedCustomerOid.ToString() : formCollection[FormCollectionConstants.SelectedCustomerOidKey];

                var isCustomerOidSuccessful = long.TryParse(customerOidString, out var selectedCustomerOid);

                if(isCustomerOidSuccessful)
                {
                    var selectedCustomer = Model.Customers.FirstOrDefault(customer => customer.CustomerOid == selectedCustomerOid);

                    Model.SelectedCustomer = selectedCustomer;
                }
            }
            else
            {
                Model.SelectedCustomer = null;
            }

            if(Model.SelectedFilterItem.FilterEnum == QBFilterEnum.TeamAuswahl)
            {
                var teamOidString = formCollection == null ? Model.SelectedTeamOid.ToString() : formCollection[FormCollectionConstants.SelectedTeamOidKey];

                var isTeamOidSuccessful = long.TryParse(teamOidString, out var selectedTeamOid);

                if(isTeamOidSuccessful)
                {
                    var selectedTeam = Model.AllTeams.FirstOrDefault(team => team.TeamOid == selectedTeamOid);

                    Model.SelectedTeam = selectedTeam;
                }
            }
            else
            {
                Model.SelectedTeam = null;
            }

            var startDay = Model.SelectedStartDay;
            var endDay   = Model.SelectedEndDay;

            var reportObjects = new List<ServicesOverviewRO>();

            var month = Model.SelectedMonth;
            var year  = Model.SelectedYear;

            var organisationOid    = Model.SelectedOrganisationOid ?? 0;
            var employeeOid        = Model.SelectedEmployeeOid ?? 0;
            var serviceCategoryOid = Model.SelectedServiceCategoryOid;
            var teamOid            = Model.SelectedTeamOid;
            var customerOid        = Model.SelectedCustomerOid ?? 0;

            switch(Model.SelectedFilterItem.FilterEnum)
            {
                case QBFilterEnum.AlleKlienten:
                    reportObjects = ServicesOverviewRO.Create(month, year, organisationOid, employeeOid, startDay, endDay, serviceCategoryOid);
                    break;
                case QBFilterEnum.NurKlientenMeinesTeams:
                    var teamRelatedCustomerOids = GetTeamCustomerOids();
                    reportObjects.AddRange(teamRelatedCustomerOids.Select(cOid => ServicesOverviewRO.Create(cOid, month, year, true, organisationOid, employeeOid, startDay, endDay, serviceCategoryOid)));
                    break;
                case QBFilterEnum.MeineKlienten:
                    var myRelatedCustomerOids = DefaultReportCreator.GetMeineKlientenOids();
                    reportObjects.AddRange(myRelatedCustomerOids.Select(cOid => ServicesOverviewRO.Create(cOid, month, year, true, organisationOid, employeeOid, startDay, endDay, serviceCategoryOid)));
                    break;
                case QBFilterEnum.KlientenAuswahl:
                    reportObjects = new List<ServicesOverviewRO> { ServicesOverviewRO.Create(customerOid, month, year, false, organisationOid, employeeOid, startDay, endDay, serviceCategoryOid)};
                    break;
                case QBFilterEnum.TeamAuswahl:
                    var customerOids = GetTeamCustomerOids(teamOid);
                    reportObjects.AddRange(customerOids.Select(cOid => ServicesOverviewRO.Create(cOid, month, year, true, organisationOid, employeeOid, startDay, endDay, serviceCategoryOid)));
                    break;
                default:
                    reportObjects = ServicesOverviewRO.Create(month, year, organisationOid, employeeOid, startDay, endDay, serviceCategoryOid, true, false);
                    break;
            }
            
            reportObjects = reportObjects.Where(x => x != null).ToList();

            var srOids = new List<long>();

            reportObjects.DoForEach(x => x.Services.DoForEach(s => srOids.AddIfNotIn(s.ServiceRecordOid)));

            Model.ConfirmationReceiptSignatures = OperationsService.LoadAllConfirmationReceiptSignaturesByServiceRecordOids(srOids, out var serviceRecordOidsWithSignature);

            var customerSignatures = Model.ConfirmationReceiptSignatures.Where(crs => crs.SignatureType == SignatureType.Customer).ToList();
            var employeeSignatures = Model.ConfirmationReceiptSignatures.Where(crs => crs.SignatureType == SignatureType.Employee).ToList();
            
            Model.ReportServiceRecordOids = new List<long>();
            reportObjects.DoForEach(ro => ro.Services.DoForEach(s =>
            {
                Model.ReportServiceRecordOids.AddIfNotIn(s.ServiceRecordOid);
            }));

            var hasEmployeeSignature = srOids.All(
                a => serviceRecordOidsWithSignature.ContainsKey(SignatureType.Employee) && 
                     serviceRecordOidsWithSignature[SignatureType.Employee].Contains(a));

            var anyEmployeeSignatures = srOids.Any(a => serviceRecordOidsWithSignature.ContainsKey(SignatureType.Employee) &&
                            serviceRecordOidsWithSignature[SignatureType.Employee].Contains(a));

            var employeeSignatureState = SignatureState.None;

            if(anyEmployeeSignatures)
            {
                employeeSignatureState = SignatureState.Some;
            }

            if(hasEmployeeSignature)
            {
                employeeSignatureState = SignatureState.All;
            }

            Model.ConfirmationReceiptObject = null;
            Model.ConfirmationReceiptObject = new ConfirmationReceiptObject(
                BuildInformationString(), 
                new List<QuittierungsbelegResult>(), 
                BuildInformationString(true), 
                GetTimeSpanString(), 
                hasEmployeeSignature, 
                employeeSignatures.ToList(), 
                employeeSignatureState);

            reportObjects.DoForEach(reportObject =>
            {
                var quittierungsbelegItems = new List<QuittierungsbelegItem>();

                reportObject.Services.DoForEach(serviceDetail =>
                {
                    quittierungsbelegItems.Add(new QuittierungsbelegItem(serviceDetail));
                });

                if(quittierungsbelegItems.Count == 0)
                {
                    return;
                }

                var oids = quittierungsbelegItems.Select(s => s.ServiceRecordOid).ToList();
                
                var hasCustomerSignature = oids.All(a => serviceRecordOidsWithSignature.ContainsKey(SignatureType.Customer) && 
                                                         serviceRecordOidsWithSignature[SignatureType.Customer].Contains(a));

                var employeeSignatureState2 = GetSignatureState(oids, serviceRecordOidsWithSignature, SignatureType.Employee);

                var customerSignatureState = GetSignatureState(oids, serviceRecordOidsWithSignature, SignatureType.Customer);

                var customerSignatureOid = hasCustomerSignature ? customerSignatures.FirstOrDefault(cs => cs.ServiceRecords.All(a => a.Customer.CustomerOid.Equals(reportObject.CustomerOid) && a.ServiceRecordOid.HasValue && serviceRecordOidsWithSignature[SignatureType.Customer].Contains(a.ServiceRecordOid.Value)))?.ConfirmationReceiptSignatureOid : null;
                var sigs = customerSignatures.Where(cs => cs.ServiceRecords.All(a => a.Customer.CustomerOid.Equals(reportObject.CustomerOid) && a.ServiceRecordOid.HasValue && serviceRecordOidsWithSignature[SignatureType.Customer].Contains(a.ServiceRecordOid.Value))).ToList();

                var customerSignatureOids = sigs.Where(signature => signature.ConfirmationReceiptSignatureOid.HasValue).Select(signature => signature.ConfirmationReceiptSignatureOid.Value).ToList();

                var employeeSignatureOids = new List<long>();

                if(serviceRecordOidsWithSignature.ContainsKey(SignatureType.Employee))
                {
                    foreach(var signature in employeeSignatures.Where(s => s.ConfirmationReceiptSignatureOid.HasValue))
                    {
                        foreach(var serviceRecord in signature.ServiceRecords)
                        {
                            var oid = serviceRecord.ServiceRecordOid;

                            if(oid.HasValue && oids.Contains(oid.Value))
                            {
                                employeeSignatureOids.AddIfNotIn(signature.ConfirmationReceiptSignatureOid.Value);
                            }
                        }
                    }
                }

                var customerSignatureServiceRecordOids = new List<long>();
                var employeeSignatureServiceRecordOids = new List<long>();
                if(serviceRecordOidsWithSignature.ContainsKey(SignatureType.Customer))
                {
                    customerSignatureServiceRecordOids = serviceRecordOidsWithSignature[SignatureType.Customer];
                }

                if(serviceRecordOidsWithSignature.ContainsKey(SignatureType.Employee))
                {
                    employeeSignatureServiceRecordOids = serviceRecordOidsWithSignature[SignatureType.Employee];
                }

                foreach(var quittierungsbelegItem in quittierungsbelegItems)
                {
                    var serviceRecordOid = quittierungsbelegItem.ServiceRecordOid;

                    quittierungsbelegItem.HasCustomerSignature = customerSignatureServiceRecordOids.Contains(serviceRecordOid);
                    quittierungsbelegItem.HasEmployeeSignature = employeeSignatureServiceRecordOids.Contains(serviceRecordOid);
                }

                Model.ConfirmationReceiptObject.ConfirmationReceiptResultList.Add(
                    item: new QuittierungsbelegResult
                    (
                        $"{reportObject.CustomerLastName}, {reportObject.CustomerFirstName}", 
                        quittierungsbelegItems, 
                        reportObject.CustomerOid, 
                        hasCustomerSignature,
                        customerSignatureOid,
                        customerSignatureState,
                        customerSignatureOids,
                        employeeSignatureState2,
                        employeeSignatureOids
                    )
                );
            });

            if(Model.ConfirmationReceiptObject.ConfirmationReceiptResultList.All(qbItem => qbItem.Items.Count == 0))
            {
                TempData["HasWarningMessage"] = true;
            }

            return RedirectToActionPermanent("Report");
        }

        private static SignatureState GetSignatureState(List<long> oids, Dictionary<SignatureType, List<long>> serviceRecordOidsWithSignature, SignatureType signatureType)
        {
            var hasSignatures = oids.All(a => serviceRecordOidsWithSignature.ContainsKey(signatureType) &&
                                                     serviceRecordOidsWithSignature[signatureType].Contains(a));

            var hasSomeSignatures = oids.Any(a => serviceRecordOidsWithSignature.ContainsKey(signatureType) &&
                                                          serviceRecordOidsWithSignature[signatureType].Contains(a));

            if(hasSignatures)
            {
                return SignatureState.All;
            }

            return hasSomeSignatures ? SignatureState.Some : SignatureState.None;
        }

        private string BuildInformationString(bool isDativ = false)
        {
            var stringBuilder = new StringBuilder(isDativ ? string.Empty : "Einträge für ");

            // Einträge für [alle Klienten/die Klienten meines Teams/meine Klienten/[CustomerName]/[TeamName]] [von [Mitarbeiter] [bei [Kostenträger]] und [Leistungskategorie]] vom 01.10. bis 31.10.2020
            // Einträge für Grube, Clair von Fisher, George bei LWL und face-to-face vom 01.10. bis 31.10.2020
            // Unterschrift für x erbrachte Leistungen von 

            switch(Model.SelectedFilterItem.FilterEnum)
            {
                case QBFilterEnum.KlientenAuswahl:
                    stringBuilder.Append(Model.SelectedCustomer);
                    break;
                case QBFilterEnum.MeineKlienten:
                    stringBuilder.Append(isDativ ? "meinen" : "meine");
                    stringBuilder.Append(" Klienten");
                    break;
                case QBFilterEnum.NurKlientenMeinesTeams:
                    stringBuilder.Append(isDativ ? "den" : "die");
                    stringBuilder.Append(" Klienten meines Teams");
                    break;
                case QBFilterEnum.TeamAuswahl:
                    stringBuilder.Append(Model.SelectedTeam);
                    break;
                default:
                    stringBuilder.Append(isDativ ? "allen" : "alle");
                    stringBuilder.Append(" Klienten");
                    break;
            }

            stringBuilder.Append(" ");

            if(Model.SelectedEmployee != null)
            {
                stringBuilder.Append($"von {Model.SelectedEmployee} ");
            }

            if(Model.SelectedOrganisation != null)
            {
                stringBuilder.Append($"bei {Model.SelectedOrganisation} ");
            }

            if(Model.SelectedServiceCategory != null)
            {
                if(Model.SelectedEmployee != null || Model.SelectedOrganisation != null)
                {
                    stringBuilder.Append("und ");
                }

                stringBuilder.Append(Model.SelectedServiceCategory.Name);
            }

            stringBuilder.Append(GetTimeSpanString());

            return stringBuilder.ToString();
        }

        private string GetTimeSpanString()
        {
            var month = Model.SelectedMonth < 10 ? $"0{Model.SelectedMonth}" : Model.SelectedMonth.ToString();
            var year  = Model.SelectedYear;
            var vom   = Model.SelectedStartDay < 10 ? $"0{Model.SelectedStartDay}" : Model.SelectedStartDay.ToString();
            var bis   = Model.SelectedEndDay < 10 ? $"0{Model.SelectedEndDay}" : Model.SelectedEndDay.ToString();

            return $"vom {vom}.{month}. bis {bis}.{month}.{year}";
        }

        private IEnumerable<long> GetTeamCustomerOids(long? teamOid = null)
        {
            var customerOids = new List<long>();

            if(MobileSessionFacade.LoggedInEmployee?.EmployeeOid != null)
            {
                customerOids.AddRangeIfElementsNotIn(EmployeeService.GetTeamRelatedCustomerOids(MobileSessionFacade.LoggedInEmployee.EmployeeOid.Value, teamOid));
            }

            return customerOids;
        }

        [Authorize]
        public string SetCustomer(long customerOid)
        {
            if(Model == null)
            {
                return _LeerzeichenFuerGetMethoden;
            }

            Model.SelectedCustomer = Model.Customers.FirstOrDefault(customer => customer.CustomerOid == customerOid);

            return _LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public string ChangeDateSelection(string startDayString, string endDayString, string monthString, string yearString)
        {
            if(Model == null)
            {
                Logout();
            }

            var isParsingSuccessful1 = int.TryParse(startDayString, out var startDay);
            var isParsingSuccessful2 = int.TryParse(endDayString, out var endDay);
            var isParsingSuccessful3 = int.TryParse(monthString, out var month);
            var isParsingSuccessful4 = int.TryParse(yearString, out var year);

            if(isParsingSuccessful1 && isParsingSuccessful2 && isParsingSuccessful3 && isParsingSuccessful4)
            {
                var start = new DateTime(year, month, startDay);
                var end = new DateTime(year, month, endDay);

                Model.SelectedEndDay   = end.Day;
                Model.SelectedStartDay = start.Day;
                Model.SelectedMonth    = month;
                Model.SelectedYear     = year;
            }

            return _LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public string ChangeFilters(string employeeOidStr, string organisationOidStr, string categoryOidStr)
        {
            if(Model == null)
            {
                Logout();
            }

            var isParsingSuccessful1 = long.TryParse(employeeOidStr, out var employeeOid);
            var isParsingSuccessful2 = long.TryParse(organisationOidStr, out var organisationOid);
            var isParsingSuccessful3 = long.TryParse(categoryOidStr, out var categoryOid);

            Model.SelectedEmployee = isParsingSuccessful1 ? EmployeeService.LoadCompactEmployee(employeeOid) : null;

            Model.SelectedOrganisation = isParsingSuccessful2 ? CustomerService.LoadOrganisationCompact(organisationOid) : null;

            Model.SelectedServiceCategory = isParsingSuccessful3 ? OperationsService.LoadServiceCategory(categoryOid) : null;

            return _LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public string SetQbFilterEnum(string filterEnumString)
        {
            if(Model == null)
            {
                Logout();
                return _LeerzeichenFuerGetMethoden;
            }

            var isParsingSuccessful = int.TryParse(filterEnumString, out var filterEnumValue);

            if(isParsingSuccessful)
            {
                var selectedFilterEnum = (QBFilterEnum) filterEnumValue;

                Model.SelectedFilterItem = new QbFilterItem(selectedFilterEnum);
            }

            return _LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        [HttpPost]
        public string CreateSignatureForServiceOverview(string base64SignatureString, string customerOidString, bool? isCustomerSignature, bool? overwrite)
        {
            if(Model == null)
            {
                Logout();
                return _LeerzeichenFuerGetMethoden;
            }

            var shouldOverwrite = overwrite.HasValue && overwrite.Value;

            var isCustomerSig = isCustomerSignature.HasValue && isCustomerSignature.Value;

            var isSuccessful = long.TryParse(customerOidString, out var customerOid);

            if(!isSuccessful || customerOid == 0)
            {
                return MobileUtils.SerializeObject("Es ist ein unbekannter Fehler aufgetreten. Bitte wenden Sie sich an den Administrator.");
            }

            var signatureType = isCustomerSig ? SignatureType.Customer : SignatureType.Employee;

            var serviceRecordOids = new List<long>();

            var resultList = Model.ConfirmationReceiptObject.ConfirmationReceiptResultList;

            if(customerOid > 0L)
            {
                resultList = resultList.Where(item => item.CustomerOid == customerOid).ToList();
            }

            resultList.DoForEach(result => result.Items.DoForEach(item => serviceRecordOids.AddIfNotIn(item.ServiceRecordOid)));

            var existingServiceRecordSignatures = OperationsService.LoadConfirmationReceiptSignaturesByServiceRecordOids(serviceRecordOids, signatureType, out var serviceRecordOidsWithSignature);

            var serviceRecords = OperationsService.GetServiceRecordsByIds(serviceRecordOids);

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

                if(!isValid)
                {
                    return MobileUtils.SerializeObject("Das Unterschriftenfeld darf nicht leer sein.");
                }

                if(shouldOverwrite)
                {
                    foreach(var csr in existingServiceRecordSignatures)
                    {
                        var temp = csr.ServiceRecords.Where(sr => sr.ServiceRecordOid.HasValue && !serviceRecordOidsWithSignature.Contains(sr.ServiceRecordOid.Value));
                        csr.ServiceRecords.Clear();
                        csr.ServiceRecords.AddRangeIfElementsNotIn(temp);

                        if(csr.ServiceRecords.Count == 0 && csr.ConfirmationReceiptSignatureOid.HasValue)
                        {
                            OperationsService.DeleteConfirmationReceiptSignature(csr.ConfirmationReceiptSignatureOid.Value);
                        }
                        else
                        {
                            OperationsService.UpdateConfirmationReceiptSignature(csr);
                        }
                    }
                }
                else
                {
                    serviceRecords = serviceRecords.Where(sr => sr.ServiceRecordOid.HasValue && !serviceRecordOidsWithSignature.Contains(sr.ServiceRecordOid.Value)).ToList();
                }

                var timeSpanString = GetTimeSpanString();
                if(timeSpanString.Contains("vom"))
                {
                    timeSpanString = timeSpanString.Substring(4);
                }

                var confirmationReceiptSignature = new ConfirmationReceiptSignatureDC
                {
                    ServiceRecords = serviceRecords,
                    CustomerOid = isCustomerSig ? (long?) customerOid : null,
                    Employee = isCustomerSig ? null : MobileSessionFacade.LoggedInCompactEmployee,
                    SignatureImage = base64SignatureString,
                    SignatureType = signatureType,
                    TimeSpanString = timeSpanString
                };

                OperationsService.InsertConfirmationReceiptSignature(confirmationReceiptSignature);
            }

            return _LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public string LoadConfirmationReceiptSignatures(string oidsAsString)
        {
            try
            {
                if(Model == null)
                {
                    Logout();
                    return _LeerzeichenFuerGetMethoden;
                }

                if(!string.IsNullOrWhiteSpace(oidsAsString))
                {
                    var oidStrings = oidsAsString.Split(',');

                    var oids = new List<long>();

                    foreach(var oidString in oidStrings)
                    {
                        if(long.TryParse(oidString, out var oid))
                        {
                            oids.AddIfNotIn(oid);
                        }
                    }

                    var signatures = Model.GetConfirmationReceitSignaturesByOids(oids).Where(signature => signature.SignatureImage != null).ToList();

                    var imageStrings = new List<string>();

                    foreach(var signature in signatures)
                    {
                        imageStrings.AddIfNotIn(MainController.ApplyWatermark(signature.SignatureImage, Server.MapPath("../Content/images/bewoplaner_logo_big.png")));
                    }

                    return MobileUtils.SerializeObject(imageStrings);
                }

                return _LeerzeichenFuerGetMethoden;
            }
            catch(Exception exception)
            {
                return MobileUtils.SerializeObject("Ein Fehler ist aufgetreten. Bitte wenden Sie sich an Ihren Administrator.");
            }
        }
    }
}