BeWoPlaner/BeWo/View/Document/DokumentViewHelper.cs

using BeWo.Core;
using BeWo.ServiceProxy;
using BeWo.View.Windows;
using BeWo.ViewModel;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.Translation;
using DevExpress.Utils;
using DevExpress.Xpf.Grid;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media.Imaging;

namespace BeWo.View.Document
{
    public class DokumentViewHelper
    {

        public static void OpenTemplateSelectionDialog(List<DokumentvorlageDC> alleVorlagen, TableID objectTid, long objectOid)
        {

            var alleVorlagenTabellen = ServiceFacade.DoOperationsServiceSync(s => s.GetVorlagentabelleDCs());
            var tabelle = alleVorlagenTabellen.FirstOrDefault(v => v.VorlagentabelleObjectTid.HasValue && v.VorlagentabelleObjectTid.Value == (int)objectTid);
            if (tabelle != null)
            {
                var view = new SingleTemplateSelectionView();

                var customerFolderList = VMFactory.CreateFolderList(objectTid, objectOid);

                var templateFolderList = VMFactory.CreateFolderList(TableID.Vorlagentabelle, tabelle.VorlagentabelleOid.Value);
                view.InitView(tabelle, alleVorlagen, templateFolderList, customerFolderList, true, false);
                var beWoWindow = BeWoWindowBuilder.GetBeWoWindow(Translator.Translate("Vorlage auswählen"), view, 500, 500);

                view.ButtonCancelClicked += () => beWoWindow.Close();
                view.ButtonCreateForSelectionClicked += () =>
                {
                    PrintTemplate(view.SelectedTemplate, objectTid, objectOid);
                    beWoWindow.Close();

                };

                beWoWindow.ShowDialog();
            }
        }
        public static void CreateTemplateTreeViewItems(TreeListControl treeControl, IList<VorlagentabelleDC> vorlagentabellen, List<BeWoFolderDC> allFolder, bool expandItems)
        {
            treeControl.BeginDataUpdate();

            foreach (var table in vorlagentabellen)
            {
                TreeListNode node = new TreeListNode();
                DocumentTreeItemDC dc = new DocumentTreeItemDC()
                {
                    DocTreeItemOid = table.VorlagentabelleOid,
                    ParentOid = null,
                    Name = table.Tabellenname,
                    Table = BS.Shared.TableID.Vorlagentabelle,
                    ObjectOid = table.VorlagentabelleOid,
                    Node = node,
                    BeWoFolderDC = new BeWoFolderDC { Name = "RootFolder", SubFolders = new List<BeWoFolderDC>() }
                };
                DocumentTreeItemVM vm = new DocumentTreeItemVM(dc);
                node.Content = vm;
                treeControl.View.Nodes.Add(node);
                node.IsExpandButtonVisible = DefaultBoolean.True;
                node.IsExpanded = expandItems;
                node.Image = LoadImage(table.ImageName);

            }

            if (allFolder != null && allFolder.Count > 0)
            {
                AddFolderToTreeView(treeControl, allFolder, expandItems);
            }
            treeControl.EndDataUpdate();
        }

        public static void AddTemplatesToTreeView(TreeListControl treeControl, List<DokumentvorlageDC> allTemplates, bool expandItems)
        {
            treeControl.BeginDataUpdate();
            foreach (var template in allTemplates)
            {
                TreeListNode parentNode = FindParentNodeForTemplate(treeControl.View.Nodes, template);
                if (parentNode != null)
                {
                    parentNode.IsExpandButtonVisible = DefaultBoolean.True;
                    var parentVm = parentNode.Content as DocumentTreeItemVM;

                    DocumentTreeItemDC dc = new DocumentTreeItemDC()
                    {
                        DocTreeItemOid = template.DokumentvorlageOid,
                        ParentOid = parentVm.DocTreeItemOid,
                        Name = template.Name,
                        Dokumentvorlage = template,
                        Table = TableID.Dokumentvorlage
                    };

                    DocumentTreeItemVM folder_vm = new DocumentTreeItemVM(dc);
                    var newFolderNode = new TreeListNode()
                    {
                        Content = folder_vm,
                        IsExpandButtonVisible = DefaultBoolean.False,
                        Tag = template,
                        IsExpanded = expandItems,
                        Image = LoadDocumentImage()
                    };
                    dc.Node = newFolderNode;
                    parentNode.Nodes.Add(newFolderNode);
                }
            }
            treeControl.EndDataUpdate();
        }

        private static TreeListNode FindParentNodeForTemplate(TreeListNodeCollection nodes, DokumentvorlageDC template)
        {
            foreach (TreeListNode node in nodes)
            {
                var docVm = node.Content as DocumentTreeItemVM;
                if (docVm != null && docVm.DataContract.Dokumentvorlage == null && docVm.DocTreeItemOid.HasValue && docVm.DocTreeItemOid == template.Parent)
                {
                    return node;
                }

                var childNode = FindParentNodeForTemplate(node.Nodes, template);
                if (childNode != null)
                {
                    return childNode;
                }
            }

            return null;
        }

        public static void AddFolderToTreeView(TreeListControl treeControl, List<BeWoFolderDC> folders, bool expandItems)
        {
            treeControl.BeginDataUpdate();


            foreach (var node in treeControl.View.Nodes)
            {
                AddFolderToNode(node, folders, expandItems);
            }

            
            treeControl.EndDataUpdate();
        }

        private static void AddFolderToNode(TreeListNode parentNode, List<BeWoFolderDC> folders, bool expandItems)
        {
            if (parentNode != null && folders != null)
            {
                var parentVm = parentNode.Content as DocumentTreeItemVM;

                foreach (var folder in folders)
                {

                    if (folder.BeWoFolderOid.HasValue)
                    {
                        //if (parentVm != null && parentVm.DocTreeItemOid == folder.ObjectOid)
                        //{
                            DocumentTreeItemDC dc = new DocumentTreeItemDC()
                            {
                                DocTreeItemOid = folder.BeWoFolderOid,
                                ParentOid = parentVm.DocTreeItemOid,
                                Name = folder.Name,
                                FilesInFolder = new List<FileAttachmentDC>(),
                                BeWoFolderDC = folder,
                                Table = parentVm.DataContract.Table,
                                ObjectOid = parentVm.DataContract.ObjectOid
                            };
                            if (folder.Files.Count != 0)
                            {
                                foreach (var file in folder.Files)
                                {
                                    dc.FilesInFolder.Add(file);
                                }
                            }
                            DocumentTreeItemVM folder_vm = new DocumentTreeItemVM(dc);
                        var newFolderNode = new TreeListNode()
                        {
                            Content = folder_vm,
                            IsExpandButtonVisible = folder.SubFolders != null && folder.SubFolders.Count > 0 ? DefaultBoolean.True : DefaultBoolean.False,
                            IsExpanded = expandItems,
                            Tag = false,
                            Image = LoadFolderImage()
                        };
                        dc.Node = newFolderNode;
                        parentNode.Nodes.Add(newFolderNode);

                        AddFolderToNode(newFolderNode, folder.SubFolders, expandItems);
                        //}
                    }
                    else
                    {
                        if (folder.ObjectOid.HasValue && folder.ObjectOid == parentVm.DocTreeItemOid)
                        {
                            AddFolderToNode(parentNode, folder.SubFolders, expandItems);
                        }
                    }
                }
                    

            }
        }

        private static void GenerateFolderStructureForSelectedNode(TreeListNode node, List<BeWoFolderDC> folderDCs, bool hideAlleOrdner)
        {
            if (node.Nodes.Count == 0)
            {
                var content = node.Content as DocumentTreeItemVM;

                foreach (var folder in folderDCs)
                {
                    TreeListNode newNode_folder = null;
                    if (folder.BeWoFolderOid.HasValue || !hideAlleOrdner)
                    {
                        DocumentTreeItemDC folder_dc = new DocumentTreeItemDC()
                        {
                            DocTreeItemOid = folder.BeWoFolderOid,
                            ParentOid = content.DocTreeItemOid,
                            Name = folder.Name,
                            FilesInFolder = new List<FileAttachmentDC>(),
                            BeWoFolderDC = folder,
                            Table = content.DataContract.Table,
                            ObjectOid = content.DataContract.ObjectOid
                        };
                        if (folder.Files.Count != 0)
                        {
                            foreach (var file in folder.Files)
                            {
                                folder_dc.FilesInFolder.Add(file);
                            }
                        }
                        DocumentTreeItemVM folder_vm = new DocumentTreeItemVM(folder_dc);
                        newNode_folder = new TreeListNode()
                        {
                            Content = folder_vm,
                            IsExpandButtonVisible = folder.SubFolders != null && folder.SubFolders.Count > 0 ? DefaultBoolean.True : DefaultBoolean.False,
                            Tag = false,
                            Image = LoadFolderImage()
                        };
                        folder_dc.Node = newNode_folder;
                        node.Nodes.Add(newNode_folder);
                    }
                    else
                    {
                        newNode_folder = node;
                        if (content.DataContract.BeWoFolderDC == null)
                        {
                            content.DataContract.BeWoFolderDC = folder;
                        }

                    }

                    if (folder.SubFolders.Count != 0)
                    {
                        GenerateFolderStructureForSelectedNode(newNode_folder, folder.SubFolders, hideAlleOrdner);
                    }
                }
            }

        }

        
        private static void PrintTemplate(DokumentvorlageDC vorlage, TableID objectTid, long objectOid)
        {
            
            string url = GenerateURL(vorlage.DokumentvorlageOid.Value, objectTid, new List<long> { objectOid });

            BeWoUtils.NavigateToReportUri(url, vorlage.Name);

        }

        

        public static string GenerateURL(long vorlage, TableID objectTid, List<long> objectOids)
        {
            string url = BeWoApp.SiteOfOrigin + "/ReportView.aspx?";

            url += "&vorlage=" + vorlage;

            url += "&obj=";
            foreach (var oid in objectOids)
            {
                if (objectOids.IndexOf(oid) == objectOids.Count - 1)
                    url += oid;
                else
                    url += oid + ",";
            }

            url += "&table=" + (int)objectTid;
            url += "&type=" + Utils.EnumName(ReportTypes.VorlagenReport);
            url = BeWoWpfUtils.GetHTMLEncodedURL(url);

            return url;
        }

        private static BitmapImage LoadImage(string imageName)
        {
            if (String.IsNullOrEmpty(imageName))
            {
                return null;
            }
            return new BitmapImage(new Uri("/Ressources/Icons/" + imageName + ".png", UriKind.Relative));
        }

        private static BitmapImage LoadFolderImage()
        {
            return LoadImage("Folder");
        }

        private static BitmapImage LoadDocumentImage()
        {
            return LoadImage("Document48");
        }
    }
}