369 lines
9.3 KiB
C#
369 lines
9.3 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
|
|
{
|
|
public partial class GkvAbrechnungServer : Page
|
|
{
|
|
public const int PROCESS_WAITFOREXIT_MS = 10 * 1000;
|
|
|
|
private readonly string GETSERVER_URL = "https://support.bewoplaner.de/api/getserver.php?k={0}&t=0";
|
|
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");
|
|
|
|
public GkvRequestDC GkvRequest { get; set; }
|
|
|
|
protected void Page_Load(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
//https://app8.bewoplaner.de/Host/GkvAbrechungServer?tenant=12345
|
|
|
|
var str = new StreamReader(Request.InputStream).ReadToEnd();
|
|
|
|
GkvRequest = GkvSender.DeserializeRequest<GkvRequestDC>(str, SendInvalidInputResponse);
|
|
|
|
if (!CheckValues(GkvRequest))
|
|
SendErrorResponse("Check Fehlgeschlagen");
|
|
|
|
if (!TryLogin(GkvRequest))
|
|
SendErrorResponse("Login Fehlgeschlagen");
|
|
|
|
switch (GkvRequest.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(JsonConvert.DeserializeObject<GkvServerGetStatusRequestDC>(str));
|
|
return;
|
|
|
|
default:
|
|
SendErrorResponse("RequestType unbekannt.");
|
|
return;
|
|
}
|
|
}
|
|
catch (ThreadAbortException eee)
|
|
{
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var ex_text = ex.Message + "\n" + ex.StackTrace;
|
|
SendErrorResponse(ex_text);
|
|
}
|
|
}
|
|
|
|
private bool CheckValues(GkvRequestDC 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(request.Password))
|
|
return false;
|
|
#endif
|
|
|
|
return true;
|
|
}
|
|
private bool TryLogin(GkvRequestDC req)
|
|
{
|
|
var server = 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 response = new GkvServerSendNewResponseDC(false);
|
|
|
|
var protokoll = req.GkvTransferProtokoll;
|
|
|
|
try
|
|
{
|
|
var finalpath = SaveFileInFileSystem(req);
|
|
|
|
req.GkvTransferProtokoll.SentApp8Success = true;
|
|
|
|
response.Success = true;
|
|
}
|
|
catch (GkvException e)
|
|
{
|
|
protokoll.ResultType = GkvTransferResultType.Soft;
|
|
protokoll.Fehlerdatum = DateTime.Now;
|
|
protokoll.Fehlertitel = "App8";
|
|
protokoll.Fehlernachricht = e.Message;
|
|
|
|
response.Message = e.Message;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
protokoll.ResultType = GkvTransferResultType.Soft;
|
|
protokoll.Fehlerdatum = DateTime.Now;
|
|
protokoll.Fehlertitel = "App8";
|
|
protokoll.Fehlernachricht = e.Message;
|
|
|
|
response.Message = e.Message;
|
|
}
|
|
|
|
response.GkvTransferProtokollDC = protokoll;
|
|
|
|
SendResponse(response);
|
|
}
|
|
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();
|
|
|
|
response.Success = true;
|
|
response.Gefunden = resolved is object;
|
|
|
|
if (response.Gefunden)
|
|
{
|
|
response.IKDatenannahmestelle = resolved.Item1;
|
|
response.IKKostentrager = resolved.Item2;
|
|
response.IKKrankenkasse = resolved.Item3;
|
|
response.BezDatenannahmestelle = resolved.Item4;
|
|
}
|
|
|
|
SendResponse(response);
|
|
}
|
|
private void GetStatus(GkvServerGetStatusRequestDC req)
|
|
{
|
|
var response = new GkvServerGetStatusResponseDC(false);
|
|
|
|
var tuple_count = req.Oids.Length;
|
|
|
|
response.Result = new GkvApp8ResultDC[tuple_count];
|
|
|
|
try
|
|
{
|
|
// Load XML Info
|
|
var results = GetResultFile(GkvRequest.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.Result[i] = fehlerDC;
|
|
}
|
|
}
|
|
|
|
ClearResultFolder(GkvRequest.Tenant, req.Oids);
|
|
|
|
response.Success = true;
|
|
}
|
|
catch (DakotaException e)
|
|
{
|
|
response.Message = e.Message;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
response.Message = e.ToString();
|
|
}
|
|
|
|
SendResponse(response);
|
|
|
|
return;
|
|
}
|
|
|
|
private string SaveFileInFileSystem(GkvServerSendNewRequestDC req)
|
|
=> SaveFileInFileSystem(req.GkvTransferProtokoll.GkvTransferProtokollOid.Value, GkvRequest.Tenant, req.GkvTransferProtokoll.IKDatenannahmestelle, req.GkvTransferProtokoll.Transfername,
|
|
req.GkvTransferProtokoll.Nutzdatendatei, req.GkvTransferProtokoll.Auftragsdatei);
|
|
private string SaveFileInFileSystem(long protokoll_oid, string tenant, string datenannahmestelle, string transfername, string nutzdaten, string auftragsdatei)
|
|
{
|
|
string root_path = QueueFolderPath;
|
|
string file_path = $@"{tenant}_{protokoll_oid}_{datenannahmestelle}_{transfername}";
|
|
|
|
Directory.CreateDirectory(root_path);
|
|
|
|
var finalpath = root_path + file_path;
|
|
|
|
return SaveFileInFileSystem(finalpath, nutzdaten, auftragsdatei);
|
|
}
|
|
private string SaveFileInFileSystem(string finalpath, string nutzdaten, string auftragsdatei)
|
|
{
|
|
File.WriteAllText(finalpath, nutzdaten);
|
|
|
|
var auftragsdatei2 = Encoding.GetEncoding("ISO-8859-1").GetBytes(auftragsdatei);
|
|
|
|
File.WriteAllBytes(finalpath + ".auf", auftragsdatei2);
|
|
|
|
return finalpath;
|
|
}
|
|
|
|
private string GetServerFromTenant(string tenant)
|
|
{
|
|
#if DEBUG
|
|
// return "localhost:3777";
|
|
#endif
|
|
try
|
|
{
|
|
String url = String.Format(GETSERVER_URL, tenant);
|
|
using (WebClient client = new WebClient())
|
|
{
|
|
//MessageBox.Show(hostAddress);
|
|
byte[] response = client.UploadValues(url, "POST", new NameValueCollection());
|
|
|
|
String server = System.Text.Encoding.ASCII.GetString(response);
|
|
|
|
return server;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
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.Oid))
|
|
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.Oid, GkvServerResultXml.ToDC(xml));
|
|
}
|
|
return dict;
|
|
}
|
|
catch (GkvException e)
|
|
{
|
|
throw e;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new GkvException("App8 Server Error: " + e.ToString());
|
|
}
|
|
}
|
|
|
|
|
|
private void Sleep() => Thread.Sleep(5000);
|
|
|
|
private void SendInvalidInputResponse() => SendErrorResponse(INVALID_INPUT);
|
|
private void SendErrorResponse(string message)
|
|
{
|
|
var response = new GkvResponseDC(false, message);
|
|
|
|
Sleep();
|
|
|
|
SendResponse(GkvSender.SerializeResponse(response));
|
|
}
|
|
private void SendResponse(GkvResponseDC res) => SendResponse(GkvSender.SerializeResponse(res));
|
|
private void SendResponse(string str)
|
|
{
|
|
Response.Write(str);
|
|
|
|
Response.End();
|
|
}
|
|
}
|
|
} |