362 lines
9.2 KiB
C#
362 lines
9.2 KiB
C#
using BS.Shared;
|
|
using BS.Shared.AppSender;
|
|
using BS.Shared.DataContracts;
|
|
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" + ex.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.Postfachanschrift = resolved.Postfachanschrift;
|
|
response.Grosskundenanschrift = resolved.Grosskundenanschrift;
|
|
}
|
|
|
|
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);
|
|
|
|
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;
|
|
|
|
File.WriteAllText(finalpath, req.Nutzdatendatei);
|
|
|
|
var auftragsdatei2 = Encoding.GetEncoding("ISO-8859-1").GetBytes(req.Auftragsdatei);
|
|
|
|
File.WriteAllBytes(finalpath + ".auf", auftragsdatei2);
|
|
|
|
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();
|
|
}
|
|
}
|
|
} |