prs/prs.desktop/Panels/Jobs/DocumentSets/JobDocumentSetFolderTree.cs

using System;
using System.Linq;
using System.Linq.Expressions;
using System.Windows;
using System.Windows.Controls;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using InABox.Wpf;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Threading;

namespace PRSDesktop;

public class JobDocumentSetFolderTree : DynamicDataGrid<JobDocumentSetFolder>, IMasterDetailControl<Job,JobDocumentSetFolder>
{
    public Job? Master { get; set; }

    public Filter<JobDocumentSetFolder> MasterDetailFilter => (Master?.ID ?? Guid.Empty) != Guid.Empty
        ? new Filter<JobDocumentSetFolder>(x => x.Job.ID).IsEqualTo(Master.ID)
        : new Filter<JobDocumentSetFolder>().None();
    
    public bool HasAllItems { get; set; } = true;
    
    public JobDocumentSetFolderTree() : base()
    {
        HiddenColumns.Add(x => x.Documents);
    }
    
    private DynamicGridTreeUIComponent<JobDocumentSetFolder, Guid>? _uiComponent;
    private DynamicGridTreeUIComponent<JobDocumentSetFolder, Guid> UIComponent
    {
        get
        {
            if(_uiComponent is null)
            {
                _uiComponent = new DynamicGridTreeUIComponent<JobDocumentSetFolder, Guid>(
                    x => x.ID,
                    x => x.Parent.ID,
                    Guid.Empty)
                {
                    Parent = this,
                    MaxRowHeight = 30,
                    ShowHeader = false
                };

                _uiComponent.OnContextMenuOpening += JobDocumentSetFolderTree_OnContextMenuOpening;
            }
            return _uiComponent;
        }
    }
    protected override IDynamicGridUIComponent<JobDocumentSetFolder> CreateUIComponent()
    {
        return UIComponent;
    }

    protected override DynamicGridColumns LoadColumns()
    {
        var columns = new DynamicGridColumns();
        columns.Add<JobDocumentSetFolder, string>(x => x.Name, 0, "Name", "", Alignment.MiddleLeft);
        return columns;
    }

    public IEnumerable<CoreRow> GetChildFolders(Guid folderID)
    {
        return UIComponent.GetChildren(folderID);
    }

    private void JobDocumentSetFolderTree_OnContextMenuOpening(CoreTreeNode<Guid>? node, ContextMenu menu)
    {
        if(node is not null && node.ID != CoreUtils.FullGuid && Options.AddRows)
        {
            menu.AddItem("Add Child Folder", null, node, (n) =>
            {
                var item = CreateItem();
                item.Parent.ID = n.ID;
                if (EditItems([item]))
                {
                    DoChanged();
                    Refresh(false, true);
                }
            });
        }
    }

    protected override void Reload(
    	Filters<JobDocumentSetFolder> criteria, Columns<JobDocumentSetFolder> columns, ref SortOrder<JobDocumentSetFolder>? sort,
    	CancellationToken token, Action<CoreTable?, Exception?> action)
    {
        criteria.Add(MasterDetailFilter);
        base.Reload(criteria, columns, ref sort, token, (table, exception) =>
        {
            if(table != null)
            {
                if (HasAllItems)
                {
                    var newRow = table.NewRow();
                    newRow.Set<JobDocumentSetFolder, Guid>(x => x.ID, CoreUtils.FullGuid);
                    newRow.Set<JobDocumentSetFolder, Guid>(x => x.Parent.ID, Guid.Empty);
                    newRow.Set<JobDocumentSetFolder, string>(x => x.Name, "All Items");
                    newRow.Set<JobDocumentSetFolder, int>(x => x.Documents, int.MaxValue);

                    table.Rows.Insert(0, newRow);
                }
            }
            action(table, exception);
        });
    }

    protected override bool CanCreateItems()
    {
        if ((Master?.ID ?? Guid.Empty) == Guid.Empty)
        {
            MessageWindow.ShowMessage("Please Select a Job First!", "No job selected");
            return false;
        }
        
        return base.CanCreateItems();
    }

    public override JobDocumentSetFolder CreateItem()
    {
        var folder = base.CreateItem();
        folder.Job.ID = Master.ID;
        folder.Job.Synchronise(Master);
        folder.Name = "New Folder";
        return folder;
    }

    public override JobDocumentSetFolder LoadItem(CoreRow row)
    {
        if(row.Get<JobDocumentSetFolder, Guid>(x => x.ID) == CoreUtils.FullGuid)
        {
            return row.ToObject<JobDocumentSetFolder>();
        }
        return base.LoadItem(row);
    }

    public override JobDocumentSetFolder[] LoadItems(IList<CoreRow> rows)
    {
        var all = rows.FirstOrDefault(x => x.Get<JobDocumentSetFolder, Guid>(x => x.ID) == CoreUtils.FullGuid);
        if(all is not null)
        {
            return new JobDocumentSetFolder[] { all.ToObject<JobDocumentSetFolder>() };
        }
        return base.LoadItems(rows);
    }

    public override bool EditItems(JobDocumentSetFolder[] items, Func<Type, CoreTable?>? PageDataHandler = null, bool PreloadPages = false)
    {
        if (items.Any(x => x.ID == CoreUtils.FullGuid))
        {
            MessageWindow.ShowMessage("This item cannot be edited.", "Cannot edit");
            return false;
        }
        return base.EditItems(items, PageDataHandler, PreloadPages);
    }

    public override void SaveItem(JobDocumentSetFolder folder)
    {
        if (folder.ID != CoreUtils.FullGuid)
        {
            Client.Save(folder, "Edited by User");
        }
    }

    protected override bool CanDeleteItems(params CoreRow[] rows)
    {
        if(rows.Any(x => x.Get<JobDocumentSetFolder, Guid>(x => x.ID) == CoreUtils.FullGuid))
        {
            MessageWindow.ShowMessage("This folder cannot be deleted.", "Cannot delete");
            return false;
        }
        else if(rows.Any(x => x.Get<JobDocumentSetFolder, int>(x => x.Documents) > 0))
        {
            MessageWindow.ShowMessage("This folder is not empty, and cannot be deleted!", "Folder not empty");
            return false;
        }
        else
        {
            return base.CanDeleteItems();
        }
    }
}