prs/prs.desktop/Panels/DataEntry/DataEntryGrid.cs

using Comal.Classes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using PRSDesktop.Panels.DataEntry;
using Syncfusion.Pdf;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Windows;
using System.Windows.Media.Imaging;

namespace PRSDesktop;

public class DataEntryCachedDocument : ICachedDocument
{
    public DateTime TimeStamp { get; set; }

    public Document? Document { get; set; }

    public Guid ID => Document?.ID ?? Guid.Empty;

    public DataEntryCachedDocument() { }

    public DataEntryCachedDocument(Document document)
    {
        Document = document;
        TimeStamp = document.TimeStamp;
    }

    public void DeserializeBinary(CoreBinaryReader reader, bool full)
    {
        TimeStamp = reader.ReadDateTime();
        if (full)
        {
            Document = reader.ReadObject<Document>();
        }
    }

    public void SerializeBinary(CoreBinaryWriter writer)
    {
        writer.Write(TimeStamp);
        if (Document is null)
        {
            throw new Exception("Cannot serialize incomplete CachedDocument");
        }
        writer.WriteObject(Document);
    }
}

public class DataEntryCache : DocumentCache<DataEntryCachedDocument>
{
    public override TimeSpan MaxAge => TimeSpan.FromDays(new UserConfiguration<DataEntryPanelSettings>().Load().CacheAge);

    private static DataEntryCache? _cache;
    public static DataEntryCache Cache
    {
        get
        {
            _cache ??= DocumentCaches.GetOrRegister<DataEntryCache>();
            return _cache;
        }
    }

    public DataEntryCache(): base(nameof(DataEntryCache)) { }

    protected override DataEntryCachedDocument? LoadDocument(Guid id)
    {
        var document = Client.Query(new Filter<Document>(x => x.ID).IsEqualTo(id))
            .ToObjects<Document>().FirstOrDefault();
        if(document is not null)
        {
            return new DataEntryCachedDocument(document);
        }
        else
        {
            return null;
        }
    }
    
    /// <summary>
    /// Fetch a bunch of documents from the cache or the database, optionally checking against the timestamp listed in the database.
    /// </summary>
    /// <param name="ids"></param>
    /// <param name="checkTimestamp">
    /// If <see langword="true"/>, then loads <see cref="Document.TimeStamp"/> from the database for all cached documents,
    /// and if they are older, updates the cache.
    /// </param>
    public IEnumerable<Document> LoadDocuments(IEnumerable<Guid> ids, bool checkTimestamp = false)
    {
        var cached = new List<Guid>();
        var toLoad = new List<Guid>();
        foreach (var docID in ids)
        {
            if (Has(docID))
            {
                cached.Add(docID);
            }
            else
            {
                toLoad.Add(docID);
            }
        }

        var loadedCached = new List<Document>();
        if (cached.Count > 0)
        {
            var docs = Client.Query(
                new Filter<Document>(x => x.ID).InList(cached.ToArray()),
                Columns.None<Document>().Add(x => x.TimeStamp, x => x.ID));
            foreach (var doc in docs.ToObjects<Document>())
            {
                try
                {
                    var timestamp = GetHeader(doc.ID).Document.TimeStamp;
                    if (doc.TimeStamp > timestamp)
                    {
                        toLoad.Add(doc.ID);
                    }
                    else
                    {
                        loadedCached.Add(GetFull(doc.ID).Document.Document!);
                    }
                }
                catch (Exception e)
                {
                    CoreUtils.LogException("", e, "Error loading cached file");
                    toLoad.Add(doc.ID);
                }
            }
        }

        if (toLoad.Count > 0)
        {
            var loaded = Client.Query(new Filter<Document>(x => x.ID).InList(toLoad.ToArray()))
                .ToObjects<Document>().ToList();
            foreach (var loadedDoc in loaded)
            {
                Add(new DataEntryCachedDocument(loadedDoc));
            }
            return loaded.Concat(loadedCached);
        }
        else
        {
            return loadedCached;
        }
    }
}

public class DataEntryGrid : DynamicDataGrid<DataEntryDocument>
{
    private List<DataEntryTag>? _tags;
    
    public DataEntryGrid()
    {
        HiddenColumns.Add(x => x.Tag.ID);
        HiddenColumns.Add(x => x.Tag.AppliesTo);
        HiddenColumns.Add(x => x.Document.ID);
        HiddenColumns.Add(x => x.Document.FileName);
        HiddenColumns.Add(x => x.EntityID);
        HiddenColumns.Add(x => x.Archived);
        HiddenColumns.Add(x => x.Note);
        
        ActionColumns.Add(new DynamicImageColumn(LinkedImage) { Position = DynamicActionColumnPosition.Start });

        var tagFilter = new Filter<DataEntryDocument>(x => x.Tag.ID).InList(GetVisibleTags().Select(x => x.ID).ToArray());
        if (Security.IsAllowed<CanSetupDataEntryTags>())
        {
            tagFilter.Or(x => x.Tag.ID).IsEqualTo(Guid.Empty);
        }

        var docs = Client.Query(
            new Filter<DataEntryDocument>(x => x.Archived).IsEqualTo(DateTime.MinValue)
                .And(tagFilter),
            Columns.None<DataEntryDocument>().Add(x => x.Document.ID));

        DataEntryCache.Cache.ClearOld();
        DataEntryCache.Cache.EnsureStrict(docs.Rows.Select(x => x.Get<DataEntryDocument, Guid>(x => x.Document.ID)).ToArray());
    }

    private static readonly BitmapImage link = PRSDesktop.Resources.link.AsBitmapImage();
    
    private BitmapImage? LinkedImage(CoreRow? arg)
    {
        return arg == null
            ? link
            : arg.Get<DataEntryDocument, Guid>(x => x.EntityID) != Guid.Empty
                ? link
                : null;
    }

    protected override void DoReconfigure(DynamicGridOptions options)
    {
        base.DoReconfigure(options);
        options.Clear();
        options.FilterRows = true;
        options.MultiSelect = true;
        options.DragSource = true;
        options.DragTarget = true;
        options.SelectColumns = true;
    }
    
    public static List<DataEntryTag> GetVisibleTagList()
    {
        var tags = new Client<DataEntryTag>().Query().ToObjects<DataEntryTag>().ToList();

        var tagsList = new List<DataEntryTag>();
        foreach (var tag in tags)
        {
            var entity = CoreUtils.GetEntityOrNull(tag.AppliesTo);
            if (entity is null || Security.CanView(entity))
            {
                var tagHasEmployee = new Client<DataEntryTagDistributionEmployee>()
                    .Query(
                        new Filter<DataEntryTagDistributionEmployee>(x => x.Tag.ID).IsEqualTo(tag.ID)
                            .And(x => x.Employee.ID).IsEqualTo(App.EmployeeID),
                        Columns.None<DataEntryTagDistributionEmployee>().Add(x => x.ID))
                    .Rows.Any();
                if (tagHasEmployee)
                {
                    tagsList.Add(tag);
                }
            }
        }
        return tagsList;
    }

    private List<DataEntryTag> GetVisibleTags()
    {
        _tags ??= GetVisibleTagList();
        return _tags;
    }

    /// <summary>
    /// Gets the currently selected tag ID, if all selected rows belong to the same tag.
    /// </summary>
    /// <returns></returns>
    private Guid GetSelectedTagID()
    {
        var tagID = Guid.Empty;
        foreach (var row in SelectedRows)
        {
            var rowTag = row.Get<DataEntryDocument, Guid>(x => x.Tag.ID);
            if (tagID == Guid.Empty)
            {
                tagID = rowTag;
            }
            else if (rowTag != tagID)
            {
                return Guid.Empty;
            }
        }
        return tagID;
    }

    private IEnumerable<Tuple<DataEntryDocument, List<DataEntryReGroupWindow.Page>>> ExplodeDocuments()
    {
        var dataEntryDocs = SelectedRows.ToArray<DataEntryDocument>();
        var docIDs = dataEntryDocs.Select(r => r.Document.ID).ToArray();
        var docs = new Client<Document>()
            .Query(
                new Filter<Document>(x => x.ID).InList(docIDs),
                Columns.None<Document>().Add(x => x.ID).Add(x => x.Data).Add(x => x.FileName))
            .ToObjects<Document>().ToDictionary(x => x.ID, x => x);

        foreach (var dataEntryDoc in dataEntryDocs)
        {
            if (docs.TryGetValue(dataEntryDoc.Document.ID, out var doc))
            {
                var ms = new MemoryStream(doc.Data);
                var pdfDoc = DataEntryReGroupWindow.RenderToPDF(doc.FileName, ms);
                yield return new(dataEntryDoc, DataEntryReGroupWindow.SplitIntoPages(doc.FileName, pdfDoc).ToList());
            }
        }
    }

    public void DoExplodeAll()
    {
        var pages = ExplodeDocuments();

        var groups = new List<DocumentGroup>();
        foreach(var (doc, docPages) in pages)
        {
            if(docPages.Count == 1)
            {
                groups.Add(new DocumentGroup(doc.Document.FileName, docPages, doc.Tag.ID));
            }
            else
            {
                var extension = Path.GetExtension(doc.Document.FileName) ?? "";
                var stem = Path.GetFileNameWithoutExtension(doc.Document.FileName);

                foreach(var (i, page) in docPages.WithIndex())
                {
                    var group = new DocumentGroup($"{stem} - {i + 1}{extension}", [page], doc.Tag.ID);
                    groups.Add(group);
                }
            }
        }
        SavePageGroups(groups);

        DeleteItems(SelectedRows);
        Refresh(false,true);
    }
    
    public void DoExplode()
    {
        var tagID = GetSelectedTagID();
        var pages = ExplodeDocuments();
        var filename = "";
        var allPages = new List<DataEntryReGroupWindow.Page>();
        foreach(var (doc, docPages) in pages)
        {
            filename = doc.Document.FileName;
            allPages.AddRange(docPages);
        }

        if (ShowDocumentWindow(allPages, filename, tagID))
        {
            // ShowDocumentWindow already saves new scans, so we just need to get rid of the old ones.
            DeleteItems(SelectedRows);
            Refresh(false,true);
        }
    }
    
    public void DoRemove()
    {
        var updates = SelectedRows.Select(x => x.ToObject<DataEntryDocument>()).ToArray();
        foreach (var update in updates)
        {
            update.Archived = DateTime.Now;
            DataEntryCache.Cache.Remove(update.Document.ID);
        }
        new Client<DataEntryDocument>().Save(updates,"Removed from Data Entry Panel");
        Refresh(false,true);
    }

    public void DoChangeTags(Guid tagid)
    {
        var updates = SelectedRows.Select(x => x.ToObject<DataEntryDocument>()).ToArray();
        foreach (var update in updates)
        {
            if (update.Tag.ID != tagid)
            {
                update.Tag.ID = tagid;
                update.EntityID = Guid.Empty;
            }
        }

        new Client<DataEntryDocument>().Save(updates.Where(x=>x.IsChanged()),"Updated Tags on Data Entry Panel");
        Refresh(false,true);
    }

    public void DoChangeNote(string note)
    {
        var updates = SelectedRows.ToObjects<DataEntryDocument>().ToArray();
        foreach (var update in updates)
        {
            if (!string.Equals(update.Note, note))
            {
                update.Note = note;
            }
        }

        Client.Save(updates.Where(x => x.IsChanged()), "Updated Note on Data Entry Panel");
        Refresh(false, true);
    }
    
    protected override DragDropEffects OnRowsDragStart(CoreRow[] rows)
    {
        var table = new CoreTable();

        table.Columns.Add(new CoreColumn { ColumnName = "ID", DataType = typeof(Guid) });
        foreach(var row in rows)
        {
            var newRow = table.NewRow();
            newRow.Set<Document, Guid>(x => x.ID, row.Get<DataEntryDocument, Guid>(x => x.Document.ID));
            table.Rows.Add(newRow);
        }

        return DragTable(typeof(Document), table);
    }

    public void UploadDocument(string filename, byte[] data, Guid tagID)
    {
        var document = new Document
        {
            FileName = filename,
            CRC = CoreUtils.CalculateCRC(data),
            TimeStamp = DateTime.Now,
            Data = data
        };

        new Client<Document>().Save(document, "");

        var dataentry = new DataEntryDocument
        {
            Document =
            {
                ID = document.ID
            },
            Tag =
            {
                ID = tagID
            },
            Employee =
            {
                ID = App.EmployeeID
            }
        };

        if(Path.GetExtension(filename) == ".pdf")
        {
            dataentry.Thumbnail = ImageUtils.GetPDFThumbnail(data, 256, 256);
        }

        new Client<DataEntryDocument>().Save(dataentry, "");

        DataEntryCache.Cache.Add(new DataEntryCachedDocument(document));

        Dispatcher.BeginInvoke(() =>
        {
            Refresh(false, true);
        });
    }

    private static PdfDocumentBase CombinePages(IEnumerable<DataEntryReGroupWindow.Page> pages)
    {
        var document = new PdfDocument();
        foreach (var page in pages)
        {
            document.ImportPage(page.Pdf, page.PageIndex);
        }
        return document;
    }

    private void SavePageGroups(IEnumerable<DocumentGroup> groups)
    {
        Progress.ShowModal("Uploading Files", (progress) =>
        {
            foreach (var group in groups)
            {
                progress.Report($"Uploading '{group.FileName}'");
                var doc = CombinePages(group.Pages);

                byte[] data;
                using (var ms = new MemoryStream())
                {
                    doc.Save(ms);
                    data = ms.ToArray();
                }

                UploadDocument(group.FileName, data, group.TagID);
            }
        });
    }

    public bool ShowDocumentWindow(List<DataEntryReGroupWindow.Page> pages, string filename, Guid tagID)
    {
        var window = new DataEntryReGroupWindow(pages, filename, tagID);
        if (window.ShowDialog() == true)
        {
            SavePageGroups(window.Groups);
            return true;
        }
        return false;
    }
    
    public override DynamicGridColumns GenerateColumns()
    {
        var columns = new DynamicGridColumns();
        columns.Add<DataEntryDocument, string>(x => x.Document.FileName, 0, "Filename", "", Alignment.MiddleLeft);
        columns.Add<DataEntryDocument, string>(x => x.Tag.Name, 100, "Tag", "", Alignment.MiddleLeft);
        return columns;
    }

    protected override void Reload(
    	Filters<DataEntryDocument> criteria, Columns<DataEntryDocument> columns, ref SortOrder<DataEntryDocument>? sort,
    	CancellationToken token, Action<CoreTable?, Exception?> action)
    {
        criteria.Add(new Filter<DataEntryDocument>(x => x.Archived).IsEqualTo(DateTime.MinValue));

        var tagFilter = new Filter<DataEntryDocument>(x => x.Tag.ID).InList(GetVisibleTags().Select(x => x.ID).ToArray());
        if (Security.IsAllowed<CanSetupDataEntryTags>())
        {
            tagFilter.Or(x => x.Tag.ID).IsEqualTo(Guid.Empty);
        }

        criteria.Add(tagFilter);
        base.Reload(criteria, columns, ref sort, token, action);
    }
}