394 lines
13 KiB
C#
394 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Security;
|
|
using BeWo.Service.Plugins;
|
|
using BS.Shared;
|
|
using BS.Shared.Core;
|
|
using BS.Shared.DataContracts;
|
|
|
|
using BeWo.Data;
|
|
using BeWo.Report;
|
|
using BeWo.Service.Security;
|
|
|
|
using DevExpress.XtraPrinting;
|
|
using DevExpress.XtraReports.UI;
|
|
|
|
using Page = System.Web.UI.Page;
|
|
using System.Text;
|
|
using Newtonsoft.Json;
|
|
using BS.Shared.DataContracts.GkvAbrechnung;
|
|
using System.Net;
|
|
using System.Collections.Specialized;
|
|
using BeWo.Data.Access;
|
|
using BeWo.Service.DCEntityMapper;
|
|
using BeWo.Data.Entities;
|
|
using BS.Shared.Extensions;
|
|
using System.Threading;
|
|
using System.Configuration;
|
|
using Dakota.Models;
|
|
using System.Xml;
|
|
using System.Xml.Linq;
|
|
using System.Diagnostics;
|
|
using System.Xml.Serialization;
|
|
using Dakota.Logic;
|
|
|
|
namespace Host
|
|
{
|
|
public partial class GkvAbrechnungView : Page
|
|
{
|
|
public const int PROCESS_WAITFOREXIT_MS = 10 * 1000;
|
|
|
|
private string GETSERVER_URL = "https://support.bewoplaner.de/api/getserver.php?k={0}&t=0";
|
|
private string LOGINSERVER_URL = "{0}/Login.aspx";
|
|
|
|
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 GkvApp8Request GkvRequest { get; set; }
|
|
|
|
protected void Page_Load(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
//https://app8.bewoplaner.de/Host/GkvAbrechungview?tenant=12345
|
|
|
|
var str = new StreamReader(Request.InputStream).ReadToEnd();
|
|
|
|
if (string.IsNullOrEmpty(str))
|
|
SendErrorResponse("Ungültige Eingabe");
|
|
|
|
GkvRequest = JsonConvert.DeserializeObject<GkvApp8Request>(str);
|
|
|
|
if (!CheckValues())
|
|
SendErrorResponse("Check Fehlgeschlagen");
|
|
|
|
if (!TryLogin())
|
|
SendErrorResponse("Login Fehlgeschlagen");
|
|
|
|
switch (GkvRequest.Type)
|
|
{
|
|
case GkvAbrechnungApp8RequestTypeDC.SendNew:
|
|
SendNew(JsonConvert.DeserializeObject<GkvApp8SendNewRequest>(str));
|
|
return;
|
|
case GkvAbrechnungApp8RequestTypeDC.GetStatus:
|
|
GetStatus(JsonConvert.DeserializeObject<GkvApp8GetStatusRequest>(str));
|
|
return;
|
|
case GkvAbrechnungApp8RequestTypeDC.GetIKNumber:
|
|
GetIK(JsonConvert.DeserializeObject<GkvApp8GetIKRequest>(str));
|
|
return;
|
|
default:
|
|
SendErrorResponse("GkvAbrechnungType unbekannt.");
|
|
return;
|
|
}
|
|
|
|
SendErrorResponse("Unbekannter Fehler");
|
|
}
|
|
catch (ThreadAbortException eee)
|
|
{
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var ex_text = ex.Message + "\n" + ex.StackTrace;
|
|
SendErrorResponse(ex_text);
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void SendErrorResponse(string message)
|
|
{
|
|
var response = new GkvApp8Response();
|
|
|
|
response.Success = false;
|
|
response.Message = message;
|
|
|
|
SendResponse(JsonConvert.SerializeObject(response));
|
|
}
|
|
private void SendResponse(object res) => SendResponse(JsonConvert.SerializeObject(res));
|
|
private void SendResponse(string str)
|
|
{
|
|
Response.Write(str);
|
|
|
|
Response.End();
|
|
//Context.ApplicationInstance.CompleteRequest();
|
|
}
|
|
|
|
private bool CheckValues() => CheckValues(GkvRequest);
|
|
private bool CheckValues(GkvApp8Request request)
|
|
{
|
|
if (request == null)
|
|
return false;
|
|
if (request.Type == GkvAbrechnungApp8RequestTypeDC.Default)
|
|
return false;
|
|
if (string.IsNullOrWhiteSpace(request.Username))
|
|
return false;
|
|
if (string.IsNullOrWhiteSpace(request.Tenant))
|
|
return false;
|
|
if (string.IsNullOrWhiteSpace(request.Password))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
private bool TryLogin() => TryLogin(GkvRequest);
|
|
private bool TryLogin(GkvApp8Request gkv_request)
|
|
{
|
|
if (gkv_request.Tenant == "demo" && gkv_request.Username == "demo" && gkv_request.DebugMode == "fozc4897b6ztvf978AFCRRG244fvFV2532fvf324AF")
|
|
{
|
|
gkv_request.Tenant = "7375324044";
|
|
return true;
|
|
}
|
|
|
|
var server = GetServerFromTenant(gkv_request.Tenant);
|
|
var loginurl = string.Format(LOGINSERVER_URL, $"https://{server}/service");
|
|
|
|
#if DEBUG
|
|
//loginurl = string.Format(LOGINSERVER_URL, "https://app4.bewoplaner.de");
|
|
loginurl = string.Format(LOGINSERVER_URL, "http://localhost:3777/Host");
|
|
#endif
|
|
|
|
bool successful = false;
|
|
|
|
try
|
|
{
|
|
using (WebClient client = new WebClient())
|
|
{
|
|
var nvc = new NameValueCollection();
|
|
nvc.Add("password", gkv_request.Password);
|
|
nvc.Add("username", gkv_request.Username);
|
|
nvc.Add("tenant", gkv_request.Tenant);
|
|
|
|
var loginresponse = client.UploadValues(loginurl, "POST", nvc);
|
|
|
|
successful = BitConverter.ToBoolean(loginresponse, 0);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new DakotaException($"loginurl: {loginurl} | " + e.ToString());
|
|
}
|
|
|
|
return successful;
|
|
}
|
|
|
|
private void SendNew(GkvApp8SendNewRequest req)
|
|
{
|
|
// Response
|
|
var response = new GkvApp8SendNewResponse(false);
|
|
|
|
var protokoll = req.GkvTransferProtokoll;
|
|
|
|
try
|
|
{
|
|
SaveFileInFileSystem(req, true);
|
|
|
|
req.GkvTransferProtokoll.SentSuccess = true;
|
|
|
|
response.Success = true;
|
|
}
|
|
catch (DakotaException e)
|
|
{
|
|
protokoll.Fehlerdatum = DateTime.Now;
|
|
protokoll.Fehlerlevel = GkvTransferFehlerlevel.Soft;
|
|
protokoll.Fehlertitel = "App8";
|
|
protokoll.Fehlernachricht = e.Message;
|
|
|
|
response.Message = e.Message;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
protokoll.Fehlerdatum = DateTime.Now;
|
|
protokoll.Fehlerlevel = GkvTransferFehlerlevel.Soft;
|
|
protokoll.Fehlertitel = "App8";
|
|
protokoll.Fehlernachricht = e.Message;
|
|
|
|
response.Message = e.Message;
|
|
}
|
|
|
|
response.GkvTransferProtokollDC = protokoll;
|
|
|
|
SendResponse(response);
|
|
}
|
|
private void GetStatus(GkvApp8GetStatusRequest req)
|
|
{
|
|
var response = new GkvApp8GetStatusResponse(false);
|
|
|
|
var tuple_count = req.Oids.Length;
|
|
|
|
response.Fehler = new GkvApp8FehlerDC[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.Fehler[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 void GetIK(GkvApp8GetIKRequest req)
|
|
{
|
|
var ktd_reader = new DakotaKTDReader(KostentragerdateiFolderPath);
|
|
|
|
var resolved = ktd_reader.Resolve(req.IKKrankenkasse, req.Abrechnungscode, req.Tarifkennzeichen);
|
|
|
|
var response = new GkvApp8GetIKResponse();
|
|
|
|
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 string SaveFileInFileSystem(GkvApp8SendNewRequest req, bool debug_mode = false)
|
|
=> SaveFileInFileSystem(req.GkvTransferProtokoll.GkvTransferProtokollOid.Value, GkvRequest.Tenant, req.GkvTransferProtokoll.IKDatenannahmestelle, req.GkvTransferProtokoll.Transfername,
|
|
req.GkvTransferProtokoll.Nutzdatendatei, req.GkvTransferProtokoll.Auftragsdatei, debug_mode);
|
|
private string SaveFileInFileSystem(long protokoll_oid, string tenant, string datenannahmestelle, string transfername, string nutzdaten, string auftragsdatei, bool debug_mode = false)
|
|
{
|
|
string root_path;
|
|
string file_path;
|
|
if (debug_mode)
|
|
{
|
|
root_path = QueueFolderPath;
|
|
file_path = $@"{tenant}_{protokoll_oid}_{datenannahmestelle}_{transfername}";
|
|
}
|
|
else
|
|
{
|
|
throw new DakotaException("No Debugmode impl");
|
|
//root_path = $@"C:\GkvAbrechnung\{tenant}\{datenannahmestelle}\";
|
|
//file_path = $@"{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)
|
|
{
|
|
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 = GkvApp8FehlerXml.GetFehlerXml(file.FullName);
|
|
|
|
if (xml_obj is GkvApp8FehlerXml xml && oids.Contains(xml.Oid))
|
|
continue;
|
|
|
|
file.Delete();
|
|
}
|
|
}
|
|
private Dictionary<long, GkvApp8FehlerDC> GetResultFile(string tenant)
|
|
{
|
|
try
|
|
{
|
|
var path = ResultFolderPath;
|
|
|
|
if (string.IsNullOrWhiteSpace(path))
|
|
throw new DakotaException("Config GkvAbrechnungResultFolderPath is empty or whitespace");
|
|
|
|
if (string.IsNullOrWhiteSpace(tenant))
|
|
throw new DakotaException("Tenant is empty or whitespace");
|
|
|
|
var folder = new DirectoryInfo(Path.Combine(path, tenant));
|
|
|
|
if (!folder.Exists)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var dict = new Dictionary<long, GkvApp8FehlerDC>();
|
|
foreach (var file in folder.GetFiles("*.xml"))
|
|
{
|
|
var xml = GkvApp8FehlerXml.GetFehlerXml(file.FullName);
|
|
|
|
if (xml is null)
|
|
continue;
|
|
|
|
dict.Add(xml.Oid, GkvApp8FehlerXml.ToDC(xml));
|
|
}
|
|
return dict;
|
|
}
|
|
catch (DakotaException e)
|
|
{
|
|
throw e;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new DakotaException("App8 Server Error: " + e.ToString());
|
|
}
|
|
}
|
|
}
|
|
} |