prs/prs.desktop/Forms/Issues/IssuesGrid.cs

using Comal.Classes;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Controls;
using System.Windows.Media;
using InABox.Wpf;
using System.Windows;
using InABox.Clients;
using InABox.Scripting;
using Microsoft.Win32;

namespace PRSDesktop.Forms.Issues;

public class IssuesGrid : DynamicGrid<Kanban>, ISpecificGrid
{
    private readonly int ChunkSize = 500;

    public IQueryProviderFactory ClientFactory { get; set; }

    private IQueryProvider<Kanban>? _kanbanClient;
    private IQueryProvider<Kanban> KanbanClient
    {
        get
        {
            _kanbanClient ??= ClientFactory.Create<Kanban>();
            return _kanbanClient;
        }
    }
    
    private IQueryProvider<Job>? _jobClient;
    private IQueryProvider<Job> JobClient
    {
        get
        {
            _jobClient ??= ClientFactory.Create<Job>();
            return _jobClient;
        }
    }

    public Guid CustomerID { get; set; }

    // public static CustomProperty CustomerProperty = new CustomProperty
    // {
    //     Name = "CustomerID",
    //     PropertyType = typeof(string),
    //     ClassType = typeof(Kanban)
    // };
    
    private String _baseDirectory;

    public IssuesGrid() : base()
    {
        
    
        
        
        var cols = LookupFactory.DefineColumns<Kanban>();

        // Minimum Columns for Lookup values
        foreach (var col in cols)
            HiddenColumns.Add(col);

        HiddenColumns.Add(x => x.Notes);

        ActionColumns.Add(new DynamicMenuColumn(BuildMenu) { Position = DynamicActionColumnPosition.End });
    }
    
    private class UIComponent : DynamicGridGridUIComponent<Kanban>
    {
        private IssuesGrid Grid;

        

        public UIComponent(IssuesGrid grid)
        {
            Grid = grid;
            Parent = grid;
        }

        protected override Brush? GetCellBackground(CoreRow row, DynamicColumnBase column)
        {
            var status = row.Get<Kanban, KanbanStatus>(x => x.Status);
            var color = status == KanbanStatus.Open
                ? Colors.Orange
                : status == KanbanStatus.InProgress
                    ? Colors.Plum
                    : status == KanbanStatus.Waiting
                        ? Colors.LightGreen
                        : Colors.Silver;
            return color.ToBrush(0.5);
        }
    }

    
    protected override IDynamicGridUIComponent<Kanban> CreateUIComponent()
    {
        return new UIComponent(this);
    }

    protected override void Init()
    {
        base.Init();

        AddButton("Check for Updates", PRSDesktop.Resources.autoupdate.AsBitmapImage(), CheckForUpdates);
        AddButton("Open Support Session", PRSDesktop.Resources.appicon.AsBitmapImage(), OpenSupportSession);
        
        _baseDirectory = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) ?? "";
        if (File.Exists(Path.Combine(_baseDirectory, "PRSAvalonia", "PRS.Avalonia.Desktop.exe")))
        {
            var btn = AddButton("PRS Mobile App", PRSDesktop.Resources.map.AsBitmapImage(), LaunchPRSMobile);
            btn.Margin = new Thickness(20, btn.Margin.Top, btn.Margin.Right, btn.Margin.Bottom);
        }

        if (File.Exists(Path.Combine(_baseDirectory, "PRSDigitalKey", "PRS.DigitalKey.Desktop.exe")))
            AddButton("PRS Digital Key App", PRSDesktop.Resources.key.AsBitmapImage(), LaunchPRSDigitalKey);

        var scriptButton = AddButton("Check Script Status", PRSDesktop.Resources.edit.AsBitmapImage(), CheckScriptStatus);
        scriptButton.Margin = new Thickness(20, scriptButton.Margin.Top, scriptButton.Margin.Right, scriptButton.Margin.Bottom);
    }

    private bool CheckScriptStatus(Button button, CoreRow[] rows)
    {
        var showHidden = MessageWindow.ShowYesNo("Include Hidden Scripts?", "Confirm");

        var results = new List<Tuple<CustomModule, string>>();
        Progress.ShowModal("Loading Data", progress =>
        {
            var filter = showHidden
                ? Filter.All<CustomModule>()
                : Filter<CustomModule>.Where(x => x.Visible).IsEqualTo(true);

            var modules = Client.Query(
                filter,
                Columns.None<CustomModule>()
                    .Add(x => x.ID)
                    .Add(x => x.Section)
                    .Add(x => x.Name)
                    .Add(x => x.Script))
                .ToArray<CustomModule>();
            foreach(var module in modules)
            {
                try
                {
                    progress.Report($"{module.Section} -> {module.Name}");

                    var scriptDocument = new ScriptDocument(module.Script);
                    if (!scriptDocument.Compile())
                    {
                        var errors = scriptDocument.Result.Split(Environment.NewLine);
                        results.Add(new(module, string.Join('\n', errors.Select(x => $"- {x}"))));
                    }
                }
                catch(Exception e)
                {
                    results.Add(new(module, e.Message));
                }
            }
        });

        if (results.Any())
        {
            var grid = new Grid();
            grid.AddRow(GridUnitType.Auto);
            grid.AddRow(GridUnitType.Star);
            grid.AddRow(GridUnitType.Auto);
            grid.AddChild(new Label
            {
                Content = "The following errors were found in custom modules:"
            }, 0, 0);

            var list = new ListBox();
            foreach(var (module, errors) in results)
            {
                var itemGrid = new Grid
                {

                };
                itemGrid.AddColumn(GridUnitType.Auto);
                itemGrid.AddColumn(GridUnitType.Star);
                var itemBtn = new Button
                {
                    Content = new Image
                    {
                        Source = PRSDesktop.Resources.pencil.AsBitmapImage(),
                    },
                    Width = 30,
                    Height = 30,
                    Padding = new(5),
                    Margin = new(0, 0, 5, 0),
                    Tag = module
                };
                itemBtn.VerticalAlignment = VerticalAlignment.Top;
                itemBtn.Click += ModuleOpen_Click;
                itemGrid.AddChild(itemBtn, 0, 0);
                itemGrid.AddChild(new Label
                {
                    Content = $"{module.Section}/{module.Name}:\n{errors}"
                }, 0, 1);
                list.Items.Add(itemGrid);
            }
            grid.AddChild(list, 1, 0);

            var dockPanel = new DockPanel
            {
                LastChildFill = false
            };

            var exportButton = new Button
            {
                Content = "Export",
                Padding = new(5),
                Margin = new(0, 5, 0, 0)
            };
            exportButton.Click += (o, e) =>
            {
                var result = string.Join("\n\n", results.Select(x => $"{x.Item1.Section}/{x.Item1.Name}:\n{x.Item2}"));
                var dlg = new SaveFileDialog()
                {
                    Filter = "Text Files (*.txt)|*.txt"
                };

                if(dlg.ShowDialog() == true)
                {
                    using var writer = new StreamWriter(dlg.FileName);
                    writer.Write(result);
                }
            };
            DockPanel.SetDock(exportButton, Dock.Left);
            dockPanel.Children.Add(exportButton);

            grid.AddChild(dockPanel, 2, 0);

            var window = new DynamicContentDialog(grid, buttonsVisible: false)
            {
                Title = "Custom Module Errors"
            };
            window.ShowDialog();
        }

        return false;
    }

    private void ModuleOpen_Click(object sender, RoutedEventArgs e)
    {
        if (sender is not FrameworkElement element
            || element.Tag is not CustomModule module) return;

        var editor = new ScriptEditorWindow(module.Script, scriptTitle: $"{module.Section}/{module.Name}");
        if (editor.ShowDialog() == true)
        {
            module.Script = editor.Script;
            Client.Save(module, "Updated by User");
        }
    }

    private bool LaunchPRSMobile(Button button, CoreRow[] rows)
    {
        var _mobileApp = System.IO.Path.Combine(_baseDirectory, "PRSAvalonia", "PRS.Avalonia.Desktop.exe");
        var _info = new ProcessStartInfo(_mobileApp);
        Process.Start(_info);
        return false;
    }
    
    private bool LaunchPRSDigitalKey(Button button, CoreRow[] rows)
    {
        
        var _mobileApp = Path.Combine(_baseDirectory, "PRSDigitalKey", "PRS.DigitalKey.Desktop.exe");
        var _info = new ProcessStartInfo(_mobileApp);
        Process.Start(_info);
        return false;
    }
    
    private bool OpenSupportSession(Button button, CoreRow[] rows)
    {
        SupportUtils.OpenSupportSession();

        return false;
    }

    private bool CheckForUpdates(Button button, CoreRow[] rows)
    {
        if (SupportUtils.CheckForUpdates())
        {
            Application.Current.Shutdown();
        }
        else
        {
            if (MessageWindow.ShowYesNo(
                    "You appear to be using the latest version already!\n\nRun the installer anyway?", "Update"))
            {
                if (SupportUtils.DownloadAndRunInstaller())
                {
                    Application.Current.Shutdown();
                }
            }
        }
        return false;
    }

    protected override void DoReconfigure(DynamicGridOptions options)
    {
        options.Clear();
        options.AddRows = true;
        options.EditRows = true;
        options.FilterRows = true;
        options.HideDatabaseFilters = true;
    }

    private void BuildMenu(DynamicMenuColumn column, CoreRow? row)
    {
        if (row is null) return;

        var menu = column.GetMenu();
        menu.AddItem("Add note", null, row, AddNote_Click);
        menu.AddItem("Attach system logs", null, row, AttachLogs_Click);
        menu.AddSeparator();
        menu.AddItem("Close issue", null, row, CloseTask_Click);
    }

    private void AttachLogs_Click(CoreRow row)
    {
        var logFile = CoreUtils.GetLogFile();
        var data = File.ReadAllBytes(logFile);
        var doc = new Document();
        doc.Data = data;
        doc.CRC = CoreUtils.CalculateCRC(data);
        doc.FileName = Path.GetFileName(logFile);
        doc.TimeStamp = File.GetLastWriteTime(logFile);

        ClientFactory.Save(doc, "Attached logs to task.");

        var kanbanDocument = new KanbanDocument();
        kanbanDocument.DocumentLink.CopyFrom(doc);
        kanbanDocument.EntityLink.CopyFrom(row.ToObject<Kanban>());
        ClientFactory.Save(kanbanDocument, "Attached logs to task.");
    }

    public override Kanban CreateItem()
    {
        var item = base.CreateItem();
        item.UserProperties["CustomerID"] = CustomerID.ToString();
        item.Notes = [
            $"Created on PRS {CoreUtils.GetVersion()} by {App.EmployeeName} ({App.EmployeeEmail})"
            ];
        // item.Status = KanbanStatus.Open;
        return item;
    }

    private void AddNote_Click(CoreRow row)
    {
        var kanban = row.ToObject<Kanban>();
        var text = "";

        if(TextBoxDialog.Execute("Enter note:", ref text))
        {
            text = string.Format("{0:yyyy-MM-dd HH:mm:ss}: {1}", DateTime.Now, text);
            kanban.Notes = kanban.Notes.Concatenate([text]);
            kanban.Status = KanbanStatus.InProgress;
            SaveItem(kanban);
            Refresh(false, true);
        }
    }

    private void CloseTask_Click(CoreRow row)
    {
        var kanban = row.ToObject<Kanban>();
        kanban.Completed = DateTime.Now;
        kanban.Closed = DateTime.Now;
        SaveItem(kanban);
        Refresh(false, true);
    }

    private Column<Kanban>[] AllowedColumns = [
        new(x => x.Number),
        new(x => x.Title),
        new(x => x.Description),
        new(x => x.Notes)];

    protected override void CustomiseEditor(IDynamicEditorForm form, Kanban[] items, DynamicGridColumn column, BaseEditor editor)
    {
        base.CustomiseEditor(form, items, column, editor);
        if(!AllowedColumns.Any(x => x.Property == column.ColumnName))
        {
            editor.Editable = editor.Editable.Combine(Editable.Hidden);
        }
    }

    public virtual CoreTable LookupValues(DataLookupEditor editor, Type parent, string columnname, BaseObject[]? items)
    {
        var client = ClientFactory.Create(editor.Type);

        var filter = LookupFactory.DefineLookupFilter(parent, editor.Type, columnname, items ?? (Array.CreateInstance(parent, 0) as BaseObject[])!);
        var columns = LookupFactory.DefineLookupColumns(parent, editor.Type, columnname);

        foreach (var key in editor.OtherColumns.Keys)
            columns.Add(key);

        var sort = LookupFactory.DefineSort(editor.Type);
        var result = client.Query(filter, columns, sort);

        result.Columns.Add(new CoreColumn { ColumnName = "Display", DataType = typeof(string) });
        foreach (var row in result.Rows)
        {
            row["Display"] = LookupFactory.FormatLookup(parent, editor.Type, row, columnname);
        }

        return result;
    }

    protected override void DefineLookups(ILookupEditorControl sender, Kanban[] items, bool async = true)
    {
        if (sender.EditorDefinition is not DataLookupEditor editor)
        {
            base.DefineLookups(sender, items, async: async);
            return;
        }

        var colname = sender.ColumnName;
        if (async)
        {
            Task.Run(() =>
            {
                try
                {
                    var values = LookupValues(editor, typeof(Kanban), colname, items);
                    Dispatcher.Invoke(
                        () =>
                        {
                            try
                            {
                                //Logger.Send(LogType.Information, typeof(T).Name, "Dispatching Results" + colname);
                                sender.LoadLookups(values);
                            }
                            catch (Exception e2)
                            {
                                Logger.Send(LogType.Information, typeof(Kanban).Name,
                                    "Exception (2) in LoadLookups: " + e2.Message + "\n" + e2.StackTrace);
                            }
                        }
                    );
                }
                catch (Exception e)
                {
                    Logger.Send(LogType.Information, typeof(Kanban).Name,
                        "Exception (1) in LoadLookups: " + e.Message + "\n" + e.StackTrace);
                }
            });
        }
        else
        {
            var values = LookupValues(editor, typeof(Kanban), colname, items);
            sender.LoadLookups(values);
        }
    }

    public override DynamicEditorPages LoadEditorPages(Kanban item)
    {
        var pages = new DynamicEditorPages
        {
            new DynamicDocumentGrid<KanbanDocument, Kanban, KanbanLink>
            {
                Client = ClientFactory
            }
        };
        return pages;
    }

    protected override DynamicGridColumns LoadColumns()
    {
        var columns = new DynamicGridColumns<Kanban>();
        columns.Add(x => x.Number, caption: "Ticket", width: 60, alignment: Alignment.MiddleCenter);
        columns.Add(x => x.Title);
        columns.Add(x => x.CreatedBy, caption: "Created By", width: 150);
        columns.Add(x => x.EmployeeLink.Name, caption: "Assigned To", width: 150);
        columns.Add(x => x.Type.Description, caption: "Type", width: 100, alignment: Alignment.MiddleCenter);
        columns.Add(x => x.Status, caption: "Status", width: 80, alignment: Alignment.MiddleCenter);
        return columns;
    }

    #region Grid Stuff

    protected override string FormatRecordCount(int count)
    {
        return IsPaging 
            ? $"{base.FormatRecordCount(count)} (loading..)"
            : base.FormatRecordCount(count);
    }

    protected override void Reload(
        Filters<Kanban> criteria, Columns<Kanban> columns, ref SortOrder<Kanban>? sort,
        CancellationToken token, Action<CoreTable?, Exception?> action)
    {
        criteria.Add(Filter<Kanban>.Where(x => x.Closed).IsEqualTo(DateTime.MinValue));
        criteria.Add(Filter<Kanban>.Where(x => x.Status).IsNotEqualTo(KanbanStatus.Complete));
        criteria.Add(Filter<Kanban>.Where(x => x.Job.Customer.ID).IsEqualTo(CustomerID));
        
        //criteria.Add(new Filter<Kanban>(CustomerProperty).IsEqualTo(CustomerID.ToString()));
        
        if(Options.PageSize > 0)
        {
            var inSort = sort;
            Task.Run(() =>
            {
                
                var page = CoreRange.Database(Options.PageSize);
                var filter = criteria.Combine();
                
                IsPaging = true;
                while (!token.IsCancellationRequested)
                {
                    try
                    {
                        var data = KanbanClient.Query(filter, columns, inSort, page);
                        data.Offset = page.Offset;
                        IsPaging = data.Rows.Count == page.Limit;

                        if (token.IsCancellationRequested)
                        {
                            break;
                        }

                        action(data, null);
                        if (!IsPaging)
                            break;
                        
                        // Proposal - Let's slow it down a bit to enhance UI responsiveness?
                        Thread.Sleep(100);
                        
                        page.Next();
                    }
                    catch (Exception e)
                    {
                        action(null, e);
                        break;
                    }
                }
            }, token);
        }
        else
        {
            KanbanClient.Query(criteria.Combine(), columns, sort, null, action);
        }
    }

    public override Kanban[] LoadItems(IList<CoreRow> rows)
    {
        var results = new List<Kanban>(rows.Count);
        for (var i = 0; i < rows.Count; i += ChunkSize)
        {
            var chunk = rows.Skip(i).Take(ChunkSize);
            var filter = Filter<Kanban>.Where(x => x.ID).InList(chunk.Select(x => x.Get<Kanban, Guid>(x => x.ID)).ToArray());

            var columns = DynamicGridUtils.LoadEditorColumns(Columns.None<Kanban>());
            var data = KanbanClient.Query(filter, columns);
            results.AddRange(data.ToObjects<Kanban>());
        }

        return results.ToArray();
    }

    public override Kanban LoadItem(CoreRow row)
    {
        var id = row.Get<Kanban, Guid>(x => x.ID);
        return KanbanClient.Query(
            Filter<Kanban>.Where(x => x.ID).IsEqualTo(id),
            DynamicGridUtils.LoadEditorColumns(Columns.None<Kanban>())).ToObjects<Kanban>().FirstOrDefault()
            ?? throw new Exception($"No Kanban with ID {id}");
    }

    public override void SaveItem(Kanban item)
    {
        CheckJob(item);
        KanbanClient.Save(item, "Edited by User");
    }

    private void CheckJob(Kanban item)
    {
        if (item.ID == Guid.Empty)
        {
            item.CreatedBy = App.EmployeeName;
            
            // Check if there is an open Project Job (ie installation or periodic billing) for this Client
            var job = JobClient.Query(
                Filter<Job>.Where(x => x.Customer.ID).IsEqualTo(CustomerID)
                    .And(x => x.JobType).IsEqualTo(JobType.Project)
                    .And(x => x.JobStatus.Active).IsEqualTo(true),
                Columns.None<Job>()
                    .Add(x => x.ID)
                    .Add(x=>x.DefaultScope.ID)
            ).ToObjects<Job>().FirstOrDefault();
            
            // No Job ?  Create a service job for this ticket
            if (job == null)
            {
                job = new Job();
                job.Name = item.Title;
                job.Customer.ID = CustomerID;
                job.JobType = JobType.Service;
                job.Notes = item.Notes?.ToList().ToArray() ?? [];
                job.UserProperties.Clear();
                JobClient.Save(job, "Created by Client Issues Screen");
            }

            // Created Tickets should always have a job #!
            item.Job.ID = job.ID;
            item.JobScope.ID = job.DefaultScope.ID;
        }
    }

    public override void SaveItems(IEnumerable<Kanban> items)
    {
        var list = items.ToArray();
        foreach (var item in list)
            CheckJob(item);
        KanbanClient.Save(list, "Edited by User");
    }

    public override void DeleteItems(params CoreRow[] rows)
    {
        var deletes = new List<Kanban>();
        foreach (var row in rows)
        {
            var delete = new Kanban
            {
                ID = row.Get<Kanban, Guid>(x => x.ID)
            };

            deletes.Add(delete);
        }

        KanbanClient.Delete(deletes, "Deleted on User Request");
    }

    #endregion
}