using Database;
using Microsoft.SqlServer.Server;
using Model;
using Newtonsoft.Json;
using NLog.LayoutRenderers.Wrappers;
using OnDoc.DocMgmt;
using OnDoc.Klassen;
using Syncfusion.Olap.MDXQueryParser;
using Syncfusion.Pdf;
using Syncfusion.Pdf.Parsing;
using Syncfusion.Windows.Forms;
using Syncfusion.Windows.Forms.Tools;
using Syncfusion.Windows.Forms.Utils;
using Syncfusion.WinForms.Controls;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.SqlTypes;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Windows.Interop;
using System.Xml.Linq;
using Versandstrasse;
using Windows.Media.Capture;
using Windows.Media.Streaming.Adaptive;

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;
        public 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);
            if (pakete.Count > 0)
            {
                this.pakete = pakete;
                this.serienbrief = pakete[0].isSerienbrief;

                if (serienbrief)
                {
                    this.ribbonButtonNewCouvert.Enabled = false;
                    this.ribbonTab2.Enabled = false;
                    this.sb = pakete[0].sb;
                    this.btnPrepare.Text = "Versand prüfen";
                }
                else
                {
                    ribbonButtonNewCouvert.Enabled = true;

                }
            }
        }

        private void load_adressen()
        {
            bool hasprivateaddresses = false;
            DB db = new DB(AppParams.connectionstring);
            db.Get_Tabledata("Select * from Antwortadresse_mitarbeiter where mitarbeiternr = " + AppParams.CurrentMitarbeiter.ToString() + " order by reihenfolge", false, true);
            if (db.dsdaten.Tables[0].Rows.Count > 0)
            {
                hasprivateaddresses = true;
                foreach (System.Data.DataRow dr in db.dsdaten.Tables[0].Rows)
                {
                    TreeNodeAdv node = new TreeNodeAdv();
                    node.Text = dr["bezeichnung"].ToString();
                    node.Tag = dr["einzeilig"].ToString();
                    node.TagObject = dr;
                    treeViewAdvAdresse.Nodes.Add(node);
                    node.TextColor = Color.Blue;
                }

                //TreeNodeAdv stdnode = new TreeNodeAdv();
                //stdnode.Text = "Standard-Adressen";
                //treeViewAdvAdresse.Nodes.Add(stdnode);
                //treeViewAdvAdresse.SelectedNode = stdnode;
            }
            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.Tag = dr["einzeilig"].ToString();
                node.TagObject = dr;
                //node.TextColor = Color.Gray;
                //if (hasprivateaddresses) { treeViewAdvAdresse.SelectedNode.Nodes.Add(node); } else { treeViewAdvAdresse.Nodes.Add(node); }
                treeViewAdvAdresse.Nodes.Add(node);
            }

            //treeViewAdvAdresse.SelectedNode = 0;
            treeViewAdvAdresse.Enabled = false;

            db = null;
        }
        private void Versandstrasse_Load(object sender, EventArgs e)
        {


            if (Properties.Settings.Default.GASSize == "True")
            {
                this.label5.Visible = false;
                this.pnlcouvertgroesse.Visible = true;
                this.pnlcouvertgroesse.Enabled = false;
                this.rbc5mini.Checked = true;
                this.rbc5normal.Checked = false;
            }
            else
            {
                this.label5.Visible = true;
                this.pnlcouvertgroesse.Visible = false;
            }

            Reload_Tree();
            load_adressen();

            DB db = new DB(AppParams.connectionstring);
            db.Get_Tabledata("Select * from OnDoc_Versandstrasse_Texte order by id", false, true);
            lblprueftext.Text = db.dsdaten.Tables[0].Rows[0]["textblock"].ToString();
            lblprueftextSB.Text = db.dsdaten.Tables[0].Rows[1]["textblock"].ToString();
            lblprueftextsb2.Text = db.dsdaten.Tables[0].Rows[2]["textblock"].ToString();
            lblpostausgang.Text = db.dsdaten.Tables[0].Rows[3]["textblock"].ToString();
            lblserienbrief.Text = db.dsdaten.Tables[0].Rows[4]["textblock"].ToString();

            lblpostausgang.MaximumSize = new Size(500, 60);

            db = null;


            if (treeViewAdv1.Nodes.Count > 0)
            {
                treeViewAdv1.SelectedNode = treeViewAdv1.Nodes[0];
                this.pnlcouvert.Visible = true;
                this.pnlpostkorb.Visible = false;
                this.pnlpostkorb.Dock = DockStyle.Fill;
                this.pnlcouvert.Dock = DockStyle.Fill;
                if (!serienbrief)
                {
                    lblpostausgang.Visible = true;
                    lblserienbrief.Visible = false;
                    this.lblpostausgang.Left = this.Width - lblpostausgang.Width;
                }
                else
                {
                    lblserienbrief.Visible = false;
                    lblpostausgang.Visible = false;
                    this.lblserienbrief.Left = this.Width - lblserienbrief.Width;
                }
            }
            else
            {
                this.lblpostausgang.Visible = true;
                this.lblpostausgang.Left = this.Width - lblpostausgang.Width;
                this.pnlcouvert.Visible = false;

                this.pnlpostkorb.Visible = true;
                this.pnlpostkorb.Dock = DockStyle.Fill;

                Refresh_VersandCouverts();
                ribbon1.Select();
                ribbon1_Click(sender, e);
                ribbon1.Tabs[0].Visible = true;
                ribbonTab2_ActiveChanged(sender, e);
                this.lblpostausgang.Left = this.Width - lblpostausgang.Width;

            }
            panelPrepare.Left = this.Width - this.panelPrepare.Width;
            lblprueftext.MaximumSize = new Size(panelVerify.Width - 10, 50);
            lblprueftextSB.MaximumSize = new Size(panelVerify.Width - 10, 50);
            lblprueftextsb2.MaximumSize = new Size(panelVerify.Width - 10, 50);
            try
            {
                Screen screen = Screen.FromControl(this);
                if (this.Width > screen.WorkingArea.Width || this.Height > screen.WorkingArea.Height)
                {
                    this.WindowState = FormWindowState.Maximized;
                }
            }
            catch { }


 
        }

        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 nrpar00, 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() + ", " + db.dsdaten.Tables[0].Rows[0][1].ToString();
                DruckJob.Tag = "Druckpaket";
                //pakete[i].partnernr = i;
                DruckJob.TagObject = pakete[i];
                set_nodeimage(DruckJob, 0);


                treeViewAdv1.Nodes.Add(DruckJob);

                PopulateDocs(pakete[i], ref DruckJob);
            }

            //db.Get_Tabledata("Select * from [applikation] where applikationsnr = 1", false, true);
            //if (Convert.ToBoolean(db.dsdaten.Tables[0].Rows[0]["Showlogin"]) == true) { button3.Visible = true; } else { button3.Visible = false; }

            db = null;
            treeViewAdv1.ExpandAll();
            foreach (TreeNodeAdv node in treeViewAdv1.Nodes)
            {
                if (node.Level == 1) { Verify_Couvert(node); }
            }
            try
            {
                treeViewAdv1.SelectedNode = treeViewAdv1.Nodes[0];
            }
            catch { }
        }

        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); }
            }
        }

        string errormessage = "";
        System.Data.DataTable errormessages = new System.Data.DataTable();
        public class errormsg
        {
            public int number = 0;
            public string message = "";

            public errormsg(int nr, string message)
            {
                this.number = nr;
                this.message = message;
            }
        }
        List<errormsg> errors = new List<errormsg>();

        private void add_errormessage(int nr, string message)

        {

            bool found = false;

            foreach (errormsg ermsg in errors)
            {
                if (ermsg.number == nr) { found = true; break; }
            }
            if (!found)
            {
                errors.Add(new errormsg(nr, message));
            }
        }
        private bool Verify_Couvert(TreeNodeAdv node)
        {
            errors.Clear();
            bool hastattachment = false;
            errormessage = "";
            errors.Clear();
            lblerror.Visible = false;
            Versandpaket vp = node.TagObject as Versandpaket;
            if (vp.isSerienbrief)
            {
                DB db1 = new DB(AppParams.connectionstring);
                db1.Get_Tabledata("Select isnull(versandstrasse_moeglich,0), isnull(versandstrasse_firstdoc,0) from dokumenttyp where dokumenttypnr=" + sb.dokumenttypnr.ToString(), false, true);
                if (Convert.ToInt32(db1.dsdaten.Tables[0].Rows[0][0]) == 0 || Convert.ToInt32(db1.dsdaten.Tables[0].Rows[0][1]) == 0)
                {

                    richTextBox1.Clear();
                    richTextBox1.BulletIndent = 20;
                    richTextBox1.SelectionBullet = true;
                    richTextBox1.SelectedText = "Der Serienbrief kann nicht über die Versandstrasse geschickt werden.";
                    this.btnPrepare.Enabled = false;
                    set_nodeimage(node, 0);
                    db1 = null;
                    return false;
                }
               
                db1 = null;
                set_nodeimage(node, 1);
                return true;
            }

            DB db = new DB(AppParams.connectionstring);
            
            if (node.Nodes.Count > 0)
            {
                Versanddokument vd = node.Nodes[0].TagObject as Versanddokument;
                if (vd.Partnernr.ToString() != vp.partnernr.ToString())
                {
                    db.Get_Tabledata("SELECT dbo.Partner.NRPAR00, dbo.Partner.BKPAR00 FROM partner where nrpar00=" + vd.Partnernr, false, true);
                    node.Text = "Versand-Couvert" + " - " + db.dsdaten.Tables[0].Rows[0][0].ToString() + " " + db.dsdaten.Tables[0].Rows[0][1].ToString();
                    vp.partnernr = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][0]);
                }
            }
            if (vp.partnernr == 0 && node.Nodes.Count == 1)
            {
                TreeNodeAdv tn = node.Nodes[0];
                db.Get_Tabledata("SELECT dbo.Partner.NRPAR00, dbo.Partner.BKPAR00 FROM dbo.dokument INNER JOIN dbo.Partner ON dbo.dokument.nrpar00 = dbo.Partner.NRPAR00 WHERE dbo.dokument.dokumentid='" + tn.Tag + "'", false, true);
                node.Text = node.Text + " - " + db.dsdaten.Tables[0].Rows[0][0].ToString() + " " + db.dsdaten.Tables[0].Rows[0][1].ToString();
                vp.partnernr = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][0]);

            }

            if (chkGAS.Checked && txtadresse.Text == "")
            {
                add_errormessage(7, "Für das Rückantwortcouvert wurde keine Adresse gewählt.");
                return false;
            }
            int currentbp = vp.partnernr;
            //node.LeftImageIndices = new int[] { 0 };
            int nodecounter = 0;
            int anzbp = 1;

            bool versandbereit = true;
            if (vp.partnernr > 99999999)
            {
                versandbereit = false;
                add_errormessage(6, "Im Versand-Couvert liegen ausschliesslich Personen-Dokumente. Der Versand braucht technisch ein BP-Dokument.");
            }

            string kdenummern = "";
            foreach (TreeNodeAdv dokumentnode in node.Nodes)
            {
                Versanddokument vd = dokumentnode.TagObject as Versanddokument;
                if (kdenummern != "") { kdenummern = kdenummern + ";"; }
                kdenummern = kdenummern + vd.Partnernr.ToString();

            }
            if (kdenummern != "")
            {
                db.clear_parameter();
                db.add_parameter("@kundennummer", kdenummern);
                db.Get_Tabledata("ondoc_versandstrasse_check_kdenr", true, false);
                if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][0]) != 0)
                {
                    versandbereit = false;

                    add_errormessage(Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][0].ToString()), db.dsdaten.Tables[0].Rows[0][1].ToString());
                }

            }
            int doccount = 0;
            foreach (TreeNodeAdv dokumentnode in node.Nodes)
            {
                doccount = doccount + 1;
                if (dokumentnode.Tag.ToString().Contains("ATT"))
                {
                    hastattachment = true;
                    if (nodecounter == 0)
                    {
                        versandbereit = false;
                        add_errormessage(11, "Ein externes Dokument kann nicht als erstes Dokument im Couvert sein");
                        break;
                    }
                    else { versandbereit = true; break; }
                }
                //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, isnull(postzustellung,0) as postzustellung 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
                //rbb1post.Enabled = true;
                //rbb2post.Enabled = true;
                //rbapost.Enabled = true;
                if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["Postzustellung"]) == 5 && nodecounter == 0)
                {
                    forceeinschreiben = true;
                }
                if (forceeinschreiben == false && Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["Postzustellung"]) == 5 && nodecounter > 0)
                {
                   // set_nodeimage(dokumentnode, 0);
                    add_errormessage(4, "Im Versand-Couvert liegt ein Dokument, welches als EINSCHREIBEN versendet wird, jedoch nicht an erster Position ist.");
                    versandbereit = false;
                }
                //    rbb1post.Enabled = false;
                //    rbb2post.Enabled = false;
                //    rbapost.Enabled = false;
                //    rbb2post.Checked = false;
                //    
                //}
                if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["vsm"]) == 0)
                {
                    set_nodeimage(dokumentnode, 0);
                    add_errormessage(4, "Im Versand-Couvert liegt ein Dokument, welches nicht via Versandstrasse verschickt werden kann");
                    versandbereit = false;
                }
                else
                {
                    if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["Postzustellung"]) > 1 && Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["Postzustellung"]) != 5)
                    {
                        set_nodeimage(dokumentnode, 2);
                        versandbereit = false;
                        add_errormessage(2, "Im Versand-Couvert liegt an erster Position ein Dokument, bei welchem die Postzustellung festgelegt wurde.");
                    }
                    if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0]["firstdoc"]) == 0)
                    {
                        if (nodecounter == 0) { set_nodeimage(dokumentnode, 4); versandbereit = false; add_errormessage(2, "Im Versand-Couvert liegt an erster Position ein Dokument, welches nicht als vorderstes Dokument tauglich ist"); }
                        else
                        {
                            set_nodeimage(dokumentnode, 5);
                        }
                        db.Get_Tabledata("Select isnull(unterschriftlinks,0), isnull(unterschriftrechts,0), signiert from dokument where dokumentid='" + dokumentnode.Tag + "'", false, true);
                        if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][0]) > 0 || Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][1]) > 0)
                        {
                            if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][2]) == 0)
                            {
                                set_nodeimage(dokumentnode, 4);
                                versandbereit = false;
                                add_errormessage(7, "Im Versand-Couvert sind Dokumente mit fehlender faksimiler Unterschrift");
                            }
                        }


                    }
                    else
                    {
                        db.Get_Tabledata("Select isnull(unterschriftlinks,0), isnull(unterschriftrechts,0), signiert from dokument where dokumentid='" + dokumentnode.Tag + "'", false, true);
                        if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][0]) > 1 || Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][1]) > 1)
                        {
                            if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][2]) == 0)
                            {
                                set_nodeimage(dokumentnode, 2);
                                versandbereit = false;
                                add_errormessage(7, "Im Versand-Couvert sind Dokumente mit fehlender faksimiler Unterschrift");
                            }
                        }
                    }
                }
                if (node.Nodes.Count == 0)
                {
                    add_errormessage(1, "Im Versand-Couvert liegen keine Dokumente");
                    versandbereit = false;
                }
                nodecounter++;
            }
            if (node.Nodes.Count < 1) { versandbereit = false; add_errormessage(1, "Im Versand-Couvert liegen keine Dokumente"); }
            if (anzbp > 1) { versandbereit = false; }
            if (hastattachment) { lblAttachment.Visible = true; } else { lblAttachment.Visible = false; }
            if (versandbereit == true)
            {
                richTextBox1.Clear();
                richTextBox1.SelectionBullet = false;
                lblerror.Visible = false;
                lblerror.Text = "";
                set_nodeimage(node, 1);
                return true;
            }
            else
            {
                if (errors.Count > 0)
                {
                    richTextBox1.Clear();
                    richTextBox1.BulletIndent = 20;
                    richTextBox1.SelectionBullet = true;
                    //errors.Sort();
                    errors.Sort((s1, s2) => s1.number.CompareTo(s2.number));
                    errormessage = "";
                    foreach (errormsg emsg in errors)
                    {
                        if (!errormessage.Contains(emsg.message))
                        {
                            //if (errormessage != "") { errormessage = errormessage + Environment.NewLine; }
                            errormessage = errormessage + emsg.message + "\n";
                        }
                    }

                    richTextBox1.SelectedText = errormessage.Substring(0, errormessage.Length - 1);

                }
                lblerror.Visible = true;
                lblerror.Text = errormessage;
                set_nodeimage(node, 0);
                return false;
            }
        }

        private void populate_serienbriefe()
        {
            foreach (Versanddokument vd in pakete[0].Dokument)
            {
                TreeNodeAdv tn = new TreeNodeAdv();
                tn.Text = vd.Bezeichnung + " (" + vd.DokumentID + ")";
                tn.Tag = vd.dokument;

                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];
                // Attachment
                if (dokumentnode.Tag.ToString().Contains("ATT"))
                {
                    set_nodeimage(dokumentnode, 5);
                }
                else
                {
                    reserve_vs_dokument(dokumentnode.Tag.ToString(), 3);
                    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)
        {
            try
            {
                if (e.Data.GetDataPresent(DataFormats.FileDrop))
                {
                    TreeViewAdv FiletreeView = sender as TreeViewAdv;
                    TreeNodeAdv FilesourceNode = (TreeNodeAdv)e.Data.GetData(typeof(TreeNodeAdv));
                    TreeNodeAdv FiledestinationNode = this.treeViewDragHighlightTracker.HighlightNode;
                    TreeViewDropPositions FiledropPosition = this.treeViewDragHighlightTracker.DropPosition;
                    Point ptInTree = FiletreeView.PointToClient(new Point(e.X, e.Y));
                    FiledestinationNode = FiletreeView.GetNodeAtPoint(ptInTree);
                    if (FiledestinationNode == null) { FiledestinationNode=treeViewAdv1.Nodes[0]; }
                    

                    Versandpaket DestPaket;
                    if (FiledestinationNode.Level == 1)
                    {
                        DestPaket = FiledestinationNode.TagObject as Versandpaket;
                    }
                    else
                    {
                        DestPaket = FiledestinationNode.Parent.TagObject as Versandpaket;
                    }
                    int partnernr = DestPaket.partnernr;
                   
                    string[] files = e.Data.GetData(DataFormats.FileDrop) as string[]; // get all files droppeds  
                    foreach (string file in files)
                    {
                        if (System.IO.Path.GetExtension(file.ToUpper()) == ".PDF")
                        {
                            Add_Attachment(file, partnernr,DestPaket.PaketNr);
                        }
                        else
                        {
                        }
                    }
                    return;
                }
            }
            catch { e.Effect = DragDropEffects.None;return; }
            try
            {
                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 (sourceNode.Level == 0)
                {
                    return;
                }

                if (destinationNode != null)
                {
                    switch (dropPosition)
                    {
                        case TreeViewDropPositions.AboveNode:
                            if (sourceNode.Parent != destinationNode.Parent) { movenode(sourceNode, destinationNode.Parent); }
                            sourceNode.Move(destinationNode, NodePositions.Previous);
                            break;
                        case TreeViewDropPositions.BelowNode:
                            if (sourceNode.Parent != destinationNode.Parent) { movenode(sourceNode, destinationNode.Parent); }
                            sourceNode.Move(destinationNode, NodePositions.Next);
                            break;
                        case TreeViewDropPositions.OnNode:

                            Versandpaket sourcepaket = sourceNode.Parent.TagObject as Versandpaket;
                            TreeNodeAdv savenode = sourceNode.Parent;
                            sourceNode.Move(destinationNode.Nodes);

                            //Versanddokument dem neuen Versandpaket zuordnen
                            Versandpaket paket = destinationNode.TagObject as Versandpaket;
                            Versanddokument vd = sourceNode.TagObject as Versanddokument;
                            paket.Dokument.Add(vd);
                            destinationNode.TagObject = paket;


                            foreach (Versanddokument vd1 in sourcepaket.Dokument)
                            {
                                if (vd1.DokumentID == vd.DokumentID)
                                {
                                    sourcepaket.Dokument.Remove(vd1);
                                    break;
                                }
                            }
                            savenode.TagObject = sourcepaket;
                            destinationNode.Expand();
                            break;
                    }
                }
                treeView.SelectedNode = sourceNode;
                Verify_Couverts();
            }
            catch { }

        }

       private void movenode(TreeNodeAdv sourceNode, TreeNodeAdv destinationNode)
        {

            Versandpaket sourcepaket = sourceNode.Parent.TagObject as Versandpaket;
            TreeNodeAdv savenode = sourceNode.Parent;
            sourceNode.Move(destinationNode.Nodes);

            //Versanddokument dem neuen Versandpaket zuordnen
            Versandpaket paket = destinationNode.TagObject as Versandpaket;
            Versanddokument vd = sourceNode.TagObject as Versanddokument;
            paket.Dokument.Add(vd);
            destinationNode.TagObject = paket;


            foreach (Versanddokument vd1 in sourcepaket.Dokument)
            {
                if (vd1.DokumentID == vd.DokumentID)
                {
                    sourcepaket.Dokument.Remove(vd1);
                    break;
                }
            }
            savenode.TagObject = sourcepaket;
            destinationNode.Expand();
        }

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

        private void treeViewAdv1_DragOver(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                bool Filedroppable = true;
                TreeNodeAdv FiledestinationNode = null;
                TreeViewAdv FiletreeView = sender as TreeViewAdv;
                Point FileptInTree = FiletreeView.PointToClient(new Point(e.X, e.Y));
                FiledestinationNode = FiletreeView.GetNodeAtPoint(FileptInTree);
                try
                {
                    if (FiledestinationNode.Nodes.Count == 0)
                    {
                        e.Effect = DragDropEffects.None;
                        return;
                    }
                    string[] files = e.Data.GetData(DataFormats.FileDrop) as string[]; // get all files droppeds  
                    foreach (string file in files)
                    {
                        if (System.IO.Path.GetExtension(file.ToUpper()) == ".PDF")
                        {
                            e.Effect = DragDropEffects.Link;
                        }
                        else
                        {
                            e.Effect = DragDropEffects.None;
                            return;
                        }
                    }
                    return;
                }
                catch { }
            }

            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;

                try
                {
                    Versanddokument vd = sourceNode.TagObject as Versanddokument;
                    if (vd.DokumentID.Contains("ATT"))
                    {
                        TreeNodeAdv destnodetop = destinationNode;
                        if (destnodetop.Level > 1) { destnodetop = destnodetop.Parent; }
                        if (destnodetop != sourceNode.Parent)
                        {
                            e.Effect = DragDropEffects.None;
                            droppable = false;
                            return;
                        }
                    }
                }
                catch { }
                
                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 (sourceNode.Level == 1) { return false; }


            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.GASSize = "";
            newpaket.Mitteilung = "";
            newpaket.Dokument = new List<Versanddokument>();

            string NodeText = "Versand-Couvert " + (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)
        {
            Cursor.Current = Cursors.WaitCursor;

            if (rbapost.Checked) { txtVersandoption.Text = "A_POST"; }
            if (rbb1post.Checked) { txtVersandoption.Text = "B1_POST"; }
            if (rbb2post.Checked) { txtVersandoption.Text = "B2_POST"; }
            if (rbeinschreiben.Checked) { txtVersandoption.Text = "EINSCHREIBEN"; }
            this.txtRückantwort.Text = txtadresse.Text.ToString();
            this.txtRückantwortSB.Text = txtRückantwort.Text;
            this.txtversandartsb.Text = txtVersandoption.Text;

            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 = false;
                panelverifysb.Visible = true;
                btnsendserienbrief.Visible = true;
                btnSendFinal.Visible = false;
                this.txtAnzahlDokumetneSB.Text = treeViewAdv1.Nodes[0].Nodes.Count.ToString();
                return;
            }

            panelPrepare.Visible = true;
            panelPrepare.Left = (this.Width - panelPrepare.Width) / 2;


            panelverifysb.Visible = false;
            btnsendserienbrief.Visible = false;
            btnSendFinal.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())
                        {
                            if (vsdok.DokumentID.Contains("ATT") && vsdok.dokument != "")
                            {

                            }
                            else
                            {
                                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);
                //}
                treeViewAdv1.SelectedNode.TagObject = paket;
                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);
                if (stapel == "File too large")
                {
                   MessageBox.Show("Das Versandpaket ist zu gross. Es können max. "+ String.Format("{0:0.0}", AppParams.MaxFileSize/(1024*1024)) + " MB versendet werden.","Versandstrasse", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    panelPrepare.Visible = false;
                    Cursor = Cursors.Default;
                    return;

                }

                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;
                this.txtAnzahlSeiten.Text = pdfViewerControl1.PageCount.ToString();
                if (Properties.Settings.Default.GASSize == "True")
                {
                    if (Convert.ToInt32(txtAnzahlSeiten.Text) > 30)

                    {
                        if (chkGAS.Checked && rbc5mini.Checked)
                        {
                            rbc5normal.Checked = true;
                            MessageBox.Show("Aufgrund der Anzahl Seiten wurde automatisch C5 Normal für das Rückantwort-Couvert gesetzt.", "Rückantwort-Couvert", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        }
                    }
                }
                this.txtAnzahlDokumente.Text = paket.Dokument.Count().ToString();
                lblprieveiwbezeichnung.Text = "Aufbereitetes PDF";
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
            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);
                PdfLoadedDocument loadedDocument = new PdfLoadedDocument(outputStream);
                if (loadedDocument.IsAllFontsEmbedded == false)
                {
                    loadedDocument.EmbedFonts();
                    loadedDocument.Save(outputStream);
                }
                var size = outputStream.ToArray().Length;
                byte[] bytes;
                bytes = outputStream.ToArray();
                
                if (size > AppParams.MaxFileSize)
                {
                    return "File too large";
                }
                return Convert.ToBase64String(bytes);
            }
            catch { return ""; }
        }

        private void chkGAS_CheckedChanged(object sender, EventArgs e)
        {
            this.panelVerify.Visible = false;
            this.panelverifysb.Visible = false;
            if (chkGAS.Checked)
            {
                treeViewAdvAdresse.Enabled = true;
                treeViewAdvAdresse.SelectedNode = treeViewAdvAdresse.Nodes[0];
                treeViewAdvAdresse_AfterSelect(sender, e);

                Versandpaket vp = treeViewAdv1.SelectedNode.TagObject as Versandpaket;
                vp.GAS = "1";
                treeViewAdv1.SelectedNode.TagObject = vp;
                this.pnlcouvertgroesse.Enabled = true;
            }
            else
            {
                this.txtadresse.Text = "";
                treeViewAdvAdresse.Enabled = false;
                Versandpaket vp = treeViewAdv1.SelectedNode.TagObject as Versandpaket;
                vp.GAS = "";
                treeViewAdv1.SelectedNode.TagObject = vp;
                this.pnlcouvertgroesse.Enabled = false;
            }
        }

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

        private void btnSendFinal_Click(object sender, EventArgs e)
        {


            if (serienbrief)
            {
                Versandpaket svp = treeViewAdv1.Nodes[0].TagObject as Versandpaket;
                if (Properties.Settings.Default.GASSize == "True")
                {
                    if (rbc5mini.Checked) { svp.GASSize = "C5mini"; }
                    if (rbc5normal.Checked) { svp.GASSize = "C5normal"; }
                }
                else
                {
                    svp.GASSize = "";
                }
                foreach (TreeNodeAdv node in treeViewAdv1.Nodes[0].Nodes)
                {

                    svp.finaldoc = node.TagObject.ToString();
                    svp.send_onbase_doc = true;
                    string dokumentid = node.Text.Substring(node.Text.Length - 23, 22);
                    string _sqlWhere = @"dokumentid = '" + dokumentid + "'";


                    DataTable _newDataTable = sb.dsempfaenger.Tables[0].Select(_sqlWhere, "").CopyToDataTable();
                    svp.partnernr = Convert.ToInt32(_newDataTable.Rows[0]["partnernr"].ToString());

                    Versanddokument vd = new Versanddokument(dokumentid, "", svp.partnernr.ToString());

                    vd.dokument = node.TagObject.ToString();
                    vd.inteintragnr = Convert.ToInt32(_newDataTable.Rows[0]["inteintragnr"].ToString());
                    svp.bemerkung = vd.DokumentID + " / " + sb.serienbriefnr.ToString() + "_" + _newDataTable.Rows[0]["inteintragnr"].ToString();
                    svp.Dokument.Clear();
                    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;
                    this.progressBarAdv1.Value = this.progressBarAdv1.Value + 1;
                    send_vs(ref svp, false);




                }


                sb.status = 1;

                pdfViewerControl1.Unload();
                lblprieveiwbezeichnung.Text = "";
                this.Close();
                return;
            }
            panelVerify.Visible = false;
            Versandpaket vp = treeViewAdv1.SelectedNode.TagObject as Versandpaket;
            List<Versanddokument> vdl = new List<Versanddokument>();
            if (Properties.Settings.Default.GASSize == "True")
            {
                if (chkGAS.Checked)
                {
                    if (rbc5mini.Checked) { vp.GASSize = "C5mini"; }
                    if (rbc5normal.Checked) { vp.GASSize = "C5normal"; }
                }
                else
                {
                    vp.GASSize = "";
                }
            }
            else
            {
                vp.GASSize = "";
            }
            foreach (TreeNodeAdv node in treeViewAdv1.SelectedNode.Nodes)
            {
                foreach (Versanddokument vdok in vp.Dokument)
                {
                    if (node.Tag == vdok.DokumentID) { vdl.Add(vdok); }
                }
            }
            vp.Dokument = vdl;
            vp.verified = true;
            treeViewAdv1.SelectedNode.TagObject = vp;
            panelVerify.Visible = false;
            pakete.Remove(vp);

            SendTo_Versandstrasse();
            pdfViewerControl1.Unload();
            lblprieveiwbezeichnung.Text = "";
            vdl = null;
            vp = null;
        }
        private void SendTo_Versandstrasse()
        {
            Versandpaket vp = treeViewAdv1.SelectedNode.TagObject as Versandpaket;
            vp.send_onbase_doc = true;
            DB db = new DB(AppParams.connectionstring);
            string dokumente = "";
            if (vp.Dokument.Count > 1) { vp.send_onbase_doc = false; }
            else
            {
                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)
        {
            string jsonstring = JsonConvert.SerializeObject(vp);

            //vp.send_onbase_doc = true;


            DB db = new DB(AppParams.connectionstring);
            db.clear_parameter();
            db.add_parameter("@ersteller", AppParams.CurrentMitarbeiter.ToString());
            db.Get_Tabledata("ondoc_create_versandpaket", true, false);
            int paketid = Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][0]);


            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;
            // db.daten.Tables[0].Rows.Add(dr);
            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();
            treeViewAdv1.Nodes.Remove(treeViewAdv1.SelectedNode);
            if (!direktversenden)
            {
                return;
            }

            string URL = AppParams.RESTURI + "api/Send_Versandstrasse?paketid=" + paketid.ToString();
            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("Couvert an Versandstrasse übergeben", "Versandstrasse", MessageBoxButtons.OK, MessageBoxIcon.Information);
                                treeViewAdv1.SelectedNode.Remove();
                            }
                        }

                    }
                }


                return;
            }
            catch { }

        }

        private void rbapost_CheckedChanged(object sender, EventArgs e)
        {
            this.panelVerify.Visible = false;
            this.panelverifysb.Visible = false;
            string versandoption = "";
            if (rbapost.Checked) { versandoption = "A_POST"; }
            if (rbb1post.Checked) { versandoption = "B1_POST"; }
            if (rbb2post.Checked) { versandoption = "B2_POST"; }
            if (rbeinschreiben.Checked) { versandoption = "EINSCHREIBEN"; }

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

        private void treeViewAdvAdresse_AfterSelect(object sender, EventArgs e)
        {
            this.panelVerify.Visible = false;
            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;
                txtadresse.Text = "";

                txtadresse.Text = dr["zeile1"].ToString() + Environment.NewLine;
                txtadresse.Text = txtadresse.Text + dr["zeile2"].ToString() + Environment.NewLine;
                txtadresse.Text = txtadresse.Text + dr["zeile3"].ToString() + Environment.NewLine;
                txtadresse.Text = txtadresse.Text + dr["zeile4"].ToString() + Environment.NewLine;
                txtadresse.Text = txtadresse.Text + dr["zeile5"].ToString() + Environment.NewLine;
                txtadresse.Text = txtadresse.Text + dr["zeile6"].ToString() + Environment.NewLine;
                try
                {
                    txtadresse.Text = txtadresse.Text + dr["zeile7"].ToString() + Environment.NewLine;
                }
                catch { }

            }
            catch
            {
                txtadresse.Text = "";
            }

        }

        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 { }
        }

        bool forceeinschreiben = false;

        private void treeViewAdv1_AfterSelect(object sender, EventArgs e)
        {
            try
            {

                this.panelVerify.Visible = false;
                Cursor.Current = Cursors.WaitCursor;
                TreeNodeAdv node = treeViewAdv1.SelectedNode;
                if (node.Level == 1)
                {
                    forceeinschreiben = false;
                    if (Verify_Couvert(node) == false)
                    {
                        GrpPaketDetails.Enabled = false;
                        return;
                    }
                    
                    GrpPaketDetails.Enabled = true;
                    Versandpaket paket = node.TagObject as Versandpaket; ;
                    if (forceeinschreiben) { rbeinschreiben.Checked = true; }
                    rbapost.Enabled = true;
                    rbb1post.Enabled = true;
                    rbb2post.Enabled = true;
                    switch (paket.Versandoption)
                    {
                        case "A_POST":
                            rbapost.Checked = true; break;
                        case "B1_POST":
                            rbb1post.Checked = true; break;
                        case "B2_POST":
                            rbb2post.Checked = true; break;
                        case "EINSCHREIBEN":
                            rbeinschreiben.Checked = true;
                            if (forceeinschreiben)
                            {
                                rbapost.Enabled = false;
                                rbb1post.Enabled = false;
                                rbb2post.Enabled = false;

                            }
                            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.Tag.ToString() == paket.GASAdresse)
                            {
                                treeViewAdvAdresse.SelectedNode = tn;
                            }
                        }
                    }

                }
                else
                {
                    if (ribbonButtonDokPreview.Checked)
                    {
                        clsVersandstrasse vs = new clsVersandstrasse();
                        lblprieveiwbezeichnung.Text = node.Text;
                        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(), this.ribbonchkadresse.Checked);

                        }
                        else
                        {
                            Versanddokument vd = node.TagObject as Versanddokument;
                            if (vd.DokumentID.Contains("ATT") && vd.dokument != "")
                            {
                                dok = vd.dokument;
                            }
                            else
                            {

                                dok = vs.Prepare_PDF(node.Tag.ToString(), AppParams.tempdir, AppParams.connectionstring, AppParams.RESTURI, AppParams.apikey, Application.StartupPath, null, null, "", this.ribbonchkadresse.Checked);
                            }
                        }

                        var stream = new MemoryStream(Convert.FromBase64String(dok));
                        this.pdfViewerControl1.Load(stream);
                    }

                    GrpPaketDetails.Enabled = false;
                }
            }
            catch (Exception ex) { }
            finally { Cursor.Current = Cursors.Default; }
        }

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

        private void contextMenuStrip1_Click(object sender, EventArgs e)
        {

        }

        private void toolStrip1_ItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {

        }

        private void TabControlDokuments_SelectedIndexChanged(object sender, EventArgs e)
        {
        }
        private void Refresh_VersandCouverts()
        {

            DB db = new DB(AppParams.connectionstring);
            DB db2 = new DB(AppParams.connectionstring);
            //STH
            try
            {
                db.Get_Tabledata("Select * from ondoc_versandstrasse_paket where isnull(signed,1)=1 and  aktiv=1 and ersteller=" + AppParams.CurrentMitarbeiter + " and versendet=0", false, true);
            }
            catch
            {
                db.Get_Tabledata("Select * from ondoc_versandstrasse_paket where aktiv=1 and 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() == "B1_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)
        {

            try
            {
                TreeNodeAdv node = treeViewAdvCouverts.SelectedNode;
                if (node.Level == 1)
                {
                    if (this.ribbonbuttondokpreviewpostkorb.Checked)
                    {
                        
                        var stream = new MemoryStream(Convert.FromBase64String(node.TagObject.ToString()));
                        this.pdfViewerControl2.Load(stream);
                        stream = null;
                    }
                    if (node.Level == 1)
                    {
                        DB db = new DB(AppParams.connectionstring);
                        db.Get_Tabledata("Select * from ondoc_versandstrasse_paket where id=" + node.Tag.ToString(), false, true);
                        Versandpaket vp = JsonConvert.DeserializeObject<Versandpaket>(db.dsdaten.Tables[0].Rows[0]["paket"].ToString());

                        db = null;
                        this.textBox4.Text = this.pdfViewerControl2.PageCount.ToString();
                        this.textBox3.Text = node.Nodes.Count.ToString();
                        this.textBox2.Text = vp.Versandoption;
                        this.textBox1.Text = vp.GASAdresse.Replace(";", Environment.NewLine);
                    }
                }
                else
                {
                    this.textBox4.Text = "";
                    this.textBox3.Text = "";
                    this.textBox2.Text = "";
                    this.textBox1.Text = "";

                }

            }
            catch { }
        }

        private void versandCouvertLöschenToolStripMenuItem_Click(object sender, EventArgs e)
        {
            DB db = new DB(AppParams.connectionstring);
            foreach (TreeNodeAdv tn in treeViewAdvCouverts.SelectedNodes)
            {
                db.Exec_SQL("Update ondoc_versandstrasse_paket set geloescht=getdate(), aktiv=0, geloescht_durch=" + AppParams.CurrentMitarbeiter.ToString() + " where id=" + tn.Tag.ToString());

            }
            db = null;
            pdfViewerControl2.Unload();
            lblprieveiwbezeichnung.Text = "";
            Refresh_VersandCouverts();

        }

        private void versandCouvertÖffnenbearbeitenToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (treeViewAdvCouverts.SelectedNode.Level != 1) { return; }
            int id = Convert.ToInt32(treeViewAdvCouverts.SelectedNode.Tag);
            DB db = new DB(AppParams.connectionstring);
            db.Get_Tabledata("Select * from Ondoc_Versandstrasse_Paket where id=" + id.ToString(), false, true);
            Versandpaket vp = JsonConvert.DeserializeObject<Versandpaket>(db.dsdaten.Tables[0].Rows[0]["Paket"].ToString());
            pakete.Add(vp);

            foreach (TreeNodeAdv tn in treeViewAdvCouverts.SelectedNodes)
            {
                db.Exec_SQL("Update ondoc_versandstrasse_paket set geloescht=getdate(), aktiv=0, reopen=1,geloescht_durch=" + AppParams.CurrentMitarbeiter.ToString() + " where id=" + id.ToString());

            }
            db = null;
            treeViewAdvCouverts.Nodes.Remove(treeViewAdvCouverts.SelectedNode);
            pdfViewerControl2.Unload();
            lblprieveiwbezeichnung.Text = "";
            Reload_Tree();
            ribbon1.TabIndex = 0;



        }

        private void löschenToolStripMenuItem_Click(object sender, EventArgs e)
        {
            try
            {
                TreeNodeAdv node = treeViewAdv1.SelectedNode;
                if (node.Level > 1)
                {
                    Versanddokument vd = node.TagObject as Versanddokument;
                    node = node.Parent;
                    Versandpaket vp = node.TagObject as Versandpaket;
                    reserve_vs_dokument(treeViewAdv1.SelectedNode.Tag.ToString(), 2);

                    vp.Dokument.Remove(vd);

                    treeViewAdv1.SelectedNode.Remove();

                    Verify_Couvert(node);
                }
                else
                {
                    foreach (TreeNodeAdv tn in node.Nodes)
                    {
                        reserve_vs_dokument(tn.Tag.ToString(), 2);
                    }
                    Versandpaket vp = treeViewAdv1.SelectedNode.TagObject as Versandpaket;
                    pakete.Remove(vp);
                    treeViewAdv1.SelectedNode.Remove();
                    this.pdfViewerControl1.Unload();


                }
            }
            catch { }
        }
        private void reserve_vs_dokument(string dokumentid, int fnkt)
        {
            DB db = new DB(AppParams.connectionstring);
            db.clear_parameter();
            db.add_parameter("@dokumentid", dokumentid);
            db.add_parameter("@mitarbeiter", AppParams.CurrentMitarbeiter.ToString());
            db.add_parameter("@fnkt", fnkt.ToString());
            db.Get_Tabledata("Ondoc_Handle_Versandstrasse_Reserved_Dokcuments", true, false);
            db = null;
        }

        private void tschkcouvertpos_CheckedChanged(object sender, EventArgs e)
        {
            treeViewAdv1_AfterSelect(sender, e);
        }

        private void contextMenuStrip1_Opening(object sender, CancelEventArgs e)
        {
            if (treeViewAdv1.SelectedNode.Level > 1 && treeViewAdv1.SelectedNode.Parent.Text.Contains("Serienbrief"))
            {
                löschenToolStripMenuItem.Enabled = false;
            }
            else
            {
                löschenToolStripMenuItem.Enabled = true;
            }
        }

        private void btnsendserienbrief_Click(object sender, EventArgs e)
        {
            direktversenden = true;
            this.pnlprogress.Visible = true;
            this.progressBarAdv1.Minimum = 0;
            this.progressBarAdv1.Value = 0;
            this.progressBarAdv1.Maximum = treeViewAdv1.SelectedNode.Nodes.Count;
            Application.DoEvents();
            btnSendFinal_Click(sender, e);

            direktversenden = false;
            this.panelverifysb.Visible = false;
            this.pnlprogress.Visible = false;
        }

        private void button5_Click(object sender, EventArgs e)
        {
            this.panelverifysb.Visible = false;
        }

        private void tsbtnpreviewdoc_Click(object sender, EventArgs e)
        {


        }

        private void tsbtncheckaddress_Click(object sender, EventArgs e)
        {
        }

        private void ribbonButton1_Click(object sender, EventArgs e)
        {

        }

        private void ribbonButtonNewCouvert_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.GASSize = "";
            newpaket.Mitteilung = "";
            newpaket.Dokument = new List<Versanddokument>();

            string NodeText = "Versand-Couvert " + (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 ribbonTab1_ActiveChanged(object sender, EventArgs e)
        {
            if (this.ribbonTab1.Active)
            {
                this.lblpostausgang.Visible = false;
                this.pnlcouvert.Visible = true;
                this.pnlcouvert.Dock = DockStyle.Fill;
                this.pnlpostkorb.Visible = false;
            }
        }

        private void ribbonTab2_ActiveChanged(object sender, EventArgs e)
        {
            if (this.ribbonTab2.Active)
            {
                this.lblpostausgang.Visible = true;
                this.lblpostausgang.Left = this.Width - lblpostausgang.Width;
                this.pnlcouvert.Visible = false;

                this.pnlpostkorb.Visible = true;
                this.pnlpostkorb.Dock = DockStyle.Fill;
                Refresh_VersandCouverts();
            }
        }

        private void ribbonButtonDokPreview_Click(object sender, EventArgs e)
        {
            if (this.ribbonButtonDokPreview.Checked)
            {
                this.ribbonButtonDokPreview.Checked = false;
                this.pdfViewerControl1.Unload();
                lblprieveiwbezeichnung.Text = "";
            }
            else
            {
                this.ribbonButtonDokPreview.Checked = true;

                treeViewAdv1_AfterSelect(sender, e);
            }
        }

        private void ribbonchkadresse_Click(object sender, EventArgs e)
        {
            treeViewAdv1_AfterSelect(sender, e);
        }

        private void ribbon1_Click(object sender, EventArgs e)
        {
            this.pnlcouvert.Dock = DockStyle.Fill;
        }

        private void ribbonbuttondokpreviewpostkorb_Click(object sender, EventArgs e)
        {
            if (ribbonbuttondokpreviewpostkorb.Checked)
            {
                ribbonbuttondokpreviewpostkorb.Checked = false;
                this.pdfViewerControl2.Unload();
                lblprieveiwbezeichnung.Text = "";
            }
            else
            {
                ribbonbuttondokpreviewpostkorb.Checked = true;
                treeViewAdv1_AfterSelect(sender, e);
            }
        }

        private void Versandstrasse_Resize(object sender, EventArgs e)
        {
            this.treeViewAdvCouverts.Height = this.Height - this.ribbon1.Height - this.grpCouvertDetails.Height;
            panelPrepare.Left = this.Width - this.panelPrepare.Width;
        }

        private void Versandstrasse_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (this.treeViewAdv1.Nodes.Count > 0)
            {
                MessageBox.Show("Vor dem Schliessen sind die pendenten Couverts zu löschen oder in den Postausgang zu legen.", "Schliessen", MessageBoxButtons.OK, MessageBoxIcon.Information);
                e.Cancel = true;
            }
        }

        private void ribbon1_TabIndexChanged(object sender, EventArgs e)
        {
            int a = 0;
        }

        public void add_doc(Versanddokument vs, string paketnr="")
        {
            bool zugewiesen = false;
            foreach (Versandpaket vp in pakete)
            {
                if (vp.partnernr.ToString() == vs.Partnernr && (paketnr=="" || paketnr==vp.PaketNr))
                {
                    vp.Dokument.Add(vs);
                    zugewiesen = true;
                    Reload_Tree();
                    break;
                }
            }
            if (!zugewiesen)
            {
                Versandpaket vp = new Versandpaket();
                vp.Dokument = new List<Versanddokument>();
                vp.partnernr = Convert.ToInt32(vs.Partnernr);
                vp.Versandoption = "B2_POST";
                vp.Mitteilung = "";
                vp.GAS = "";
                vp.GASAdresse = "";
                vp.GASSize = "";
                vp.PaketNr = Guid.NewGuid().ToString();

                vp.Dokument.Add(vs);
                pakete.Add(vp);
                zugewiesen = true;
                Reload_Tree();

            }

        }

        private void Versandstrasse_FormClosed(object sender, FormClosedEventArgs e)
        {
            AppParams.versandstrassewindows_open = false;
        }

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

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

        private void externesPDFHinzufügenToolStripMenuItem_Click(object sender, EventArgs e)
        {
            TreeNodeAdv node = treeViewAdv1.SelectedNode;
            if (node.Level != 1)
            {
                node = node.Parent;
            }
            if (node.Nodes.Count < 1)
            {
                MessageBox.Show("Bitte zuerst ein reguläres OnDoc-Dokument zum Paket hinzufügen, "+Environment.NewLine+"bevor ein Anhang zugefügt wird.", "PDF-Datei hinzufügen", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            Versandpaket vp = node.TagObject as Versandpaket;
            int partnernr = vp.partnernr;

            Random random = new Random(19);
            openFileDialog1.FileName = "";
            openFileDialog1.Filter = "PDF-Dokumente (*.pdf)|*.pdf|Alle Dokumente (*.*)|*.*";
            if (openFileDialog1.ShowDialog() == DialogResult.OK)
            {
                if (System.IO.Path.GetExtension(openFileDialog1.FileName).ToLower() != ".pdf")
                {
                    MessageBox.Show("Es können lediglich PDF-Dateien hinzugefügt werden.","PDF-Datei hinzufügen",MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }
                Add_Attachment(openFileDialog1.FileName, partnernr,vp.PaketNr);
            }
        }
        private void Add_Attachment(string filename,int partnernr, string paketnr)
        {
            Helper.FileHelper fh = new Helper.FileHelper();
            string att = fh.Base64FromFile(filename);
            clsVersandstrasse vs = new clsVersandstrasse();
            att = vs.check_pdf_pages(att);
            string gid = "ATT" + RandomString(19);
            vs = null;
            Versanddokument attachment = new Versanddokument(gid, "Externe Datei: " + filename, partnernr.ToString());
            attachment.dokument = att;
            add_doc(attachment,paketnr );

        }

        public string RandomString(int size, bool lowerCase = false)
        {
            var builder = new StringBuilder(size);

            // Unicode/ASCII Letters are divided into two blocks
            // (Letters 65–90 / 97–122):
            // The first group containing the uppercase letters and
            // the second group containing the lowercase.

            // char is a single Unicode character
            char offset = lowerCase ? 'a' : 'A';
            const int lettersOffset = 26; // A...Z or a..z: length=26

            for (var i = 0; i < size; i++)
            {
                var @char = (char)_random.Next(offset, offset + lettersOffset);
                builder.Append(@char);
            }

            return lowerCase ? builder.ToString().ToLower() : builder.ToString();
        }
        private readonly Random _random = new Random();

        // Generates a random number within a range.
        public int RandomNumber(int min, int max)
        {
            return _random.Next(min, max);
        }

        private void ribbonAddPDF_Click(object sender, EventArgs e)
        {
            externesPDFHinzufügenToolStripMenuItem_Click(sender, e);
        }

        private void contextMenuStrip2_Opening(object sender, CancelEventArgs e)
        {
            int id = Convert.ToInt32(treeViewAdvCouverts.SelectedNode.Tag);
            DB db = new DB(AppParams.connectionstring);
            try
            {
                db.Get_Tabledata("Select versendet, aktiv from Ondoc_Versandstrasse_Paket where id = " + id.ToString(), false, true);
                if (Convert.ToBoolean(db.dsdaten.Tables[0].Rows[0][0]) == true)
                {
                    MessageBox.Show("Das Paket wurde zwischenzeitlich versendet. Bitte die Ansicht aktualisieren.", "Versandcouvert", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    e.Cancel = true;
                }
                if (Convert.ToBoolean(db.dsdaten.Tables[0].Rows[0][1]) == false)
                {
                    MessageBox.Show("Das Paket wurde zwischenzeitlich gelöscht. Bitte die Ansicht aktualisieren.", "Versandcouvert", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    e.Cancel = true;
                }
            }
            catch { }
            finally { db = null; }

            
        }

        private void ribbonbtnAktualisieren_Click(object sender, EventArgs e)
        {
            Refresh_VersandCouverts();
        }

        private void rbeinschreiben_CheckedChanged(object sender, EventArgs e)
        {


            Versandpaket vp = treeViewAdv1.SelectedNode.TagObject as Versandpaket;
            DB db = new DB(AppParams.connectionstring);
            try
            {
                if (rbeinschreiben.Checked == true)
                {
                    MessageBox.Show("Bei 'Einschreiben' wird die Hauptadresse von Avaloq auf dem Adressträger verwendet und kann dadurch von der Zustelladresse im Dokument abweichen.", "Versandart", MessageBoxButtons.OK, MessageBoxIcon.Information);

                    db.Get_Tabledata("Select dbo.fnkt_ondoc_check_landcode(" + vp.partnernr.ToString() + ")", false, true);
                    try
                    {
                        if (Convert.ToInt32(db.dsdaten.Tables[0].Rows[0][0]) == 1)
                        {
                            return;
                        }
                        else
                        {
                            MessageBox.Show("Einschreiben kann nur für Schweiz und Deutschland verwendet werden." + Environment.NewLine + "Bitte prüfe im ersten Dokument die Zustelladresse.", "Versandsart", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        }

                    }
                    catch { }
                }

            }
            catch { }
            finally { db = null; vp = null; }
        }
    }
}