inabox/InABox.Core/DigitalForms/DataModel/DigitalFormDataModel.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using InABox.Clients;

namespace InABox.Core
{
    public enum MobileLogType
    {
        START,
        END
    }
    public class MobileLog
    {
        public string Message { get; set; }

        public MobileLog(string message, MobileLogType type)
        {
            Message = type + " " + message + "(" + DateTime.Now.ToString("m.s.fffff") + ")";        
        }

        public static string ProduceLog(List<MobileLog> logs)
        {
            string finallog = "";
            foreach (var log in logs)
            {
                finallog = finallog + System.Environment.NewLine + log.Message;
            }
            return finallog;
        }
    }
    public class DigitalFormDataModel<TEntity, TEntityLink, TInstance> : IDigitalFormDataModel
        where TEntity : Entity, IRemotable, IPersistent, new()
        where TEntityLink : EntityLink<TEntity>
        where TInstance : Entity, IRemotable, IPersistent, IDigitalFormInstance<TEntityLink>, new()
    {
        private readonly bool bRequiresLoad = true;
        List<MobileLog> logs = new List<MobileLog>();
        public DigitalFormDataModel(Guid entityid, Guid instanceid)
        {
            Entity = new TEntity();
            Entity.ID = entityid;
            Entity.CommitChanges();
            Instance = new TInstance();
            Instance.ID = instanceid;
            bRequiresLoad = true;
        }

        public DigitalFormDataModel(TEntity entity, TInstance instance)
        {
            Entity = entity;
            Instance = instance;
            bRequiresLoad = false;
        }

        public Entity Entity { get; set; }

        public object? GetEntityValue(string name)
        {
            try
            {
                return CoreUtils.GetPropertyValue(Entity, name);
            }
            catch (Exception e)
            {
                return null;
            }
        }

        public void SetEntityValue(string name, object? value)
        {
            try
            {
                CoreUtils.SetPropertyValue(Entity, name, value);
            }
            catch (Exception e)
            {
                Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
            }
        }

        public IDigitalFormInstance Instance { get; set; }

        public event DigitalFormUpdateHandler OnModelSaved;

        public event DigitalFormBeforeUpdateHandler BeforeModelSaved;

        public void Load(Action<IDigitalFormDataModel>? callback = null)
        {
            logs.Add(new MobileLog("Load", MobileLogType.START));
            if (!bRequiresLoad)
            {
                callback?.Invoke(this);
                return;
            }

            var client = new MultiQuery();

            DoAddQueries(client);

            logs.Add(new MobileLog("Query", MobileLogType.START));

            if (callback == null)
            {
                if (client.Count > 0)
                {
                    client.Query();
                    DoParseQueries(client);
                }
            }
            else
            {
                if (client.Count > 0)
                    client.Query(c =>
                    {
                        DoParseQueries(client);
                        callback.Invoke(this);
                    });
                else
                    callback.Invoke(this);
            }
            logs.Add(new MobileLog("Query", MobileLogType.END));
            logs.Add(new MobileLog("Load", MobileLogType.END));
            var log = MobileLog.ProduceLog(logs);
        }

        public void Update(Action<IDigitalFormDataModel>? callback = null)
        {
            //this never get used and causes a crash in the app for Job ITP forms - maybe time for a rebuild?
            //if (!bRequiresLoad)
            //{
            //    callback.Invoke(this);
            //    return;
            //}

            if (callback == null)
                DoUpdate();
            else
                Task.Run(() =>
                {
                    DoUpdate();
                    callback.Invoke(this);
                });
        }

        public virtual void AddQueries(MultiQuery client)
        {
        }

        private void DoAddQueries(MultiQuery client)
        {
            if (Entity.ID != Guid.Empty)
                client.Add(
                    new QueryDef<TEntity>(
                        new Filter<TEntity>(x => x.ID).IsEqualTo(Entity.ID),
                        new Columns<TEntity>(x => x.ID),
                        null
                    ),
                    typeof(TEntity)
                );

            if (Instance.ID != Guid.Empty)
                client.Add(
                    new QueryDef<TInstance>(
                        new Filter<TInstance>(x => x.ID).IsEqualTo(Instance.ID),
                        new Columns<TInstance>
                        (
                            x => x.ID, 
                            x => x.FormData, 
                            x => x.Form.ID,
                            x => x.FormCompleted,
                            x => x.FormCompletedBy.ID,
                            x => x.Created,
                            x => x.FormOpen,
                            x => x.BlobData
                            
                            ),
                        null
                    ),
                    typeof(TInstance)
                );

            AddQueries(client);
        }

        public virtual void ParseQueries(MultiQuery client)
        {
        }

        private void DoParseQueries(MultiQuery client)
        {
            if (client.Contains(typeof(TEntity)))
            {
                var table = client.Get(typeof(TEntity));
                if (table.Rows.Any())
                    Entity = table.Rows.First().ToObject<TEntity>();
            }

            if (client.Contains(typeof(TInstance)))
            {
                var table = client.Get(typeof(TInstance));
                if (table.Rows.Any())
                    Instance = table.Rows.First().ToObject<TInstance>();
            }

            ParseQueries(client);
        }

        protected virtual void AddPrimaryUpdates(MultiSave client)
        {
        }

        protected virtual void AddSecondaryUpdates(MultiSave client)
        {
        }

        private void DoUpdate()
        {
            BeforeModelSaved?.Invoke(this);

            var entityaudittrail = "";
            var instanceaudittrail = "";

            var parents = new MultiSave();
            if (Entity.IsChanged())
            {
                parents.Add(typeof(TEntity), Entity);
                entityaudittrail = "Updated from App - Digital Forms Module";
            }
            else if (Entity.ID == Guid.Empty)
            {
                parents.Add(typeof(TEntity), Entity);
                entityaudittrail = "Created from App - Digital Forms Module";
            }

            AddPrimaryUpdates(parents);

            parents.Save(null, entityaudittrail);

            ((IDigitalFormInstance<TEntityLink>)Instance).Parent.ID = Entity.ID; //be careful of bug here in future due to cast            

            var children = new MultiSave();
            if (Instance.IsChanged())
            {
                children.Add(typeof(TInstance), (TInstance)Instance);
                instanceaudittrail = "Updated from App - Digital Forms Module";
            }
            else if (Entity.ID == Guid.Empty)
            {
                children.Add(typeof(TInstance), (TInstance)Instance);
                instanceaudittrail = "Created from App - Digital Forms Module";
            }

            AddSecondaryUpdates(children);

            children.Save(null, instanceaudittrail);

            OnModelSaved?.Invoke(this);
        }
    }
}