prs/prs.mobile/comal.timesheets/DigitalForms/DataModels/DigitalFormHostModel.cs

using comal.timesheets.QAForms;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using XF.Material.Forms.UI.Dialogs;

namespace comal.timesheets
{

    public class DigitalFormHostModel<TEntity, TEntityLink, TInstance> : IDigitalFormHostModel
        where TEntity : Entity, IRemotable, IPersistent, new()
        where TEntityLink : EntityLink<TEntity>, new()
        where TInstance : Entity, IRemotable, IPersistent, IDigitalFormInstance<TEntityLink>, new()
    {
        public IDigitalFormDataModel DigitalFormDataModel { get; set; }
        public DFLayout DFLayout { get; set; }
        public DigitalFormLayout DigitalFormLayout { get; set; }
        public Entity Entity { get; set; }
        public bool ReadOnly { get; set; }
        public bool NewForm { get; set; }

        public event OnDigitalFormHostModelSaved OnDigitalFormHostModelSaved;
        public event OnDigitalFormHostModelBeforeSave OnDigitalFormHostModelBeforeSave;

        public DigitalFormHostModel()
        {
            DFLayout = new DFLayout();
            NewForm = true;
            ReadOnly = false;
        }

        public void LoadItems(Entity parent, Entity form, DigitalFormLayout layout = null)
        {
            List<DigitalFormVariable> variables = new List<DigitalFormVariable>();

            var getLayout = Task.Run(() =>
            {
                var loadLayout = Task.Run(() =>
                {
                    if (layout == null)
                        DigitalFormLayout = QueryDigitalFormLayout(form);
                    else
                        DigitalFormLayout = layout;

                    DFLayout.LoadLayout(DigitalFormLayout.Layout);
                });

                (form as EntityForm<TEntity, TEntityLink>).Form.ID = layout.Form.ID;

                var getVariables = Task.Run(() => { variables = QueryVariables(form); });

                Task.WaitAll(loadLayout, getVariables);

                DFLayout.LoadVariables(variables);
            });
            var loadDFDataModel = Task.Run(() =>
            {
                DigitalFormDataModel = new DigitalFormDataModel<TEntity, TEntityLink, TInstance>(parent.ID, form.ID);
                DigitalFormDataModel.Load(null);
                Entity = DigitalFormDataModel.Entity;
            });
            Task.WaitAll(getLayout, loadDFDataModel);

            DigitalFormDataModel.Instance.Form.ID = DigitalFormLayout.Form.ID;

            if (!string.IsNullOrWhiteSpace(DigitalFormDataModel.Instance.FormData))
                NewForm = false;

            if (DigitalFormDataModel.Instance.FormCompleted != DateTime.MinValue)
                ReadOnly = true;

            DigitalFormDataModel.BeforeModelSaved += (m) =>
            {
                OnDigitalFormHostModelBeforeSave?.Invoke();
                DigitalFormDataModel.Entity = Entity;
                CheckEntity(SaveType.BeforeSave);
            };

            DigitalFormDataModel.OnModelSaved += (m) =>
            {
                CheckEntity(SaveType.AfterSave);
                OnDigitalFormHostModelSaved?.Invoke();
            };

        }

        public DigitalFormLayout QueryDigitalFormLayout(Entity form)
        {
            DigitalFormLayout layout = new Client<DigitalFormLayout>().Query
                (
                new Filter<DigitalFormLayout>(x => x.Form.ID).IsEqualTo((form as EntityForm<TEntity, TEntityLink>).Form.ID)
                .And(x => x.Type).IsEqualTo(DFLayoutType.Mobile)
                .And(x => x.Active).IsEqualTo(true)
                )
                .Rows.FirstOrDefault().ToObject<DigitalFormLayout>();
            return layout;
        }

        public List<DigitalFormVariable> QueryVariables(Entity form)
        {
            List<DigitalFormVariable> variables = new List<DigitalFormVariable>();
            var table = new Client<DigitalFormVariable>().Query(
                    new Filter<DigitalFormVariable>(x => x.Form.ID).IsEqualTo((form as EntityForm<TEntity, TEntityLink>).Form.ID),
                    new Columns<DigitalFormVariable>(x => x.Code, x => x.Parameters, x => x.Description, x => x.VariableType),
                    null
                    );
            foreach (CoreRow coreRow in table.Rows)
            {
                var variable = coreRow.ToObject<DigitalFormVariable>();
                variables.Add(variable);
            }
            return variables;
        }

        public List<DigitalFormVariable> QueryVariables(DigitalFormLayout layout)
        {
            List<DigitalFormVariable> variables = new List<DigitalFormVariable>();
            var table = new Client<DigitalFormVariable>().Query(
                    new Filter<DigitalFormVariable>(x => x.Form.ID).IsEqualTo(layout.Form.ID),
                    new Columns<DigitalFormVariable>(x => x.Code, x => x.Parameters, x => x.Description, x => x.VariableType),
                    null
                    );
            foreach (CoreRow coreRow in table.Rows)
            {
                var variable = coreRow.ToObject<DigitalFormVariable>();
                variables.Add(variable);
            }
            return variables;
        }

        public void SetPropertyValues(QAFormViewer viewer) //currently does not include Employee Forms
        {
            try
            {
                if (DigitalFormLayout.Form.AppliesTo.Equals("Kanban"))
                {
                    foreach (KeyValuePair<string, string> pair in viewer.propertyResults)
                    {
                        if (pair.Key.Contains("ID"))
                        {
                            //this only sets the entity lookup.ID, not the description or code - is this an issue??
                            CoreUtils.SetPropertyValue(Entity, pair.Key, Guid.Parse(pair.Value));
                        }
                        else if (DateTime.TryParse(pair.Value, out DateTime datetime))
                        {
                            string parsedDate = "";
                            parsedDate = datetime.ToString("yyyy-mm-dd hh:mm:ss.zzz"); ;
                            CoreUtils.SetPropertyValue(Entity, pair.Key, parsedDate);
                        }
                        else
                        {
                            CoreUtils.SetPropertyValue(Entity, pair.Key, pair.Value);
                        }

                    }
                }
                else if (DigitalFormLayout.Form.AppliesTo.Equals("LeaveRequest"))
                {
                    foreach (KeyValuePair<string, string> pair in viewer.propertyResults)
                    {
                        if (pair.Key.Contains("ID"))
                        {
                            CoreUtils.SetPropertyValue(Entity, pair.Key, Guid.Parse(pair.Value));
                        }
                        else if (pair.Key.Equals("From"))
                        {
                            (Entity as LeaveRequest).From = DateTime.Parse(pair.Value);
                        }
                        else if (pair.Key.Equals("To"))
                        {
                            (Entity as LeaveRequest).To = DateTime.Parse(pair.Value);
                        }
                        else if (pair.Key.Equals("FromTime"))
                        {
                            (Entity as LeaveRequest).FromTime = TimeSpan.Parse(pair.Value);
                        }
                        else if (pair.Key.Equals("ToTime"))
                        {
                            (Entity as LeaveRequest).ToTime = TimeSpan.Parse(pair.Value);
                        }
                        else if (pair.Key.Equals("Notes"))
                        {
                            (Entity as LeaveRequest).Notes = (Entity as LeaveRequest).Notes + System.Environment.NewLine + pair.Value;
                        }
                        else
                        {
                            CoreUtils.SetPropertyValue(Entity, pair.Key, pair.Value);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                viewer.errors.Add(e.Message);
            }
        }

        private void CheckEntity(SaveType saveType)
        {
            if (Entity.GetType() == typeof(Kanban))
                DoKanbanActions(saveType);
            else if (Entity.GetType() == typeof(LeaveRequest))
                (Entity as LeaveRequest).EmployeeLink.ID = GlobalVariables.EmpID;
        }

        private void DoKanbanActions(SaveType saveType)
        {
                if (saveType == SaveType.BeforeSave)
                    CheckAndCreateKanban();
                else if (saveType == SaveType.AfterSave)
                    CheckSubscriber();
        }

        private void CheckAndCreateKanban()
        {
            if (Entity.ID == Guid.Empty)
            {
                Kanban kanban = Entity as Kanban;
                kanban.EmployeeLink.ID = GlobalVariables.EmpID;
                kanban.DueDate = DateTime.Today;
                kanban.Title = "Form - " + DigitalFormLayout.Description;
                kanban.Notes = new string[] { "Created by Forms App" };
                kanban.Category = "In Progress";

                Entity = kanban;
            }
        }

        private void CheckSubscriber()
        {
            var sub = new Client<KanbanSubscriber>().Query(
                new Filter<KanbanSubscriber>(x => x.Kanban.ID).IsEqualTo(Entity.ID),
                new Columns<KanbanSubscriber>(x => x.ID)
                );
            if (sub.Rows.Count == 0)
                AddSubscriber();
        }

        private void AddSubscriber()
        {
            KanbanSubscriber subscriber = new KanbanSubscriber();
            subscriber.Kanban.ID = Entity.ID;
            subscriber.Assignee = true;
            subscriber.Employee.ID = GlobalVariables.EmpID;
            new Client<KanbanSubscriber>().Save(subscriber, "Updated From Mobile Device");
        }

        enum SaveType
        {
            BeforeSave,
            AfterSave,
        }
    }
}