inabox/InABox.DynamicGrid/DigitalForms/DigitalFormGrid.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Imaging;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.Reports;
using InABox.Reports.Common;
using InABox.WPF;
using Microsoft.Win32;

namespace InABox.DynamicGrid
{
    public class DigitalFormExportData
    {
        public string Code { get; set; }

        public string Description { get; set; }

        public string AppliesTo { get; set; }

        public DigitalFormExportData() { }

        public DigitalFormExportData(DigitalForm form)
        {
            Code = form.Code;
            Description = form.Description;
            AppliesTo = form.AppliesTo;
        }

        public List<LayoutData> Layouts { get; set; }

        public List<VariableData> Variables { get; set; }

        public List<DocumentData> Documents { get; set; }

        public DigitalForm ToForm() => new DigitalForm
        {
            Code = Code,
            Description = Description,
            AppliesTo = AppliesTo
        };

        public class LayoutData
        {
            public string Code { get; set; }

            public string Description { get; set; }

            public DFLayoutType Type { get; set; }

            public string Layout { get; set; }

            public LayoutData() { }

            public LayoutData(DigitalFormLayout layout)
            {
                Code = layout.Code;
                Description = layout.Description;
                Type = layout.Type;
                Layout = layout.Layout;
            }

            public DigitalFormLayout ToLayout() => new DigitalFormLayout
            {
                Code = Code,
                Description = Description,
                Type = Type,
                Layout = Layout
            };
        }

        public class VariableData
        {
            public string Code { get; set; }

            public string Description { get; set; }

            public string VariableType { get; set; }

            public string Parameters { get; set; }

            public bool Required { get; set; }

            public bool Secure { get; set; }

            public bool Retain { get; set; }

            public bool Hidden { get; set; }

            public long Sequence { get; set; }

            public VariableData() {  }

            public VariableData(DigitalFormVariable variable)
            {
                Code = variable.Code;
                Description = variable.Description;
                VariableType = variable.VariableType;
                Parameters = variable.Parameters;
                Required = variable.Required;
                Secure = variable.Secure;
                Retain = variable.Retain;
                Hidden = variable.Hidden;
                Sequence = variable.Sequence;
            }

            public DigitalFormVariable ToVariable() => new DigitalFormVariable
            {
                Code = Code,
                Description = Description,
                VariableType = VariableType,
                Parameters = Parameters,
                Required = Required,
                Secure = Secure,
                Retain = Retain,
                Hidden = Hidden,
                Sequence = Sequence
            };
        }

        public class DocumentData
        {
            public string FileName { get; set; }

            public byte[] Data { get; set; }

            public Guid ID { get; set; }

            public DocumentData() { }

            public DocumentData(Document document)
            {
                FileName = document.FileName;
                Data = document.Data;
                ID = document.ID;
            }

            public Document ToDocument() => new Document
            {
                FileName = FileName,
                Data = Data,
                TimeStamp = DateTime.Now,
                ID = ID
            };
        }
    }

    public class DigitalFormGrid : DynamicDataGrid<DigitalForm>
    {
        private bool _showall;

        public DigitalFormGrid()
        {
            Options.AddRange(DynamicGridOption.ImportData, DynamicGridOption.ExportData);

            AddButton("Show All", null, ShowAllClick);
            // TODO: Add back in
            //ActionColumns.Add(new DynamicImageColumn(ReportImage, ReportClick));

            AddButton("Groups", null, EditGroupsClick);
        }

        private bool EditGroupsClick(Button arg1, CoreRow[] arg2)
        {
            new MasterList(typeof(DigitalFormGroup)).ShowDialog();
            return false;
        }

        private BitmapImage ReportImage(CoreRow arg)
        {
            return arg != null ? Properties.Resources.printer.AsBitmapImage() : null;
        }

        /*private bool ReportClick(CoreRow arg)
        {
            if (arg == null)
                return false;

            var typename = arg.Get<DigitalForm, string>(c => c.AppliesTo);
            var formid = arg.Get<DigitalForm, Guid>(c => c.ID);

            // Get Applies To
            /*Type type = CoreUtils.GetEntity("Comal.Classes."+typename);
            CoreTable entity = new CoreTable();
            entity.LoadColumns(type);
    
            // Get Form Details
            CoreTable form = new CoreTable();
            form.Columns.Add(new CoreColumn() { ColumnName = "ID", DataType = typeof(Guid) });
            form.Columns.Add(new CoreColumn() { ColumnName = "Parent.ID", DataType = typeof(Guid) });
            form.Columns.Add(new CoreColumn() { ColumnName = CoreUtils.GetFullPropertyName<IDigitalFormInstance, String>(x => x.Form.Description, "."), DataType = typeof(String) });
            form.Columns.Add(new CoreColumn() { ColumnName = CoreUtils.GetFullPropertyName<IDigitalFormInstance, String>(x => x.FormCompletedBy.UserID, "."), DataType = typeof(String) });
            form.Columns.Add(new CoreColumn() { ColumnName = CoreUtils.GetFullPropertyName<IDigitalFormInstance, DateTime>(x => x.FormCompleted, "."), DataType = typeof(String) });
            form.Columns.Add(new CoreColumn() { ColumnName = CoreUtils.GetFullPropertyName<IDigitalFormInstance, String>(x => x.Location.Address, "."), DataType = typeof(String) });
            form.Columns.Add(new CoreColumn() { ColumnName = CoreUtils.GetFullPropertyName<IDigitalFormInstance, double>(x => x.Location.Latitude, "."), DataType = typeof(String) });
            form.Columns.Add(new CoreColumn() { ColumnName = CoreUtils.GetFullPropertyName<IDigitalFormInstance, double>(x => x.Location.Longitude, "."), DataType = typeof(String) });
    
            var variables = new Client<DigitalFormVariable>().Query(new Filter<DigitalFormVariable>(x => x.Form.ID).IsEqualTo(formid));
            foreach (var row in variables.Rows)
            {
                form.Columns.Add(
                    new CoreColumn()
                    {
                        ColumnName = row.Get<DigitalFormVariable, String>(c => c.Code),
                        DataType = DigitalFormVariable.DataType(row.Get<DigitalFormVariable, DigitalFormVariableType>(c => c.VariableType))
                    }
                );
            }*


            // Create DataModel
            //DigitalFormReportDataModel model = new DigitalFormReportDataModel(form,entity,typename);
            AutoDataModel<DigitalForm> model = new AutoDataModel<DigitalForm>(new Filter<DigitalForm>(x => x.ID).IsEqualTo(formid));

            // Load Template
            var template = new Client<ReportTemplate>()
                .Load(new Filter<ReportTemplate>(x => x.Section).IsEqualTo("DigitalForms").And(x => x.Name).IsEqualTo(formid.ToString()))
                .FirstOrDefault();
            if (template == null)
            {
                template = new ReportTemplate
                {
                    Section = "DigitalForms",
                    Name = formid.ToString(),
                    Visible = false
                };
                new Client<ReportTemplate>().Save(template, "");
            }

            ReportUtils.DesignReport(template, model);

            // Preview Report
            return false;
        }*/

        private bool ShowAllClick(Button arg1, CoreRow[] arg2)
        {
            _showall = !_showall;
            UpdateButton(arg1, null, _showall ? "Hide Inactive" : "Show All");
            return true;
        }

        protected override void Reload(Filters<DigitalForm> criteria, Columns<DigitalForm> columns, ref SortOrder<DigitalForm>? sort,
            Action<CoreTable?, Exception?> action)
        {
            if (!_showall)
                criteria.Add(new Filter<DigitalForm>(x => x.Active).IsEqualTo(true));
            base.Reload(criteria, columns, ref sort, action);
        }

        public override bool EditItems(DigitalForm[] items, Func<Type, CoreTable>? PageDataHandler = null, bool PreloadPages = false)
        {
            // Need to do this to make sure that the variables are available to the layouts (and vice versa?)
            return base.EditItems(items, PageDataHandler, true);
        }

        private const string ExportFileFilter = "Digital Forms (*.prs-form)|*.prs-form";

        protected override void DoImport()
        {
            var dialog = new OpenFileDialog
            {
                Filter = ExportFileFilter
            };
            if (dialog.ShowDialog() != true)
                return;

            DigitalFormExportData? data;
            using(var stream = dialog.OpenFile())
            {
                data = Serialization.Deserialize<DigitalFormExportData>(stream);
                if (data is null)
                {
                    MessageBox.Show("File corrupt");
                    return;
                }
            }

            try
            {
                var form = data.ToForm();
                var layouts = data.Layouts.Select(x => x.ToLayout()).ToList();
                var variables = data.Variables.Select(x => x.ToVariable()).ToList();
                var documents = data.Documents.Select(x => x.ToDocument()).ToList();
                var formDocuments = new List<DigitalFormDocument>();

                foreach (var document in documents)
                {
                    new Client<Document>().Save(document, "");

                    var digitalFormDocument = new DigitalFormDocument();
                    digitalFormDocument.DocumentLink.ID = document.ID;
                    digitalFormDocument.DocumentLink.Synchronise(document);
                    formDocuments.Add(digitalFormDocument);
                }

                if (EditItems(new DigitalForm[] { form }, (type) =>
                {
                    var table = new CoreTable();
                    table.LoadColumns(type);
                    if(type == typeof(DigitalFormLayout))
                    {
                        table.LoadRows(layouts);
                    }
                    else if(type == typeof(DigitalFormVariable))
                    {
                        table.LoadRows(variables);
                    }
                    else if(type == typeof(DigitalFormDocument))
                    {
                        table.LoadRows(formDocuments);
                    }
                    return table;
                }))
                {
                    Refresh(false, true);
                }

                /*new Client<DigitalForm>().Save(form, "Imported by user");

                foreach (var layout in layouts)
                {
                    layout.Form.ID = form.ID;
                    new Client<DigitalFormLayout>().Save(layout, "");
                }
                foreach (var variable in variables)
                {
                    variable.Form.ID = form.ID;
                    new Client<DigitalFormVariable>().Save(variable, "");
                }
                foreach (var document in documents)
                {
                    new Client<Document>().Save(document, "");

                    var digitalFormDocument = new DigitalFormDocument();
                    digitalFormDocument.EntityLink.ID = form.ID;
                    digitalFormDocument.DocumentLink.ID = document.ID;

                    new Client<DigitalFormDocument>().Save(digitalFormDocument, "");
                }*/
            }
            catch(Exception e)
            {
                MessageBox.Show(e.Message);
            }
        }

        protected override void DoExport()
        {
            var rows = SelectedRows;
            if(rows.Length == 0)
            {
                MessageBox.Show("Please select a form to export.");
                return;
            }
            else if(rows.Length > 1)
            {
                MessageBox.Show("Please select only one form to export.");
                return;
            }
            var formID = rows[0].Get<DigitalForm, Guid>(x => x.ID);

            var results = Client.QueryMultiple(
                new KeyedQueryDef<DigitalForm>(
                    new Filter<DigitalForm>(x => x.ID).IsEqualTo(formID),
                    new Columns<DigitalForm>(x => x.Code)
                        .Add(x => x.Description)
                        .Add(x => x.AppliesTo)),
                new KeyedQueryDef<DigitalFormLayout>(
                    new Filter<DigitalFormLayout>(x => x.Form.ID).IsEqualTo(formID),
                    new Columns<DigitalFormLayout>(x => x.Code)
                        .Add(x => x.Description)
                        .Add(x => x.Type)
                        .Add(x => x.Layout)),
                new KeyedQueryDef<DigitalFormVariable>(
                    new Filter<DigitalFormVariable>(x => x.Form.ID).IsEqualTo(formID),
                    new Columns<DigitalFormVariable>(x => x.Code)
                        .Add(x => x.Description)
                        .Add(x => x.VariableType)
                        .Add(x => x.Parameters)
                        .Add(x => x.Required)
                        .Add(x => x.Secure)
                        .Add(x => x.Retain)
                        .Add(x => x.Hidden)
                        .Add(x => x.Sequence)),
                new KeyedQueryDef<Document>(
                    new Filter<Document>(x => x.ID).InQuery(
                        new Filter<DigitalFormDocument>(x => x.EntityLink.ID).IsEqualTo(formID),
                        x => x.DocumentLink.ID),
                    new Columns<Document>(x => x.FileName)
                        .Add(x => x.Data)));

            var data = new DigitalFormExportData(results.Get<DigitalForm>().Rows.First().ToObject<DigitalForm>())
            {
                Layouts = results.Get<DigitalFormLayout>().ToObjects<DigitalFormLayout>().Select(x => new DigitalFormExportData.LayoutData(x)).ToList(),
                Variables = results.Get<DigitalFormVariable>().ToObjects<DigitalFormVariable>().Select(x => new DigitalFormExportData.VariableData(x)).ToList(),
                Documents = results.Get<Document>().ToObjects<Document>().Select(x => new DigitalFormExportData.DocumentData(x)).ToList()
            };

            var filename = rows[0].Get<DigitalForm, string>(x => x.Description);
            if (string.IsNullOrWhiteSpace(filename))
                filename = rows[0].Get<DigitalForm, string>(x => x.Code);
            if (string.IsNullOrWhiteSpace(filename))
                filename = "form";

            var dialog = new SaveFileDialog
            {
                Filter = ExportFileFilter,
                FileName = $"{filename}.prs-form"
            };
            if(dialog.ShowDialog() == true)
            {
                using var stream = dialog.OpenFile();
                Serialization.Serialize(data, stream);
            }
        }

        protected override void DoValidate(DigitalForm[] items, List<string> errors)
        {
            base.DoValidate(items, errors);
            if (items.Any(x => string.IsNullOrWhiteSpace(x.AppliesTo)))
                errors.Add("[Applies To] must not be blank!");
        }
    }
}