BeWoPlaner/Service/ServiceImplementations/GkvAccountingServiceImp.cs

using BeWo.Data;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Data.Entities.Light;
using BeWo.ServerUtils.Core;
using BeWo.Service.Core;
using BeWo.Service.DCEntityMapper;
using BeWo.Service.Plugins;
using BeWo.Service.ServiceContracts;
using BS.Shared;
using BS.Shared.AppSender;
using BS.Shared.Core;
using BS.Shared.Core.Validation;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.GkvAbrechnung;
using BS.Shared.DataContracts.Light;
using BS.Shared.Exceptions;
using BS.Shared.Extensions;
using BS.Shared.Interface;
using Dakota;
using Dakota.Logic;
using Dakota.Models.Schlüssels;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
using System.Threading.Tasks;

using Utils = BeWo.Service.Core.Utils;

namespace BeWo.Service.ServiceImplementations
{
	[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Single)]
	public class GkvAccountingServiceImp : IGkvAccountingService
	{
		public string Tenant => MultitenancyOperationContextExt.Current?.Tenant;

		public GkvAbrechnungLightDC GetGkvAbrechnung(long oid)
		{
			try
			{
				var gkv = DAOFactory.GenericDAO.GetByID<GkvAbrechnungLight>(oid);

				var dc = MapperFactory.GkvAbrechnungLight.MapToNewDC(gkv);

				return dc;
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<GkvAbrechnungLightDC> GetAllGkvAbrechnungen()
		{
			try
			{
				return GetGkvAbrechnungen(() => DAOFactory.GenericDAO.GetAllActive<GkvAbrechnungLight>());
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public List<GkvAbrechnungLightDC> GetAllGkvAbrechnungenBy(GkvAbrechnungViewFilterDC gkvAbrechnungViewFilter)
		{
			if (gkvAbrechnungViewFilter == null || !gkvAbrechnungViewFilter.FilterTime)
			{
				var dcs = GetAllGkvAbrechnungen();

				ServiceValidator.CheckSerializationError(dcs);

				return dcs;
			}

			try
			{
				var start = gkvAbrechnungViewFilter.Start;
				var end = gkvAbrechnungViewFilter.End;
				var filter = gkvAbrechnungViewFilter.FilterForCreationDate;

				return GetGkvAbrechnungen(() => DAOFactory.FinanceDAO.GetGkvAbrechnungen(start, end, filter));
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		private List<GkvAbrechnungLightDC> GetGkvAbrechnungen(Func<IEnumerable<GkvAbrechnungLight>> get_entities)
		{
			var entities = get_entities();

			var dcs = MapperFactory.GkvAbrechnungLight.MapToNewDCs(entities);

			var updateables = dcs.Where(x => x.IsWaiting()).ToArray();

			if (!updateables.Any())
				return dcs;

			var isUpToDate = SendApp8GetStatusRequest(updateables);

			if (isUpToDate)
				return dcs;

			entities = get_entities();

			dcs = MapperFactory.GkvAbrechnungLight.MapToNewDCs(entities);

			return dcs;
		}
		public string GetProtokollRawDataString(long oid, GkvRawDataType gkvRawData)
		{
			try
			{
				if (oid <= 0)
				{
					throw new ArgumentOutOfRangeException(nameof(oid), $"oid \'{oid}\' nicht positiv");
				}

				var str = DAOFactory.FinanceDAO.GetGkvRawData(oid, gkvRawData);

				return str;
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		public GkvAbrechnungCreateResponseDC CreateNewGkvAbrechnung(GkvAbrechnungCreateRequestDC request)
		{
			var response = new GkvAbrechnungCreateResponseDC();

			try
			{
				var invoice_bases = DAOFactory.GenericDAO.LoadByIDs<InvoiceBase>(request.SelectedInvoiceBases);

				GkvValidation.ValidateGkvAbrechnung(request.GkvAbrechnungDC, invoice_bases);

				var gkv_abrechnung = MapperFactory.GkvAbrechnungDC_GkvAbrechnung.MapToNewEntity(request.GkvAbrechnungDC);

				if (gkv_abrechnung.AbrechnungsZeitraumEnde.Value.Hour == 0)
				{
					gkv_abrechnung.AbrechnungsZeitraumEnde = gkv_abrechnung.AbrechnungsZeitraumEnde.Value.Date.AddDays(1).AddMilliseconds(-1);
				}

				var orga = gkv_abrechnung.Organisation;

				gkv_abrechnung.Verfahrensstufe = orga.Verfahrensstufe;

				decimal gesamt = 0;
				foreach (var invoicebase_oid in request.SelectedInvoiceBases)
				{
					var service = DAOFactory.SearchDAO.GetServiceInvoiceByInvoiceBaseOid(invoicebase_oid);

					foreach (var peroid in service.ServiceInvoicePeriodList)
					{
						foreach (var invoice in peroid.InvoiceItemList)
						{
							gesamt += invoice.AmountTotal.Value;
						}
					}
				}

				gkv_abrechnung.Betrag = gesamt;
				gkv_abrechnung.Bezahlt = false;

				gkv_abrechnung.ErstelltAm = DateTime.Now;

				DAOFactory.GenericDAO.Insert(gkv_abrechnung);

				var gkv_light = DAOFactory.GenericDAO.LoadByID<GkvAbrechnungLight>(gkv_abrechnung.Oid.Value);

				var gkv_abrechnung_dc = MapperFactory.GkvAbrechnungLight.MapToNewDC(gkv_light);

				response.Success = true;
				response.GkvAbrechnungLightDC = gkv_abrechnung_dc;
			}
			catch (GkvException exc)
			{
				MailUtils.SendGkvModuleErrorMail("CreateNewGkvAbrechnung", exc, Tenant);

				if (exc.Title.IsNotNullOrWhiteSpace())
					response.TitleMessage = exc.Title;
				response.Message = exc.Message;
			}
			catch (Exception e)
			{
				MailUtils.SendGkvModuleErrorMail("CreateNewGkvAbrechnung", e, Tenant);

				throw Utils.CreateBeWoFaultException(e);
			}

			return response;
		}
		public GkvAbrechnungLightDC UpdateGkvAbrechnung(GkvAbrechnungLightDC abrechnung)
		{
			try
			{
				var entity = DAOFactory.GenericDAO.GetByID<GkvAbrechnungLight>(abrechnung.Oid);

				MapperFactory.GkvAbrechnungLight.MergeWithEntity(abrechnung, entity);

				DAOFactory.GenericDAO.Update(entity);

				var dc = MapperFactory.GkvAbrechnungLight.MapToNewDC(entity);

				return dc;
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}
		public void DeleteGkvAbrechnung(long oid, long version)
		{
			try
			{
				ServiceLogic.SetActivationType<GkvAbrechnung>(oid, version, ActivationTypeId.Deleted);
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		/// <summary>
		/// Erstellt GkvTransferProtokoll
		/// </summary>
		/// <param name="req"></param>
		/// <returns></returns>
		public GkvAbrechnungSendResponseDC SendNewGkvAbrechnung(GkvAbrechnungSendRequestDC req)
		{
			var response = new GkvAbrechnungSendResponseDC();

			var oid = req.GkvAbrechnungOid;

			var entity = DAOFactory.GenericDAO.LoadByID<GkvAbrechnung>(oid);

			var state = entity.GetState();

			if (entity.IsWaiting() || state == GkvState.Paid)
			{
				response.Message = "Validierung fehlgeschlagen";
				return response;
			}

			var protokoll = CreateGkvTransferProtokoll(entity, out var error);
			if (error is object)
			{
				MailUtils.SendGkvModuleErrorMail("SendNewGkvAbrechnung - CreateGkvTransferProtokoll", error, Tenant);

				response.TitleMessage = "Protokoll Erstellung";
				response.Message = error;
				return response;
			}

			if (entity.GkvTransferProtokolle is null)
				entity.GkvTransferProtokolle = new List<GkvTransferProtokoll>();

			entity.GkvTransferProtokolle.Add(protokoll);

			// Protokoll braucht Oid
			DAOFactory.GenericDAO.Update(entity);

			try
			{
				var app8_response = SendApp8SendNewRequest(protokoll);

				var app8_protokoll = app8_response.GkvTransferProtokollDC;

				MapperFactory.GkvTransferProtokollDC_GkvTransferprotokoll.MergeWithEntity(app8_protokoll, protokoll);

				response.Success = app8_response.Success;
				response.Message = app8_response.Message;
			}
			catch (GkvException de)
			{
				protokoll.ResultType = GkvTransferResultType.FailSoft;
				protokoll.Fehlerdatum = DateTime.Now;
				protokoll.Fehlernachricht = de.Message;
				protokoll.Fehlertitel = de.Title ?? "Default";
			}
			catch (Exception e)
			{
				protokoll.ResultType = GkvTransferResultType.FailFatal;
				protokoll.Fehlerdatum = DateTime.Now;
				protokoll.Fehlernachricht = e.ToString();
				protokoll.Fehlertitel = "Erstellung (kritisch)";
			}

			DAOFactory.GenericDAO.Update(entity);

			var entity_light = DAOFactory.GenericDAO.LoadByID<GkvAbrechnungLight>(entity.Oid.Value);
			var protokoll_light = DAOFactory.GenericDAO.LoadByID<GkvTransferProtokollLight>(protokoll.Oid.Value);

			response.GkvAbrechnungDC = MapperFactory.GkvAbrechnungLight.MapToNewDC(entity_light);
			response.TransferProtokoll = MapperFactory.GkvTransferprotokollLight.MapToNewDC(protokoll_light);

			return response;
		}
		public GkvAbrechnungGetIKResponseDC SendGetIKRequest(GkvAbrechnungGetIKRequestDC req)
		{
			try
			{
				var app8req = new GkvServerGetIKRequestDC
				{
					IKKrankenkasse = req.IKKrankenkasse,
					Leistungserbringergruppe = req.Leistungserbringergruppe,
					Abrechnungscode = DakotaUtils.GetAbrechnungscode(req.Leistungserbringergruppe),
					Tarifkennzeichen = DakotaUtils.GetTarifkennzeichen(req.Leistungserbringergruppe)
				};

				var app8res = SendApp8Request<GkvServerGetIKRequestDC, GkvServerGetIKResponseDC>(app8req);

				// Erstelle Response
				var res = new GkvAbrechnungGetIKResponseDC
				{
					BezDatenannahmestelle = app8res.BezDatenannahmestelle,
					Gefunden = app8res.Gefunden,
					IKDatenannahmestelle = app8res.IKDatenannahmestelle,
					IKKostentrager = app8res.IKKostentrager,
					IKKrankenkasse = app8res.IKKrankenkasse,
					Message = app8res.Message,
					Success = app8res.Success,
					Hausanschrift = app8res.Hausanschrift ?? new AddressDC(),
					PostfachGKanschrift = app8res.PostfachGKanschrift ?? new AddressDC(),
					Papierannahmeanschrift = app8res.Papierannahmeanschrift ?? new AddressDC(),
				};

				// Schaue, ob IK Krankenkassen bereits bei einer anderen Organisation hinterlegt ist
				if (res.Gefunden)
				{
					// Holt alle Organisationen
					var orgas = DAOFactory.OrganisationDAO.GetAllActiveOrganisationByIKKrankenkasse(req.IKKrankenkasse);

					// Entfernt sich selber
					if (req.OrganisationOid is long oid)
					{
						orgas.RemoveAll(x => x.Oid == oid);
					}

					if (orgas.Any())
					{
						res.BereitsEnthalten = true;
						res.BereitsEnthaltenBei = orgas.Select(x => x.Name).ToList();
					}
				}

				return res;
			}
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
		}

		private GkvTransferProtokoll CreateGkvTransferProtokoll(GkvAbrechnung gkvAbrechnung, out string error)
		{
			Action<string> eval = (error_str) =>
			{
				if (error_str is string)
					throw new GkvException(error_str);
			};

			var protokoll = new GkvTransferProtokoll
			{
				ErstelltAm = DateTime.Now,
				GkvAbrechnungOid = gkvAbrechnung.Oid.Value
			};

			error = null;

			try
			{
				eval(GkvValidation.ValidateGkvAbrechnung(gkvAbrechnung, gkvAbrechnung.InvoiceBases));

				var leistungsbereich = GkvAbrechnungGetLeistungsbereich(gkvAbrechnung.InvoiceBases);
				var manager = new DakotaManager(DateTime.Now.Month, DateTime.Now, leistungsbereich);
				var mandatordc = new OperationsServiceImp().GetMandator();

				eval(GkvValidation.ValidateMandator(mandatordc));

				var gkvAbrechnungDC = MapperFactory.GkvAbrechnungDC_GkvAbrechnung.MapToNewDC(gkvAbrechnung);
				var orgadc = gkvAbrechnungDC.Organisation;

				eval(GkvValidation.ValidateOrganisation(orgadc));

				var datenannahmestelle = orgadc.IKDatenannahmestelle;
				var (datenaustauschreferenz, transfernummer) = GetNextDatenaustauschreferenzTransfernummer(gkvAbrechnung, datenannahmestelle);
				var (dat_short, tra_short) = ClearDatenaustauschreferenzTransfernummer(datenaustauschreferenz, transfernummer);

				var first_cost = gkvAbrechnung.InvoiceBases.First().CostBearer2SupportConcept.SupportConcept.Customer;

				var plugin = PluginLoader.FindClass<AccountingService>();
				var addressInfo = plugin.GetAddressInformation(first_cost.Oid);

				foreach (var invoicebase in gkvAbrechnung.InvoiceBases)
				{
					var customer = invoicebase.CostBearer2SupportConcept.SupportConcept.Customer;

					var addressInfo2 = plugin.GetAddressInformation(customer.Oid);

					if (addressInfo.IKLeistungserbringer != addressInfo2.IKLeistungserbringer)
					{
						throw new GkvException($"Klient '{first_cost.Person.LastNameFirstName}' ({addressInfo.IKLeistungserbringer}) und '{customer.Person.LastNameFirstName}' ({addressInfo2.IKLeistungserbringer}) verweisen auf unterschiedliche Leistungserbringer.");
					}
				}

				foreach (var invoicebase in gkvAbrechnung.InvoiceBases)
				{
					var service = DAOFactory.SearchDAO.GetServiceInvoiceByInvoiceBaseOid(invoicebase.Oid.Value);
					var orga2 = invoicebase.CostBearer2SupportConcept.CostBearer.Organisation;
					var customer = invoicebase.CostBearer2SupportConcept.SupportConcept.Customer;

					var invoicebase_dc = MapperFactory.InvoiceBaseDC_InvoiceBase.MapToNewDC(invoicebase);

					var servicedc = MapperFactory.ServiceInvoiceDC_ServiceInvoice.MapToNewDC(service);
					var customerdc = MapperFactory.CustomerDC_Customer.MapToNewDC(customer);

					eval(GkvValidation.ValidateCustomer(customerdc));

					manager.Add(servicedc, orgadc, customerdc, addressInfo, dat_short, tra_short);
				}

				manager.Apply();

				if (manager.DakotaFileDict.Count != 1 || manager.DakotaFileDict.First().Value.GetKostenträgerCount() != 1)
				{
					var msg = "Unerwartete Anzahl an Dakota Files berechnet.";

					throw new GkvException(msg);
				}

				var file_from_manager = manager.DakotaFileDict.First().Value;

				var nutzdatendatei = file_from_manager.GetNutzdatendatei();

				// https://dev.mysql.com/doc/refman/8.3/en/string-type-syntax.html
				// A TEXT column with a maximum length of 16,777,215 (224 − 1) characters.
				// The effective maximum length is less if the value contains multibyte characters.
				// Each MEDIUMTEXT value is stored using a 3-byte length prefix that indicates the number of bytes in the value.
				//
				//        Type | Maximum length
				//  -----------+-------------------------------------
				//    TINYTEXT | 255(2^8−1) bytes
				//        TEXT | 65,535(2^16−1) bytes = 64 KiB
				//  MEDIUMTEXT | 16,777,215(2^24−1) bytes = 16 MiB
				//    LONGTEXT | 4,294,967,295(2^32−1) bytes = 4 GiB
				if (nutzdatendatei.Length > 16777215)
				{
					var msg = $"nutzdatendatei - Länger als 16777215: {nutzdatendatei.Length}";

					throw new GkvException(msg);
				}

				protokoll.Datenaustauschreferenz = datenaustauschreferenz;
				protokoll.Transfernummer = transfernummer;

				protokoll.IKDatenannahmestelle = file_from_manager.GetIKDatenannahmestelle();
				protokoll.IKKostentrager = file_from_manager.GetIKKostenträger();
				protokoll.IKLeistungserbringer = file_from_manager.GetIKLeistungserbringer();
				protokoll.IKKrankenkasse = file_from_manager.GetIKVersichertenKarte();

				protokoll.Rechnungsnummer = file_from_manager.GetRechnungsnummer();
				protokoll.Auftragsdatei = file_from_manager.GetAuftragsdatei();
				protokoll.Nutzdatendatei = nutzdatendatei;
				protokoll.Transfername = file_from_manager.GetTransferName();
				protokoll.Dateigrosse = nutzdatendatei.Length;

				protokoll.Dateityp = "Nutzdatendatei";
				protokoll.Dateiname = protokoll.Transfername;

				protokoll.AbsenderBezeichnung = "ownSoft GmbH";
				protokoll.EmpfangerBezeichnung = orgadc.BezDatenannahmestelle;

				return protokoll;
			}
			catch (GkvException de)
			{
				error = de.ToString();
			}
			catch (Exception e)
			{
				error = e.ToString();
			}

			return null;
		}

		private static SchlüsselLeistungserbringerSammelgruppenschlussel GkvAbrechnungGetLeistungsbereich(IEnumerable<InvoiceBase> invoiceBases)
		{
			var invoiceIds = invoiceBases.Select(ib => ib.InvoiceId).Distinct().ToList();

			if (invoiceIds.All(id => id == "RechnungNichtaerztlicheDialysesachleistung"))
				return SchlüsselLeistungserbringerSammelgruppenschlussel.NichtÄrztlicheDialysesachleistung;

			if (invoiceIds.All(id => id == "RechnungHaeuslicheKrankenpflege"))
				return SchlüsselLeistungserbringerSammelgruppenschlussel.LeistungserbringerVonHäuslicherKrankenpflege;

			return SchlüsselLeistungserbringerSammelgruppenschlussel.SoziotherapeutischerLeistungserbringer;
		}

		private Tuple<int, int> GetNextDatenaustauschreferenzTransfernummer(GkvAbrechnung gkvAbrechnung, string datenannahmestelle)
		{
			bool newDatenaustauschref;
			var state = gkvAbrechnung.GetState();

			if (state == GkvState.NoSend)
			{
				newDatenaustauschref = true;
			}
			else if (state == GkvState.ErrorSoft || state == GkvState.ErrorFatal)
			{
				newDatenaustauschref = false;
			}
			else
			{
				throw new ArgumentException($"Versucht Transfernummer zu laden, invalid state: {state}", nameof(state));
			}

			return SendApp8GetNumberRequest(datenannahmestelle, newDatenaustauschref, true);
		}
		private Tuple<int, int> ClearDatenaustauschreferenzTransfernummer(int datenaustauschreferenz, int transfernummer)
		{
			int d = datenaustauschreferenz % 99999;
			int t = transfernummer % 1000;

			if (d == 0)
			{
				d = 99999;
			}

			return new Tuple<int, int>(d, t);
		}

		private GkvServerSendNewResponseDC SendApp8SendNewRequest(GkvTransferProtokoll protokoll)
		{
			var gkv_transfer_dc = MapperFactory.GkvTransferProtokollDC_GkvTransferprotokoll.MapToNewDC(protokoll);

			var request_app8 = new GkvServerSendNewRequestDC
			{
				Protokoll = gkv_transfer_dc
			};

			var response_app8 = SendApp8Request<GkvServerSendNewRequestDC, GkvServerSendNewResponseDC>(request_app8);

			if (response_app8 == null)
				throw new GkvException("response null", "App8");

			if (!response_app8.Success)
			{
				if(string.IsNullOrWhiteSpace(response_app8.TitleMessage) && string.IsNullOrWhiteSpace(response_app8.Message))
				{
					throw new GkvException("no success", "App8");
				}
				else
				{
					throw new GkvException(response_app8.TitleMessage + ":" + response_app8.Message, "App8");
				}
			}

			return response_app8;
		}
		/// <summary>
		/// 
		/// </summary>
		/// <param name="updateables"></param>
		/// <param name="loginName"></param>
		/// <param name="hashed_password"></param>
		/// <returns>Returns true, if the states are all up to date. False otherwise.</returns>
		private bool SendApp8GetStatusRequest(IGkvAbrechnung[] updateables)
		{
			var updateables_len = updateables.Count();

			var request = new GkvServerGetStatusRequestDC
			{
				Tenant = MultitenancyOperationContextExt.Current.Tenant,
				Oids = new long[updateables_len]
			};

			for (int id = 0; id < updateables_len; id++)
			{
				var gkv_abrechnung = updateables[id];
				var gkv_transfer = gkv_abrechnung.TransferProtokolle.Last();

				request.Oids[id] = gkv_transfer.Oid.Value;
			}

			GkvServerGetStatusResponseDC response_app8;
			try
			{
				response_app8 = SendApp8Request<GkvServerGetStatusRequestDC, GkvServerGetStatusResponseDC>(request);
			}
			catch (Exception e)
			{
				MailUtils.SendGkvModuleErrorMail("GkvServerGetStatusRequest Error", e, Tenant);

				return true;
			}

			if (!response_app8.Success)
				throw new GkvException("Success false - " + response_app8.Message);

			if (response_app8.Results is null)
				throw new GkvException("Result null - " + response_app8.Message);

			var results = response_app8.Results.Where(x => x is object);

			if (!results.Any())
				return true;

			HandleGkvServerResults(results);

			return false;
		}

		private Tuple<int, int> SendApp8GetNumberRequest(string ik_datenannahmestelle, bool newDatenaustauschref, bool newTransferNumber)
		{
			var request = new GkvServerGetNumberRequestDC();

			request.IKDatenannahmestelle = ik_datenannahmestelle;
			request.NewDatenaustauschRef = newDatenaustauschref;
			request.NewTransferNumber = newTransferNumber;	

			GkvServerGetNumberResponseDC response_app8;

			response_app8 = SendApp8Request<GkvServerGetNumberRequestDC, GkvServerGetNumberResponseDC>(request);

			if (!response_app8.Success)
				throw new GkvException("Success false - " + response_app8.Message);

			return new Tuple<int, int>(response_app8.Datenaustauschreferenz, response_app8.Transfernummer);

			// Kein Try-Catch, damit der Prozess oben abgebrochen wird

			//try
			//{

			//}
			//catch (Exception e)
			//{
			//	MailUtils.SendGkvModuleErrorMail("GkvServerGetNumberRequest Error", e, Tenant);
			//}

			//return null;
		}

		public void HandleGkvServerResults(IEnumerable<GkvServerResultDC> results)
		{
			var protokolls = new List<GkvTransferProtokollLight>();
			foreach (var result in results)
			{
				var protokoll = DAOFactory.GenericDAO.GetByID<GkvTransferProtokollLight>(result.ProtokollOid);

				protokoll.ResultType = result.ResultType;
				protokoll.Fehlertitel = result.Titel;
				protokoll.Fehlerdatum = result.Datum;
				protokoll.Fehlernachricht = result.Nachricht;

				switch (result.ResultType)
				{
					case GkvTransferResultType.Success:
						protokoll.SentDakotaSuccess = true;
						break;
					case GkvTransferResultType.FailSoft:
						protokoll.SentApp8Success = false;
						break;
					case GkvTransferResultType.FailFatal:
						protokoll.SentApp8Success = false;
						break;
				}

				protokolls.Add(protokoll);
			}

			if (protokolls.Any())
				DAOFactory.GenericDAO.Update(protokolls);
		}

		private Res SendApp8Request<Req, Res>(Req request) where Req : GkvServerRequestDC where Res : GkvResponseDC
		{
			var user = LoggedInUserOperationContextExt.Current?.User ?? SessionFacade.LoggedInUser;
			if (user == null)
			{
				throw new GkvException("User unbekannt", "KundenApp");
			}

			request.Username = user.LoginName;
			request.Password = user.BCryptPassword;
			request.Tenant = MultitenancyOperationContextExt.Current.Tenant;

			if (request is GkvServerSendNewRequestDC send_new_req)
			{
				send_new_req.ApplicationUserOid = user.Oid.Value;
			}

			return GkvSender.SendApp8Request<Req, Res>(request, request.Tenant);
		}
	}
}