inabox/inabox.wpf/DigitalForms/DigitalFormReportGrid.cs

using FastReport;
using FastReport.Data;
using InABox.Clients;
using InABox.Core;
using InABox.Core.Reports;
using InABox.Wpf.Reports;
using InABox.WPF;
using Syncfusion.DocIO.DLS;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Imaging;

namespace InABox.DynamicGrid
{
    public class DigitalFormReportGrid : DynamicItemsListGrid<ReportTemplate>, IDynamicEditorPage
    {
        public DynamicEditorGrid EditorGrid { get; set; }

        public PageType PageType => PageType.Other;

        public bool Ready { get; set; }

        private DigitalForm Form { get; set; }

        private List<ReportTemplate> OriginalItems { get; set; } = new();

        public DigitalFormReportGrid()
        {
            Options.BeginUpdate();
            Options.Add(DynamicGridOption.ShowHelp);

            if (Security.CanEdit<ReportTemplate>())
            {
                Options.Add(DynamicGridOption.AddRows);
                Options.Add(DynamicGridOption.EditRows);

                ActionColumns.Add(new DynamicImageColumn(ScriptImage, ScriptClick));
                ActionColumns.Add(new DynamicImageColumn(Wpf.Resources.pencil.AsBitmapImage(), DesignClick));
            }
            if (Security.CanDelete<ReportTemplate>())
                Options.Add(DynamicGridOption.DeleteRows);
            Options.EndUpdate();
        }

        public void Load(object item, Func<Type, CoreTable>? PageDataHandler)
        {
            Form = (DigitalForm)item;

            CoreTable data;
            if (Form.ID == Guid.Empty)
            {
                data = new CoreTable();
                data.LoadColumns(typeof(ReportTemplate));
            }
            else
            {
                data = new Client<ReportTemplate>()
                    .Query(new Filter<ReportTemplate>(x => x.Section).IsEqualTo(Form.ID.ToString()));
            }
            OriginalItems = data.Rows.Select(x => x.ToObject<ReportTemplate>()).ToList();

            Items = OriginalItems.ToList();
            Refresh(true, true);

            Ready = true;
        }

        private DynamicVariableGrid? GetVariableGrid()
            => EditorGrid.Pages?.FirstOrDefault(x => x is DynamicVariableGrid)
                as DynamicVariableGrid;
        private List<DigitalFormVariable> GetVariables()
            => GetVariableGrid()?.Items.ToList() ?? new List<DigitalFormVariable>();

        private DynamicFormLayoutGrid? GetLayoutGrid()
            => EditorGrid.Pages?.FirstOrDefault(x => x is DynamicFormLayoutGrid)
                as DynamicFormLayoutGrid;
        private List<DigitalFormLayout> GetLayouts()
            => GetLayoutGrid()?.Items.ToList() ?? new List<DigitalFormLayout>();

        private static List<Type>? _entityForms;
        private DataModel? GetDataModel()
        {
            _entityForms ??= CoreUtils.Entities
                .Where(x => x.IsSubclassOfRawGeneric(typeof(EntityForm<,>)))
                .ToList();
            var entityForm = _entityForms
                .Where(x => x.GetSuperclassDefinition(typeof(EntityForm<,>))?.GenericTypeArguments[0].Name == Form.AppliesTo)
                .FirstOrDefault();
            if(entityForm is not null)
            {
                var model = (Activator.CreateInstance(typeof(DigitalFormReportDataModel<>).MakeGenericType(entityForm), Filter.Create(entityForm).None(), null) as DataModel)!;
                (model as IDigitalFormReportDataModel)!.Variables = GetVariables().ToArray();
                return model;
            }
            return null;
        }
        private BitmapImage? ScriptImage(CoreRow? arg)
        {
            return arg == null ? Wpf.Resources.edit.AsBitmapImage() :
                arg.Get<ReportTemplate, bool>(x => x.IsRDL) ? null : Wpf.Resources.edit.AsBitmapImage();
        }

        private bool ScriptClick(CoreRow? arg)
        {
            if (arg != null)
            {
                if (GetDataModel() is not DataModel model)
                {
                    Logger.Send(LogType.Error, "", "Invalid entity type for data model.");
                    return false;
                }

                var template = LoadItem(arg);
                var script = template.Script;
                if (string.IsNullOrWhiteSpace(script))
                    script = string.Format(ReportTemplate.DefaultScriptTemplate, model.GetType().Name.Split('.').Last());
                var editor = new ScriptEditorWindow(script);
                if (editor.ShowDialog() == true)
                {
                    template.Script = editor.Script;

                    SaveItem(template);
                    return true;
                }
            }

            return false;
        }

        private bool DesignClick(CoreRow? arg)
        {
            if (arg is null) return false;
            if (GetDataModel() is not DataModel model)
            {
                Logger.Send(LogType.Error, "", "Invalid entity type for data model.");
                return false;
            }

            var template = LoadItem(arg);
            ReportUtils.DesignReport(template, model, true, saveTemplate: (template) => SaveItem(template));
            return false;
        }

        protected override void DoAdd(bool OpenEditorOnDirectEdit = false)
        {
            var layouts = GetLayouts();
            if(layouts.Count == 0)
            {
                base.DoAdd(OpenEditorOnDirectEdit);
            }
            else
            {
                var menu = new ContextMenu();
                foreach (var layout in layouts)
                {
                    menu.AddItem($"{layout.Code}: {layout.Description}", null, layout, AddLayout);
                }
                menu.IsOpen = true;
            }
        }

        private Report? GenerateReport(DigitalFormLayout layout)
        {
            var model = GetDataModel();
            if (model is null) return null;

            var report = ReportUtils.SetupReport(null, model, true);

            var dfLayout = new DFLayout();
            dfLayout.LoadLayout(layout.Layout);

            foreach(var element in dfLayout.Elements)
            {
                
            }

            return report;
        }

        private void AddLayout(DigitalFormLayout layout)
        {
            var item = CreateItem();
            item.Name = string.IsNullOrWhiteSpace(layout.Description) ? layout.Code : layout.Description;
            item.RDL = GenerateReport(layout)?.SaveToString();

            if (EditItems(new[] { item }))
            {
                SaveItem(item);
                Refresh(false, true);
            }
        }

        public void BeforeSave(object item)
        {
        }

        public void AfterSave(object item)
        {
            // First remove any deleted files
            foreach (var original in OriginalItems)
                if (!Items.Contains(original))
                    new Client<ReportTemplate>().Delete(original, typeof(ReportTemplate).Name + " Deleted by User");

            foreach (var template in Items)
            {
                template.Section = Form.ID.ToString();
            }

            new Client<ReportTemplate>().Save(Items.Where(x => x.IsChanged()), "Updated by User");
        }

        protected override ReportTemplate CreateItem()
        {
            var item = base.CreateItem();
            if(Form.ID != Guid.Empty)
            {
                item.Section = Form.ID.ToString();
            }
            return item;
        }

        public string Caption() => "Reports";

        public Size MinimumSize()
        {
            return new Size(400, 400);
        }

        public int Order()
        {
            return int.MinValue;
        }
    }
}