Lyndon Jetten
3ca4ec5323
Das Mehrfachbuchungsformular hat ebenfalls die Schnittmenge der Leistungen und Kategorien von den ausgewählten Hilfeplänen. Das Caching ist wieder aktiviert. Und lädt pro Post-Aufruf nur noch einmal 13 MB und danach nur noch 300 kb herunter. Überall konsequent geprüft, ob das Model nicht null ist und falls dem so ist, wird ausgeloggt, damit es zu keinen Fehlern mehr kommt.
1156 lines
44 KiB
C#
1156 lines
44 KiB
C#
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 : AbstractBaseController
|
|
{
|
|
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 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.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 });
|
|
}
|
|
|
|
|
|
#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("CustomerReportPartial", Model);
|
|
}
|
|
|
|
var selectedReportType = (CustomerReportType)reportType;
|
|
|
|
SelectReport(selectedReportType);
|
|
|
|
return PartialView("CustomerReportPartial", 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("CustomerReportPartial", Model);
|
|
}
|
|
|
|
Model.SelectedReportType = CustomerReportType.Historie;
|
|
|
|
GenerateMobileMedListForSelectedCustomer(medListOid);
|
|
|
|
return PartialView("CustomerReportPartial", 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;
|
|
}
|
|
}
|
|
|
|
[Authorize]
|
|
public string ResetReport()
|
|
{
|
|
Model.Report = null;
|
|
|
|
return LeerzeichenFuerGetMethoden;
|
|
}
|
|
#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("CustomerReportPartial", 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("CustomerReportPartial", 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("CustomerReportPartial", 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("CustomerReportPartial", 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("CustomerReportPartial", 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
|
|
}
|
|
} |