BeWoPlaner/Host/GkvAbrechnungServer.aspx.cs

using BS.Shared;
using BS.Shared.AppSender;
using BS.Shared.DataContracts.GkvAbrechnung;
using BS.Shared.Exceptions;
using Dakota.Logic;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;
using Page = System.Web.UI.Page;

namespace Host
{
	/// <summary>
	/// 
	/// Stellt einen Entpunkt für Server dar.
	/// Hier: app8
	/// 
	/// 
	/// </summary>
	public partial class GkvAbrechnungServer : Page
	{
		public const int PROCESS_WAITFOREXIT_MS = 10 * 1000;
		public const int WAIT_BEFORE_ERROR_MS = 5 * 1000;

		private readonly string LOGINSERVER_URL = "{0}/Login.aspx";
		private readonly string INVALID_INPUT = "Ungültige Eingabe";

		private string ResultFolderPath { get; set; } = ConfigurationManager.AppSettings.Get("GkvAbrechnungResultFolderPath");
		private string QueueFolderPath { get; set; } = ConfigurationManager.AppSettings.Get("GkvAbrechnungQueueFolderPath");
		private string KostentragerdateiFolderPath { get; set; } = ConfigurationManager.AppSettings.Get("GkvKostentragerdateiFolderPath");

		protected void Page_Load(object sender, EventArgs e)
		{
			try
			{
				//https://app8.bewoplaner.de/Host/GkvAbrechungServer?tenant=12345

				var str = new StreamReader(Request.InputStream).ReadToEnd();

				var req = GkvSender.DeserializeRequest<GkvServerRequestDC>(str, SendInvalidInputResponse);

				if (!CheckValues(req))
					SendErrorResponse("Check Fehlgeschlagen");

				if (!TryLogin(req))
					SendErrorResponse("Login Fehlgeschlagen");

				switch (req.Type)
				{
					case RequestType.GkvServerSendNew:
						SendNew(GkvSender.DeserializeRequest<GkvServerSendNewRequestDC>(str, SendInvalidInputResponse));
						return;

					case RequestType.GkvServerGetIKNumber:
						GetIK(GkvSender.DeserializeRequest<GkvServerGetIKRequestDC>(str, SendInvalidInputResponse));
						return;

					case RequestType.GkvServerGetStatus:
						GetStatus(GkvSender.DeserializeRequest<GkvServerGetStatusRequestDC>(str, SendInvalidInputResponse));
						return;

					case RequestType.GkvServerGetNumber:
						GetNumber(GkvSender.DeserializeRequest<GkvServerGetNumberRequestDC>(str, SendInvalidInputResponse));
						return;

					default:
						SendErrorResponse("RequestType unbekannt.");
						return;
				}
			}
			catch (ThreadAbortException eee)
			{

			}
			catch (Exception ex)
			{
				var ex_text = ex.Message + "\n\n" + ex.StackTrace;

				if(ex.InnerException != null)
				{
					ex_text += "\n\n" + ex.InnerException.Message + "\n\n" + ex.InnerException.StackTrace;

					if (ex.InnerException.InnerException != null)
					{
						ex_text += "\n\n" + ex.InnerException.InnerException.Message + "\n\n" + ex.InnerException.InnerException.StackTrace;
					}
				}

				SendErrorResponse("Exception: " + ex_text);
			}

			Response.End();
		}

		private bool CheckValues(GkvServerRequestDC req)
		{
			if (req == null)
				return false;
			if (req.Type == RequestType.Default)
				return false;
			if (string.IsNullOrWhiteSpace(req.Username))
				return false;
			if (string.IsNullOrWhiteSpace(req.Tenant))
				return false;

#if !DEBUG
			if (string.IsNullOrWhiteSpace(req.Password))
				return false;
#endif

			return true;
		}
		private bool TryLogin(GkvServerRequestDC req)
		{
			var server = AppRequestSender.GetServerFromTenant(req.Tenant);

			if (string.IsNullOrEmpty(server))
				return false;

			var loginurl = string.Format(LOGINSERVER_URL, $"https://{server}/service");

#if DEBUG
			if (server.IndexOf("localhost") >= 0)
				loginurl = string.Format(LOGINSERVER_URL, $"http://{server}/Host");
#endif

			bool successful;
			byte[] result;
			string result_str;

			try
			{
				using (WebClient client = new WebClient())
				{
					var nvc = new NameValueCollection();
					nvc.Add("password", req.Password);
					nvc.Add("username", req.Username);
					nvc.Add("tenant", req.Tenant);

					result = client.UploadValues(loginurl, "POST", nvc);
					result_str = Encoding.Default.GetString(result);
				}
			}
			catch (Exception e)
			{
				throw new GkvException($"loginurl: {loginurl} | " + e.ToString());
			}

			successful = Convert.ToBoolean(result_str);

			return successful;
		}

		private void SendNew(GkvServerSendNewRequestDC req)
		{
			// Response
			var res = new GkvServerSendNewResponseDC();

			res.GkvTransferProtokollDC = req.Protokoll;

			try
			{
				var finalpath = SaveFileInQueue(req);

				req.Protokoll.SentApp8Success = true;

				res.Success = true;
			}
			catch (GkvException e)
			{
				req.Protokoll.ResultType = GkvTransferResultType.FailSoft;
				req.Protokoll.Fehlerdatum = DateTime.Now;
				req.Protokoll.Fehlertitel = "App8 - Gkv";
				req.Protokoll.Fehlernachricht = e.Message;

				res.Message = e.Message;
			}
			catch (Exception e)
			{
				req.Protokoll.ResultType = GkvTransferResultType.FailSoft;
				req.Protokoll.Fehlerdatum = DateTime.Now;
				req.Protokoll.Fehlertitel = "App8";
				req.Protokoll.Fehlernachricht = e.Message;

				res.Message = e.Message;
			}

			SendResponse(res);
		}
		private void GetIK(GkvServerGetIKRequestDC req)
		{
			var ktd_reader = new DakotaKTDReader(KostentragerdateiFolderPath);

			var resolved = ktd_reader.Resolve(req.IKKrankenkasse, req.Abrechnungscode, req.Tarifkennzeichen);

			var response = new GkvServerGetIKResponseDC(true)
			{
				Gefunden = resolved is object
			};

			if (response.Gefunden)
			{
				response.IKDatenannahmestelle = resolved.IKDatenannahmestelle;
				response.IKKostentrager = resolved.IKKostentrager;
				response.IKKrankenkasse = resolved.IKKrankenkasse;
				response.BezDatenannahmestelle = resolved.BezDatenannahmestelle;
				response.Hausanschrift = resolved.Hausanschrift;
				response.PostfachGKanschrift = resolved.PostfachGKanschrift;
				response.Papierannahmeanschrift = resolved.Papierannahmeanschrift;
			}

			SendResponse(response);
		}
		private void GetStatus(GkvServerGetStatusRequestDC req)
		{
			var response = new GkvServerGetStatusResponseDC(false);

			var tuple_count = req.Oids.Length;

			response.Results = new GkvServerResultDC[tuple_count];

			try
			{
				// Load XML Info
				var results = GetResultFile(req.Tenant);

				if (results is object)
					for (int i = 0; i < tuple_count; i++)
					{
						var gkv_transfer_oid = req.Oids[i];

						if (results.TryGetValue(gkv_transfer_oid, out var fehlerDC))
						{
							response.Results[i] = fehlerDC;
						}
					}

				ClearResultFolder(req.Tenant, req.Oids);

				response.Success = true;
			}
			catch (GkvException e)
			{
				response.Message = e.Message;
			}
			catch (Exception e)
			{
				response.Message = e.ToString();
			}

			SendResponse(response);

			return;
		}
		private void GetNumber(GkvServerGetNumberRequestDC req)
		{
			var response = new GkvServerGetNumberResponseDC(false);

			var path = ConfigurationManager.AppSettings.Get("GkvAbrechnungRootPath");
			var filePath = Path.Combine(path, "numbers.json");
			var manager = new DakotaNumberManager(filePath);

			(response.Datenaustauschreferenz, response.Transfernummer)
				= manager.GetNextNumber(req.IKDatenannahmestelle, req.NewDatenaustauschRef);

			response.Success = true;

			SendResponse(response);

			return;
		}

		private string SaveFileInQueue(GkvServerSendNewRequestDC req)
		{
			string root_path = QueueFolderPath;
			string file_path = string.Format("{0}_{1}_{2}_{3}_{4}", 
				req.Tenant, req.ApplicationUserOid, req.Protokoll_Oid, req.Datenannahmestelle, req.Transfername);

			Directory.CreateDirectory(root_path);

			var finalpath = root_path + file_path;
			var encoding = Encoding.GetEncoding("ISO-8859-1");

			var nutzdatendatei_encoded = encoding.GetBytes(req.Nutzdatendatei);
			File.WriteAllBytes(finalpath, nutzdatendatei_encoded);

			var auftragsdatei_encoded = Encoding.GetEncoding("ISO-8859-1").GetBytes(req.Auftragsdatei);
			File.WriteAllBytes(finalpath + ".auf", auftragsdatei_encoded);

			return finalpath;
		}

		private void ClearResultFolder(string tenant, long[] oids)
		{
			var folder = new DirectoryInfo(Path.Combine(ResultFolderPath, tenant));

			if (!folder.Exists)
				return;

			foreach (var file in folder.GetFiles())
			{
				var xml_obj = GkvServerResultXml.GetResultXml(file.FullName);

				if (xml_obj is GkvServerResultXml xml && oids.Contains(xml.ProtokollOid))
					continue;

				file.Delete();
			}
		}
		private Dictionary<long, GkvServerResultDC> GetResultFile(string tenant)
		{
			try
			{
				var path = ResultFolderPath;

				if (string.IsNullOrWhiteSpace(path))
					throw new GkvException("Config GkvAbrechnungResultFolderPath is empty or whitespace");

				if (string.IsNullOrWhiteSpace(tenant))
					throw new GkvException("Tenant is empty or whitespace");

				var folder = new DirectoryInfo(Path.Combine(path, tenant));

				if (!folder.Exists)
				{
					return null;
				}

				var dict = new Dictionary<long, GkvServerResultDC>();
				foreach (var file in folder.GetFiles("*.xml"))
				{
					var xml = GkvServerResultXml.GetResultXml(file.FullName);

					if (xml is null)
						continue;

					dict.Add(xml.ProtokollOid, GkvServerResultXml.ToDC(xml));
				}
				return dict;
			}
			catch (GkvException e)
			{
				throw e;
			}
			catch (Exception e)
			{
				throw new GkvException("App8 Server Error: " + e.ToString());
			}
		}

		private void SendInvalidInputResponse() => SendErrorResponse(INVALID_INPUT);
		private void SendErrorResponse(string message)
		{
			var response = new GkvResponseDC(false, message);

			Thread.Sleep(WAIT_BEFORE_ERROR_MS);

			SendResponse(GkvSender.SerializeResponse(response));
		}
		private void SendResponse(GkvResponseDC res) => SendResponse(GkvSender.SerializeResponse(res));
		private void SendResponse(string str)
		{
			Response.Write(str);

			Response.End();
		}
	}
}