OnDoc/Client/Versandstrasse/Versandstrasse.cs

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;

namespace OnDoc.Versandstrasse
{
    public partial class Versandstrasse : SfForm
    {
        private Versandpakete pakete = new Versandpakete();
        private TreeViewAdvDragHighlightTracker treeViewDragHighlightTracker = null;
        private TreeNodeAdv currentSourceNode;
       
        public Versandstrasse(Versandpakete 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;
        }

        private void Versandstrasse_Load(object sender, EventArgs e)
        {
            Reload_Tree();
        }
        private void Reload_Tree() { 
            treeViewAdv1.Nodes.Clear();

            TreeNodeAdv DruckJob;
            for (int i = 0; i < pakete.paket.Count; i++)
            {
                DruckJob = new TreeNodeAdv();
                DruckJob.Text = "Druckpaket " + pakete.paket[i].PaketNr;
                DruckJob.Tag = "Druckpaket";
                DruckJob.TagObject = pakete.paket[i];
                treeViewAdv1.Nodes.Add(DruckJob);

                PopulateDocs(pakete.paket[i], ref DruckJob);
            }
            treeViewAdv1.ExpandAll();
        }

        private void PopulateDocs(Versandpaket paket, ref TreeNodeAdv parentnode)
        {
            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];
                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;
        }

        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)
        {
            if (node.Tag == null
                || ("Druckpaket").CompareTo(node.Tag.ToString()) != 0)
            {
                return false;
            }
            else
                return true;
        }
        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 = "1";
            newpaket.GAS = "0";
            newpaket.GASAdresse = "0";
            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;

            treeViewAdv1.Nodes.Add(drucknode);
        }

        private void treeViewAdv1_NodeMouseClick(object sender, TreeViewAdvMouseClickEventArgs e)
        {
            TreeNodeAdv node = e.Node;
            if (node.Level == 1) {
                GrpPaketDetails.Enabled = true;
                Versandpaket paket = node.TagObject as Versandpaket;
                switch (paket.Versandoption) {
                    case "1":
                        rbversandoption1.Checked= true; break;
                        case "2":
                        rbversandoption2.Checked= true;break;
                    case "3":
                        rbversandoption3.Checked= true;break;
                    default:
                        break;
                }
               
                if (paket.GAS.ToString() == "1"){ 
                    chkGAS.Checked= true; 
                    lbgasadresse.SelectedIndex = Convert.ToInt32(paket.GASAdresse.ToString());
                } else { chkGAS.Checked= false; }
            }
            else {
                if (tscheckboxpreview.Checked)
                {
                    clsVersandstrasse vs = new clsVersandstrasse();
                    string dok = vs.Prepare_PDF(node.Tag.ToString(), AppParams.tempdir, AppParams.connectionstring);
                    var stream = new MemoryStream(Convert.FromBase64String(dok));
                    this.pdfViewerControl1.Load(stream);
                }

                GrpPaketDetails.Enabled=false; }
        }

        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)
        {
            Versandpaket paket = treeViewAdv1.SelectedNode.TagObject as Versandpaket;
            foreach (Versanddokument vsdok in paket.Dokument)
            {
                clsVersandstrasse vs = new clsVersandstrasse();
                vsdok.dokument = vs.Prepare_PDF(vsdok.DokumentID.ToString(), AppParams.tempdir, AppParams.connectionstring);
                //string dok = vs.Prepare_PDF(vsdok.DokumentID.ToString(), AppParams.tempdir, AppParams.connectionstring);
            }
            Stream[] streams = new Stream[paket.Dokument.Count];
            int i = 0;
            foreach (Versanddokument vsdok in paket.Dokument)
            {
                var stream = new MemoryStream(Convert.FromBase64String(vsdok.dokument));
                streams[i] = stream;
                i++;
            }

            string stapel = save_stapel(ref streams);
            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;
        }
        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 ""; }
        }
    }
}