using Syncfusion.Windows.Forms.Tools;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Syncfusion.WinForms.Controls;
using Syncfusion.Windows.Forms.Utils;
using OnDoc.Klassen;
using Syncfusion.Windows.Forms;
using Model;
using OnDoc.DocMgmt;
using System.Xml.Linq;
using Versandstrasse;
using System.IO;
using Syncfusion.Pdf;
using Database;
using System.Net;
using Newtonsoft.Json;
using Windows.Media.Capture;

namespace OnDoc.Versandstrasse
{

    public partial class Versandstrasse : SfForm
    {
        private List<Versandpaket> pakete = new List<Versandpaket>();
        private TreeViewAdvDragHighlightTracker treeViewDragHighlightTracker = null;
        private TreeNodeAdv currentSourceNode;
        private bool serienbrief = false;
        private serienbrief sb;
        private bool direktversenden = false;
        public Versandstrasse(List<Versandpaket> pakete)
        {
            InitializeComponent();
            this.treeViewAdv1.AutoScrolling = ScrollBars.Both;
            this.Style.TitleBar.BackColor = Theaming.Titelbar();
            this.Style.TitleBar.ForeColor = Theaming.TitelFontColor();
            this.Style.ShadowOpacity = Theaming.ShadowOpacity;
            this.Style.InactiveShadowOpacity = Theaming.InactivShadowOpacity;
            this.treeViewDragHighlightTracker = new TreeViewAdvDragHighlightTracker(this.treeViewAdv1);
            this.treeViewDragHighlightTracker.QueryAllowedPositionsForNode +=
                new QueryAllowedPositionsEventHandler(this.TreeDragDrop_QueryAllowedPositionsForNode);
            this.treeViewDragHighlightTracker.QueryDragInsertInfo +=
                new QueryDragInsertInfoEventHandler(treeViewDragHighlightTracker_QueryDragInsertInfo);
            this.pakete = pakete;
            this.serienbrief = pakete[0].isSerienbrief;
            if (serienbrief)
            {
                this.sb = pakete[0].sb;
            }
        }

        private void load_adressen()
        {
            DB db = new DB(AppParams.connectionstring);
            db.Get_Tabledata("Select * from Antwortadresse order by bezeichnung", false, true);
            foreach (System.Data.DataRow dr in db.dsdaten.Tables[0].Rows)
            {
                TreeNodeAdv node = new TreeNodeAdv();
                node.Text = dr["bezeichnung"].ToString();
                node.TagObject = dr;
                treeViewAdvAdresse.Nodes.Add(node);

            }
            treeViewAdvAdresse.Enabled = false;
            treeViewAdvAdresse.SelectedNode = treeViewAdvAdresse.Nodes[0];
        }
        private void Versandstrasse_Load(object sender, EventArgs e)
        {
            
            Reload_Tree();
            load_adressen();
        }
        private void Reload_Tree() {

            if (serienbrief)
            {
                TreeNodeAdv DruckJobSB;
                DruckJobSB = new TreeNodeAdv();
                DruckJobSB.Text = "Serienbrief";
                DruckJobSB.Tag = "Druckpaket";
                DruckJobSB.TagObject = pakete[0];
                treeViewAdv1.Nodes.Add(DruckJobSB);
                populate_serienbriefe();
                treeViewAdv1.ExpandAll();
                return;
            }
            treeViewAdv1.Nodes.Clear();
            TreeNodeAdv DruckJob;
            DB db = new DB(AppParams.connectionstring);
            for (int i = 0; i < pakete.Count; i++)
            {
                db.Get_Tabledata("Select bkpar00 from partner where nrpar00=" + pakete[i].partnernr.ToString(), false, true);
                DruckJob = new TreeNodeAdv();
                DruckJob.Text = "Versand-Couvert  - " + db.dsdaten.Tables[0].Rows[0][0].ToString();
                DruckJob.Tag = "Druckpaket";
                DruckJob.TagObject = pakete[i];
                set_nodeimage(DruckJob, 0);

                treeViewAdv1.Nodes.Add(DruckJob);

                PopulateDocs(pakete[i], ref DruckJob);
            }
            db = null;
            treeViewAdv1.ExpandAll();
            foreach (TreeNodeAdv node in treeViewAdv1.Nodes)
            {
                if (node.Level == 1) { Verify_Couvert(node); }
            }
        }

        private void set_nodeimage(TreeNodeAdv node, int img)
        {
            node.LeftImageIndices = null;
            node.LeftImageIndices = new int[] { img };
        }

        private void Verify_Couverts()
        {
            foreach (TreeNodeAdv node in treeViewAdv1.Nodes)
            {
                if (node.Level == 1) { Verify_Couvert(node); }
            }
        }
        private bool Verify_Couvert(TreeNodeAdv node)
        {
            Versandpaket vp = node.TagObject as Versandpaket;
            int currentbp = vp.partnernr;
            DB db = new DB(AppParams.connectionstring);
            //node.LeftImageIndices = new int[] { 0 };
            int nodecounter = 0;
            int anzbp = 1;
            
            bool versandbereit = true;
            
            foreach (TreeNodeAdv dokumentnode in node.Nodes)
            {
                //node.LeftImageIndices = new int[] { 0 };
                db.Get_Tabledata("SELECT dbo.dokument.nrpar00, dbo.dokument.dokumentid, isnull(dbo.dokumenttyp.Versandstrasse_moeglich,0) as vsm, isnull(dbo.dokumenttyp.versandstrasse_firstdoc,0) as firstdoc FROM dbo.dokument INNER JOIN " +
                            " dbo.dokumenttyp ON dbo.dokument.dokumenttypnr = dbo.dokumenttyp.dokumenttypnr where dbo.dokument.dokumentid='" + dokumentnode.Tag + "'", false, true);
                //BP-Verifikation
                if (currentbp != Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["nrpar00"]))
                {
                    currentbp = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["nrpar00"]);
                    anzbp = anzbp + 1;
                }

                //Versandstrasse möglich
                if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["vsm"]) == 0)
                {
                    set_nodeimage(dokumentnode, 0);
                   
                    versandbereit = false;
                }
                else
                {
                    if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["firstdoc"]) == 0)
                    {
                        if (nodecounter == 0) { set_nodeimage(dokumentnode, 4); }
                        else
                        {
                            set_nodeimage(dokumentnode, 5);
                        }


                    }
                }
                if (node.Nodes.Count == 0)
                {
                    versandbereit = false;
                }
                nodecounter++;
            }
            if (node.Nodes.Count < 1) { versandbereit = false; }
            if (anzbp > 1) { versandbereit = false; }
            if (versandbereit == true) 
            {
                set_nodeimage(node, 1);
                return true;
            } else
            {
                set_nodeimage(node, 0);
                return false;
            }
        }

        private void populate_serienbriefe()
        {
            DB db = new DB(AppParams.connectionstring);
            db.Get_Tabledata("Select dokumentid, dbo.BinaryToBase64(dokument) as dokument from edex_sb_serienbrief_dokument where serienbriefnr=" + sb.serienbriefnr.ToString() + "order by inteintragnr", false,true);
            foreach (System.Data.DataRow dr in db.dsdaten.Tables[0].Rows)
            {
                TreeNodeAdv tn = new TreeNodeAdv();
                tn.Text = dr["dokumentid"].ToString();
                tn.Tag = dr["dokument"].ToString();
                set_nodeimage(tn, 3);
                treeViewAdv1.Nodes[0].Nodes.Add(tn);
            }
        }
        private void PopulateDocs(Versandpaket paket, ref TreeNodeAdv parentnode)
        {
            DB db = new DB(AppParams.connectionstring);
            TreeNodeAdv dokumentnode;
            for (int i = 0; i < paket.Dokument.Count; i++)
            {
                dokumentnode = new TreeNodeAdv();
                dokumentnode.Text = paket.Dokument[i].Bezeichnung+" (" + paket.Dokument[i].Partnernr+")";
                dokumentnode.Tag = paket.Dokument[i].DokumentID;
                dokumentnode.TagObject= paket.Dokument[i];
                db.Get_Tabledata("SELECT dbo.dokument.dokumentid, isnull(dbo.dokumenttyp.Versandstrasse_moeglich,0) as vsm, isnull(dbo.dokumenttyp.versandstrasse_firstdoc,0) as firstdoc FROM dbo.dokument INNER JOIN " +
                    " dbo.dokumenttyp ON dbo.dokument.dokumenttypnr = dbo.dokumenttyp.dokumenttypnr where dbo.dokument.dokumentid='" + dokumentnode.Tag + "'", false, true);

                if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["firstdoc"]) == 0) 
                {
                    set_nodeimage(dokumentnode, 5);
                } else 
                {
                    set_nodeimage(dokumentnode, 3);
                }
                if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["vsm"]) ==0) 
                {
                    set_nodeimage(dokumentnode, 0);
                } else 
                { 
                    //dokumentnode.LeftImageIndices = new int[] { 3}; 
                }
            
                parentnode.Nodes.Add(dokumentnode);

            }
        }

        #region "Treeview"
        private void treeViewAdv1_DragDrop(object sender, DragEventArgs e)
        {
            TreeViewAdv treeView = sender as TreeViewAdv;
            TreeNodeAdv sourceNode = (TreeNodeAdv)e.Data.GetData(typeof(TreeNodeAdv));
            TreeNodeAdv destinationNode = this.treeViewDragHighlightTracker.HighlightNode;
            TreeViewDropPositions dropPosition = this.treeViewDragHighlightTracker.DropPosition;
            this.treeViewDragHighlightTracker.ClearHighlightNode();
            this.currentSourceNode = null;
            if (destinationNode != null)
            {
                switch (dropPosition)
                {
                    case TreeViewDropPositions.AboveNode:
                        sourceNode.Move(destinationNode, NodePositions.Previous);
                        break;
                    case TreeViewDropPositions.BelowNode:
                        sourceNode.Move(destinationNode, NodePositions.Next);
                        break;
                    case TreeViewDropPositions.OnNode:
                        sourceNode.Move(destinationNode.Nodes);
                        destinationNode.Expand();
                        break;
                }
            }
            treeView.SelectedNode = sourceNode;
            Verify_Couverts();
     
        }

        private void treeViewAdv1_DragLeave(object sender, EventArgs e)
        {
            this.treeViewDragHighlightTracker.ClearHighlightNode();
        }

        private void treeViewAdv1_DragOver(object sender, DragEventArgs e)
        {
            bool droppable = true;
            TreeNodeAdv destinationNode = null;
            TreeViewAdv treeView = sender as TreeViewAdv;
            Point ptInTree = treeView.PointToClient(new Point(e.X, e.Y));
            this.currentSourceNode = null;
            if (e.Data.GetDataPresent(typeof(TreeNodeAdv)))
            {
                destinationNode = treeView.GetNodeAtPoint(ptInTree);
                TreeNodeAdv sourceNode = (TreeNodeAdv)e.Data.GetData(typeof(TreeNodeAdv));
                this.currentSourceNode = sourceNode;
                droppable = this.CanDrop(sourceNode, destinationNode);
                //if (droppable == true) { if (destinationNode.Tag.ToString() != "Druckpaket") { droppable = false; } }
            }
            else
                droppable = false;
            
            if (droppable)
                e.Effect = DragDropEffects.Move;
            else
                e.Effect = DragDropEffects.None;
            this.treeViewDragHighlightTracker.SetHighlightNode(destinationNode, ptInTree);
        }
        private bool CanDrop(TreeNodeAdv sourceNode, TreeNodeAdv destinationNode)
        {
            TreeNodeAdv xdestinationNode = this.treeViewDragHighlightTracker.HighlightNode;
            TreeViewDropPositions dropPosition = this.treeViewDragHighlightTracker.DropPosition;
           
          
            if (destinationNode == null || destinationNode == sourceNode)
                return false;
            else
               {
                try
                {
                  
                    if (xdestinationNode.Level == 1 && dropPosition != TreeViewDropPositions.OnNode)
                    {
                        return false;
                    }
                    if (xdestinationNode.Level == 2 ) { return true; }
            }
                catch { }


                return true; }
        }

        private void treeViewAdv1_ItemDrag(object sender, ItemDragEventArgs e)
        {
            TreeViewAdv treeViewAdv = sender as TreeViewAdv;
            TreeNodeAdv[] nodes = e.Item as TreeNodeAdv[];
            TreeNodeAdv node = nodes[0];
            {
                DragDropEffects result = treeViewAdv.DoDragDrop(node, DragDropEffects.Move);
            }
        }
        private bool IsDruckPaket(TreeNodeAdv node)
        {
            int i = -1;
            bool numeric = int.TryParse(node.Tag.ToString(), out i);
            if (node.Tag.ToString() == "Druckpaket") { return true; } else { return false; }
            
        }
        private void treeViewDragHighlightTracker_QueryDragInsertInfo(object sender, QueryDragInsertInfoEventArgs args)
        {
            args.DragInsertColor = Color.Red;
        }
        private void TreeDragDrop_QueryAllowedPositionsForNode(object sender, QueryAllowedPositionsEventArgs e)
        {
            if (!this.IsDruckPaket(e.HighlightNode))
            {
                if (e.HighlightNode != this.currentSourceNode)
                    e.AllowedPositions = TreeViewDropPositions.AboveNode | TreeViewDropPositions.BelowNode;
                else
                    e.AllowedPositions = TreeViewDropPositions.None;

                this.treeViewDragHighlightTracker.EdgeSensitivityOnTop = e.HighlightNode.Bounds.Height / 2;
                e.ShowSelectionHighlight = false;
            }
            else
            {
                this.treeViewDragHighlightTracker.EdgeSensitivityOnTop = e.HighlightNode.Bounds.Height / 4;
                e.ShowSelectionHighlight = false;
            }

        }
        #endregion

        private void tsbtnDruckPaketNew_Click(object sender, EventArgs e)
        {
            Versandpaket newpaket = new Versandpaket();
            newpaket.PaketNr= (treeViewAdv1.Nodes.Count + 1).ToString();
            newpaket.Versandoption = "B2_POST";
            newpaket.GAS = "";
            newpaket.GASAdresse = "";
            newpaket.Mitteilung = "";
            newpaket.Dokument = new List<Versanddokument>();

            string NodeText = "Druckpaket " + (treeViewAdv1.Nodes.Count + 1).ToString();
            TreeNodeAdv drucknode  = new TreeNodeAdv(); 
            drucknode.Text = NodeText;
            drucknode.Tag = "Druckpaket";
            drucknode.TagObject=newpaket;
            pakete.Add(newpaket);

            treeViewAdv1.Nodes.Add(drucknode);
        }

        private void treeViewAdv1_NodeMouseClick(object sender, TreeViewAdvMouseClickEventArgs e)
        {
           
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Versandpaket paket =  treeViewAdv1.SelectedNode.TagObject as Versandpaket; 
            //if (rbversandoption1.Checked) { paket.Versandoption = "1"; }
            //if (rbversandoption2.Checked) { paket.Versandoption = "2"; }
            //if (rbversandoption3.Checked) { paket.Versandoption = "3"; }
           
            //if (chkGAS.Checked) { paket.GAS = "1"; } else { paket.GAS = "0"; }
            //try { paket.GASAdresse = lbgasadresse.SelectedIndex.ToString(); } catch { paket.GASAdresse= "0"; }
           // paket.verified = true;
            //treeViewAdv1.SelectedNode.TagObject = paket;
            //pakete.paket.Add(paket);
           // Reload_Tree();


        }

        private void btnSend_Click(object sender, EventArgs e)
        {
            if (serienbrief)
            {
                clsVersandstrasse vs = new clsVersandstrasse();
                foreach (TreeNodeAdv tn in treeViewAdv1.Nodes[0].Nodes)
                {
                    tn.TagObject = vs.Prepare_PDF(tn.Text.ToString(), AppParams.tempdir, AppParams.connectionstring,AppParams.RESTURI,AppParams.apikey,Application.StartupPath,null,sb, tn.Tag.ToString());
                }
                vs = null;
                panelVerify.Visible = true;
                return;
            }
            panelPrepare.Visible = true;
            Application.DoEvents();
            Cursor = Cursors.WaitCursor;
            try
            {
                Versandpaket paket = treeViewAdv1.SelectedNode.TagObject as Versandpaket;

                foreach (TreeNodeAdv tn in treeViewAdv1.SelectedNode.Nodes)
                {
                    foreach(Versanddokument vsdok in paket.Dokument)
                    {
                        if (vsdok.DokumentID == tn.Tag.ToString())
                        {
                            clsVersandstrasse vs = new clsVersandstrasse();
                            vsdok.dokument = vs.Prepare_PDF(vsdok.DokumentID.ToString(), AppParams.tempdir, AppParams.connectionstring, AppParams.RESTURI, AppParams.apikey, Application.StartupPath);
                        }
                    }
                }
                //foreach (Versanddokument vsdok in paket.Dokument)
                //{
                //    clsVersandstrasse vs = new clsVersandstrasse();
                //    vsdok.dokument = vs.Prepare_PDF(vsdok.DokumentID.ToString(), AppParams.tempdir, AppParams.connectionstring,AppParams.RESTURI,AppParams.apikey, Application.StartupPath);
                //    //string dok = vs.Prepare_PDF(vsdok.DokumentID.ToString(), AppParams.tempdir, AppParams.connectionstring);
                //}
                Stream[] streams = new Stream[paket.Dokument.Count];
                int i = 0;

                foreach (TreeNodeAdv tn in treeViewAdv1.SelectedNode.Nodes)
                {
                    foreach (Versanddokument vsdok in paket.Dokument)
                    {
                        if (vsdok.DokumentID == tn.Tag.ToString())
                        {
                            var stream = new MemoryStream(Convert.FromBase64String(vsdok.dokument));
                            streams[i] = stream;
                            i++;
                        }
                    }
                }


                //foreach (Versanddokument vsdok in paket.Dokument)
                //{
                //    var stream = new MemoryStream(Convert.FromBase64String(vsdok.dokument));
                //    streams[i] = stream;
                //    i++;
                //}

                string stapel = save_stapel(ref streams);

               
                paket.finaldoc=stapel;

                var finalestream = new MemoryStream(Convert.FromBase64String(stapel));
                this.pdfViewerControl1.Load(finalestream);


                for (int i1 = 0; i1 < streams.Length; i1++)
                {
                    streams[i1].Close();

                    streams[i1].Dispose();
                    streams[i1] = null;
                }
                streams = null;
                treeViewAdv1.SelectedNode.TagObject = paket;
                panelVerify.Visible = true;
            }
            catch { }
            panelPrepare.Visible = false;
            Cursor = Cursors.Default;
            Application.DoEvents();

        }

        private string save_stapel(ref Stream[] streams)
        {
            try
            {

                PdfDocument finalDoc = new PdfDocument();
                PdfDocumentBase.Merge(finalDoc, streams);

                MemoryStream outputStream = new MemoryStream();
                finalDoc.Save(outputStream);
                byte[] bytes;
                bytes = outputStream.ToArray();
                return Convert.ToBase64String(bytes);
            }
            catch { return ""; }
        }

        private void chkGAS_CheckedChanged(object sender, EventArgs e)
        {
            if (chkGAS.Checked)
            {
                treeViewAdvAdresse.Enabled= true;
                Versandpaket vp = treeViewAdv1.SelectedNode.TagObject as Versandpaket;
                vp.GAS = "1";
                treeViewAdv1.SelectedNode.TagObject = vp;
            }
            else
            {
                treeViewAdvAdresse.Enabled = false;
                Versandpaket vp = treeViewAdv1.SelectedNode.TagObject as Versandpaket;
                vp.GAS = "";
                treeViewAdv1.SelectedNode.TagObject = vp;
            }
        }

        private void button3_Click(object sender, EventArgs e)
        {
            direktversenden = true;
            btnSendFinal_Click(sender, e);
            direktversenden = false;
        }

        private void btnSendFinal_Click(object sender, EventArgs e)
        {
            if (serienbrief)
            {
                Versandpaket svp = treeViewAdv1.Nodes[0].TagObject as Versandpaket ;
                foreach (TreeNodeAdv node in treeViewAdv1.Nodes[0].Nodes)
                {
                    svp.finaldoc = node.TagObject.ToString();
                    svp.send_onbase_doc = true;
                    string _sqlWhere = @"dokumentid = '"+node.Text+"'";

                    DataTable _newDataTable = sb.dsempfaenger.Tables[0].Select(_sqlWhere, "").CopyToDataTable();
                    svp.partnernr = Convert.ToInt32(_newDataTable.Rows[0]["partnernr"].ToString());
                    
                    Versanddokument vd = new Versanddokument(node.Text,"",svp.partnernr.ToString());
                    
                    vd.dokument = node.TagObject.ToString();
                    vd.inteintragnr = Convert.ToInt32(_newDataTable.Rows[0]["inteintragnr"].ToString());
                    svp.Dokument.Add(vd);
                    DB db = new DB(AppParams.connectionstring);
                    db.clear_parameter();
                    db.add_parameter("@tgnummer", AppParams.currenttgnummer);
                    db.add_parameter("@partnernr", svp.partnernr.ToString());
                    db.add_parameter("@gasadresse", svp.GASAdresse);
                    db.add_parameter("@versandoption", svp.Versandoption);
                    db.add_parameter("@dokumente", node.Text+" / "+sb.serienbriefnr.ToString()+"_"+_newDataTable.Rows[0]["inteintragnr"].ToString());
                    db.Get_Tabledata("Ondoc_Insert_Versandprotokoll", true, false);
                    svp.protokollid = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][0]);
                    db = null;

                    send_vs(ref svp,false);
                }
                return;
            }
            panelVerify.Visible = false;
            Versandpaket vp = treeViewAdv1.SelectedNode.TagObject as Versandpaket;
            vp.verified = true;
            treeViewAdv1.SelectedNode.TagObject = vp;
            panelVerify.Visible = false;

            SendTo_Versandstrasse();

        }
        private void SendTo_Versandstrasse()
        {
            Versandpaket vp = treeViewAdv1.SelectedNode.TagObject as Versandpaket;
            vp.send_onbase_doc = true;
            DB db = new DB(AppParams.connectionstring);
            string dokumente = "";
            foreach (Versanddokument vd in vp.Dokument)
            {
                dokumente = dokumente + vd.DokumentID + ";";
                string sql = "SELECT dbo.dokumenttyp.ErstellungInOffice FROM dbo.dokument INNER JOIN dbo.dokumenttyp ON dbo.dokument.dokumenttypnr = dbo.dokumenttyp.dokumenttypnr WHERE (dbo.dokument.dokumentid = '" + vd.DokumentID + "')";
                db.Get_Tabledata(sql, false, true);
                if (db.dsdaten.Tables[0].Rows[0][0].ToString() == "True")
                {
                    vd.dokument = "";
                    vp.send_onbase_doc = false;
                }
            }
            db.clear_parameter();
            db.add_parameter("@tgnummer", AppParams.currenttgnummer);
            db.add_parameter("@partnernr", vp.partnernr.ToString());
            db.add_parameter("@gasadresse", vp.GASAdresse);
            db.add_parameter("@versandoption", vp.Versandoption);
            db.add_parameter("@dokumente", dokumente);
            db.Get_Tabledata("Ondoc_Insert_Versandprotokoll", true, false);
            vp.protokollid = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][0]);
            db = null;
            send_vs(ref vp);

        }
        private void send_vs(ref Versandpaket vp, bool showmessage = true, bool direktversenden = false) {
            string jsonstring = JsonConvert.SerializeObject(vp);

            //vp.send_onbase_doc = true;
            if (!direktversenden)
            {
            
            DB db = new DB(AppParams.connectionstring);
            db.Get_Tabledata_for_Update("Select top 1 * from Ondoc_Versandstrasse_Paket where id=1", false, true);
            DataRow dr = db.daten.Tables[0].NewRow();
            dr[1] = AppParams.CurrentMitarbeiter.ToString();
            dr[2] = jsonstring;
            dr[3] = DateTime.Now;

            db.daten.Tables[0].Rows.Add(dr);
            db.Update_Data();
                return;
            }

            string URL = AppParams.RESTURI + "api/Send_Versandstrasse";
            panelVerify.Visible = false;


            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 " + AppParams.apikey;
            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"))
                        {
                            if (showmessage)
                            {
                                MessageBox.Show("Paket an Versandstrasse übergeben", "Versandstrasse", MessageBoxButtons.OK, MessageBoxIcon.Information);
                                treeViewAdv1.SelectedNode.Remove();
                            }
                        }
                      
                    }
                }


                return;
            }
            catch { }
          
        }

        private void rbapost_CheckedChanged(object sender, EventArgs e)
        {
            string versandoption = "";
            if (rbapost.Checked) { versandoption = "A_POST"; }
            if (rbb1post.Checked) { versandoption = "B1_POST"; }
            if (rbb2post.Checked) { versandoption = "B2_POST"; }

            Versandpaket vp = treeViewAdv1.SelectedNode.TagObject as Versandpaket; ;
            vp.Versandoption = versandoption;
            treeViewAdv1.SelectedNode.TagObject = vp;
        }

        private void treeViewAdvAdresse_AfterSelect(object sender, EventArgs e)
        {
            try
            {
                Versandpaket vp = treeViewAdv1.SelectedNode.TagObject as Versandpaket;
                System.Data.DataRow dr = treeViewAdvAdresse.SelectedNode.TagObject as System.Data.DataRow;
                DataRow dr2 = treeViewAdvAdresse.SelectedNode.TagObject as DataRow;

                vp.GASAdresse = dr2["einzeilig"].ToString();
                treeViewAdv1.SelectedNode.TagObject = vp;
            }
            catch { }

        }

        private void treeViewAdvAdresse_NodeMouseClick(object sender, TreeViewAdvMouseClickEventArgs e)
        {
            try
            {
                Versandpaket vp = treeViewAdv1.SelectedNode.TagObject as Versandpaket;
                System.Data.DataRow dr = treeViewAdvAdresse.SelectedNode.TagObject as System.Data.DataRow;
                DataRow dr2 = treeViewAdvAdresse.SelectedNode.TagObject as DataRow;

                vp.GASAdresse = dr2["einzeilig"].ToString();
                treeViewAdv1.SelectedNode.TagObject = vp;
            }
            catch { }
        }

        private void treeViewAdv1_AfterSelect(object sender, EventArgs e)
        {
            TreeNodeAdv node = treeViewAdv1.SelectedNode;
            if (node.Level == 1)
            {
                if (Verify_Couvert(node)==false)
                {
                    GrpPaketDetails.Enabled = false;
                    return;
                }
                GrpPaketDetails.Enabled = true;
                Versandpaket paket = node.TagObject as Versandpaket; ;

                switch (paket.Versandoption)
                {
                    case "A_POST":
                        rbapost.Checked = true; break;
                    case "B1_POST":
                        rbb1post.Checked = true; break;
                    case "B2_POST":
                        rbb2post.Checked = true; break;
                    default:
                        rbb2post.Checked = true; break;
                }

                if (paket.GAS != "")
                {
                    this.chkGAS.Checked = true;
                }
                else
                { this.chkGAS.Checked = false; }

                if (paket.GASAdresse.ToString() != "")
                {
                    foreach (TreeNodeAdv tn in treeViewAdvAdresse.Nodes)
                    {
                        if (tn.Text == paket.GASAdresse) { treeViewAdvAdresse.SelectedNode = tn; }
                    }
                }

            }
            else
            {
                if (tscheckboxpreview.Checked)
                {
                    clsVersandstrasse vs = new clsVersandstrasse();
                    string dok = "";
                    if (serienbrief)
                    {
                        dok = vs.Prepare_PDF(node.Text.ToString(), AppParams.tempdir, AppParams.connectionstring,AppParams.RESTURI,AppParams.apikey, Application.StartupPath, null, sb, node.Tag.ToString());

                    }
                    else
                    {
                        dok = vs.Prepare_PDF(node.Tag.ToString(), AppParams.tempdir, AppParams.connectionstring, AppParams.RESTURI, AppParams.apikey, Application.StartupPath);
                    }
                    
                    var stream = new MemoryStream(Convert.FromBase64String(dok));
                    this.pdfViewerControl1.Load(stream);
                }

                GrpPaketDetails.Enabled = false;
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            panelVerify.Visible = false;
        }

        private void contextMenuStrip1_Click(object sender, EventArgs e)
        {
            try
            {
                TreeNodeAdv node = treeViewAdv1.SelectedNode;
                if (node.Level > 1) { 
                    node = node.Parent;
                    treeViewAdv1.SelectedNode.Remove();
                    Verify_Couvert(node);
                }
                else { 
                treeViewAdv1.SelectedNode.Remove();
                }
            }
            catch { }
        }

        private void toolStrip1_ItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {

        }

        private void TabControlDokuments_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (TabControlDokuments.SelectedIndex == 1)
            {
                DB db = new DB(AppParams.connectionstring);
                DB db2 = new DB(AppParams.connectionstring);

                db.Get_Tabledata("Select * from ondoc_versandstrasse_paket where ersteller=" + AppParams.CurrentMitarbeiter + " and versendet=0", false, true);
                treeViewAdvCouverts.Nodes.Clear();
                foreach (DataRow dr in db.dsdaten.Tables[0].Rows)
                {
                    Versandpaket vp = JsonConvert.DeserializeObject<Versandpaket>(dr["paket"].ToString());
                    TreeNodeAdv tn = new TreeNodeAdv();
                    db2.Get_Tabledata("Select bkpar00 from partner where nrpar00=" + vp.partnernr.ToString(), false, true);
                    tn.Text = vp.partnernr.ToString() + " - " + db2.dsdaten.Tables[0].Rows[0][0].ToString();
                    tn.TagObject = vp.finaldoc;
                    tn.Tag = dr[0].ToString();
                    if (vp.Versandoption.ToString() == "A_POST") { set_nodeimage(tn, 0); }
                    if (vp.Versandoption.ToString() == "B2_POST") { set_nodeimage(tn, 1); }
                    if (vp.Versandoption.ToString() == "B2_POST") { set_nodeimage(tn, 2); }
                    treeViewAdvCouverts.Nodes.Add(tn);
                    foreach (Versanddokument vd in vp.Dokument)
                    {
                        TreeNodeAdv tn2 = new TreeNodeAdv();
                        tn2.Text = vd.Bezeichnung;
                        tn2.Tag = vd.DokumentID;
                        tn2.TagObject = vd.dokument;
                        tn.Nodes.Add(tn2);
                    }
                }
                db = null;
                db2 = null;
            }

        }

        private void treeViewAdvCouverts_AfterSelect(object sender, EventArgs e)
        {
            TreeNodeAdv node = treeViewAdvCouverts.SelectedNode;

            var stream = new MemoryStream(Convert.FromBase64String(node.TagObject.ToString()));
            this.pdfViewerControl2.Load(stream);
            stream = null;
        }

    }
}