prs/prs.desktop/DockPanels/DigitalFormsDock.xaml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.Reports;
using InABox.Reports.Common;
using InABox.Scripting;
using InABox.WPF;
using PRSDesktop.Configuration;

namespace PRSDesktop
{
    
    public class DigitalFormDockModel : BaseObject
    {
        [NullEditor]
        public Guid ID { get; set; }
        
        [NullEditor]
        public Guid FormID { get; set; }
        
        [TextBoxEditor(Visible = Visible.Default)]
        [EditorSequence(1)]
        public String FormName { get; set; }
        
        [DateTimeEditor(Visible=Visible.Default, Width=100, Format = "dd-MM HH:mm")]
        [EditorSequence(2)]
        public DateTime Completed { get; set; }
        
        [TextBoxEditor(Visible=Visible.Default, Width=100, Alignment = Alignment.MiddleCenter)]
        [EditorSequence(3)]
        public String CompletedBy { get; set; }
        
        public Type FormType { get; set; }
        
    }
    
    public class DigitalFormDockGrid : DynamicGrid<DigitalFormDockModel>
    {
        private CoreFieldMap<IDigitalFormInstance, DigitalFormDockModel> _mappings = null;
        private IEnumerable<Type> _types = null;
        private MultiQuery _query = null;
        private CoreTable _data = null;

        public Dictionary<Type, System.Drawing.Bitmap> Images { get; private set; }
        public List<Type> ExcludedTypes { get; private set; }
        public DateTime StartDate { get; set; }
        
        public DigitalFormDockGrid() : base()
        {

            StartDate = DateTime.Today;
            ExcludedTypes = new List<Type>();

            Images = new Dictionary<Type, System.Drawing.Bitmap>()
            {
                { typeof(AssignmentForm), PRSDesktop.Resources.assignments },
                { typeof(KanbanForm), PRSDesktop.Resources.kanban },
                { typeof(JobForm), PRSDesktop.Resources.project },
                { typeof(JobITPForm), PRSDesktop.Resources.checklist },
                { typeof(EmployeeForm), PRSDesktop.Resources.employees },
                { typeof(LeaveRequestForm), PRSDesktop.Resources.leave },
                { typeof(ManufacturingPacketStage), PRSDesktop.Resources.factory },
                { typeof(TimeSheetForm), PRSDesktop.Resources.time },
                { typeof(PurchaseOrderItemForm), PRSDesktop.Resources.purchase }
            };

            ActionColumns.Add(new DynamicActionColumn(TypeImage)
            {
                Position = DynamicActionColumnPosition.Start,
                Filters = Images.Keys.Select(x=>x.EntityName().Split('.').Last().SplitCamelCase()).ToArray(),
                FilterRecord = TypeFilter
            });

            ActionColumns.Add(new DynamicMenuColumn(MenuBuild, MenuStatus) { Position = DynamicActionColumnPosition.End });

            _mappings = new CoreFieldMap<IDigitalFormInstance, DigitalFormDockModel>()
                .Add(x => x.ID, x => x.ID)
                .Add(x => x.Form.ID, x => x.FormID)
                .Add(x => x.Form.Description, x => x.FormName)
                .Add(x => x.FormCompleted, x => x.Completed)
                .Add(x => x.FormCompletedBy.UserID, x => x.CompletedBy);
            
            _query = new MultiQuery();
            
            _types = CoreUtils.TypeList(e =>
                e.IsSubclassOf(typeof(Entity))
                && e.GetInterfaces().Contains(typeof(IRemotable))
                && e.GetInterfaces().Contains(typeof(IPersistent))
                && e.GetInterfaces().Contains(typeof(IDigitalFormInstance))
            );
            
            _data = new CoreTable();
            _data.LoadColumns(typeof(DigitalFormDockModel));
            Options.BeginUpdate();
            Options.Clear();
            Options.Add(DynamicGridOption.FilterRows);
            Options.EndUpdate();

        }

        private bool TypeFilter(CoreRow row, string[] filter)
        {
            string typename = row.Get<DigitalFormDockModel, Type>(x => x.FormType).EntityName().Split('.').Last().SplitCamelCase();
            return filter.Contains(typename);
        }

        private BitmapImage? TypeImage(CoreRow arg)
        {
            if (arg == null)
                return null;
            var type = arg.Get<DigitalFormDockModel, Type>(x => x.FormType);
            return Images.GetValueOrDefault(type)?.AsBitmapImage();
        }

        private void MenuBuild(DynamicMenuColumn column, CoreRow row)
        {
            if (row == null) return;

            var instanceID = row.Get<DigitalFormDockModel, Guid>(x => x.ID);
            var formID = row.Get<DigitalFormDockModel, Guid>(x => x.FormID);
            var formType = row.Get<DigitalFormDockModel, Type>(x => x.FormType);
            var filter = Filter.Create<IDigitalFormInstance>(formType, x => x.ID).IsEqualTo(instanceID);
            var model = (Activator.CreateInstance(typeof(DigitalFormReportDataModel<>).MakeGenericType(formType), filter, formID) as DataModel)!;

            var modules = new Client<CustomModule>().Query(
                new Filter<CustomModule>(x => x.DataModel).IsEqualTo(model.Name)
                    .And(x => x.Section).IsEqualTo(formID.ToString())
                ).Rows.Select(x => x.ToObject<CustomModule>());
            foreach(var module in modules)
            {
                column.AddItem(module.Name, PRSDesktop.Resources.edit, row =>
                {
                    try
                    {
                        if(ScriptDocument.RunCustomModule(model, new Dictionary<string, object[]>(), module.Script))
                        {
                            Refresh(true, true);
                        }
                    }
                    catch(CompileException c)
                    {
                        MessageBox.Show(c.Message);
                    }
                    catch(Exception e)
                    {
                        MessageBox.Show(CoreUtils.FormatException(e));
                    }
                });
            }
            if (Security.IsAllowed<CanCustomiseModules>())
            {
                column.AddSeparator();
                column.AddItem("Customise Modules", PRSDesktop.Resources.script, row =>
                {
                    var manager = new CustomModuleManager
                    {
                        Section = formID.ToString(),
                        DataModel = model
                    };
                    manager.ShowDialog();
                });
            }

            if (Security.IsAllowed<CanPrintReports>())
            {
                column.AddSeparator();
                var printItem = column.AddItem("Print", PRSDesktop.Resources.printer, null);

                ReportUtils.PopulateMenu(printItem, formID.ToString(), model, Security.IsAllowed<CanDesignReports>(), true);
            }
        }

        private DynamicMenuStatus MenuStatus(CoreRow row)
        {
            if (row == null) return DynamicMenuStatus.Hidden;
            return DynamicMenuStatus.Enabled;
        }

        protected override void Reload(Filters<DigitalFormDockModel> criteria, Columns<DigitalFormDockModel> columns, ref SortOrder<DigitalFormDockModel> sort, Action<CoreTable, Exception> action)
        {
            
            _query.Clear();
            foreach (var type in _types.Where(x => !ExcludedTypes.Contains(x)))
            {

                var filter = Filter.Create<IDigitalFormInstance>(type, x => x.FormCompleted)
                    .IsGreaterThanOrEqualTo(StartDate);

                var cols = Columns.Create<IDigitalFormInstance>(type)
                    .Add<IDigitalFormInstance>(c => c.ID)
                    .Add<IDigitalFormInstance>(c => c.Form.ID)
                    .Add<IDigitalFormInstance>(c => c.Form.Description)
                    .Add<IDigitalFormInstance>(c => c.FormCompleted)
                    .Add<IDigitalFormInstance>(c => c.FormCompletedBy.UserID);

                var sorts = SortOrder.Create<IDigitalFormInstance>(type, x => x.FormCompleted, SortDirection.Descending);

                _query.Add(
                    new QueryDef(type)
                    {
                        Filter = filter,
                        Columns = cols,
                        SortOrder = sorts
                    },
                    type
                );

            }

            _query.Query((q) =>
            {
                _data.Rows.Clear();
                foreach (var type in _types.Where(x=>!ExcludedTypes.Contains(x)))
                    _data.LoadFrom(
                        _query.Get(type), 
                        _mappings, 
                        (r) => r.Set<DigitalFormDockModel,Type>(x=>x.FormType,type)
                    );
                action.Invoke(_data, null);
            });
        }

        protected override DigitalFormDockModel LoadItem(CoreRow row)
        {
            return row.ToObject<DigitalFormDockModel>();
        }

        protected override void SaveItem(DigitalFormDockModel item)
        {
            //throw new NotImplementedException();
        }

        protected override void DeleteItems(params CoreRow[] rows)
        {
            //throw new NotImplementedException();
        }

        protected override void DoDoubleClick(object sender)
        {
            base.DoDoubleClick(sender);
            CoreRow row = SelectedRows.FirstOrDefault();
            var instanceid = row.Get<DigitalFormDockModel, Guid>(x => x.ID);
            var formid = row.Get<DigitalFormDockModel, Guid>(x => x.FormID);
            var formtype = row.Get<DigitalFormDockModel, Type>(x => x.FormType);

            var results = Client.QueryMultiple(new Dictionary<string, IQueryDef>
            {
                { "Form", new QueryDef(formtype) {
                    Filter = Filter.Create<IDigitalFormInstance>(formtype, x => x.ID).IsEqualTo(instanceid),
                    Columns = Columns.Create<IDigitalFormInstance>(formtype).Add<IDigitalFormInstance>(x=>x.FormData)
                } },
                { "Variable", new QueryDef<DigitalFormVariable>(
                    new Filter<DigitalFormVariable>(x => x.Form.ID).IsEqualTo(formid),
                    null,
                    null
                ) },
                { "Layout", new QueryDef<DigitalFormLayout>(
                    new Filter<DigitalFormLayout>(x => x.Form.ID).IsEqualTo(formid).And(x => x.Active).IsEqualTo(true),
                    null,
                    null
                ) }
            });

            var formdata = results["Form"].Rows.FirstOrDefault()?.Get<IDigitalFormInstance, string>(x => x.FormData);
            var variables = results["Variable"].Rows.Select(x => x.ToObject<DigitalFormVariable>());
            var layout = results["Layout"].Rows.FirstOrDefault()?.ToObject<DigitalFormLayout>();

            if (formid == Guid.Empty)
            {
                var window = new DeletedFormWindow();
                window.FormData = formdata;
                window.ShowDialog();
                return;
            }

            if (layout == null)
            {
                MessageBox.Show("No Active Layouts Found!");
                return;
            }

            var form = new DynamicFormEditWindow()
            {
                Type = layout.Type
            };
            form.LoadLayout(layout, variables.ToArray());
            form.Initialize();

            if (!string.IsNullOrWhiteSpace(formdata))
                form.Values = Serialization.Deserialize<Dictionary<string, object>>(formdata);

            form.ShowDialog();
            
        }
        
    }
    
    public partial class DigitalFormsDock : UserControl, IDockPanel
    {
        
        public DigitalFormsDock()
        {
            InitializeComponent();
            RefreshButton.Content = new Image() { Source = PRSDesktop.Resources.refresh.AsBitmapImage() };
            foreach (var type in Items.Images.Keys)
            {
                Button button = new Button();
                button.Content = new Image() { Source = Items.Images[type].AsBitmapImage() };
                button.BorderBrush = new SolidColorBrush(Colors.Gray);
                button.BorderThickness = new Thickness(0.75);
                button.Margin = new Thickness(2, 0, 0, 0);
                button.Width = 25D;
                button.Padding = new Thickness(2);
                button.ToolTip = type.EntityName().Split('.').Last().SplitCamelCase();
                button.Click += TypeFilterClick;
                button.Tag = type;
                TypeStack.Children.Add(button);
            }

        }

        private void TypeFilterClick(object sender, RoutedEventArgs e)
        {
            Button button = sender as Button;
            Type type = button.Tag as Type;
            if (Items.ExcludedTypes.Contains(type))
                Items.ExcludedTypes.Remove(type);
            else
                Items.ExcludedTypes.Add(type);
            button.Content = Items.ExcludedTypes.Contains(type)
                ? new Image() { Source = Items.Images[type].AsGrayScale().AsBitmapImage() }
                : new Image() { Source = Items.Images[type].AsBitmapImage() };
            Refresh();
        }
        
        private void RefreshButton_OnClick(object sender, RoutedEventArgs e)
        {
            Refresh();
        }
        
        public void Setup()
        {
            Items.Refresh(true, false);           
        }
        
        public void Refresh()
        {
            Items.Refresh(false, true);
        }

        private void AgeCombo_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var startdate = AgeCombo.SelectedIndex == 2
                ? DateTime.Today.AddDays(-30)
                : AgeCombo.SelectedIndex == 1
                    ? DateTime.Today.AddDays(-7)
                    : DateTime.Today;
            if ((Items != null) && (startdate != Items.StartDate))
            {
                Items.StartDate = startdate;
                Refresh();
            }
        }
    }
}