using API_NetFramework.Models;
using CSVNET;
using Database;
using DOCGEN;
using DOCGEN.Klassen;
using edoka_dms;
using Helper;
using Logging;
using Microsoft.Ajax.Utilities;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.SqlServer.Server;
using Model;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using SecuringWebApiUsingApiKey.Middleware;
using Swashbuckle.Swagger;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Mime;
using System.Runtime.CompilerServices;
using System.Runtime.Remoting.Messaging;
using System.Security.Cryptography;
using System.Security.Policy;
using System.Text;
using System.Threading;
using System.Web;
using System.Web.Http;
using System.Web.UI.WebControls;


namespace API_NetFramework.Controllers
{
    /// <summary>
    /// 
    /// </summary>
    /// <remarks></remarks>
    /// 
    public class ILResponse
    {
        public int StatusCode;
        public int senderror { get; set; } = 0;
        public string response { get; set; } = "";
    }



    public enum uploadtype
    {
        fast = 1,
        slow = 2,
        docupload = 3,
        revision = 4

    }

    public class ArchivController : ApiController
    {
        // GET: OnBase
        string tokenfunction = "Archiv";
        string connectionstring = StringCipher.Decrypt(ConfigurationManager.ConnectionStrings["EDOKAConnectionstring"].ConnectionString, "i%!k!7pab%bNLdA5hE4pkR4XaB%E^jB3d9tHuQ4pbF&BZjF7SB#WBWit5#HrbJiLrLVm");
        private void Update_IL_Log(ref ILResponse ilr, string dokumentid)
        {
            APILogging.Log((HttpRequestMessage)Request, "Start Update IL_Log: DokumentID:" + dokumentid, LogLevelType.Debug);

            DB dB = new DB(StringCipher.Decrypt(ConfigurationManager.ConnectionStrings["JournalConnectionstring"].ConnectionString, "i%!k!7pab%bNLdA5hE4pkR4XaB%E^jB3d9tHuQ4pbF&BZjF7SB#WBWit5#HrbJiLrLVm"));
            string sql = "Insert OnDoc_IL_Log (dokumentid, ilresponse,error, erstellt_am) values ('" + dokumentid + "',";
            sql = sql + "'" + ilr.response.ToString() + "',";
            if (ilr.senderror != 0) { sql = sql + "1,"; } else { sql = sql + "0,"; }
            sql = sql + "getdate() )";
            dB.Exec_SQL(sql);
            dB = null;
            APILogging.Log((HttpRequestMessage)Request, "Ende Update IL_Log: DokumentID:" + dokumentid, LogLevelType.Debug);
        }

        private void update_dokumentstatus(string dokumentid)
        {
            DB db = new DB(connectionstring);
            db.dokument_abschliessen(dokumentid);
            db = null;
        }

        /// <summary>
        /// CheckDocID prüft auf eine vorhandene DokumentID in OnDoc (DokumentID OFFEDK... / Barcode-Klenber-Nr)
        /// </summary>
        /// <param name="DokumentID"></param>
        /// <returns>
        /// 200: OK 
        /// </returns>
        /// <remarks></remarks>
        [HttpGet]
        [Route("API/CheckDocID")]

        public IHttpActionResult CheckDocID(string DokumentID)
        {
            if (SecuringWebApiUsingApiKey.Middleware.ApiKeyMiddleware.Authorized((HttpRequestMessage)Request, tokenfunction) == false)
            {
                return Content(HttpStatusCode.Unauthorized, "Invalid Token or API-Key");
            }
            try
            {
                APILogging.Log((HttpRequestMessage)Request, "Start Check DokumentID: DokumentID:" + DokumentID, LogLevelType.Debug);
                Database.DB db = new Database.DB(connectionstring);
                //db.Get_Tabledata("Select * from dokument where dokumentid = '" + DokumentID + "'", false, true);

                string SQL = "Select * from dokument where dokumentid = @DokumentID";
                db.clear_parameter();
                db.add_parameter("@DokumentID", DokumentID);
                db.Get_Tabledata_Addvar(SQL, false, true);
                if (db.dsdaten.Tables[0].Rows.Count > 0)
                {
                    return Ok(DokumentID);
                }
                //                db.Get_Tabledata("Select barcodenr from barcodeetikette where dokumentid='" + DokumentID + "'", false, true);
                SQL = "Select barcodenr from barcodeetikette where dokumentid=@DokumentID";
                db.clear_parameter();
                db.add_parameter("@DokumentID", DokumentID);
                db.Get_Tabledata_Addvar(SQL, false, true);

                if (db.dsdaten.Tables[0].Rows.Count > 0)
                {
                    return Ok(DokumentID);
                }
                APILogging.Log((HttpRequestMessage)Request, "Ende Check DokumentID: DokumentID:" + DokumentID, LogLevelType.Debug);

                return Content(HttpStatusCode.NotFound, DokumentID);
            }
            catch (Exception e)
            {
                APILogging.Log((HttpRequestMessage)Request, e.Message, LogLevelType.Error);
                return Content(HttpStatusCode.InternalServerError, e.Message);
            }



        }
        /// <summary>
        /// Archiviert das Dokument aus OnDoc in OnBase
        /// </summary>
        /// <param name="DokumentID"></param>
        /// <returns>
        /// Returncode: 200 (OK)
        /// Dokumenthandle aus OnBase
        /// </returns>
        /// <remarks></remarks>
        [HttpGet]
        [Route("API/ArchiveDocFromDatabase")]

        public IHttpActionResult ArchivDocFromDatabase(string DokumentID, string pdfdoc = "", string force = "")
        {
            if (SecuringWebApiUsingApiKey.Middleware.ApiKeyMiddleware.Authorized((HttpRequestMessage)Request, tokenfunction) == false)
            {
                return Content(HttpStatusCode.Unauthorized, "Invalid Token or API-Key");
            }
            string ArchivAktiv;
            ArchivAktiv = System.Configuration.ConfigurationManager.AppSettings["ArchivierungAktiv"].ToString();
            if (ArchivAktiv != "True")
            {
                string message = "Hinweismeldung: " + System.Configuration.ConfigurationManager.AppSettings["ArchivierungNoAktivMessage"].ToString();
                return Content(HttpStatusCode.OK, message);
            }
            try
            {

                string doktypnr = "";
                string extension = "";
                APILogging.Log((HttpRequestMessage)Request, "Start ArchiveDocFromDatabase: DokumentID:" + DokumentID, LogLevelType.Debug);
                DB db = new DB(connectionstring);
                //db.Get_Tabledata("Select dokumenttypnr, dokumentname from dokument where dokumentid='" + DokumentID + "'", false, true);

                string SQL = "Select dokumenttypnr, dokumentname from dokument where dokumentid=@DokumentID";
                db.clear_parameter();
                db.add_parameter("@DokumentID", DokumentID);
                db.Get_Tabledata_Addvar(SQL, false, true);

                extension = System.IO.Path.GetExtension(db.dsdaten.Tables[0].Rows[0]["dokumentname"].ToString());
                doktypnr = db.dsdaten.Tables[0].Rows[0][0].ToString();
                //db.Get_Tabledata("Select erstellunginoffice from dokumenttyp where dokumenttypnr="+doktypnr.ToString(), false, true);

                SQL = "Select erstellunginoffice from dokumenttyp where dokumenttypnr=@doktypnr";
                db.add_parameter("@doktypnr", doktypnr);
                db.Get_Tabledata_Addvar(SQL, false, true);
               
                if (force=="TRUE")
                {
                    db.dsdaten.Tables[0].Rows[0]["Erstellunginoffice"] = false;
                }
                if (Convert.ToBoolean(db.dsdaten.Tables[0].Rows[0]["Erstellunginoffice"]))
                {
                    APILogging.Log((HttpRequestMessage)Request, DokumentID + " ErstellungInOffec - EDKB02DMS", LogLevelType.Debug);

                    db.clear_parameter();
                    db.add_parameter("@dokumentid", DokumentID);
                    if (DokumentID.Contains("OFFEDK008"))
                    {
                        db.add_parameter("@ondocdoc", "1");
                    }
                    db.Get_Tabledata("[OnDoc_IRIS_Archivierung]", true, false);
                    string returnmessage = db.dsdaten.Tables[0].Rows[0][0].ToString();
                    switch (db.dsdaten.Tables[0].Rows[0][1].ToString())
                    {
                        case "1":
                            APILogging.Log((HttpRequestMessage)Request, DokumentID + " Image des Dokuments nicht vorhanden", LogLevelType.Error);
                            return Content(HttpStatusCode.NotFound, DokumentID);
                            break;
                        case "2":
                            APILogging.Log((HttpRequestMessage)Request, DokumentID + " nicht vorhanden", LogLevelType.Error);
                            return Content(HttpStatusCode.NotFound, DokumentID);
                            break;
                        case "3":
                            APILogging.Log((HttpRequestMessage)Request, db.dsdaten.Tables[0].Rows[0][0].ToString() + DokumentID, LogLevelType.Debug);
                            return Content(HttpStatusCode.OK, returnmessage);
                        case "0":
                            return (ArchivDocFromDatabase(DokumentID));
                        case "4":
                            APILogging.Log((HttpRequestMessage)Request, "Dokumentarchivierung via EDKB02_DMS ausgelöst" + DokumentID, LogLevelType.Info);
                            break;
                        case "5":
                            APILogging.Log((HttpRequestMessage)Request, "Dokument bereit zur Ausgangsarchivierung" + DokumentID, LogLevelType.Info);
                            break;
                        case "6":
                            APILogging.Log((HttpRequestMessage)Request, "Dokument in EDOKA abgeschlossen" + DokumentID, LogLevelType.Info);
                            break;

                        default:
                            break;
                    }
                    ;
                    return Content(HttpStatusCode.OK, DokumentID + " archiviert");
                }




                db.clear_parameter();
                db.add_parameter("@dokumentid", DokumentID);
                db.Get_Tabledata("[sp_Get_OnDoc_Parameters]", true, false);

                bool revisionupload = false;
                string revisionhandle = "";
                foreach (System.Data.DataRow dr in db.dsdaten.Tables[1].Rows)
                {
                    if (dr[0].ToString() == "Handle" && dr[1].ToString() != "")
                    {
                        revisionhandle = dr[1].ToString();
                        revisionupload = true;
                    }
                }

                OnBaseDocUpload.OnBaseDokument onbasedoc = new OnBaseDocUpload.OnBaseDokument();
                OnBaseDocUpload.OnBaseDokument_Revision onbasedoc_revision = new OnBaseDocUpload.OnBaseDokument_Revision();

                DocGet dg = new DocGet(connectionstring);
                clsdok dok = new clsdok("", "", "", "");

                string[] officeformat = System.Configuration.ConfigurationManager.AppSettings["ArchivierungOfficeFormat"].ToString().Split(',');
                string[] excelconvert = System.Configuration.ConfigurationManager.AppSettings["ExcelDokType"].ToString().Split(',');
                string excelvaluefile = System.Configuration.ConfigurationManager.AppSettings["ExcelValueFile"].ToString();
                if (excelconvert.Contains(doktypnr))
                {
                    var settings = new CSVSettings()
                    {
                        FieldDelimiter = ';',
                        TextQualifier = '\'',
                        ForceQualifiers = true
                    };
                    DataTable dt = CSVDataTable.FromFile(excelvaluefile, settings);
                    DataTable dt1 = dt.Copy();
                    dt1.Rows.Clear();
                    foreach (System.Data.DataRow dr in dt.Rows)
                    {
                        if (dr[0].ToString() == doktypnr.ToString()) { dt1.ImportRow(dr); }
                    }
                    dt.Dispose();
                    dt1.Columns.Add("value");


                    Excel_Reader reader = new Excel_Reader();
                    dok = dg.GetDoc(DokumentID);

                    DB db1 = new DB(connectionstring);
                    reader.get_valus_from_excel(ref dt1, dok.dokument);
                    foreach (System.Data.DataRow dr in dt1.Rows)
                    {
                        try
                        {
                            db1.clear_parameter();
                            db1.add_parameter("@dokumentid", DokumentID);
                            db1.add_parameter("@vorlagenfeldnr", dr["valuenr"].ToString());
                            db1.add_parameter("@value", dr["bezeichnung"].ToString() + ";" + dr["value"].ToString());
                            db1.Get_Tabledata("dbo.SP_Dokument_Information_Wert", true, false);
                        }
                        catch { }
                    }
                    db1 = null;
                    dt = null;
                    reader = null;
                    db.clear_parameter();
                    db.add_parameter("@dokumentid", DokumentID);
                    db.Get_Tabledata("[sp_Get_OnDoc_Parameters]", true, false);
                }
                if (officeformat.Contains(doktypnr) || extension.ToUpper() == "PDF")
                {
                    dg.GetDoc(DokumentID);
                    extension = extension.ToUpper().Replace(".", "");
                }
                else
                {

                    dok = dg.GetDocAsPDF(DokumentID);
                    extension = "PDF";
                }

                if (!revisionupload)
                {
                    if (db.dsdaten.Tables[0].Rows[0]["BpNummer"].ToString() == "")
                    {
                        onbasedoc.personNummer = db.dsdaten.Tables[0].Rows[0]["PersonNummer"].ToString();
                        onbasedoc.bpNummer = "";
                    }
                    else
                    {
                        onbasedoc.bpNummer = db.dsdaten.Tables[0].Rows[0]["BpNummer"].ToString();
                        onbasedoc.personNummer = "";
                    }
                    onbasedoc.dokumentDatum = db.dsdaten.Tables[0].Rows[0]["DokumentDatum"].ToString();
                    onbasedoc.dokumentTyp = db.dsdaten.Tables[0].Rows[0]["dokumenttyp"].ToString(); ;
                    onbasedoc.dateiTyp = extension;
                    var Attribute = new List<Model.OnBaseDocUpload.attribute>();
                    onbasedoc.attributes = new List<Model.OnBaseDocUpload.attribute>();
                    foreach (System.Data.DataRow rw in db.dsdaten.Tables[1].Rows)
                    {
                        OnBaseDocUpload.attribute na = new OnBaseDocUpload.attribute(rw["fieldname"].ToString(), rw["fieldvalue"].ToString());
                        onbasedoc.attributes.Add(na);
                    }
                    onbasedoc.dokumentDatei = dok.dokument;


                    if (pdfdoc != "")
                    {
                        onbasedoc.dokumentDatei = pdfdoc;
                    }
                }
                else
                {
                    onbasedoc_revision.dokumentHandle = revisionhandle;
                    onbasedoc_revision.dokumentTyp = db.dsdaten.Tables[0].Rows[0]["dokumenttyp"].ToString(); ;
                    onbasedoc_revision.dateiTyp = extension;
                    onbasedoc_revision.dokumentDatum = db.dsdaten.Tables[0].Rows[0]["DokumentDatum"].ToString();
                    var Attribute = new List<Model.OnBaseDocUpload.attribute>();
                    onbasedoc_revision.attributes = new List<Model.OnBaseDocUpload.attribute>();
                    onbasedoc_revision.comment = "";
                    foreach (System.Data.DataRow rw in db.dsdaten.Tables[1].Rows)
                    {
                        if (rw[0].ToString() != "Handle")
                        {
                            OnBaseDocUpload.attribute na = new OnBaseDocUpload.attribute(rw["fieldname"].ToString(), rw["fieldvalue"].ToString());
                            onbasedoc_revision.attributes.Add(na);
                        }
                    }
                    onbasedoc_revision.dokumentDatei = dok.dokument;
                    if (pdfdoc != "")
                    {
                        onbasedoc_revision.dokumentDatei = pdfdoc;
                    }

                }
                db = null;
                ILResponse ilr = new ILResponse();
                string debugfilename = System.Configuration.ConfigurationManager.AppSettings["JSONDebugPath"];
                string SendToOnBase = System.Configuration.ConfigurationManager.AppSettings["SendToOnBase"];
                string SendToFile = System.Configuration.ConfigurationManager.AppSettings["SendToFile"];
                string debugdir = System.Configuration.ConfigurationManager.AppSettings["DebugDir"];
                string jsonstring = "";
                if (!revisionupload)
                {
                    jsonstring = Newtonsoft.Json.JsonConvert.SerializeObject(onbasedoc);
                }
                else
                {
                    jsonstring = Newtonsoft.Json.JsonConvert.SerializeObject(onbasedoc_revision);
                }
                IHttpActionResult transferResult = null;
                if (SendToOnBase != "Yes")
                {
                    if (!revisionupload)
                    {
                        transferResult = Transfer_OnBase(uploadtype.fast, ref jsonstring, ref ilr);
                    }
                    else
                    {
                        transferResult = Transfer_OnBase(uploadtype.revision, ref jsonstring, ref ilr);
                    }
                    if (SendToFile == "Yes")
                    {
                        if (debugfilename != "")
                        {
                            debugfilename = debugfilename + DokumentID + ".json";
                            System.IO.File.WriteAllText(debugfilename, jsonstring);
                            debugfilename = debugfilename + ".pdf";
                            Helper.clsFileHelper fh = new Helper.clsFileHelper();
                            fh.SaveBase64ToFile(onbasedoc.dokumentDatei, debugfilename);
                            fh = null;
                        }
                    }
                }
                APILogging.Log((HttpRequestMessage)Request, "Ende ArchiveDocFromDatabase: DokumentID:" + DokumentID, LogLevelType.Debug);

                //Log nachführen
                Update_IL_Log(ref ilr, DokumentID);
                if (ilr.senderror == 1)
                {
                    return Content(HttpStatusCode.InternalServerError, ilr.response);
                }
                else
                {
                    update_dokumentstatus(DokumentID);
                    return Content(HttpStatusCode.OK, DokumentID + " archiviert");
                }
            }
            catch (Exception e)
            {
                APILogging.Log((HttpRequestMessage)Request, e.Message, LogLevelType.Error);
                return Content(HttpStatusCode.InternalServerError, e.Message);
            }
            finally
            {
            }
        }



        [HttpPost]
        [Route("API/ArchivDoc")]
        public IHttpActionResult ArchivDoc(string dokumentid)
        {
            if (SecuringWebApiUsingApiKey.Middleware.ApiKeyMiddleware.Authorized((HttpRequestMessage)Request, tokenfunction) == false)
            {
                return Content(HttpStatusCode.Unauthorized, "Invalid Token or API-Key");
            }
            string ArchivAktiv;
            ArchivAktiv = System.Configuration.ConfigurationManager.AppSettings["ArchivierungAktiv"].ToString();
            if (ArchivAktiv != "True")
            {
                string message = ArchivAktiv = System.Configuration.ConfigurationManager.AppSettings["ArchivierungNoAktivMessage"].ToString();
                return Content(HttpStatusCode.InternalServerError, message);
            }
            try
            {
                APILogging.Log((HttpRequestMessage)Request, "Start ArchivDocFromIRIS DokumentID: " + dokumentid, LogLevelType.Debug);

                if (dokumentid.Substring(0, 9).ToUpper() == "OFFEDK008")
                {
                    return (ArchivDocFromDatabase(dokumentid));
                }
                else
                {
                    DB db = new DB(connectionstring);
                    db.clear_parameter();
                    db.add_parameter("@dokumentid", dokumentid);

                    db.Get_Tabledata("[OnDoc_IRIS_Archivierung]", true, false);
                    string returnmessage = db.dsdaten.Tables[0].Rows[0][0].ToString();
                    switch (db.dsdaten.Tables[0].Rows[0][1].ToString())
                    {
                        case "1":
                            APILogging.Log((HttpRequestMessage)Request, dokumentid + " Image des Dokuments nicht vorhanden", LogLevelType.Error);
                            return Content(HttpStatusCode.NotFound, dokumentid);
                            break;
                        case "2":
                            APILogging.Log((HttpRequestMessage)Request, dokumentid + " nicht vorhanden", LogLevelType.Error);
                            return Content(HttpStatusCode.NotFound, dokumentid);
                            break;
                        case "3":
                            APILogging.Log((HttpRequestMessage)Request, db.dsdaten.Tables[0].Rows[0][0].ToString() + dokumentid, LogLevelType.Debug);
                            return Content(HttpStatusCode.OK, returnmessage);
                        case "0":
                            return (ArchivDocFromDatabase(dokumentid));
                        case "4":
                            APILogging.Log((HttpRequestMessage)Request, "Dokumentarchivierung von Iris ausgelöst" + dokumentid, LogLevelType.Info);
                            break;
                        case "5":
                            APILogging.Log((HttpRequestMessage)Request, "Dokument bereit zur Ausgangsarchivierung" + dokumentid, LogLevelType.Info);
                            break;
                        case "6":
                            APILogging.Log((HttpRequestMessage)Request, "Dokument in EDOKA abgeschlossen" + dokumentid, LogLevelType.Info);
                            break;

                        default:
                            break;
                    }
                    ;

                }


                APILogging.Log((HttpRequestMessage)Request, "Ende ArchivDocFromIRIS DokumentID:" + dokumentid, LogLevelType.Debug);
                return Ok(dokumentid);
            }
            catch (Exception e)
            {
                APILogging.Log((HttpRequestMessage)Request, e.Message, LogLevelType.Error);
                return Content(HttpStatusCode.InternalServerError, e.Message);
            }
        }


        [HttpPost]
        [Route("API/ArchivDocFromIRIS")]
        public IHttpActionResult ArchivDocFromIRIS(string dokumentid)
        {
            if (SecuringWebApiUsingApiKey.Middleware.ApiKeyMiddleware.Authorized((HttpRequestMessage)Request, tokenfunction) == false)
            {
                return Content(HttpStatusCode.Unauthorized, "Invalid Token or API-Key");
            }
            string ArchivAktiv;
            ArchivAktiv = System.Configuration.ConfigurationManager.AppSettings["ArchivierungAktiv"].ToString();
            if (ArchivAktiv != "True")
            {
                string message = ArchivAktiv = System.Configuration.ConfigurationManager.AppSettings["ArchivierungNoAktivMessage"].ToString();
                return Content(HttpStatusCode.InternalServerError, message);
            }
            try
            {
                APILogging.Log((HttpRequestMessage)Request, "Start ArchivDocFromIRIS DokumentID: " + dokumentid, LogLevelType.Debug);

                if (dokumentid.Substring(0, 9).ToUpper() == "OFFEDK008")
                {
                    return (ArchivDocFromDatabase(dokumentid));
                }
                else
                {
                    DB db = new DB(connectionstring);
                    db.clear_parameter();
                    db.add_parameter("@dokumentid", dokumentid);

                    db.Get_Tabledata("[OnDoc_IRIS_Archivierung]", true, false);
                    string returnmessage = db.dsdaten.Tables[0].Rows[0][0].ToString();
                    switch (db.dsdaten.Tables[0].Rows[0][1].ToString())
                    {
                        case "1":
                            APILogging.Log((HttpRequestMessage)Request, dokumentid + " Image des Dokuments nicht vorhanden", LogLevelType.Error);
                            return Content(HttpStatusCode.NotFound, dokumentid);
                            break;
                        case "2":
                            APILogging.Log((HttpRequestMessage)Request, dokumentid + " nicht vorhanden", LogLevelType.Error);
                            return Content(HttpStatusCode.NotFound, dokumentid);
                            break;
                        case "3":
                            APILogging.Log((HttpRequestMessage)Request, db.dsdaten.Tables[0].Rows[0][0].ToString() + dokumentid, LogLevelType.Debug);
                            return Content(HttpStatusCode.OK, returnmessage);
                        case "0":
                            return (ArchivDocFromDatabase(dokumentid));
                        case "4":
                            APILogging.Log((HttpRequestMessage)Request, "Dokumentarchivierung von Iris ausgelöst" + dokumentid, LogLevelType.Info);
                            break;
                        case "5":
                            APILogging.Log((HttpRequestMessage)Request, "Dokument bereit zur Ausgangsarchivierung" + dokumentid, LogLevelType.Info);
                            break;
                        case "6":
                            APILogging.Log((HttpRequestMessage)Request, "Dokument in EDOKA abgeschlossen" + dokumentid, LogLevelType.Info);
                            break;

                        default:
                            break;
                    }
                    ;

                }


                APILogging.Log((HttpRequestMessage)Request, "Ende ArchivDocFromIRIS DokumentID:" + dokumentid, LogLevelType.Debug);
                return Ok(dokumentid);
            }
            catch (Exception e)
            {
                APILogging.Log((HttpRequestMessage)Request, e.Message, LogLevelType.Error);
                return Content(HttpStatusCode.InternalServerError, e.Message);
            }
        }
        [HttpPost]
        [Route("API/ArchivSBDoc")]

        public IHttpActionResult ArchivSBDoc(string sbnr, string intid, int partnernr, string dokumentid)
        {
            if (SecuringWebApiUsingApiKey.Middleware.ApiKeyMiddleware.Authorized((HttpRequestMessage)Request, tokenfunction) == false)
            {
                return Content(HttpStatusCode.Unauthorized, "Invalid Token or API-Key");
            }
            string ArchivAktiv;
            ArchivAktiv = System.Configuration.ConfigurationManager.AppSettings["ArchivierungAktiv"].ToString();
            if (ArchivAktiv != "True")
            {
                string message = ArchivAktiv = System.Configuration.ConfigurationManager.AppSettings["ArchivierungNoAktivMessage"].ToString();
                return Content(HttpStatusCode.InternalServerError, message);
            }
            APILogging.Log((HttpRequestMessage)Request, "Start ArchivSBDoc DokumentID: DokumentID:" + dokumentid, LogLevelType.Debug);

            string json = "";
            if (HttpContext.Current.Request.InputStream.Length > 0)
            {
                using (var inputStream = new StreamReader(HttpContext.Current.Request.InputStream))
                {
                    json = inputStream.ReadToEnd();
                }
            }
            string debugfilename = System.Configuration.ConfigurationManager.AppSettings["JSONDebugPath"];
            string SendToOnBase = System.Configuration.ConfigurationManager.AppSettings["SendToOnBase"];
            string SendToFile = System.Configuration.ConfigurationManager.AppSettings["SendToFile"];
            string debugdir = System.Configuration.ConfigurationManager.AppSettings["DebugDir"];
            string jsonstring = json;

            ILResponse ilr = new ILResponse();
            //jsonstring = Newtonsoft.Json.JsonConvert.SerializeObject(od);
            IHttpActionResult transferResult = null;
            if (SendToOnBase != "Yes")
            {
                transferResult = Transfer_OnBase(uploadtype.slow, ref jsonstring, ref ilr);
                if (SendToFile == "Yes")
                {
                    if (debugfilename != "")
                    {
                        debugfilename = debugfilename + sbnr.ToString() + "_" + intid.ToString() + "_" + partnernr.ToString() + ".json";
                        System.IO.File.WriteAllText(debugfilename, jsonstring);
                    }

                }
            }

            //Log nachführen
            Update_IL_Log(ref ilr, "SB_" + sbnr.ToString() + "_" + intid.ToString());
            APILogging.Log((HttpRequestMessage)Request, "Ende ArchivSBDoc DokumentID: DokumentID:" + dokumentid, LogLevelType.Debug);
            return transferResult;
            //return Content(HttpStatusCode.OK, "");
        }

        private IHttpActionResult Transfer_OnBase(uploadtype utype, ref string jsonstring, ref ILResponse ilr)
        {
            //ILResponse ilr = new ILResponse();
            string response;
            WebRequest request;
            APILogging.Log((HttpRequestMessage)Request, "Start Transfer to OnBase", LogLevelType.Debug);

            string url = "";
            switch (utype)
            {
                case uploadtype.fast:
                    url = System.Configuration.ConfigurationManager.AppSettings["ILFast"];
                    break;
                case uploadtype.slow:
                    url = System.Configuration.ConfigurationManager.AppSettings["ILSlow"];
                    break;
                case uploadtype.docupload:
                    url = System.Configuration.ConfigurationManager.AppSettings["ILDocupload"];
                    break;
                case uploadtype.revision:
                    url = System.Configuration.ConfigurationManager.AppSettings["ILRevision"];
                    break;
            }
            APILogging.Log((HttpRequestMessage)Request, "Upload URL:" + url, LogLevelType.Debug);

            var data = Encoding.UTF8.GetBytes(jsonstring);
            request = WebRequest.Create(url);
            request.ContentLength = data.Length;
            request.ContentType = "application/json";
            request.Method = "POST";
            try
            {
                using (Stream requestStream = request.GetRequestStream())
                {
                    requestStream.Write(data, 0, data.Length);
                    requestStream.Close();

                    using (Stream responseStream = request.GetResponse().GetResponseStream())
                    {
                        using (var reader = new StreamReader(responseStream))
                        {
                            response = reader.ReadToEnd();
                        }
                    }
                }
                ilr.StatusCode = 0;
                ilr.senderror = 0;
                ilr.response = response;

                APILogging.Log((HttpRequestMessage)Request, "Ende Transfer to OnBase", LogLevelType.Debug);
                return Content(HttpStatusCode.OK, ilr);
            }
            catch (Exception ex)
            {
                ilr.StatusCode = 1;
                ilr.senderror = 1;
                ilr.response = ex.Message;
                return Content(HttpStatusCode.InternalServerError, ilr);
            }
        }


        private string archiv_sb_doc(string dokumentid, string partnernr, string serienbriefnr, string dokument, string inteintragnr)
        {
            OnBaseDocUpload.OnBaseDokument onbasedoc = new OnBaseDocUpload.OnBaseDokument();
            DB db = new DB(connectionstring);
            db.clear_parameter();
            db.add_parameter("@serienbriefnr", serienbriefnr);
            db.add_parameter("@intEintragnr", inteintragnr);
            db.add_parameter("@partnernr", partnernr);
            db.add_parameter("@dokumentid", dokumentid);
            db.Get_Tabledata("sp_get_onbase_parameters_sb", true, false);
            if (db.dsdaten.Tables[0].Rows[0]["BpNummer"].ToString() == "")
            {
                onbasedoc.personNummer = db.dsdaten.Tables[0].Rows[0]["PersonNummer"].ToString();
                onbasedoc.bpNummer = "";
            }
            else
            {
                onbasedoc.bpNummer = db.dsdaten.Tables[0].Rows[0]["BpNummer"].ToString();
                onbasedoc.personNummer = "";
            }
            onbasedoc.dokumentDatum = db.dsdaten.Tables[0].Rows[0]["DokumentDatum"].ToString();
            onbasedoc.dokumentTyp = db.dsdaten.Tables[0].Rows[0]["dokumenttyp"].ToString();
            onbasedoc.dateiTyp = db.dsdaten.Tables[0].Rows[0]["dateityp"].ToString();


            onbasedoc.attributes = new List<Model.OnBaseDocUpload.attribute>();
            foreach (System.Data.DataRow rw in db.dsdaten.Tables[1].Rows)

            {
                OnBaseDocUpload.attribute p = new OnBaseDocUpload.attribute(rw["fieldname"].ToString(), rw["fieldvalue"].ToString());
                onbasedoc.attributes.Add(p);
            }
            onbasedoc.dokumentDatei = dokument;
            string URL = "";
            string response = "";

            string jsonstring = Newtonsoft.Json.JsonConvert.SerializeObject(onbasedoc);
            ILResponse ilr = new ILResponse();
            Transfer_OnBase(uploadtype.fast, ref jsonstring, ref ilr);
            Update_IL_Log(ref ilr, serienbriefnr.ToString() + "_" + inteintragnr.ToString());
            return ilr.response;
        }


        [HttpPost]
        [Route("API/Send_Versandstrasse")]

        public IHttpActionResult Send_Versandstrasse(string paketid = "")
        {

            string json_versandpaket = "";
            if (paketid != "")
            {
                Database.DB db = new Database.DB(connectionstring);
                //db.Get_Tabledata("Select * from dokument where dokumentid = '" + DokumentID + "'", false, true);

                string SQL = "Select * from Ondoc_Versandstrasse_Paket where id = @ID";
                db.clear_parameter();
                db.add_parameter("@ID", paketid);
                db.Get_Tabledata_Addvar(SQL, false, true);
                if (db.dsdaten.Tables[0].Rows.Count == 0)
                {
                    db = null;
                    return Content(HttpStatusCode.NotFound, paketid);
                }
                json_versandpaket = db.dsdaten.Tables[0].Rows[0]["Paket"].ToString();

                db = null;
            }
            else
            {
                json_versandpaket = Request.Content.ReadAsStringAsync().Result;
            }

            Versandpaket versandpaket = new Versandpaket();
            versandpaket.Dokument = new List<Versanddokument>();
            versandpaket = JsonConvert.DeserializeObject<Versandpaket>(json_versandpaket);

            string inthandle = "";
            if (SecuringWebApiUsingApiKey.Middleware.ApiKeyMiddleware.Authorized((HttpRequestMessage)Request, tokenfunction) == false)
            {
                return Content(HttpStatusCode.Unauthorized, "Invalid Token or API-Key");
            }
            string ArchivAktiv;
            ArchivAktiv = System.Configuration.ConfigurationManager.AppSettings["ArchivierungAktiv"].ToString();
            if (ArchivAktiv != "True")
            {
                string message = "Hinweismeldung: " + System.Configuration.ConfigurationManager.AppSettings["ArchivierungNoAktivMessage"].ToString();
                return Content(HttpStatusCode.OK, message);
            }
            try
            {
                if (paketid != "")
                {
                    DB db = new DB(connectionstring);
                    db.clear_parameter();
                    db.add_parameter("@tgnummer", "API/Service");
                    db.add_parameter("@partnernr", versandpaket.partnernr.ToString());
                    db.add_parameter("@gasadresse", versandpaket.GASAdresse);
                    db.add_parameter("@versandoption", versandpaket.Versandoption);

                    string dokumente = "";
                    foreach (Versanddokument vd in versandpaket.Dokument)
                    {
                        dokumente = dokumente + vd.DokumentID + ";";
                    }
                    db.add_parameter("@dokumente", dokumente);
                    db.add_parameter("@paketid", paketid);
                    db.Get_Tabledata("Ondoc_Insert_Versandprotokoll", true, false);
                    versandpaket.protokollid = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][0]);
                }

                OnBase_Attributes oba = new OnBase_Attributes();
                if (!versandpaket.send_onbase_doc)
                {
                    oba.BPNummer = versandpaket.partnernr.ToString();
                    oba.DocumentHandle = "";
                    oba.DistributionOption = versandpaket.Versandoption.ToString();
                    oba.GASCouvert = versandpaket.GAS;
                    oba.GASSize = versandpaket.GASSize;
                    oba.Returnaddress = versandpaket.GASAdresse;
                    oba.O2ODochandle = "";
                    oba.Status = "";
                    oba.ReferenceId = versandpaket.ReferenceID;

                    //if (oba.GASCouvert == "") { oba.GASCouvert = "false"; } else { oba.GASCouvert = "true"; }
                    foreach (Versanddokument vd in versandpaket.Dokument)
                    {
                        IHttpActionResult res = ArchivDocFromDatabase(vd.DokumentID, "");
                    }
                }
                else
                {

                    oba.BPNummer = versandpaket.partnernr.ToString();
                    oba.DocumentHandle = "";
                    oba.DistributionOption = versandpaket.Versandoption.ToString();
                    oba.GASCouvert = versandpaket.GAS;
                    oba.GASSize = versandpaket.GASSize;
                    oba.Returnaddress = versandpaket.GASAdresse;
                    oba.O2ODochandle = "";
                    oba.Status = "";
                    oba.ReferenceId = versandpaket.ReferenceID;

                    foreach (Versanddokument vd in versandpaket.Dokument)
                    {
                        if (versandpaket.isSerienbrief)
                        {
                            string result = "";

                            inthandle = archiv_sb_doc(vd.DokumentID, vd.Partnernr, versandpaket.sb.serienbriefnr.ToString(), vd.dokument, vd.inteintragnr.ToString());

                            int test;
                            bool isnumeric = int.TryParse(inthandle, out test);

                            if (!isnumeric || inthandle == "")
                            {
                                ILResponse ilr1 = new ILResponse();
                                ilr1.response = "Dokument IntEIntrag=" + vd.inteintragnr.ToString() + " nicht archiviert";
                                ilr1.senderror = 1;
                                DB db = new DB(connectionstring);
                                db.Exec_SQL("Update OnDoc_Versandstrasse_paket set fehler=1, fehlerdatum=getdate(), fehlerbeschreibung='" + ilr1.response + "' where id=" + paketid);
                                return Content(HttpStatusCode.InternalServerError, ilr1.response);
                            }
                            oba.DocumentHandle = inthandle.ToString();
                            DOCGEN.DocGen dg = new DOCGEN.DocGen();
                            versandpaket.finaldoc = dg.geneate_dummy_pdf("VS Serienbrief: Handle " + oba.DocumentHandle.ToString() + " " + DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss"));
                        }
                        else
                        {
                            if (!vd.DokumentID.Contains("ATT"))
                            {
                                IHttpActionResult res = ArchivDocFromDatabase(vd.DokumentID, vd.dokument);
                                DB db = new DB(connectionstring);
                                db.clear_parameter();
                                db.add_parameter("@dokumentid", vd.DokumentID);
                                db.Get_Tabledata("sp_get_handle", true, false);

                                if (db.dsdaten.Tables[0].Rows.Count > 0)
                                {
                                    inthandle = db.dsdaten.Tables[0].Rows[0][0].ToString();
                                    int test;
                                    bool isnumeric = int.TryParse(inthandle, out test);
                                    if (!isnumeric || inthandle == "")
                                    {
                                        ILResponse ilr1 = new ILResponse();
                                        ilr1.response = "Dokument ID:'" + vd.DokumentID + "' nicht archiviert";
                                        ilr1.senderror = 1;
                                        db.Exec_SQL("Update OnDoc_Versandstrasse_paket set fehler=1, fehlerdatum=getdate(), fehlerbeschreibung='" + ilr1.response + "' where id=" + paketid);

                                        return Content(HttpStatusCode.InternalServerError, ilr1.response);
                                    }

                                    oba.DocumentHandle = inthandle;
                                    DOCGEN.DocGen dg = new DOCGEN.DocGen();
                                    versandpaket.finaldoc = dg.geneate_dummy_pdf("Versandstrasse - DummyDokument - " + DateTime.Now.ToString("dd.MM.yyyy hh:mm:ss"));
                                    //versandpaket.finaldoc = "";
                                    dg = null;
                                }
                                else
                                {
                                    ILResponse ilr1 = new ILResponse();
                                    ilr1.response = "Dokument ID:'" + vd.DokumentID + "' nicht archiviert";
                                    ilr1.senderror = 1;
                                    db.Exec_SQL("Update OnDoc_Versandstrasse_paket set fehler=1, fehlerdatum=getdate(), fehlerbeschreibung='" + ilr1.response + "' where id=" + paketid);

                                    return Content(HttpStatusCode.InternalServerError, ilr1.response);

                                }
                                db = null;
                            }
                        }
                    }
                }

                OnBaseDocUpload.OnBaseDokument onbasedoc = new OnBaseDocUpload.OnBaseDokument();
                onbasedoc.bpNummer = oba.BPNummer;
                onbasedoc.dokumentTyp = "Tech Versandstrasse SendDoc";
                onbasedoc.personNummer = "";
                onbasedoc.dokumentDatum = DateTime.Now.ToString("dd.MM.yyyy");
                onbasedoc.dokumentDatei = versandpaket.finaldoc;
                onbasedoc.dateiTyp = "PDF";
                onbasedoc.ReferenceId = versandpaket.ReferenceID;
                onbasedoc.attributes = new List<OnBaseDocUpload.attribute>();
                if (oba.GASCouvert == "") { oba.GASCouvert = "false"; } else { oba.GASCouvert = "true"; }

                onbasedoc.attributes.Add(new OnBaseDocUpload.attribute("Document Handle", oba.DocumentHandle.ToString()));
                onbasedoc.attributes.Add(new OnBaseDocUpload.attribute("O2O DistributionOption", oba.DistributionOption.ToString()));
                onbasedoc.attributes.Add(new OnBaseDocUpload.attribute("O2O GasCouvert", oba.GASCouvert.ToString()));
                onbasedoc.attributes.Add(new OnBaseDocUpload.attribute("O2O Returnaddress", oba.Returnaddress.ToString()));
                if (System.Configuration.ConfigurationManager.AppSettings["GASSize"].ToString() == "True")
                {
                    if (oba.GASCouvert.ToString().ToUpper() == "TRUE")
                    {
                        onbasedoc.attributes.Add(new OnBaseDocUpload.attribute("O2O GasSize", oba.GASSize.ToString()));
                    }
                    else
                    {
                        onbasedoc.attributes.Add(new OnBaseDocUpload.attribute("O2O GasSize", ""));
                    }

                }
                onbasedoc.attributes.Add(new OnBaseDocUpload.attribute("O2O Dochandle", oba.DocumentHandle.ToString()));
                onbasedoc.attributes.Add(new OnBaseDocUpload.attribute("O2O Status", oba.Status.ToString()));
                onbasedoc.attributes.Add(new OnBaseDocUpload.attribute("O2O ExternalReference", oba.ReferenceId.ToString()));

                ILResponse ilr = new ILResponse();
                string debugfilename = System.Configuration.ConfigurationManager.AppSettings["JSONDebugPath"];
                string SendToOnBase = System.Configuration.ConfigurationManager.AppSettings["SendToOnBase"];
                string SendToFile = System.Configuration.ConfigurationManager.AppSettings["SendToFile"];
                string debugdir = System.Configuration.ConfigurationManager.AppSettings["DebugDir"];
                string jsonstring = Newtonsoft.Json.JsonConvert.SerializeObject(onbasedoc);
                IHttpActionResult transferResult = null;
                if (SendToOnBase != "Yes")
                {
                    transferResult = Transfer_OnBase(uploadtype.fast, ref jsonstring, ref ilr);

                    if (SendToFile == "Yes")
                    {
                        if (debugfilename != "")
                        {
                            debugfilename = debugfilename + "VS_" + oba.BPNummer + "_" + DateTime.Now.ToString("yyyyMMddhhmmss") + ".json";
                            System.IO.File.WriteAllText(debugfilename, jsonstring);
                            debugfilename = debugfilename + ".pdf";
                            Helper.clsFileHelper fh = new Helper.clsFileHelper();
                            fh.SaveBase64ToFile(onbasedoc.dokumentDatei, debugfilename);
                            fh = null;
                        }
                    }
                }
                DB db1 = new DB(connectionstring);
                db1.Exec_SQL("Update Versandstrasse_Protokoll set handle = '" + ilr.response + "' where id=" + versandpaket.protokollid.ToString());
                if (paketid != "")
                {
                    db1.Exec_SQL("Update OnDoc_Versandstrasse_paket set versendet=1, versendet_am=getdate() where id=" + paketid);
                }
                db1 = null;
                APILogging.Log((HttpRequestMessage)Request, "Upload Versandstrasse:" + debugfilename, LogLevelType.Debug);

                //Log nachführen
                // Update_IL_Log(ref ilr, DokumentID);
                if (ilr.senderror == 1)
                {
                    return Content(HttpStatusCode.InternalServerError, ilr.response);
                }
                else
                {
                    // update_dokumentstatus(debugfilename);
                    return Content(HttpStatusCode.OK, oba.BPNummer.ToString() + " *archiviert*");
                }
            }
            catch (Exception e)
            {
                APILogging.Log((HttpRequestMessage)Request, e.Message, LogLevelType.Error);
                return Content(HttpStatusCode.InternalServerError, e.Message);
            }
            finally
            {
            }
        }

        [HttpGet]
        [Route("API/ResendVersandpaket")]

        public IHttpActionResult ResendVersandpaket(string PaketID)
        {
            if (SecuringWebApiUsingApiKey.Middleware.ApiKeyMiddleware.Authorized((HttpRequestMessage)Request, tokenfunction) == false)
            {
                return Content(HttpStatusCode.Unauthorized, "Invalid Token or API-Key");
            }
            try
            {
                APILogging.Log((HttpRequestMessage)Request, "Start Resend Versandstrasse: PaketID:" + PaketID, LogLevelType.Debug);
                Database.DB db = new Database.DB(connectionstring);
                //db.Get_Tabledata("Select * from dokument where dokumentid = '" + DokumentID + "'", false, true);

                string SQL = "Select * from Ondoc_Versandstrasse_Paket where  = @ID";
                db.clear_parameter();
                db.add_parameter("@ID", PaketID);
                db.Get_Tabledata_Addvar(SQL, false, true);
                if (db.dsdaten.Tables[0].Rows.Count == 0)
                {
                    return Content(HttpStatusCode.NotFound, PaketID);
                }

                Versandpaket vp = JsonConvert.DeserializeObject<Versandpaket>(db.dsdaten.Tables[0].Rows[0].ToString());
                IHttpActionResult res = Send_Versandstrasse();



                APILogging.Log((HttpRequestMessage)Request, "Ende Resend_Versandstrasse: PaketID:" + PaketID, LogLevelType.Debug);

                return Content(HttpStatusCode.NotFound, PaketID);
            }
            catch (Exception e)
            {
                APILogging.Log((HttpRequestMessage)Request, e.Message, LogLevelType.Error);
                return Content(HttpStatusCode.InternalServerError, e.Message);
            }
        }

        [HttpPost]
        [Route("API/ArchivDocIL")]
        public IHttpActionResult ArchivDocIL()
        {
            int a = 0;
            APIErrorSimple apireturn = new APIErrorSimple();
            APIOK apiok = new APIOK();
            ArchiveDoc archivdoc = new ArchiveDoc();
            try
            {
                string guid = Guid.NewGuid().ToString();
                Logging.APIDocLog.Info("Start ArchivDocIL", "CreateDoc", guid, "");
                if (SecuringWebApiUsingApiKey.Middleware.ApiKeyMiddleware.Authorized((HttpRequestMessage)Request, tokenfunction) == false)
                {
                    apireturn.code = "ONDOC-ERR-ArchivDocIL-01";
                    apireturn.status = "401";
                    apireturn.message = "Invalid Token or API-Key";
                    apireturn.traceid = "";
                    apireturn.field = "";

                    return Content(HttpStatusCode.BadRequest, apireturn);
                }


                string ArchivAktiv;
                ArchivAktiv = System.Configuration.ConfigurationManager.AppSettings["ArchivierungAktiv"].ToString();
                if (ArchivAktiv != "True")
                {
                    apireturn.code = "ONDOC-ERR-ArchivDocIL-02";
                    apireturn.status = "401";
                    apireturn.message = "Archivierung z.Zt. inaktiv";
                    apireturn.traceid = "";
                    apireturn.field = "";

                    return Content(HttpStatusCode.BadRequest, apireturn);
                }
                try
                {


                    HttpRequestMessage rmsg = (HttpRequestMessage)Request;
                    string OwnHost = System.Configuration.ConfigurationManager.AppSettings["OwnHost"].ToString();
                    string imagepath = System.Configuration.ConfigurationManager.AppSettings["VSImagePath"].ToString();

                    var key = rmsg.Headers.Authorization.Parameter.ToString();
                    string result = Request.Content.ReadAsStringAsync().Result;
                    var root = JsonConvert.DeserializeObject<JsonTable>(result);
                    Logging.APIDocLog.Info("Input JSON", "CreateDoc", guid, result);


                    archivdoc = JsonConvert.DeserializeObject<ArchiveDoc>(result);
                    APILogging.Log((HttpRequestMessage)Request, "Start ArchivDocFromIRIS DokumentID: " + archivdoc.DokumentID, LogLevelType.Debug);
                    int i = 0;
                    if (archivdoc.DokumentID != "")
                    {
                        if (!archivdoc.Dokument.Contains("OFFEDK"))
                        {
                            string savedokumentid = archivdoc.DokumentID;
                            DB db = new DB(connectionstring);
                            try
                            {
                                db.Get_Tabledata("Select dokumentid from OnDoc_CLM_Dokumente where clmdokumentid='" + archivdoc.DokumentID + "'", false, true);
                                archivdoc.DokumentID = db.dsdaten.Tables[0].Rows[0][0].ToString(); ;
                            }
                            catch 
                            {
                                apireturn.code = "ONDOC-ERR-ArchivDocIL-04";
                                apireturn.status = "401";
                                apireturn.message = "Dokument nicht gefunden für ID :" + archivdoc.DokumentID;
                                apireturn.traceid = "";
                                apireturn.field = "";
                                return Content(HttpStatusCode.BadRequest, apireturn);
                            }
                            finally { db = null; }
                        }
                        int i1 = 0;
                        // var  hres = ArchivDocFromDatabase(archivdoc.DokumentID);
                        IHttpActionResult result1 = ArchivDocFromDatabase(archivdoc.DokumentID,"","TRUE");

                        // Execute the result
                        HttpResponseMessage response = result1.ExecuteAsync(CancellationToken.None).Result;

                        if (response.IsSuccessStatusCode)
                        {
                            string content = response.Content.ReadAsStringAsync().Result;
                            apiok.file = "";
                            apiok.code = "OK";
                            apiok.status = "200";
                            apiok.documentid = archivdoc.DokumentID;
                            return Content(HttpStatusCode.OK, apiok);
                        }
                        else
                        {
                            apireturn.code = "ONDOC-ERR-ArchivDocIL-05";
                            apireturn.status = "401";
                            apireturn.message = "Archivierung nicht OK:" + archivdoc.DokumentID;
                            apireturn.traceid = "";
                            apireturn.field = "";
                            return Content(HttpStatusCode.BadRequest, apireturn);
                        }
                    }
                    else
                    {
                        //archivdoc.DokumentDatum = "07/16/2025";
                        archivdoc.DokumentDatum = OnDocAPI_NetFramework.Helper.Helper.NormalizeDateToSystemFormat(archivdoc.DokumentDatum);

                        DateTime date = Convert.ToDateTime(archivdoc.DokumentDatum);
                        archivdoc.DokumentDatum = date.ToString("dd.MM.yyyy");
                        //DateTime d = Convert.ToDateTime(archivdoc.DokumentDatum);
                        //archivdoc.DokumentDatum = d.ToString("dd.MM.yyyy");
                        DB db = new DB(connectionstring);
                        db.clear_parameter();
                        db.add_parameter("@dokumenttypnr", archivdoc.DokumenttypNr);
                        db.add_parameter("@partnernr", archivdoc.PartnerNr);
                        db.add_parameter("@status", archivdoc.Status);
                        db.add_parameter("@verantwortlich", archivdoc.TGResponsible);
                        db.add_parameter("@ersteller", archivdoc.TGCreatedBy);

                        db.Get_Tabledata("dbo.sp_ondoc_get_archiv_parameter", true, false);
                        OnBaseDocUpload.OnBaseDokument onbasedoc = new OnBaseDocUpload.OnBaseDokument();
                        var Attribute = new List<Model.OnBaseDocUpload.attribute>();
                        onbasedoc.attributes = new List<Model.OnBaseDocUpload.attribute>();
                        onbasedoc.dokumentTyp = db.dsdaten.Tables[0].Rows[0][0].ToString();
                        onbasedoc.bpNummer = db.dsdaten.Tables[0].Rows[0][2].ToString();
                        onbasedoc.personNummer = db.dsdaten.Tables[0].Rows[0][3].ToString();
                        onbasedoc.dokumentDatum = archivdoc.DokumentDatum.ToString();
                        onbasedoc.dokumentDatei = archivdoc.Dokument;
                        onbasedoc.dateiTyp = archivdoc.DokumentType;

                        Add_Attribute(ref onbasedoc, "EDOKA Dokument-ID", "");
                        Add_Attribute(ref onbasedoc, "EDOKA Dokumenttyp Nr", archivdoc.DokumenttypNr);
                        Add_Attribute(ref onbasedoc, "Bezeichnung", db.dsdaten.Tables[0].Rows[0][1].ToString());
                        Add_Attribute(ref onbasedoc, "Dokumenttyp", db.dsdaten.Tables[0].Rows[0][0].ToString());
                        if (db.dsdaten.Tables[0].Rows[0][3].ToString() == "")
                        {
                            Add_Attribute(ref onbasedoc, "BP Nummer", onbasedoc.bpNummer);
                        }
                        else
                        {
                            Add_Attribute(ref onbasedoc, "Person Nummer", onbasedoc.personNummer);
                        }
                        Add_Attribute(ref onbasedoc, "Partner Kurzname/Ort", db.dsdaten.Tables[0].Rows[0][5].ToString());
                        if (db.dsdaten.Tables[0].Rows[0][4].ToString() == "In Aufbewahrung")
                        {
                            Add_Attribute(ref onbasedoc, "Status Korrespondenz", db.dsdaten.Tables[0].Rows[0][4].ToString());
                        }
                        else
                        {
                            Add_Attribute(ref onbasedoc, "Status Verträge", db.dsdaten.Tables[0].Rows[0][4].ToString());

                        }
                        Add_Attribute(ref onbasedoc, "Original Filename", guid);
                        Add_Attribute(ref onbasedoc, "Dokumentdatum", archivdoc.DokumentDatum);
                        Add_Attribute(ref onbasedoc, "Verantwortlich Email", db.dsdaten.Tables[0].Rows[0][6].ToString());
                        Add_Attribute(ref onbasedoc, "Verantwortlich Name", db.dsdaten.Tables[0].Rows[0][7].ToString());
                        Add_Attribute(ref onbasedoc, "Verantwortlich Benutzername", archivdoc.TGResponsible);
                        Add_Attribute(ref onbasedoc, "Created By", archivdoc.TGCreatedBy);
                        Add_Attribute(ref onbasedoc, "Papierkorb", "NEIN");
                        Add_Attribute(ref onbasedoc, "Herkunftsapplikation", archivdoc.Herkunftsapplikation);
                        Add_Attribute(ref onbasedoc, "ExternalReference", archivdoc.Reference);
                        string debugfilename = System.Configuration.ConfigurationManager.AppSettings["JSONDebugPath"];
                        string SendToOnBase = System.Configuration.ConfigurationManager.AppSettings["SendToOnBase"];
                        string SendToFile = System.Configuration.ConfigurationManager.AppSettings["SendToFile"];
                        string debugdir = System.Configuration.ConfigurationManager.AppSettings["DebugDir"];
                        string jsonstring = Newtonsoft.Json.JsonConvert.SerializeObject(onbasedoc);
                        IHttpActionResult transferResult = null;
                        ILResponse ilr = new ILResponse();
                        if (SendToOnBase != "Yes")
                        {
                            if (SendToFile == "Yes")
                            {
                                if (debugfilename != "")
                                {
                                    debugfilename = debugfilename + guid + ".json";
                                    System.IO.File.WriteAllText(debugfilename, jsonstring);
                                    debugfilename = debugfilename + ".pdf";
                                    Helper.clsFileHelper fh = new Helper.clsFileHelper();
                                    fh.SaveBase64ToFile(onbasedoc.dokumentDatei, debugfilename);
                                    fh = null;
                                }
                            }

                            {
                                transferResult = Transfer_OnBase(uploadtype.fast, ref jsonstring, ref ilr);
                                HttpResponseMessage response = transferResult.ExecuteAsync(CancellationToken.None).Result;

                                if (response.IsSuccessStatusCode)
                                {
                                    string content = response.Content.ReadAsStringAsync().Result;
                                    apiok.file = "";
                                    apiok.code = "OK";
                                    apiok.status = "200";
                                    apiok.documentid = guid;
                                    return Content(HttpStatusCode.OK, apiok);
                                }
                                else
                                {
                                    apireturn.code = "ONDOC-ERR-ArchivDocIL-06";
                                    apireturn.status = "401";
                                    apireturn.message = "Archivierung nicht OK:" + guid;
                                    apireturn.traceid = "";
                                    apireturn.field = "";
                                    return Content(HttpStatusCode.BadRequest, apireturn);
                                }

                            }

                        }
                    }

                    return Content(HttpStatusCode.InternalServerError, "e.Message");

                }
                catch (Exception e)
                {
                    APILogging.Log((HttpRequestMessage)Request, e.Message, LogLevelType.Error);
                    return Content(HttpStatusCode.InternalServerError, e.Message);
                }
            }
            catch (Exception ex)
            {
                apireturn.code = "ONDOC-ERR-ArchivDocIL-03";
                apireturn.status = "401";
                apireturn.message = ex.Message; ;
                apireturn.traceid = "";
                apireturn.field = "";
                apireturn = null; apiok = null;
                return Content(HttpStatusCode.BadRequest, apireturn);
            }
            finally
            {
                apireturn = null; apiok = null; archivdoc = null;
            }


        }
        private void Add_Attribute(ref OnBaseDocUpload.OnBaseDokument onbasedoc, string Attributname, string value)
        {
            OnBaseDocUpload.attribute na = new OnBaseDocUpload.attribute(Attributname, value);
            onbasedoc.attributes.Add(na);
        }
    }

}