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

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

namespace PRSDesktop
{
    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.EntityID);
            HiddenColumns.Add(x=>x.Archived);
            
            ActionColumns.Add(new DynamicImageColumn(LinkedImage) { Position = DynamicActionColumnPosition.Start });
        }

        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(FluentList<DynamicGridOption> options)
        {
            base.DoReconfigure(options);
            options.BeginUpdate()
                .Clear()
                .Add(DynamicGridOption.MultiSelect)
                .Add(DynamicGridOption.DragSource)
                .Add(DynamicGridOption.SelectColumns)
                .EndUpdate();
        }
        
        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),
                            new Columns<DataEntryTagDistributionEmployee>(x => x.ID))
                        .Rows.Any();
                    if (tagHasEmployee)
                    {
                        tagsList.Add(tag);
                    }
                }
            }
            return tagsList;
        }

        private List<DataEntryTag> GetVisibleTags()
        {
            _tags ??= GetVisibleTagList();
            return _tags;
        }
        
        public void DoExplode()
        {
            Guid 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)
                {
                    tagID = Guid.Empty;
                    break;
                }
            }

            var docIDs = SelectedRows.Select(r => r.Get<DataEntryDocument, Guid>(c => c.Document.ID)).ToArray();
            var docs = new Client<Document>()
                .Query(
                    new Filter<Document>(x => x.ID).InList(docIDs),
                    new Columns<Document>(x => x.ID).Add(x => x.Data).Add(x => x.FileName))
                .ToObjects<Document>().ToDictionary(x => x.ID, x => x);

            var pages = new List<DataEntryReGroupWindow.Page>();
            string filename = "";
            foreach (var docID in docIDs)
            {
                if (docs.TryGetValue(docID, out var doc))
                {
                    filename = doc.FileName;
                    var ms = new MemoryStream(doc.Data);
                    var pdfDoc = DataEntryReGroupWindow.RenderToPDF(doc.FileName, ms);
                    foreach (var page in DataEntryReGroupWindow.SplitIntoPages(doc.FileName, pdfDoc))
                    {
                        pages.Add(page);
                    }
                }
            }

            if (ShowDocumentWindow(pages, 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;
            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);
        }
        
        protected override void 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);
            }

            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
                },
                Thumbnail = ImageUtils.GetPDFThumbnail(data, 256, 256)
            };
            new Client<DataEntryDocument>().Save(dataentry, "");

            Dispatcher.Invoke(() =>
            {
                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;
        }

        public bool ShowDocumentWindow(List<DataEntryReGroupWindow.Page> pages, string filename, Guid tagID)
        {
            var window = new DataEntryReGroupWindow(pages, filename, tagID);
            if (window.ShowDialog() == true)
            {
                Progress.ShowModal("Uploading Files", (progress) =>
                {
                    foreach (var group in window.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);
                    }
                });
                return true;
            }
            return false;
        }
        
        protected override void GenerateColumns(DynamicGridColumns columns)
        {
            columns.Add<DataEntryDocument, string>(x => x.Document.FileName, 0, "Filename", "", Alignment.MiddleLeft);
            columns.Add<DataEntryDocument, string>(x => x.Tag.Name, 100, "Tag", "", Alignment.MiddleLeft);
        }

        protected override void Reload(Filters<DataEntryDocument> criteria, Columns<DataEntryDocument> columns, ref SortOrder<DataEntryDocument>? sort, 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, action);
        }
    }
}