inabox/InABox.Core/DigitalForms/DFUtils.cs

using InABox.Core.Notifications;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace InABox.Core
{
    public interface IEntityFormUtils
    {
        public abstract bool CanEditForm(IDigitalFormInstance Form, Entity Entity);
    }
    public class EntityFormUtils<TForm, TEntity, TEntityLink> : IEntityFormUtils
        where TForm : EntityForm<TEntity, TEntityLink>
        where TEntity : Entity, new()
        where TEntityLink : EntityLink<TEntity>, new()
    {
        public delegate bool CanEditForm(TForm Form, TEntity Entity);

        public CanEditForm CanEdit;

        public EntityFormUtils(CanEditForm canEditForm)
        {
            CanEdit = canEditForm;
        }

        bool IEntityFormUtils.CanEditForm(IDigitalFormInstance Form, Entity Entity)
             => CanEdit((Form as TForm)!, (Entity as TEntity)!);
    }

    public static class DFUtils
    {

        private static List<Type>? _fieldTypes;

        public static List<Type> GetFieldTypes()
        {
            _fieldTypes ??= CoreUtils.TypeList(
                AppDomain.CurrentDomain.GetAssemblies(),
                x => x.IsClass
                && !x.IsAbstract
                && !x.IsGenericType
                && x.GetInterfaces().Any(x => x == typeof(IDFLayoutFormField))).ToList();
            return _fieldTypes;
        }

        public static Type? GetFieldType(string typeName)
        {
            var type = GetFieldTypes().Where(x => x.FullName == typeName).FirstOrDefault();
            if(type != null) return type;

            if(Enum.TryParse(typeName, out DigitalFormVariableType variableType))
            {
                // For the old types
                switch (variableType)
                {
                    case DigitalFormVariableType.String:
                        return typeof(DFLayoutStringField);
                    case DigitalFormVariableType.Boolean:
                        return typeof(DFLayoutBooleanField);
                    case DigitalFormVariableType.Integer:
                        return typeof(DFLayoutIntegerField);
                    case DigitalFormVariableType.Double:
                        return typeof(DFLayoutDoubleField);
                    case DigitalFormVariableType.Date:
                        return typeof(DFLayoutDateField);
                    case DigitalFormVariableType.Time:
                        return typeof(DFLayoutTimeField);
                    case DigitalFormVariableType.Choice:
                        return typeof(DFLayoutOptionField);
                    case DigitalFormVariableType.Lookup:
                        return typeof(DFLayoutLookupField);
                    case DigitalFormVariableType.SignaturePad:
                        return typeof(DFLayoutSignaturePad);
                    case DigitalFormVariableType.EmbeddedImage:
                        return typeof(DFLayoutEmbeddedImage);
                    case DigitalFormVariableType.MultiImage:
                        return typeof(DFLayoutMultiImage);
                }
            }
            return null;
        }


        private static Dictionary<Type, IEntityFormUtils> _formUtils = new Dictionary<Type, IEntityFormUtils>();

        public static void AddFormUtils<TForm, TEntity, TEntityLink>(EntityFormUtils<TForm, TEntity, TEntityLink>.CanEditForm editFormFunc)
            where TForm : EntityForm<TEntity, TEntityLink>
            where TEntity : Entity, new()
            where TEntityLink : EntityLink<TEntity>, new()
        {
            _formUtils.Add(typeof(TForm), new EntityFormUtils<TForm, TEntity, TEntityLink>(editFormFunc));
        }

        public static bool CanEditForm(Type TForm, IDigitalFormInstance Form, Entity Entity)
        {
            if(_formUtils.TryGetValue(TForm, out var utils))
            {
                return utils.CanEditForm(Form, Entity);
            }
            return false;
        }
        public static bool CanEditForm<TForm, TEntity, TEntityLink>(TForm Form, TEntity Entity)
            where TForm : EntityForm<TEntity, TEntityLink>
            where TEntity : Entity, new()
            where TEntityLink : EntityLink<TEntity>, new()
        {
            return CanEditForm(typeof(TForm), Form, Entity);
        }
    }
}