using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using DOCGEN;
using Model;
using Database;
using Newtonsoft.Json;
using API_NetFramework.Models;
using System.Security.Cryptography;
using edoka_dms;
using SecuringWebApiUsingApiKey.Middleware;
using System.Linq.Expressions;
using System.Data;
using System.Web.Management;
using System.Web;
using System.IO;
using OnDocAPI_NetFramework.Controllers;
using Versandstrasse;
using System.ComponentModel;
using System.Text;
using System.Text.Json.Serialization;
using Microsoft.Ajax.Utilities;
using System.Collections;
using Microsoft.Extensions.Options;
using System.Web.Helpers;
using Syncfusion.CompoundFile.DocIO.Native;
using System.Web.UI.WebControls;
using System.Drawing.Text;
using System.Runtime.InteropServices.ComTypes;
using System.Reflection;
using Newtonsoft.Json.Linq;
using System.Runtime.Serialization.Json;
using System.Web.Http.Results;
using Syncfusion.DocIO.DLS.XML;
using System.Reflection.Emit;
using System.Web.UI.WebControls.WebParts;
using System.Diagnostics;


namespace API_NetFramework.Controllers
{

    public class DocumentController : ApiController
    {

        private string guid = "";

        public string tokenfunction = "Dokument";
        string connectionstring = StringCipher.Decrypt(ConfigurationManager.ConnectionStrings["EDOKAConnectionstring"].ConnectionString, "i%!k!7pab%bNLdA5hE4pkR4XaB%E^jB3d9tHuQ4pbF&BZjF7SB#WBWit5#HrbJiLrLVm");

        [HttpGet]
        [Route("API/GetDocument")]
        public IHttpActionResult GetDocument(string dokid)
        {
            if (SecuringWebApiUsingApiKey.Middleware.ApiKeyMiddleware.Authorized((HttpRequestMessage)Request, tokenfunction) == false)
            {
                return Content(HttpStatusCode.Unauthorized, "Invalid Token or API-Key");
            }
            try
            {
                APILogging.Log((HttpRequestMessage)Request, "Start GetDocument DokumentID:" + dokid, LogLevelType.Debug);

                DOCGEN.DocGet gd = new DocGet(connectionstring);
                clsdok dok = new clsdok("", "", "", "");
                dok = gd.GetDoc(dokid);
                APILogging.Log((HttpRequestMessage)Request, "Ende GetDocument DokumentID:" + dokid, LogLevelType.Debug);

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

        }

        [Route("API/GetDocumentPDF")]
        [HttpGet]
        public IHttpActionResult GetDocumentPDF(string dokid)
        {
            if (SecuringWebApiUsingApiKey.Middleware.ApiKeyMiddleware.Authorized((HttpRequestMessage)Request, tokenfunction) == false)
            {
                return Content(HttpStatusCode.Unauthorized, "Invalid Token or API-Key");
            }
            try
            {
                APILogging.Log((HttpRequestMessage)Request, "Start GetDocumentPDF DokumentID:" + dokid, LogLevelType.Debug);

                DOCGEN.DocGet gd = new DocGet(connectionstring);
                clsdok dok = new clsdok("", "", "", "");
                dok = gd.GetDocAsPDF(dokid);
                dok.extension = "pdf";
                dok.doktype = "P";
                APILogging.Log((HttpRequestMessage)Request, "Ende GetDocument DokumentID:" + dokid, LogLevelType.Debug);

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

        }

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

                    try
                    {
                        //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                        return Content(HttpStatusCode.BadRequest, apireturn);
                    }
                    catch
                    {
                        return Content(HttpStatusCode.Unauthorized, "Invalid Token or API-Key");
                    }
                    finally { apireturn = null; apiok = null; };
                }
                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;
                dynamic dataj = JsonConvert.DeserializeObject(result);
                try
                {
                    string type = dataj.Dokumente.ToString();
                    if (!String.IsNullOrEmpty(type))
                    {
                        return CreateDoks();
                    }
                }
                catch { }
                try
                {
                    string type = dataj.TGNrErsteller.ToString();
                    if (!String.IsNullOrEmpty(type))
                    {
                        return CreateDok();
                    }
                }
                catch { }

               return CreateCLM();

            }
            catch
            {
                apireturn.code = "DokumentGenerator";
                apireturn.status = "401";
                apireturn.message = "Invalid JSON";
                apireturn.traceid = "";
                apireturn.field = "";
                try
                {
                    //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                    return Content(HttpStatusCode.BadRequest, apireturn);
                }
                catch { return BadRequest(); }
                 
            }
            finally { apiok = null;apireturn = null; }

        }

        [HttpPost]
        [Route("API/CreateDoks")]
        public IHttpActionResult CreateDoks()
        {
            APIErrorSimple apireturn = new APIErrorSimple();
            APIOK apiok = new APIOK();
            try
            {
                guid = Guid.NewGuid().ToString();
                Logging.APIDocLog.Info("CreateDoks Start", "CreateDoks", guid, "");
                bool hasattachment = false;
                if (SecuringWebApiUsingApiKey.Middleware.ApiKeyMiddleware.Authorized((HttpRequestMessage)Request, tokenfunction) == false)
                {
                    apireturn.code = "ONDOC-ERR-CreateDoks-01";
                    apireturn.status = "401";
                    apireturn.message = "Invalid Token or API-Key";
                    apireturn.traceid = "";
                    apireturn.field = "";
                    try
                    {
                        //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                        return Content(HttpStatusCode.BadRequest, apireturn);
                    }
                    catch
                    {
                        return Content(HttpStatusCode.Unauthorized, "Invalid Token or API-Key");
                    }
                    finally { apireturn = null; apiok = null; };
                    //return Content(HttpStatusCode.Unauthorized, "Invalid Token or API-Key");
                }

                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;
                DokumentCreate paket = new DokumentCreate();
                paket = JsonConvert.DeserializeObject<DokumentCreate>(result);
                Logging.APIDocLog.Info("Input Json", "CreateDoks", guid, result);
                result = "";
                Logging.APIDocLog.Info("Herkunftsapplikation", "CreateDoks", guid, paket.Herkunftsapplikation);
                Logging.APIDocLog.Info("Ersteller", "CreateDoks", guid, paket.Dokumente[0].TGNrErsteller);


                string CheckResult = "";
                CheckResult = CreatePaket_Verify(ref paket, ref apireturn);
                if (CheckResult != "")
                {
                    Logging.APIDocLog.Error(CheckResult, "OnDocAPI", guid, "");
                    apireturn.code = "ONDOC-ERR-Verify";
                    apireturn.status = "400";
                    apireturn.message = CheckResult;
                    apireturn.traceid = "";
                    apireturn.field = "";
                    paket = null;
                    try
                    {
                        //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                        return Content(HttpStatusCode.BadRequest, apireturn);
                    }
                    catch
                    {
                        //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                        return Content(HttpStatusCode.BadRequest, apireturn);
                    }
                    finally { apireturn = null; apiok = null; };
                }

                try
                {
                    foreach (APIDokument dokument in paket.Dokumente)
                    {
                        if (dokument.PDFDoc != "" && dokument.PDFDoc != null)
                        {
                            string gid = "ATT" + OnDocAPI_NetFramework.Helper.Helper.RandomString(19);
                            dokument.DokumentID = gid;
                            hasattachment = true;
                            Logging.APIDocLog.Info("Attachment angefügt", "CreateDoks", guid, dokument.DokumentID);
                        }
                        else
                        {
                            clsDocData dokdata = new clsDocData();
                            Model.clsdocgendata docgendata = new Model.clsdocgendata();
                            DocCreate doccreate = new DocCreate();

                            OnDocAPI_NetFramework.Helper.Helper.CopyProperties(dokdata, docgendata);
                            OnDocAPI_NetFramework.Helper.Helper.CopyProperties(dokument, doccreate);
                            dokument.DokumentID = gendoc(ref doccreate, ref dokdata, ref docgendata, key.ToString());
                            dokument.DokumentID = dokdata.Dokumentid;
                            dokdata = null;
                            docgendata = null;
                            doccreate = null;

                            Logging.APIDocLog.Info("Dok erstellt", "CreateDoks", guid, dokument.DokumentID);
                        }
                    }
                }
                catch (Exception ex)
                {
                    Logging.APIDocLog.Error("ONDOC-ERR-CreatePaketDoc", "CreateDoks", guid, ex.Message);
                    paket = null;
                    apireturn.code = "ONDOC-ERR-CreatePaketDoc";
                    apireturn.status = "400";
                    apireturn.message = ex.Message;
                    apireturn.traceid = "";
                    apireturn.field = "";
                    paket = null;
                    try
                    {
                        //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                        return Content(HttpStatusCode.BadRequest, apireturn);
                    }

                    catch
                    {
                        //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                        return Content(HttpStatusCode.BadRequest, apireturn);
                    }
                    finally { apireturn = null; apiok = null; };

                }

          

                if (paket.Versandstrasse == "true")
                {
                    clsVersandstrasse vs = new clsVersandstrasse();
                    string vsdoc = "";
                    List<Versanddokument> vdoc = new List<Versanddokument>();
                    string partnernr = "";
                    int i = 0;
                    Versandpaket vp = new Versandpaket();
                    Stream[] streams = new Stream[paket.Dokumente.Count];
                    try
                    {
                        foreach (APIDokument dokumennt in paket.Dokumente)
                        {
                            if (dokumennt.DokumentID.Contains("ATT"))
                            {

                                vsdoc = vs.check_pdf_pages(dokumennt.PDFDoc);
                            }
                            else
                            {
                                vsdoc = vs.Prepare_PDF(dokumennt.DokumentID.ToString(), "", connectionstring, OwnHost, key.ToString(), imagepath);
                            }
                            i = i + 1;
                            Versanddokument vd = new Versanddokument(dokumennt.DokumentID.ToString(), dokumennt.PartnerNr.ToString() + " - " + dokumennt.Bezeichnung, partnernr);
                            vd.Partnernr = dokumennt.PartnerNr;
                            vd.dokument = vsdoc;
                            
                            vdoc.Add(vd);
                        }


                        i = 0;

                        foreach (Versanddokument vd in vdoc)
                        {
                            {
                                var stream = new MemoryStream(Convert.FromBase64String(vd.dokument));
                                streams[i] = stream;
                                i++;
                            }
                        }
                        string stapel = vs.save_stapel(ref streams, 19000000);


                        vp.partnernr = Convert.ToInt32(paket.Dokumente[0].PartnerNr.ToString());
                        vp.GASAdresse = paket.GASAdresse;
                        vp.Mitteilung = "";
                        vp.PaketNr = new Guid().ToString();
                        if (vp.GASAdresse != "") { vp.GAS = "1"; } else { vp.GAS = ""; }
                        vp.GASSize = paket.GASCouvert;
                        vp.Versandoption = paket.VersandOption;
                        vp.Dokument = vdoc;
                        vp.ReferenceID = paket.Reference;
                        vp.finaldoc = stapel;
                        if (vp.Dokument.Count > 1) { vp.send_onbase_doc = false; } else { vp.send_onbase_doc = true; }
                        vp.verified = true;
                        DB db = new DB(connectionstring);
                        int manr = db.Get_Mitarbeiternr(paket.VersandVerantwortlich.ToString());
                        if (paket.ResultSender == "true")
                        {
                            apiok.code = "200";
                            apiok.status = "200";
                            apiok.message = "";
                            apiok.documentid = "";
                            apiok.file = stapel;
                            try
                            {
                                return Ok((apiok));
                            }
                            catch { }
                            finally {
                                db = null;
                                streams = null;
                                vs = null;
                                vp = null;
                                vdoc = null;
                                
                            }
                        }
                        else
                        {

                            send_vs(ref vp, manr.ToString(), paket.VersandDirekt == "true", OwnHost, key.ToString(), "", paket.Dokumente[0].PartnerNr, paket, ref apireturn);
                        }
                        db = null;
                        streams = null;
                        vs = null;
                        vp = null;
                        vdoc = null;
                    }
                    catch (Exception ex)
                    {
                        streams = null;
                        vs = null;
                        vp = null;
                        vdoc = null;
                        apireturn.code = "ONDOC-ERR-PaketVersandstrasse";
                        apireturn.status = "400";
                        apireturn.message = ex.Message;
                        apireturn.traceid = "";
                        apireturn.field = "";

                        //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                        return Content(HttpStatusCode.BadRequest, apireturn);
                    }
                }
                Logging.APIDocLog.Info("Dokumentpaket abgeschlossen", "CreateDoks", guid, "");
                apireturn.code = "OK";
                apireturn.status = "200";
                apireturn.message = "Paket generiert";
                apireturn.traceid = "";
                apireturn.field = "GUID=" + guid;
                //return Ok(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                return Ok((apireturn));
            }
            catch (Exception ex)
            {
                Logging.APIDocLog.Error("ONDOC-ERR-CreatePaketDoc", "CreateDoks", guid, ex.Message);

                apireturn.code = "ONDOC-ERR-CreatePaketDoc";
                apireturn.status = "400";
                apireturn.message = ex.Message;
                apireturn.traceid = "";
                apireturn.field = "";
                //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                return Content(HttpStatusCode.BadRequest, apireturn);
            }
            finally { apireturn = null; apiok = null;};
        }

        [HttpPost]
        [Route("API/CreateDok")]
        public IHttpActionResult CreateDok()
        {
            APIErrorSimple apireturn = new APIErrorSimple();
            APIOK apiok = new APIOK();
            try
            {
                string guid = Guid.NewGuid().ToString();
                Logging.APIDocLog.Info("Start CreateDoc", "CreateDoc", guid, "");
                if (SecuringWebApiUsingApiKey.Middleware.ApiKeyMiddleware.Authorized((HttpRequestMessage)Request, tokenfunction) == false)
                {
                    apireturn.code = "ONDOC-ERR-CreateDok-01";
                    apireturn.status = "401";
                    apireturn.message = "Invalid Token or API-Key";
                    apireturn.traceid = "";
                    apireturn.field = "";
                    try
                    {
                        //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                        return Content(HttpStatusCode.BadRequest, apireturn);
                    }
                    catch
                    {
                        //return Content(HttpStatusCode.Unauthorized, "Invalid Token or API-Key");
                        return Content(HttpStatusCode.BadRequest, apireturn);
                    }
                    finally { apireturn = null; apiok = null; };
                }
                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);

                DocCreate doccreate = new DocCreate();
                //dynamic data = JsonConvert.DeserializeObject(result);
                doccreate = JsonConvert.DeserializeObject<DocCreate>(result);
                result = "";

                //clsDocData dokdata = new clsDocData();
                //string dokumentid = "";

                string CheckResult = "";
                CheckResult = CreateDoc_Verify(ref doccreate);
                if (CheckResult != "")
                {
                    Logging.APIDocLog.Error("Error Verify ", "CreateDoks", guid, CheckResult);

                    apireturn.code = "ONDOC-ERR-CreateDoc";
                    apireturn.status = "400";
                    apireturn.message = CheckResult;
                    apireturn.traceid = "";
                    apireturn.field = "";
                    //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                    return Content(HttpStatusCode.BadRequest, apireturn);
                }
                clsDocData dokdata = new clsDocData();
                Model.clsdocgendata docgendata = new Model.clsdocgendata();
                string dokumentid = gendoc(ref doccreate, ref dokdata, ref docgendata, key.ToString());
                dokumentid = dokdata.Dokumentid;
                if (doccreate.ResultSender == "true")
                {
                    DocGet dg = new DocGet(this.connectionstring);
                    clsdok dok = new clsdok("", "", "", "");
                    Logging.APIDocLog.Info("Dokument return to sender", "CreateDok", guid, "");

                    if (doccreate.ResultFileType == "PDF")
                    {
                        dok = dg.GetDocAsPDF(dokumentid);
                        dok.extension = "pdf";
                        dok.doktype = "P";
                        apiok.file = dok.dokument;
                        apiok.code = "OK";
                        apiok.status = "200";
                        apiok.documentid = dokumentid;
                        dg = null;
                        dok = null;
                        dokdata = null;
                        docgendata = null;

                        return Ok(apiok);
                    }
                    else
                    {
                        dok = dg.GetDoc(dokumentid);
                        apiok.file = dok.dokument;
                        apiok.code = "OK";
                        apiok.status = "200";
                        apiok.documentid = dokumentid;
                        dg = null;
                        dok = null;
                        dokdata = null;
                        docgendata = null;
                        return Ok(apiok);
                    }

                }
                if (doccreate.Versandstrasse == "true")
                {
                    clsVersandstrasse vs = new clsVersandstrasse();
                    string vsdoc = "";
                    vsdoc = vs.Prepare_PDF(dokumentid, "", connectionstring, OwnHost, key.ToString(), imagepath);
                   
                    Versandpaket vp = new Versandpaket();
                    vp.PaketNr = Guid.NewGuid().ToString();
                    vp.partnernr = Convert.ToInt32(docgendata.partnernr);
                    vp.GASAdresse = doccreate.GASAdresse;
                    if (vp.GASAdresse.ToString().Trim() == "") { vp.GAS = ""; } else { vp.GAS = "true"; }
                    vp.Versandoption = doccreate.VersandOption; ;
                    List<Versanddokument> vdoc = new List<Versanddokument>();
                    Versanddokument vd = new Versanddokument(dokumentid, doccreate.PartnerNr + " - " + dokdata.Bezeichnung, doccreate.PartnerNr);
                    vd.dokument = vsdoc;
                    vdoc.Add(vd);
                    vp.Dokument = vdoc;
                    vp.finaldoc = vsdoc;
                    vp.send_onbase_doc = true;
                    vp.verified = true;
                    send_vs(ref vp, dokdata.Ersteller, doccreate.VersandDirekt == "true", OwnHost, key.ToString(), dokumentid, doccreate.PartnerNr, null, ref apireturn);
                    if (apireturn.status != "")
                    {
                        vp = null;
                        vdoc = null;
                        doccreate = null;
                        dokdata = null;
                        //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                        return Content(HttpStatusCode.BadRequest, apireturn);
                    }
                }
                if (doccreate.ConfirmationMail == "true")
                {

                    string message = "Dokument '" + doccreate.Bezeichnung + "' für Partner " + doccreate.PartnerNr + " erstellt." + Environment.NewLine;
                    if (doccreate.Versandstrasse == "true")
                    {
                        if (doccreate.VersandDirekt == "true")
                        {
                            message = message + " Dokument über Versandstrasse versendet.";
                        }
                        else
                        {
                            message = message + " Dokument über Versandstrasse bereit gestellt.";
                        }
                    }


                }
                Logging.APIDocLog.Info("Dokument abgeschlossen", "CreateDok", guid, "");
                apireturn.code = "OK";
                apireturn.status = "200";
                apireturn.message = "Dokument generiert";
                apireturn.traceid = "";
                apireturn.field = "GUID=" + guid;

                return Ok((apireturn));
            }
            catch (Exception ex)
            {
                Logging.APIDocLog.Error("ONDOC-ERR-CreatePaketDoc", "CreateDoks", guid, ex.Message);

                apireturn.code = "ONDOC-ERR-CreatePaketDoc";
                apireturn.status = "400";
                apireturn.message = ex.Message;
                apireturn.traceid = "";
                apireturn.field = "";
                //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                return Content(HttpStatusCode.BadRequest, apireturn);
            }
            finally { apireturn = null; apiok = null; };
        }

        private string Get_OnDoc_Value(string type, string inputvalue1,string inputvalue2)
        {
            Database.DB db = new DB(connectionstring);
            db.clear_parameter();
            db.add_parameter("@fieldtype", type);
            db.add_parameter("@inputvalue1", inputvalue1);
            db.add_parameter("@inputvalue2", inputvalue2);
            try
            {
                db.Get_Tabledata("ondoc_get_clm_value", true, false);
                return db.dsdaten.Tables[0].Rows[0][0].ToString();
            }
            catch 
            {
                return "";
                    }
            finally
            {
                db = null;
            }
        }


        [HttpPost]
        [Route("API/CreateCLM")]
        public IHttpActionResult CreateCLM()
        {
            APIErrorSimple apireturn = new APIErrorSimple();
            APIOK apiok = new APIOK();

            List<CLMDocItem> clmdocitemlist = new List<CLMDocItem>();
            string clmdokumentid = "";


            dynamic dataj = null;
            try
            {
                string guid = Guid.NewGuid().ToString();
                Logging.APIDocLog.Info("Start CreateCLM", "CreateESS", guid, "");
                if (SecuringWebApiUsingApiKey.Middleware.ApiKeyMiddleware.Authorized((HttpRequestMessage)Request, tokenfunction) == false)
                {
                    apireturn.code = "ONDOC-ERR-CreateCLM-01";
                    apireturn.status = "401";
                    apireturn.message = "Invalid Token or API-Key";
                    apireturn.traceid = "";
                    apireturn.field = "";
                    try
                    {
                        //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                        //return Content(HttpStatusCode.BadRequest, apireturn);
                        return Content(HttpStatusCode.BadRequest, apireturn);
                    }
                    catch
                    {
                        //return Content(HttpStatusCode.Unauthorized, "Invalid Token or API-Key");
                        return Content(HttpStatusCode.BadRequest, apireturn);
                    }
                    finally { apireturn = null; apiok = null; clmdocitemlist = null; dataj = null; };
                }

                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;


                dataj = JsonConvert.DeserializeObject(result);
                Logging.APIDocLog.Info("Input JSON", "CreateCLM", guid, result);

                var jo = JObject.Parse(Request.Content.ReadAsStringAsync().Result);
                var x = dataj.Produkt;
                //Console.WriteLine(dataj.Bp.Zustaendiger.TgNummer);
                var valueTuples = GetNodes(jo).ToList();
                foreach (var valueTuple in valueTuples)
                {
                    CLMDocItem d = new CLMDocItem();
                    d.itemname = valueTuple.Item1;
                    d.itemtag = valueTuple.Item2;
                    d.itemvalue = valueTuple.Item3;
                    d.doclinkname = "";
                    clmdocitemlist.Add(d);

                }
                Database.DB db = new Database.DB(connectionstring);


               
                db.clear_parameter();
                db.add_parameter("@dokumenttypnr", dataj.Dokumenttyp.ToString());
                db.Get_Tabledata("sp_get_ondoc_clm_vorlagenfeld", true, false);
                //db.Get_Tabledata("Select * from vorlagenfeld where dokumenttypnr=" + dataj.Dokumenttyp.ToString() + " and aktiv=1 and ess_field_class_id<>0", false, true);
                foreach (DataRow dr in db.dsdaten.Tables[0].Rows)
                {
                    if (dr["ess_field_class_id"].ToString() == "11")
                    {
                        CLMDocItem d = new CLMDocItem();
                        d.itemname = "Logo";
                        d.itemtag = "";
                        d.itemvalue = "Logo";
                        d.type = "11";
                        d.doclinkname = "";
                        d.done = true;
                        d.bmstart = dr["beginntextmarke"].ToString();
                        d.bmend = dr["endetextmarke"].ToString();
                        d.field = dr["feldname"].ToString();
                        d.top = dr["ess_img_top"].ToString();
                        d.left = dr["ess_img_left"].ToString();
                        d.width = dr["ess_img_width"].ToString();
                        d.height = dr["ess_img_height"].ToString();
                        clmdocitemlist.Add(d);

                    }
                    if (dr["ess_field_class_id"].ToString() == "17")
                    {
                        CLMDocItem d = new CLMDocItem();
                        d.itemname = "DataMatrix";
                        d.itemtag = "";
                        d.itemvalue = dr["ess_feldname"].ToString();
                        d.type = "17";
                        d.doclinkname = "";
                        clmdokumentid = db.get_dbkey("Dokument");
                        d.itemvalue = get_datamatrix_value(d.itemvalue,clmdokumentid, ref clmdocitemlist);
                        d.done = true;
                        d.bmstart = dr["beginntextmarke"].ToString();
                        d.bmend = dr["endetextmarke"].ToString();
                        d.field = dr["feldname"].ToString();
                        d.top = dr["ess_img_top"].ToString();
                        d.left = dr["ess_img_left"].ToString();
                        d.width = dr["ess_img_width"].ToString();
                        d.height = dr["ess_img_height"].ToString();
                        clmdocitemlist.Add(d);
                        
                    }
                    if (dr["ess_field_class_id"].ToString() == "18")
                    {
                        CLMDocItem d = new CLMDocItem();
                        d.itemname = "PZ";
                        d.itemtag = "";
                        d.type = "18";
                        
                        d.itemvalue = pruefziffer(get_item_value(dr["ess_feldname"].ToString(), ref clmdocitemlist));
                        d.doclinkname = "";
                        d.done = true;
                        d.bmstart = dr["beginntextmarke"].ToString();
                        d.bmend = dr["endetextmarke"].ToString();
                        d.field = dr["feldname"].ToString();
                        d.top = dr["ess_img_top"].ToString();
                        d.left = dr["ess_img_left"].ToString();
                        d.width = dr["ess_img_width"].ToString();
                        d.height = dr["ess_img_height"].ToString();
                        clmdocitemlist.Add(d);
                    }

                    foreach (CLMDocItem di in clmdocitemlist)
                    {

                        if ("$." + di.itemname == dr["ess_feldname"].ToString() && di.done == false)
                        {
                            
                            di.done = true;
                            di.bmstart = dr["beginntextmarke"].ToString();
                            di.bmend = dr["endetextmarke"].ToString();
                            di.field = dr["feldname"].ToString();
                            di.top = dr["ess_img_top"].ToString();
                            di.left = dr["ess_img_left"].ToString();
                            di.width = dr["ess_img_width"].ToString();
                            di.height = dr["ess_img_height"].ToString();
                            di.type = dr["ess_field_class_id"].ToString();
                            switch (di.type.ToString())
                            {
                                case "7":   //Dokumentversion
                                    di.itemvalue = Get_OnDoc_Value("7", di.itemvalue.ToString(), "");
                                    break;
                                case "8":  //Bankbetriebseinheit
                                    di.itemvalue = Get_OnDoc_Value("8", di.itemvalue.ToString(), "");
                                    break;
                                case "9":  //Allg. Telefonnummer
                                    di.itemvalue = Get_OnDoc_Value("9", di.itemvalue.ToString(), "");
                                    break;
                                case "10": //Allg Faxnummer
                                    di.itemvalue = Get_OnDoc_Value("10", di.itemvalue.ToString(), "");
                                    break;
                                case "11": //Logo
                                    break;
                                case "13": //Vorname
                                    di.itemvalue = Get_OnDoc_Value("13", di.itemvalue.ToString(), "");
                                    break;
                                case "14": //MA-Name
                                    di.itemvalue = Get_OnDoc_Value("14", di.itemvalue.ToString(), "");
                                    break;
                                case "15": //MA-E-Mail
                                    di.itemvalue = Get_OnDoc_Value("15", di.itemvalue.ToString(), "");
                                    break;
                                case "16": //MA-Direktwahl
                                    di.itemvalue = Get_OnDoc_Value("16", di.itemvalue.ToString(), "");

                                    break;
                                case "17": //Datamatrix
                                    string a = "";

                                    break;
                                case "18": //Pruefziffer
                                    di.itemvalue = pruefziffer(di.itemvalue);
                                    break;
                                default:
                                    break;

                            }
                           
                        }

                    }

                   
                    if (dr["ess_feldname"].ToString().Contains("@T:"))
                    {
                        string[] arr = dr["ess_feldname"].ToString().Split(new string[] { "$Format:" }, StringSplitOptions.None);
                        dr["ess_feldname"] = arr[0];
                        string value = "";
                        string tablename = "";
                        string format = "";

                        get_tabledata(dr["ess_feldname"].ToString(), ref clmdocitemlist, out value, out tablename);

                        CLMDocItem di = new CLMDocItem();
                        di.bmstart = dr["beginntextmarke"].ToString();
                        di.bmend = dr["endetextmarke"].ToString();
                        di.field = dr["feldname"].ToString();
                        di.top = dr["ess_img_top"].ToString();
                        di.left = dr["ess_img_left"].ToString();
                        di.width = dr["ess_img_width"].ToString();
                        di.height = dr["ess_img_height"].ToString();
                        di.type = dr["ess_field_class_id"].ToString();
                        di.itemname = tablename;
                        di.itemvalue = value;
                        di.itemname = tablename;
                        try
                        {
                            di.format = arr[1];
                        }
                        catch { di.format = ""; }
                        clmdocitemlist.Add(di);
                    }

                }
                db = null;
                clmdocitemlist.RemoveAll((y) => string.IsNullOrEmpty(y.type));

                string CheckResult = "";
                CheckResult = CLM_Verify(ref clmdocitemlist, ref result);
                if (CheckResult != "")
                {
                    Logging.APIDocLog.Error("Error Verify ", "CreateDoks", guid, CheckResult);

                    apireturn.code = "ONDOC-ERR-CreateCLM";
                    apireturn.status = "400";
                    apireturn.message = CheckResult;
                    apireturn.traceid = "";
                    apireturn.field = "";
                    //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                    return Content(HttpStatusCode.BadRequest, apireturn);
                }
                clsdok dok = new clsdok("", "", "", "");

                gendocCLM(ref clmdocitemlist, ref dataj, ref dok, key,clmdokumentid);

                Logging.APIDocLog.Info("Dokument abgeschlossen", "CreateDok", guid, "");
                apiok.code = "200";
                apiok.status = "200";
                apiok.message = "";
                apiok.documentid = dataj.Id.ToString();
                apiok.file = dok.dokument;
                return Ok((apiok));
            }
            catch (Exception ex)
            {
                Logging.APIDocLog.Error("ONDOC-ERR-CreateCLM", "CreateCLM", guid, ex.Message);

                apireturn.code = "ONDOC-ERR-CreatePaketDoc";
                apireturn.status = "400";
                apireturn.message = ex.Message;
                apireturn.traceid = "";
                apireturn.field = "";

                //return BadRequest(Newtonsoft.Json.JsonConvert.SerializeObject(apireturn));
                return Content(HttpStatusCode.BadRequest, apireturn);
            }
            finally { apireturn = null; apiok = null; clmdocitemlist = null; dataj = null; };
        }

        private void get_tabledata(string ifeldname, ref List<CLMDocItem> docitemlist, out string value, out string tablename)
        {
            //@T: Produkt.Produktinfo:Name,Beschreibung
            string Feldname = ifeldname;
            string Source = Feldname.Replace("@T:", "");
            string Tablename = Source.Split(':')[0];
            Source = Source.Replace(Tablename + ":", "");
            string[] attributs = Source.Split(',');

            var newlist = docitemlist.FindAll(s => s.itemname.Contains(Tablename));

            string suchText = Tablename;
            var treffer = docitemlist
                .Where(p => p.itemname.Contains(suchText))
                .ToList()
                .OrderBy(p => p.itemname);

            DataTable dt = new DataTable();
            foreach (string attrib in attributs)
            {
                dt.Columns.Add(attrib);
            }
            int rowcounter = 0;
            foreach (CLMDocItem di in treffer)
            {
                string x = di.itemname;
                x = x.Replace(Tablename + "[", "");
                char ch = ']';
                int offset = x.IndexOf(ch);
                string prefix = x.Substring(0, offset);
                rowcounter = Convert.ToInt32(prefix);

            }

            for (int i = 0; i < rowcounter + 1; i++)
            {
                DataRow dx = dt.NewRow();
                for (int j = 0; dt.Columns.Count > j; j++)
                {
                    foreach (CLMDocItem di in newlist)
                    {
                        if (di.itemname == Tablename + "[" + i.ToString().Trim() + "]" + "." + dt.Columns[j].ColumnName)
                        {
                            dx[dt.Columns[j]] = di.itemvalue;
                        }
                    }
                }
                dt.Rows.Add(dx);
            }
            foreach (CLMDocItem di in treffer)
            {
                docitemlist.Remove(di);
            }
            dt.AcceptChanges();
            string JSONresult;
            JSONresult = JsonConvert.SerializeObject(dt);
            tablename = Tablename;
            value = JSONresult;


        }

        #region Helper
        private IEnumerable<(string path, string key, string value)> GetNodes(JToken token)
        {
            foreach (var jt in token.Children())
            {
                if (!jt.Children().Any())
                {
                    yield return (
                        path: jt.Path,
                        key: jt.Path.Split('.').Last(),
                        value: jt.ToString()
                    );
                }

                foreach (var (path, key, value) in GetNodes(jt))
                {
                    yield return (path, key, value);
                }
            }
        }
        private string CreatePaket_Verify(ref DokumentCreate paket, ref APIErrorSimple apireturn)
        {
            try
            {
                APILogging.Log((HttpRequestMessage)Request, "Start GenDoc ", LogLevelType.Debug);
                int i = 0;
                foreach (APIDokument dokument in paket.Dokumente)
                {
                    i = i + 1;
                    if (dokument.PDFDoc != null && dokument.PDFDoc.Length > 0)
                    {
                        if (i == 1) { return "Ein Anhang (PDF-Dokument) kann nicht als erstes Dokument bereit gestellt werden."; }
                        if (!(ParamCheck("partnernr", dokument.PartnerNr.ToString()))) { return "Partnernr " + dokument.PartnerNr + " ist ungültig"; }
                        if (dokument.VorlagenTypID != "0") { return "Vorlagentyp muss bei PDF-Dokumenten '0' sein"; }
                        break;
                    }
                    if (!(ParamCheck("partnernr", dokument.PartnerNr.ToString()))) { return "PartnerNr " + dokument.PartnerNr + " ist ungültig"; }
                    if (dokument.VorlagenTypID == "" && dokument.PDFDoc == "") { return "Vorlagentyp emptry und PDFDoc empty"; }
                    if (!(ParamCheck("dokumenttyp", dokument.VorlagenTypID))) { return "Vorlagentyp " + dokument.VorlagenTypID + " ist ungültig"; }
                    if (!(ParamCheck("tgnr", dokument.TGNrErsteller))) { return "TGNr-Ersteller " + dokument.TGNrErsteller + " ist ungültig"; }
                    if (!(ParamCheck("tgnr", dokument.TGNrVerantwortlich))) { return "TGNr-Verantwortlich " + dokument.TGNrVerantwortlich + " ist ungültig"; }
                    if (!(ParamCheck("tgnr", dokument.TGNrUnterschriftLinks))) { return "TGNr-Unterschriftlinks " + dokument.TGNrUnterschriftLinks + " ist ungültig"; }
                    if (!(ParamCheck("tgnr", dokument.TGNrUnterschriftRechts))) { return "TGNr-Unterschriftrechts " + dokument.TGNrUnterschriftRechts + " ist ungültig"; }
                    if (!(ParamCheck("yesno", dokument.FaksimileUnterschrift))) { return "Parameter Faxsimile  " + dokument.FaksimileUnterschrift + " ist ungültig"; }
                    if (!(ParamCheck("yesno", dokument.OhneUnterschrift))) { return "Parameter Form ohne Unterschrift " + dokument.OhneUnterschrift + " ist ungültig"; }
                    if (!(ParamCheck("yesno", dokument.PrintLogo))) { return "Parameter PrintLogo " + dokument.PrintLogo + " ist ungültig"; }
                    if (!(ParamCheck("yesno", dokument.UnterschriftLinksGeprueft))) { return "Parameter UnterschriftLinksGeprueft" + dokument.UnterschriftLinksGeprueft + " ist ungültig"; }
                    if (!(ParamCheck("yesno", dokument.UnterschriftRechtsGeprueft))) { return "Parameter UnterschriftRechtsGeprueft" + dokument.UnterschriftRechtsGeprueft + " ist ungültig"; }
                    if (dokument.TGNrUnterschriftLinks.ToString() == "") { dokument.TGNrUnterschriftLinks = "-1"; }
                    if (dokument.TGNrUnterschriftRechts.ToString() == "") { dokument.TGNrUnterschriftRechts = "-1"; }
                    if (dokument.FaksimileUnterschrift.ToUpper() == "TRUE")
                    {
                        if (dokument.TGNrUnterschriftLinks.ToString() == "-1") { return "Faksimile Unterschrift benötigt mit den Parameter TGUnterschriftLinks"; }
                        if (dokument.TGNrUnterschriftLinks.ToString() != "")
                        {
                            string path = System.Configuration.ConfigurationManager.AppSettings["UnterschriftPath"].ToString() + dokument.TGNrUnterschriftLinks.ToString() + ".jpg";
                            if (!System.IO.File.Exists(path)) { return "Image Unterschrift links " + dokument.TGNrUnterschriftLinks + " ist nicht vorhanden"; }
                        }
                        if (dokument.TGNrUnterschriftRechts.ToString() != "-1")
                        {
                            string path = System.Configuration.ConfigurationManager.AppSettings["UnterschriftPath"].ToString() + dokument.TGNrUnterschriftLinks.ToString() + ".jpg";
                            if (!System.IO.File.Exists(path)) { return "Image Unterschrift rechts " + dokument.TGNrUnterschriftRechts + " ist nicht vorhanden"; }
                        }
                    }
                    if (paket.Versandstrasse == "true")
                    {
                        if (dokument.TGNrUnterschriftLinks != "" && dokument.UnterschriftLinksGeprueft != "true" && paket.OnDocSignCheck != "true")
                        {
                            return "Versandstrasse mit ungeprüfter, linker Unterschrift ist nicht möglich";
                        }
                        if (dokument.TGNrUnterschriftRechts != "" && dokument.UnterschriftRechtsGeprueft != "true" && paket.OnDocSignCheck != "true")
                        {
                            return "Versandstrasse mit ungeprüfter, rechter Unterschrift ist nicht möglich";
                        }
                        if (ParamCheck("doktypversandstrasse", dokument.VorlagenTypID) == false) { return "Vorlagentyp " + dokument.VorlagenTypID + " ist nicht für die Versandstrasse konfiguriert"; }
                        if (i == 1)
                        {
                            if (ParamCheck("firstdoc", dokument.VorlagenTypID) == false) { return "Vorlagentyp " + dokument.VorlagenTypID + " kann nicht als erstes Dokument im Paket sein"; }
                        }
                        //if (dokument.TGNrUnterschriftLinks.ToLower() != "-1" && dokument.TGNrUnterschriftRechts.ToString() != "-1") { return "Versandstrasse mit zwei Unterschriften kann nicht automatisch angesteuert werden"; }

                    }

                }

                if (!(ParamCheck("yesno", paket.Versandstrasse))) { return "Parameter Versandstrasse " + paket.Versandstrasse + " ist ungültig"; }
                if (!(ParamCheck("yesno", paket.VersandDirekt))) { return "Parameter Versand Direkt " + paket.VersandDirekt + " ist ungültig"; }
                if (!(ParamCheck("yesno", paket.ResultOnDoc))) { return "Parameter Result_OnDoc " + paket.ResultOnDoc + " ist ungültig"; }
                if (!(ParamCheck("yesno", paket.ResultSender))) { return "Parameter Result_Sender " + paket.ResultSender + " ist ungültig"; }
                if (!(ParamCheck("filetype", paket.ResultFileType))) { return "Parameter Result_Filetype " + paket.ResultFileType + " ist ungültig"; }
                if (!(ParamCheck("yesno", paket.ConfirmationMail))) { return "Parameter ConfirmationMail " + paket.ConfirmationMail + " ist ungültig"; }
                if (!(ParamCheck("yesno", paket.ConfirmationMail))) { return "Parameter ConfirmationMail " + paket.ConfirmationMail + " ist ungültig"; }
                if (!(ParamCheck("versandoption", paket.VersandOption))) { return "Versandoption  " + paket.VersandOption + " ist ungültig"; }
                if (paket.ConfirmationMail.ToUpper() == "YES" && paket.ConfirmationMailAddress.ToString() != "") { return "E-Mailadresse für Confirmation fehlt"; }

                if (paket.Versandstrasse == "true")
                {
                    if (paket.VersandOption == "") { return "Versandoption fehlt (A_Post, B1_Post, B2_Post"; }
                }
                return "";
            }
            catch (Exception ex) { return ex.Message; }

        }

        private string CreateDoc_Verify(ref DocCreate doccreate)
        {
            try
            {
                APILogging.Log((HttpRequestMessage)Request, "Start GenDoc ", LogLevelType.Debug);
                if (!(ParamCheck("partnernr", doccreate.PartnerNr.ToString()))) { return "Partnernr " + doccreate.PartnerNr + " ist ungültig"; }
                if (!(ParamCheck("dokumenttyp", doccreate.VorlagenTypID))) { return "Vorlagentyp " + doccreate.VorlagenTypID + " ist ungültig"; }
                if (!(ParamCheck("tgnr", doccreate.TGNrErsteller))) { return "TGNr-Ersteller " + doccreate.TGNrErsteller + " ist ungültig"; }
                if (!(ParamCheck("tgnr", doccreate.TGNrVerantwortlich))) { return "TGNr-Verantwortlich " + doccreate.TGNrVerantwortlich + " ist ungültig"; }
                if (!(ParamCheck("tgnr", doccreate.TGNrUnterschriftLinks))) { return "TGNr-Unterschriftlinks " + doccreate.TGNrUnterschriftLinks + " ist ungültig"; }
                if (!(ParamCheck("tgnr", doccreate.TGNrUnterschriftRechts))) { return "TGNr-Unterschriftrechts " + doccreate.TGNrUnterschriftRechts + " ist ungültig"; }
                if (!(ParamCheck("yesno", doccreate.FaksimileUnterschrift))) { return "Parameter Faxsimile  " + doccreate.FaksimileUnterschrift + " ist ungültig"; }
                if (!(ParamCheck("yesno", doccreate.OhneUnterschrift))) { return "Parameter Form ohne Unterschrift " + doccreate.OhneUnterschrift + " ist ungültig"; }
                if (!(ParamCheck("yesno", doccreate.PrintLogo))) { return "Parameter PrintLogo " + doccreate.PrintLogo + " ist ungültig"; }
                if (!(ParamCheck("yesno", doccreate.Versandstrasse))) { return "Parameter Result_Versandstrasse " + doccreate.Versandstrasse + " ist ungültig"; }
                if (!(ParamCheck("yesno", doccreate.VersandDirekt))) { return "Parameter Versand Direkt " + doccreate.VersandDirekt + " ist ungültig"; }
                if (!(ParamCheck("yesno", doccreate.ResultOnDoc))) { return "Parameter Result_OnDoc " + doccreate.ResultOnDoc + " ist ungültig"; }
                if (!(ParamCheck("yesno", doccreate.ResultSender))) { return "Parameter Result_Sender " + doccreate.ResultSender + " ist ungültig"; }
                if (!(ParamCheck("filetype", doccreate.ResultFileType))) { return "Parameter Result_Filetype " + doccreate.ResultFileType + " ist ungültig"; }
                if (!(ParamCheck("yesno", doccreate.ConfirmationMail))) { return "Parameter ConfirmationMail " + doccreate.ConfirmationMail + " ist ungültig"; }
                if (!(ParamCheck("yesno", doccreate.ConfirmationMail))) { return "Parameter ConfirmationMail " + doccreate.ConfirmationMail + " ist ungültig"; }
                if (!(ParamCheck("versandoption", doccreate.VersandOption))) { return "Versandoption  " + doccreate.VersandOption + " ist ungültig"; }
                if (doccreate.ConfirmationMail.ToUpper() == "TRUE" && doccreate.ConfirmationMailAddress.ToString() != "") { return "E-Mailadresse für Confirmation fehlt"; }
                if (doccreate.TGNrUnterschriftLinks.ToString() == "") { doccreate.TGNrUnterschriftLinks = "-1"; }
                if (doccreate.TGNrUnterschriftRechts.ToString() == "") { doccreate.TGNrUnterschriftRechts = "-1"; }
                if (doccreate.FaksimileUnterschrift.ToUpper() == "TRUE")
                {
                    if (doccreate.TGNrUnterschriftLinks.ToString() == "-1") { return "Faksimile Unterschrift benötigt mit den Parameter TGUnterschriftLinks"; }
                    if (doccreate.TGNrUnterschriftLinks.ToString() != "")
                    {
                        string path = System.Configuration.ConfigurationManager.AppSettings["UnterschriftPath"].ToString() + doccreate.TGNrUnterschriftLinks.ToString() + ".jpg";
                        if (!System.IO.File.Exists(path)) { return "Image Unterschrift links " + doccreate.TGNrUnterschriftLinks + " ist nicht vorhanden"; }
                    }
                    if (doccreate.TGNrUnterschriftRechts.ToString() != "-1")
                    {
                        string path = System.Configuration.ConfigurationManager.AppSettings["UnterschriftPath"].ToString() + doccreate.TGNrUnterschriftLinks.ToString() + ".jpg";
                        if (!System.IO.File.Exists(path)) { return "Image Unterschrift rechts " + doccreate.TGNrUnterschriftRechts + " ist nicht vorhanden"; }
                    }
                }
                if (doccreate.Versandstrasse == "true")
                {
                    if (ParamCheck("doktypversandstrasse", doccreate.VorlagenTypID) == false) { return "Vorlagentyp " + doccreate.VorlagenTypID + " ist nicht für die Versandstrasse konfiguriert"; }
                    //if (doccreate.TGNrUnterschriftLinks.ToLower() != "-1" && doccreate.TGNrUnterschriftRechts.ToLower() != "-1")
                    //{ 
                    //    return "Versandstrasse mit zwei Unterschriften kann nicht automatisch angesteuert werden"; 
                    //}
                    if (doccreate.VersandOption == "") { return "Versandoption fehlt (A_Post, B1_Post, B2_Post"; }
                }
                return "";
            }
            catch (Exception ex) { return ex.Message; }
        }
        private string CLM_Verify(ref List<CLMDocItem> clmdocitemlist, ref string json)
        {
            try
            {
                dynamic dataj = JsonConvert.DeserializeObject(json);
                if (!ParamCheck("dokumenttyp", dataj.Dokumenttyp.ToString())) { return "Vorlagentyp " + dataj.Dokumenttyp.ToString() + " ist ungültig"; }
                if (dataj.Id.ToString() == "") { return "ID fehlt"; }
                return "";
            }
            catch (Exception ex) { return ex.Message; }
        }

        private bool ParamCheck(string ParamType, string ParamValue)
        {
            DB db = new DB(connectionstring);
            try
            {

                switch (ParamType)
                {
                    case "partnernr":
                        db.Get_Tabledata("Select count(*) from partner where nrpar00=" + ParamValue, false, true);
                        if (db.dsdaten.Tables[0].Rows[0][0].ToString() == "0") { return false; }
                        break;
                    case "dokumenttyp":
                        db.Get_Tabledata("Select count(*) from dokumenttyp where dokumenttypnr=" + ParamValue, false, true);
                        if (db.dsdaten.Tables[0].Rows[0][0].ToString() == "0") { return false; }
                        break;
                    case "partnerdokumenttyp":
                        //Prüfung Person/Doktyp BP/Doktyp
                        break;
                    case "tgcreator":
                    case "tgresp":
                    case "tgul":
                    case "tgur":
                    case "tgnr":
                        if (ParamType == "tgcreator" && ParamValue == "") { return false; } else { if (ParamValue == "") { return true; } };
                        db.Get_Tabledata("Select count(*) from mitarbeiter where tgnummer='" + ParamValue + "'", false, true);
                        if (db.dsdaten.Tables[0].Rows[0][0].ToString() == "0") { return false; }
                        break;
                    case "yesno":
                        if (ParamValue != "true" && ParamValue != "false" && ParamValue != "") { return false; };
                        break;
                    case "filetype":
                        if (ParamValue != "WORD" && ParamValue != "PDF") { return false; }
                        break;
                    case "versandoption":
                        if (ParamValue != "A_POST" && ParamValue != "B1_POST" && ParamValue != "B2_POST" && ParamValue != "") { return false; }
                        break;
                    case "doktypversandstrasse":
                        db.Get_Tabledata("Select versandstrasse_moeglich, versandstrasse_firstdoc from dokumenttyp where dokumenttypnr=" + ParamValue, false, true);
                        if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][0]) == 0) { return false; }
                        break;
                    case "firstdoc":
                        db.Get_Tabledata("Select versandstrasse_moeglich, versandstrasse_firstdoc from dokumenttyp where dokumenttypnr=" + ParamValue, false, true);
                        if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][1]) == 0) { return false; }
                        break;
                    default:
                        return false;
                        break;
                }
                return true;
            }
            catch
            {
                return false;
            }
            finally
            {
                db = null;
            }
        }
        private string gendoc(ref DocCreate doccreate, ref clsDocData dokdata, ref Model.clsdocgendata docgendata, string key)
        {
          
                string OwnHost = System.Configuration.ConfigurationManager.AppSettings["OwnHost"].ToString();
                string imagepath = System.Configuration.ConfigurationManager.AppSettings["VSImagePath"].ToString();

                string dokumentid = "";
                ;
                Database.DB db = new DB(connectionstring);
                db.Get_Tabledata("Select * from dokumenttyp where dokumenttypnr=" + doccreate.VorlagenTypID, false, true);
                System.Data.DataRow dr = db.dsdaten.Tables[0].Rows[0];
                dokdata.Barcode = Convert.ToBoolean(dr["Vertrag"]) == true;
                db.Get_Tabledata("Select beschreibung from physischesarchiv where physischesarchivnr = " + dr["physisches_archiv"].ToString(), false, true);
                dokdata.barcode_zusatz = db.dsdaten.Tables[0].Rows[0][0].ToString();
                if (dokdata.barcode_zusatz != "") { dokdata.barcode_zusatz = " " + dokdata.barcode_zusatz; }

                db.Get_Tabledata("Select office_vorlagenr,kopfzeile_generieren, bcpt,bcpl, bcw, bch, bchorizontal, barcodetype, datamatrixcontent  from office_vorlage where office_vorlagenr=" + dr["office_vorlagenr"].ToString(), false, true);
                dokdata.VorlageNr = Convert.ToInt32(dr["office_vorlagenr"]).ToString(); ;
                try
                {
                    dokdata.Kopfzeile_generieren = false;
                    if (Convert.ToBoolean(db.dsdaten.Tables[0].Rows[0][1]) == true) { dokdata.Kopfzeile_generieren = true; }
                }
                catch { }

                if (dokdata.Barcode)
                {
                    dokdata.barcode_left = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bcpl"]);
                    dokdata.barcode_top = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bcpt"]);
                    dokdata.barcode_width = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bcw"]);
                    dokdata.barcode_height = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bch"]);
                    dokdata.barcode_horizontal = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bchorizontal"]);
                    dokdata.barcode_type = db.dsdaten.Tables[0].Rows[0]["BarcodeType"].ToString();
                    dokdata.barcode_content = db.dsdaten.Tables[0].Rows[0]["DatamatrixContent"].ToString();
                    string sql = "";
                    sql = "select bcpt, bcpl, bcw, bch, bchorizontal from OnDocBarcodeMpping ";
                    sql = sql + "where orig_bcpt = " + dokdata.barcode_top.ToString() + " and orig_bcpl=" + dokdata.barcode_left.ToString() + " ";
                    sql = sql + "and orig_bcw=" + dokdata.barcode_width.ToString() + " and orig_bch=" + dokdata.barcode_height.ToString();
                    db.Get_Tabledata(sql, false, true);
                    if (db.dsdaten.Tables[0].Rows.Count > 0)
                    {
                        dokdata.barcode_left = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bcpl"]);
                        dokdata.barcode_top = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bcpt"]);
                        dokdata.barcode_width = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bcw"]);
                        dokdata.barcode_height = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bch"]);
                    }
                    if (dokdata.barcode_type == "1")
                    {
                        DB dB = new DB(connectionstring);
                        dB.clear_parameter();
                        dB.add_parameter("@dokumentid", dokumentid);
                        dB.add_parameter("@DokumentidBR", "");
                        dB.add_parameter("@BARCODEFONTNAME", "");
                        dB.add_parameter("@BARCODEFONTSIZE", "");
                        dB.add_parameter("@BarcodeKantenlaenge", "");
                        dB.Get_Tabledata("sp_get_OnDoc_barcodetype_and_value", true, false);
                        dokdata.barcode_content = dB.dsdaten.Tables[0].Rows[0][1].ToString();
                        dokdata.barcode_formatn = dB.dsdaten.Tables[0].Rows[0][3].ToString();
                        dokdata.barcode_text = dB.dsdaten.Tables[0].Rows[0][4].ToString();
                        dokdata.barcode_kantenlaenge = dB.dsdaten.Tables[0].Rows[0][5].ToString();
                        dokdata.Zusatz_Font = dB.dsdaten.Tables[0].Rows[0][6].ToString();
                        dokdata.Zusatz_FontSize = Convert.ToInt32(dB.dsdaten.Tables[0].Rows[0][7]);
                        dokdata.barcode_width = Convert.ToInt32(dB.dsdaten.Tables[0].Rows[0][8]);
                        dokdata.barcode_height = Convert.ToInt32(dB.dsdaten.Tables[0].Rows[0][9]);

                        //dokdata.barcode_type= dB.dsdaten.Tables[0].Rows[0][3].ToString();

                        sql = "select bcpt, bcpl, bcw, bch, bchorizontal from OnDocBarcodeMpping ";
                        sql = sql + "where orig_bcpt = " + dokdata.barcode_top.ToString() + " and orig_bcpl=" + dokdata.barcode_left.ToString() + " ";
                        sql = sql + "and orig_bcw=" + dokdata.barcode_width.ToString() + " and orig_bch=" + dokdata.barcode_height.ToString();
                        dB.Get_Tabledata(sql, false, true);
                        if (dB.dsdaten.Tables[0].Rows.Count > 0)
                        {
                            Logging.Logging.Debug("Barcode-Übersteuerung" + dokdata.DokumenttypNr.ToString(), "Dokumenterstellung", "");
                            dokdata.barcode_left = Convert.ToInt32(dB.dsdaten.Tables[0].Rows[0]["bcpl"]);
                            dokdata.barcode_top = Convert.ToInt32(dB.dsdaten.Tables[0].Rows[0]["bcpt"]);
                            dokdata.barcode_width = Convert.ToInt32(dB.dsdaten.Tables[0].Rows[0]["bcw"]);
                            dokdata.barcode_height = Convert.ToInt32(dB.dsdaten.Tables[0].Rows[0]["bch"]);
                        }
                    }
                    db.Get_Tabledata("Select * from ondoc_appparams", false, true);
                    dokdata.barcode_font = db.dsdaten.Tables[0].Rows[0]["barcodefont"].ToString();
                    dokdata.barcode_fontsize = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["barcodefontsize"].ToString());
                    dokdata.Zusatz_Font = db.dsdaten.Tables[0].Rows[0]["Zusatzfont"].ToString();
                    dokdata.Zusatz_FontSize = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["ZusatzfontSize"].ToString());
                    dokdata.barcode_textposition = db.dsdaten.Tables[0].Rows[0]["barcodetextposition"].ToString(); ;
                }

                DataTable dokwertlist = new DataTable();
                dokwertlist = db.Get_DokumentWertList("", Convert.ToInt32(doccreate.VorlagenTypID), 1);

                docgendata.dokumentwerte = dokwertlist;
                docgendata.partnernr = doccreate.PartnerNr;
                docgendata.inhaberadresse = "";
                docgendata.zustelladresse = "";
                docgendata.dokumenttypnr = doccreate.VorlagenTypID;
                docgendata.unterschriftLinks = db.Get_Mitarbeiternr(doccreate.TGNrUnterschriftLinks).ToString();
                docgendata.unterschriftRehts = db.Get_Mitarbeiternr(doccreate.TGNrUnterschriftRechts).ToString();
                docgendata.verantwortlich = db.Get_Mitarbeiternr(doccreate.TGNrVerantwortlich).ToString();
                docgendata.ersteller = db.Get_Mitarbeiternr(doccreate.TGNrErsteller).ToString();
                docgendata.team = db.Get_Teamnr(docgendata.ersteller).ToString();
                docgendata.digitaleunterschrift = false;
                docgendata.frormularOhneUnterschrift = doccreate.OhneUnterschrift == "true";
                docgendata.zustaendigkube = db.Get_Mitarbeiternr(doccreate.TGNrVerantwortlich).ToString();
                docgendata.status = "-1";
                docgendata.dokumentdatum = DateTime.Now.ToString("dd.MM.yyyy");
                docgendata.dokumentdatum = doccreate.Dokumentdatum;
                docgendata.frormularOhneUnterschrift = doccreate.OhneUnterschrift == "true";
                docgendata.bezeichnung = doccreate.Bezeichnung;
                if (doccreate.ResultFileType == "WORD") { docgendata.erstellungsart = Erstellungsart.DokumentBearbeiten; } else { docgendata.erstellungsart = Erstellungsart.DokumentAlsPDF; }
                if (docgendata.verantwortlich == "0") { docgendata.verantwortlich = docgendata.ersteller; }


                dokdata.PartnerNr = docgendata.partnernr;
                dokdata.UseEDOKA_Values = "True";
                dokdata.DokumenttypNr = docgendata.dokumenttypnr;
                dokdata.Unterschrift_Links = docgendata.unterschriftLinks;
                if (dokdata.Unterschrift_Links == "0") { dokdata.Unterschrift_Links = "-1"; }
                dokdata.Unterschrift_Rechts = docgendata.unterschriftRehts;
                if (dokdata.Unterschrift_Rechts == "0") { dokdata.Unterschrift_Rechts = "-1"; }
                dokdata.Verantwortlich = docgendata.verantwortlich;
                dokdata.Team = docgendata.team;
                dokdata.Zustaendig = docgendata.zustaendigkube;
                dokdata.Zustaendig = docgendata.zustaendigkube;
                dokdata.Status = docgendata.status;
                dokdata.Ersteller = docgendata.ersteller;
                dokdata.DokumentDatum = docgendata.dokumentdatum;
                dokdata.Termin = "01.01.1900";
                dokdata.Bezeichnung = docgendata.bezeichnung;
                dokdata.dokumentwerte = docgendata.dokumentwerte;

                //Unterschriftenprüfung
                dokdata.Form_ohne_Unterschrift = docgendata.frormularOhneUnterschrift.ToString();
                dokdata.approval1 = 0;
                dokdata.approval2 = 0;
                dokdata.approved = 0;
                if (dokdata.Form_ohne_Unterschrift == "True")
                {
                    dokdata.Unterschrift_Links = "-1";
                    dokdata.Unterschrift_Rechts = "-1";
                }
            if (doccreate.FaksimileUnterschrift == "true")
            {
                dokdata.As_Faksimile = "True"; dokdata.sign = true; docgendata.digitaleunterschrift = true;
                if (dokdata.Unterschrift_Links != "-1") { dokdata.approval1 = 1; }
                if (dokdata.Unterschrift_Rechts != "-1") { dokdata.approval2 = 1; }
                dokdata.approved = 1;
            }
                //if ((dokdata.Unterschrift_Links != "-1" && dokdata.Unterschrift_Rechts == "-1") || doccreate.fromAPI==true)
                //    {
                //        if (dokdata.Ersteller == dokdata.Unterschrift_Links)
                //        {
                //            dokdata.approved = 1;
                //        }
                //        else
                //        {
                //            dokdata.sign = false;
                //            dokdata.toapprove = 1;
                //            dokdata.approved = 0;
                //            dokdata.approval1 = 0;
                //            dokdata.approval2 = 1;
                //            docgendata.erstellungsart = Erstellungsart.DokumentBearbeiten;
                //        }

                //    }
                //    else
                //    {
                //        docgendata.erstellungsart = Erstellungsart.DokumentBearbeiten;
                //        dokdata.toapprove = 1;
                //        dokdata.sign = false;
                //    }

                //}

                dokdata.APIValues = doccreate.APIValues;
                dokdata.TextToReplace = doccreate.TextToReplace;

                if (doccreate.PrintLogo == "true") { dokdata.PrintLogo = true; } else { dokdata.PrintLogo = false; }
                if (docgendata.erstellungsart == Erstellungsart.DokumentAlsPDF) { dokdata.Result_as_PDF = "True"; } else { dokdata.Result_as_PDF = "False"; }
                if (docgendata.digitaleunterschrift == true) { dokdata.As_Faksimile = "True"; } else { dokdata.As_Faksimile = "False"; }

                dokumentid = db.Create_EDOKA_Doc(dokdata, false, "");
                dokdata.Dokumentid = dokumentid;

                DOCGEN.Generator.DocGenerator_from_EDOKA Generator = new DOCGEN.Generator.DocGenerator_from_EDOKA(this.connectionstring, OwnHost, key.ToString());
                clsdok dok = new clsdok("", "", "", "");
                dok = Generator.Generate_Doc_EDOKA(dokumentid, ref dokdata, false, 0, false, false);
                db.Save_To_DB(dokumentid, "", dok.dokument);
                APILogging.Log((HttpRequestMessage)Request, "Ende GenDoc DokumentID:" + dokumentid, LogLevelType.Debug);
                APILogging.DocLog((HttpRequestMessage)Request, doccreate.PartnerNr, "Dokument über API erstellt", dokumentid, LogLevelType.Info);
                Generator = null;
                db = null;
                return "";
           

        }
        private void gendocCLM(ref List<CLMDocItem> clmdocitemlist, ref dynamic dataj, ref clsdok dok, string key, string clmdokumentid)
        {
            string OwnHost = System.Configuration.ConfigurationManager.AppSettings["OwnHost"].ToString();
            string imagepath = System.Configuration.ConfigurationManager.AppSettings["VSImagePath"].ToString();
            clsDocData dokdata = new clsDocData();
            string dokumentid = clmdokumentid;
            dokdata.Dokumentid = clmdokumentid;
            string bezeichnung = "";
            ;
            Database.DB db = new DB(connectionstring);
            db.Get_Tabledata("Select * from dokumenttyp where dokumenttypnr=" + dataj.Dokumenttyp.ToString(), false, true);
            System.Data.DataRow dr = db.dsdaten.Tables[0].Rows[0];
            bezeichnung = db.dsdaten.Tables[0].Rows[0]["Bezeichnung"].ToString();
            dokdata.Barcode = Convert.ToBoolean(dr["Vertrag"]) == true;
            db.Get_Tabledata("Select beschreibung from physischesarchiv where physischesarchivnr = " + dr["physisches_archiv"].ToString(), false, true);
            dokdata.barcode_zusatz = db.dsdaten.Tables[0].Rows[0][0].ToString();
            if (dokdata.barcode_zusatz != "") { dokdata.barcode_zusatz = " " + dokdata.barcode_zusatz; }

            db.Get_Tabledata("Select office_vorlagenr,kopfzeile_generieren, bcpt,bcpl, bcw, bch, bchorizontal, barcodetype, datamatrixcontent  from office_vorlage where office_vorlagenr=" + dr["office_vorlagenr"].ToString(), false, true);
            dokdata.VorlageNr = Convert.ToInt32(dr["office_vorlagenr"]).ToString(); ;
            try
            {
                dokdata.Kopfzeile_generieren = false;
                if (Convert.ToBoolean(db.dsdaten.Tables[0].Rows[0][1]) == true) { dokdata.Kopfzeile_generieren = true; }
            }
            catch { }

            if (dokdata.Barcode)
            {
                dokdata.barcode_left = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bcpl"]);
                dokdata.barcode_top = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bcpt"]);
                dokdata.barcode_width = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bcw"]);
                dokdata.barcode_height = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bch"]);
                dokdata.barcode_horizontal = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bchorizontal"]);
                dokdata.barcode_type = db.dsdaten.Tables[0].Rows[0]["BarcodeType"].ToString();
                dokdata.barcode_content = db.dsdaten.Tables[0].Rows[0]["DatamatrixContent"].ToString();
                string sql = "";
                sql = "select bcpt, bcpl, bcw, bch, bchorizontal from OnDocBarcodeMpping ";
                sql = sql + "where orig_bcpt = " + dokdata.barcode_top.ToString() + " and orig_bcpl=" + dokdata.barcode_left.ToString() + " ";
                sql = sql + "and orig_bcw=" + dokdata.barcode_width.ToString() + " and orig_bch=" + dokdata.barcode_height.ToString();
                db.Get_Tabledata(sql, false, true);
                if (db.dsdaten.Tables[0].Rows.Count > 0)
                {
                    dokdata.barcode_left = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bcpl"]);
                    dokdata.barcode_top = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bcpt"]);
                    dokdata.barcode_width = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bcw"]);
                    dokdata.barcode_height = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["bch"]);
                }
                if (dokdata.barcode_type == "1")
                {
                    DB dB = new DB(connectionstring);
                    dB.clear_parameter();
                    dB.add_parameter("@dokumentid", dokumentid);
                    dB.add_parameter("@DokumentidBR", "");
                    dB.add_parameter("@BARCODEFONTNAME", "");
                    dB.add_parameter("@BARCODEFONTSIZE", "");
                    dB.add_parameter("@BarcodeKantenlaenge", "");
                    dB.Get_Tabledata("sp_get_OnDoc_barcodetype_and_value", true, false);
                    dokdata.barcode_content = dB.dsdaten.Tables[0].Rows[0][1].ToString();
                    dokdata.barcode_formatn = dB.dsdaten.Tables[0].Rows[0][3].ToString();
                    dokdata.barcode_text = dB.dsdaten.Tables[0].Rows[0][4].ToString();
                    dokdata.barcode_kantenlaenge = dB.dsdaten.Tables[0].Rows[0][5].ToString();
                    dokdata.Zusatz_Font = dB.dsdaten.Tables[0].Rows[0][6].ToString();
                    dokdata.Zusatz_FontSize = Convert.ToInt32(dB.dsdaten.Tables[0].Rows[0][7]);
                    dokdata.barcode_width = Convert.ToInt32(dB.dsdaten.Tables[0].Rows[0][8]);
                    dokdata.barcode_height = Convert.ToInt32(dB.dsdaten.Tables[0].Rows[0][9]);

                    //dokdata.barcode_type= dB.dsdaten.Tables[0].Rows[0][3].ToString();

                    sql = "select bcpt, bcpl, bcw, bch, bchorizontal from OnDocBarcodeMpping ";
                    sql = sql + "where orig_bcpt = " + dokdata.barcode_top.ToString() + " and orig_bcpl=" + dokdata.barcode_left.ToString() + " ";
                    sql = sql + "and orig_bcw=" + dokdata.barcode_width.ToString() + " and orig_bch=" + dokdata.barcode_height.ToString();
                    dB.Get_Tabledata(sql, false, true);
                    if (dB.dsdaten.Tables[0].Rows.Count > 0)
                    {
                        Logging.Logging.Debug("Barcode-Übersteuerung" + dokdata.DokumenttypNr.ToString(), "Dokumenterstellung", "");
                        dokdata.barcode_left = Convert.ToInt32(dB.dsdaten.Tables[0].Rows[0]["bcpl"]);
                        dokdata.barcode_top = Convert.ToInt32(dB.dsdaten.Tables[0].Rows[0]["bcpt"]);
                        dokdata.barcode_width = Convert.ToInt32(dB.dsdaten.Tables[0].Rows[0]["bcw"]);
                        dokdata.barcode_height = Convert.ToInt32(dB.dsdaten.Tables[0].Rows[0]["bch"]);
                    }
                }
                db.Get_Tabledata("Select * from ondoc_appparams", false, true);
                dokdata.barcode_font = db.dsdaten.Tables[0].Rows[0]["barcodefont"].ToString();
                dokdata.barcode_fontsize = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["barcodefontsize"].ToString());
                dokdata.Zusatz_Font = db.dsdaten.Tables[0].Rows[0]["Zusatzfont"].ToString();
                dokdata.Zusatz_FontSize = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["ZusatzfontSize"].ToString());
                dokdata.barcode_textposition = db.dsdaten.Tables[0].Rows[0]["barcodetextposition"].ToString(); ;
            }
            clsdocgendata docgendata = new clsdocgendata();

            docgendata.partnernr = dataj.Bp.Partnernummer.ToString().Replace(".", "");
            docgendata.inhaberadresse = "";
            docgendata.zustelladresse = "";
            docgendata.dokumenttypnr = dataj.Dokumenttyp.ToString();
            docgendata.unterschriftLinks = System.Configuration.ConfigurationManager.AppSettings["CLMUnterschriftlinks"].ToString();
            docgendata.unterschriftRehts = System.Configuration.ConfigurationManager.AppSettings["CLMUnterschriftrechts"].ToString();
            docgendata.verantwortlich = System.Configuration.ConfigurationManager.AppSettings["CLMVerantwortung"].ToString();
            docgendata.ersteller = System.Configuration.ConfigurationManager.AppSettings["CLMVerantwortung"].ToString();
            docgendata.team = System.Configuration.ConfigurationManager.AppSettings["CLMTeam"].ToString();
            docgendata.digitaleunterschrift = false;
            docgendata.frormularOhneUnterschrift = false;
            docgendata.zustaendigkube = System.Configuration.ConfigurationManager.AppSettings["CLMKube"].ToString(); ;
            docgendata.status = "-1";
            docgendata.dokumentdatum = DateTime.Now.ToString("dd.MM.yyyy");
            docgendata.dokumentdatum = DateTime.Now.ToString();
            docgendata.bezeichnung = bezeichnung;

            dokdata.PartnerNr = docgendata.partnernr;
            dokdata.UseEDOKA_Values = "True";
            dokdata.DokumenttypNr = docgendata.dokumenttypnr;
            dokdata.Unterschrift_Links = docgendata.unterschriftLinks;
            if (dokdata.Unterschrift_Links == "0") { dokdata.Unterschrift_Links = "-1"; }
            dokdata.Unterschrift_Rechts = docgendata.unterschriftRehts;
            if (dokdata.Unterschrift_Rechts == "0") { dokdata.Unterschrift_Rechts = "-1"; }
            dokdata.Verantwortlich = docgendata.verantwortlich;
            dokdata.Team = docgendata.team;
            dokdata.Zustaendig = docgendata.zustaendigkube;
            dokdata.Zustaendig = docgendata.zustaendigkube;
            dokdata.Status = docgendata.status;
            dokdata.Ersteller = docgendata.ersteller;
            dokdata.DokumentDatum = docgendata.dokumentdatum;
            dokdata.Termin = "01.01.1900";
            dokdata.Bezeichnung = docgendata.bezeichnung;
            dokdata.dokumentwerte = docgendata.dokumentwerte;

            List<CLMDocItem> deflist = new List<CLMDocItem>();
            foreach (CLMDocItem item in clmdocitemlist)
            {
                if (item.type == null || item.type == String.Empty || item.type == "")
                {

                }
                else
                {
                    deflist.Add(item);
                }

            }

            dokdata.CLMDocItems = deflist;

            //Unterschriftenprüfung
            dokdata.Form_ohne_Unterschrift = docgendata.frormularOhneUnterschrift.ToString();
            dokdata.approval1 = 0;
            dokdata.approval2 = 0;
            dokdata.approved = 0;
            if (dokdata.Form_ohne_Unterschrift == "True")
            {
                dokdata.Unterschrift_Links = "-1";
                dokdata.Unterschrift_Rechts = "-1";
            }
            if (docgendata.erstellungsart == Erstellungsart.DokumentAlsPDF) { dokdata.Result_as_PDF = "True"; } else { dokdata.Result_as_PDF = "False"; }
            if (docgendata.digitaleunterschrift == true) { dokdata.As_Faksimile = "True"; } else { dokdata.As_Faksimile = "False"; }
            // dokdata.dokumentwerte = ToDataTable<CLMDocItem>
            dokumentid = db.Create_EDOKA_Doc(dokdata, false, clmdokumentid);
            dokdata.Dokumentid = dokumentid;

            dokdata.Erstellung_in_Office = false;
            DOCGEN.Generator.DocGenerator_from_EDOKA Generator = new DOCGEN.Generator.DocGenerator_from_EDOKA(this.connectionstring, OwnHost, key.ToString());
            dok = Generator.Generate_Doc_EDOKA(dokumentid, ref dokdata, false, 0, false, false);
            DocGet dget = new DocGet(this.connectionstring);
            dok.dokument = dget.Convert_Word_To_PDF(dok.dokument);
            // db.Save_To_DB(dokumentid, "", dok.dokument);


            // dok = dget.GetDocAsPDF(dokumentid);
            dok.extension = "pdf";
            dok.doktype = "P";
            if (System.Configuration.ConfigurationManager.AppSettings["CLMSaveOnDoc"].ToString() == "True" || clmdokumentid != "")
            {
                db.Save_To_DB(dokumentid, "", dok.dokument);
            }
            else
            {
                db.clear_parameter();
                db.add_parameter("@dokumentid", dokumentid);
                db.Get_Tabledata("ondoc_delete_apidoc", true, false);
            }
            deflist.Clear();
            dget = null;
            Generator = null;
            clmdocitemlist.Clear();
            APILogging.Log((HttpRequestMessage)Request, "Ende GenDoc DokumentID:" + dokumentid, LogLevelType.Debug);
            APILogging.DocLog((HttpRequestMessage)Request, docgendata.partnernr.ToString(), "Dokument über API erstellt", dokumentid, LogLevelType.Info);
            db = null;

        }


        private void send_vs(ref Versandpaket vp, string mitarbeiternr, bool direktversenden, string url, string key, string dokumentid, string partnernr, DokumentCreate doccreate, ref APIErrorSimple apireturn)
        {
            string jsonstring = JsonConvert.SerializeObject(vp);
            DB db = new DB(connectionstring);
            db.clear_parameter();
            db.add_parameter("@ersteller", mitarbeiternr);
            db.Get_Tabledata("ondoc_create_versandpaket", true, false);
            int paketid = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][0]);
            vp.PaketNr = new Guid().ToString();

            db.Get_Tabledata_for_Update("Select top 1 * from Ondoc_Versandstrasse_Paket where id=" + paketid.ToString(), false, true);
            DataRow dr = db.daten.Tables[0].Rows[0];
            dr[2] = jsonstring;
            dr["aktiv"] = 1;
            dr["versandoption"] = vp.Versandoption.ToString();
            dr["Bemerkung"] = vp.bemerkung;
            dr["Signed"] = 1;
            try
            {
                if (doccreate.OnDocSignCheck == "true")
                {
                    dr["Signed"] = 0;

                }
            }
            catch { }
            db.Update_Data();


            db.daten.Tables.Clear();
            db.Get_Tabledata_for_Update("Select * from ondoc_versandstrasse_paket_dokumentid where couvert_id = -1", false, true);
            foreach (Versanddokument vd in vp.Dokument)
            {
                DataRow dr1 = db.daten.Tables[0].NewRow();
                dr1[1] = paketid;
                dr1[2] = vd.DokumentID;
                dr1[3] = 1;
                db.daten.Tables[0].Rows.Add(dr1);

            }
            db.Update_Data();

            if (doccreate != null)
            {
                if (doccreate.OnDocSignCheck == "true")
                {
                    dr["Signed"] = 0;

                }

                if (Convert.ToInt32(dr["Signed"]) == 0)
                {
                    db.daten.Tables.Clear();
                    db.Get_Tabledata_for_Update("Select * from OnDoc_Prov_VersandstrasseDokument where id = -1", false, true);
                    foreach (APIDokument dc in doccreate.Dokumente)
                    {
                        DataRow dr1 = db.daten.Tables[0].NewRow();
                        dr1[1] = paketid;
                        dr1[2] = dc.DokumentID;

                        dr1[3] = "";
                        if (dc.PDFDoc != "")
                        { dr1[3] = dc.PDFDoc; }
                        dr1[4] = true;
                        db.daten.Tables[0].Rows.Add(dr1);
                    }
                }

                db.Update_Data();
                db.daten.Tables.Clear();
                if (doccreate.OnDocSignCheck == "true")
                {
                    db.Get_Tabledata_for_Update("Select top 1 * from ondoc_prov_versandstrassepaket where id=-1", false, true);
                    DataRow dr2 = db.daten.Tables[0].NewRow();
                    dr2[1] = paketid;
                    dr2[2] = DateTime.Now;
                    dr2[3] = doccreate.Dokumente[0].TGNrUnterschriftLinks.ToString();
                    dr2[4] = 0;
                    if (doccreate.Dokumente[0].TGNrVerantwortlich == doccreate.Dokumente[0].TGNrUnterschriftLinks)
                    {
                        dr2[4] = 1;
                    }
                    dr2[6] = doccreate.Dokumente[0].TGNrUnterschriftRechts.ToString();
                    dr2[7] = 0;
                    if (doccreate.Dokumente[0].TGNrVerantwortlich == doccreate.Dokumente[0].TGNrUnterschriftRechts)
                    {
                        dr2[7] = 1;
                    }
                    dr2[9] = 1;
                    dr2[10] = doccreate.Dokumente[0].TGNrVerantwortlich;
                    dr2[11] = doccreate.Dokumente[0].PartnerNr;
                    dr2[12] = doccreate.Paketbezeichnung.ToString();
                    db.daten.Tables[0].Rows.Add(dr2);
                    db.Update_Data();
                }
                db = null;
            }

            Logging.DocLog.Info("Versandpaket vorbereitet", "OnDoc-API", dokumentid, partnernr, "");
            if (!direktversenden)
            {
                return;
            }

            string URL = url + "api/Send_Versandstrasse?paketid=" + paketid.ToString();



            WebRequest request;
            var data = Encoding.UTF8.GetBytes(jsonstring);
            request = WebRequest.Create(URL);
            request.ContentLength = data.Length;
            request.ContentType = "application/json";
            request.Method = "POST";
            request.Headers["Authorization"] = "Bearer " + key;
            string response;
            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();
                        }
                        if (response.ToString().Contains("*archiviert"))
                        {

                        }

                    }
                }

                Logging.DocLog.Info("Versandpaket versendet", "OnDoc-API", dokumentid, partnernr, "");

                return;
            }
            catch (Exception ex)
            {
                Logging.DocLog.Info("Direktversand nicht möglich: " + ex.Message, "OnDoc-API", dokumentid, partnernr, "");
                apireturn.code = "ONDOC-ERR-SendVS";
                apireturn.status = "400";
                apireturn.message = ex.Message;
                apireturn.traceid = "";
                apireturn.field = "";
                return;
            }

        }

        private string get_item_value(string inhalt, ref List<CLMDocItem> clmdocitemlist)
        {
            string result = "";
            try
            {
                foreach (CLMDocItem di in clmdocitemlist)
                {
                    if (di.itemname == inhalt.Replace("$.",""))
                    {
                        result= di.itemvalue;
                        break;
                    }
                }
                return result;
            }
            catch
            {
                return "";
            }
        }
        private string get_datamatrix_value(string inhalt,string clmdokumentid, ref List<CLMDocItem> clmdocitemlist)
        {
            string datamatrixstring = "";
            string[] parts= inhalt.Split('$');
            foreach (string part in parts) 
            {

                if (part.Contains("&"))
                {
                    if (part.Replace("&", "") == "DokumentID")
                    {
                        if (datamatrixstring.Length > 0) { datamatrixstring = datamatrixstring + "$"; }
                        datamatrixstring = datamatrixstring + clmdokumentid.Replace("OFFEDK", "");
                    }
                    foreach (CLMDocItem di in clmdocitemlist)
                    {
                        if (di.itemname == part.Replace("&", ""))
                        {
                            if (datamatrixstring.Length > 0) { datamatrixstring = datamatrixstring + "$"; }
                            datamatrixstring = datamatrixstring + di.itemvalue;
                        }
                       
                    }
                }
                else
                {
                    if (datamatrixstring.Length > 0) { datamatrixstring = datamatrixstring + "$"; }
                    datamatrixstring = datamatrixstring + part;
                }
            }

            return datamatrixstring;
        }
        private string pruefziffer(string value)
        {
                int[] row = new int[] { 0, 9, 4, 6, 8, 2, 7, 1, 3, 5 };
                int uebertrag = 0;
                foreach (char c in value.Replace(".", ""))
                {
                    int digit = int.Parse("" + c);
                    int index = (uebertrag + digit) % 10;
                    uebertrag = row[index];
                }
                int checkDigit = (10 - uebertrag) % 10;
                return checkDigit.ToString();
            }

            #endregion

        }
    public static class DataTableHelper
    {
        public static DataTable ToDataTable<T>(List<T> items)
        {
            DataTable table = new DataTable(typeof(T).Name);

            // Properties der Klasse holen
            PropertyInfo[] properties = typeof(T).GetProperties();

            // Spalten anlegen
            foreach (PropertyInfo prop in properties)
            {
                table.Columns.Add(prop.Name, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType);
            }

            // Zeilen füllen
            foreach (T item in items)
            {
                DataRow row = table.NewRow();
                foreach (PropertyInfo prop in properties)
                {
                    row[prop.Name] = prop.GetValue(item) ?? DBNull.Value;
                }
                table.Rows.Add(row);
            }

            return table;
        }
    }
}