DymWebForm-Archive/DymWebForm/DymWebFormControlMappnig.cs

using System;
using System.Collections.Generic;
using System.Web.UI;
using System.Web.UI.WebControls;
using DymWebForm.Common;
using DymWebForm.Common.BasicDataType;
using DymWebForm.Common.Linq;
using DymWebForm.Controls;

namespace DymWebForm
{
    public class DymWebFormControlMappnig
    {
        private readonly Type _typControl;

        private readonly Action<object> _delInitControl;

        public Action<object, object> ControlSetValue { get; set; }

        public Func<object, object> ControlGetValue { get; private set; }

        public DymWebFormValidation Validation { get; set; }

        //
        internal WebControl CreateControl()
        {
            var c = (WebControl)Activator.CreateInstance(_typControl);

            if (_delInitControl != null)
                _delInitControl(c);

            return c;
        }

        //

        private DymWebFormControlMappnig(Type controlType, Action<object> controlInit, Action<object, object> controlSetValue, Func<object, object> controlGetValue, DymWebFormValidation validation)
        {
            this._typControl = controlType;
            this._delInitControl = controlInit;
            this.ControlSetValue = controlSetValue;
            this.ControlGetValue = controlGetValue;
            this.Validation = validation;
        }

        //

        private static Dictionary<Type, Dictionary<Type, DymWebFormControlMappnig>> ms_dicMapping;

        public static void SetControlMapping<TDataType, TControl, TValidation>(
            Action<TControl, TValidation> init
            , Action<TControl, TDataType> setValueToControl
            , Func<TControl, TDataType> getValueFromControl
            , TValidation validation) where TControl : WebControl, new()
                                      where TValidation : DymWebFormValidation
        {
            if (false == ms_dicMapping.ContainsKey(typeof(TDataType)))
            {
                ms_dicMapping[typeof(TDataType)] = new Dictionary<Type, DymWebFormControlMappnig>();
            }

            ms_dicMapping[typeof(TDataType)][typeof(TValidation)] = new DymWebFormControlMappnig(
                    typeof(TControl)
                    , init == null ? null : new Action<object>(c => init((TControl)c, validation))
                    , (c, d) => setValueToControl((TControl)c, (TDataType)d)
                    , c => getValueFromControl((TControl)c)
                    , validation
            );
        }

        //internal for cctor

        private static void Bdts<TD>(ITextControl c, TD d)
        {
            if (d != null)
                c.Text = d.ToString();
        }

        private static T Bdcv<T>(TextBox c) where T : struct
        {
            return TypeParser<T>.Convert(c.Text);
        }

        private static T? Bdcvn<T>(TextBox c) where T : struct
        {
            return TypeParser<T>.ConvertNullable(c.Text);
        }

        //init bulid-in

        static DymWebFormControlMappnig()
        {
            ms_dicMapping = new Dictionary<Type, Dictionary<Type, DymWebFormControlMappnig>>();

            SetControlMapping<string, TextBox, DymWebFormDefaultValidation>(null, Bdts, c => c.Text, null);
            SetControlMapping<string, TextBox, DymWebFormEmailValidation>(null, Bdts, c => c.Text, new DymWebFormEmailValidation());
            SetControlMapping<string, TextBox, DynWebFormPasswordValidation>((t, v) => t.TextMode = TextBoxMode.Password, Bdts, c => c.Text, new DynWebFormPasswordValidation());
            SetControlMapping<string, TextArea, DymWebFormTextAreaValidation>((t, v) =>
            {
                t.Columns = v.Cols;
                t.Rows = v.Rows;
            }, Bdts, c => c.Text, new DymWebFormTextAreaValidation());

            SetControlMapping<int, TextBox, DymWebFormDefaultValidation>(null, Bdts, Bdcv<int>, new DymWebFormDefaultValidation(ValidationDataType.Integer));
            SetControlMapping<uint, TextBox, DymWebFormDefaultValidation>(null, Bdts, Bdcv<uint>, new DymWebFormDefaultValidation(ValidationDataType.Integer));

            SetControlMapping<int?, TextBox, DymWebFormDefaultValidation>(null, Bdts, Bdcvn<int>, new DymWebFormDefaultValidation(ValidationDataType.Integer));
            SetControlMapping<uint?, TextBox, DymWebFormDefaultValidation>(null, Bdts, Bdcvn<uint>, new DymWebFormDefaultValidation(ValidationDataType.Integer));

            SetControlMapping<long, TextBox, DymWebFormDefaultValidation>(null, Bdts, Bdcv<long>, new DymWebFormDefaultValidation(ValidationDataType.Integer));

            SetControlMapping<float, TextBox, DymWebFormDefaultValidation>(null, Bdts, Bdcv<float>, new DymWebFormDefaultValidation(ValidationDataType.Double));
            SetControlMapping<double, TextBox, DymWebFormDefaultValidation>(null, Bdts, Bdcv<double>, new DymWebFormDefaultValidation(ValidationDataType.Double));
            SetControlMapping<double?, TextBox, DymWebFormDefaultValidation>(null, Bdts, Bdcvn<double>, new DymWebFormDefaultValidation(ValidationDataType.Double));
            SetControlMapping<decimal, TextBox, DymWebFormDefaultValidation>(null, Bdts, Bdcv<decimal>, new DymWebFormDefaultValidation(ValidationDataType.Double));

            SetControlMapping<DateTime, DateTimeTextBox, DwfDateTimeValidation>(null, Bdts, Bdcv<DateTime>, new DwfDateTimeValidation());
            SetControlMapping<DateTime?, DateTimeTextBox, DwfDateTimeValidation>(null, Bdts, Bdcvn<DateTime>, new DwfDateTimeValidation());

            SetControlMapping<bool, CheckBox, DymWebFormDefaultValidation>(null, (c, d) => c.Checked = d, c => c.Checked, null);

            SetControlMapping<Guid, TextBox, DwfGuidValidation>(null, Bdts, c => new Guid(c.Text), new DwfGuidValidation());
            SetControlMapping<Guid?, TextBox, DwfGuidValidation>(null, Bdts, c => string.IsNullOrEmpty(c.Text) ? (Guid?)null : new Guid(c.Text), new DwfGuidValidation());
        }

        //static

        internal static DymWebFormControlMappnig GetInst(Type dataType, Type validationType)
        {
            if (false == ms_dicMapping.ContainsKey(dataType))
                throw new ArgumentException("Not registed data type:" + dataType);

            if (validationType == null)
                return ms_dicMapping[dataType].FirstValue();

            if (false == ms_dicMapping[dataType].ContainsKey(validationType))
                throw new ArgumentException("Not registed validation type of the data type:" + validationType);

            return ms_dicMapping[dataType][validationType];
        }
    }

    public abstract class DymWebFormValidation
    {
        private enum ControlType
        {
            None,
            Basic,
            Regexp,
            Custom,
        }

        private ControlType m_ControlType;

        //basic
        private ValidationDataType m_vdtCompareValidatorDataType;

        //cuctom
        private ServerValidateEventHandler m_svCustomValidate;

        private string m_strClientValidateJs;

        //regexp
        private string m_regexp;

        //ctor
        public DymWebFormValidation(ValidationDataType vdt)
        {
            m_ControlType = ControlType.Basic;
            m_vdtCompareValidatorDataType = vdt;
        }

        public DymWebFormValidation(ServerValidateEventHandler sve, string clientValidateJS = null)
        {
            m_ControlType = ControlType.Custom;
            m_svCustomValidate = sve;
            m_strClientValidateJs = clientValidateJS;
        }

        public DymWebFormValidation(string regexp)
        {
            m_ControlType = ControlType.Regexp;
            m_regexp = regexp;
        }

        public DymWebFormValidation()
        {
            m_ControlType = ControlType.None;
        }

        //get
        internal BaseValidator CreateValidator(Control container)
        {
            switch (m_ControlType)
            {
                case ControlType.None:
                    return new CustomValidator() { Enabled = false };
                case ControlType.Basic:
                    return new CompareValidator()
                    {
                        Operator = ValidationCompareOperator.DataTypeCheck,
                        Type = m_vdtCompareValidatorDataType
                    };

                case ControlType.Regexp:
                    return new RegularExpressionValidator()
                    {
                        ValidationExpression = m_regexp,
                    };

                case ControlType.Custom:
                    var cv = new CustomValidator();
                    cv.ServerValidate += m_svCustomValidate;

                    if (string.IsNullOrEmpty(m_strClientValidateJs) == false)
                    {
                        cv.ClientValidationFunction = ""
                            //+ "DWF" + "_"
                            + "ClientValidationFunction"
                            //+ "_" + this.GetType().Name
                            + "_" + m_strClientValidateJs
                                        .GetHashCode()
                                        .ToBytes()
                                        .ToHexString();

                        var js =
                             "function " + cv.ClientValidationFunction + "(source, arguments){"
                             + m_strClientValidateJs
                             + "}";

                        ScriptManager.RegisterClientScriptBlock(container.Page, container.Page.GetType(), cv.ClientValidationFunction, js, true);
                    }
                    return cv;

                default:
                    throw new Exception("Unknown Validation ControlType");
            }
        }
    }

    public sealed class DwfGuidValidation : DymWebFormValidation
    {
        private static string clientValidateJS =
            "arguments.IsValid="
                + "/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i"
                + ".test(arguments.Value);";

        private static void Validation(object source, ServerValidateEventArgs args)
        {
            try
            {
                new Guid(args.Value);
                args.IsValid = true;
            }
            catch (Exception)
            {
                args.IsValid = false;
            }
        }

        public DwfGuidValidation()
            : base(Validation, clientValidateJS)
        {
        }
    }

    public sealed class DwfDateTimeValidation : DymWebFormValidation
    {
        private static string clientValidateJS =
            "arguments.IsValid=!isNaN(new Date(arguments.Value).getMilliseconds());";

        private static void Validation(object source, ServerValidateEventArgs args)
        {
            DateTime tmp;
            args.IsValid = DateTime.TryParse(args.Value, out tmp);
        }

        public DwfDateTimeValidation()
            : base(Validation, clientValidateJS)
        {
        }
    }

    public sealed class DymWebFormDefaultValidation : DymWebFormValidation
    {
        public DymWebFormDefaultValidation(ValidationDataType vdt)
            : base(vdt)
        {
        }

        public DymWebFormDefaultValidation(ServerValidateEventHandler sve, string clientValidateJS = null)
            : base(sve, clientValidateJS)
        {
        }
    }

    public sealed class DymWebFormEmailValidation : DymWebFormValidation
    {
        public DymWebFormEmailValidation()
            : base(@"^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$")
        {
        }
    }

    public sealed class DynWebFormPasswordValidation : DymWebFormValidation
    {
    }

    public sealed class DymWebFormTextAreaValidation : DymWebFormValidation
    {
        public int Cols { get; private set; }
        public int Rows { get; private set; }

        public DymWebFormTextAreaValidation(int cols = 30, int rows = 5)
        {
            Cols = cols;
            Rows = rows;
        }
    }
}