AjaxControlToolkit.MaskedEditValidator.EvaluateIsValid C# (CSharp) 메소드

EvaluateIsValid() 보호된 메소드

protected EvaluateIsValid ( ) : bool
리턴 bool
        protected override bool EvaluateIsValid()
        {
            var maskExt = (MaskedEditExtender)FindControl(ControlExtender);
            var target = (TextBox)maskExt.FindControl(ControlToValidate);

            base.ErrorMessage = String.Empty;
            base.Text = String.Empty;

            var cssError = String.Empty;
            var ok = true;

            if(!IsValidEmpty)
                if(target.Text.Trim() == InitialValue) {
                    base.ErrorMessage = EmptyValueMessage;
                    if(String.IsNullOrEmpty(EmptyValueBlurredText))
                        base.Text = base.ErrorMessage;
                    else
                        base.Text = EmptyValueBlurredText;

                    cssError = maskExt.OnInvalidCssClass;
                    ok = false;
                }

            if(ok && target.Text.Length != 0 && ValidationExpression.Length != 0)
                try {
                    var regex = new Regex(ValidationExpression);
                    ok = regex.IsMatch(target.Text);
                }
                catch {
                    ok = false;
                }

            if(ok && target.Text.Length != 0) {
                var culture = maskExt.CultureName;
                if(String.IsNullOrEmpty(culture))
                    culture = CultureInfo.CurrentCulture.Name;

                ControlCulture = CultureInfo.GetCultureInfo(culture);
                var cultureAMPMP = String.Empty;

                if(!String.IsNullOrEmpty(ControlCulture.DateTimeFormat.AMDesignator) && !String.IsNullOrEmpty(ControlCulture.DateTimeFormat.PMDesignator))
                    cultureAMPMP = ControlCulture.DateTimeFormat.AMDesignator + ";" + ControlCulture.DateTimeFormat.PMDesignator;

                switch(maskExt.MaskType) {
                    case MaskedEditType.Number:
                        try {
                            var numval = Decimal.Parse(target.Text, ControlCulture);
                        }
                        catch {
                            ok = false;
                        }
                        break;
                    case MaskedEditType.DateTime:
                    case MaskedEditType.Date:
                    case MaskedEditType.Time:
                        var tamtext = target.Text.Length;
                        // gmorgan (25/06/2007) - Added check for AcceptAMPM in MaskedEditExtender to fix bug
                        // with validation in 24hr mode.
                        if(maskExt.AcceptAMPM &&
                            !String.IsNullOrEmpty(cultureAMPMP) &&
                            (maskExt.MaskType == MaskedEditType.Time || maskExt.MaskType == MaskedEditType.DateTime)) {

                            var charSeparators = new char[] { ';' };
                            var arrAMPM = cultureAMPMP.Split(charSeparators);
                            if(arrAMPM[0].Length != 0)
                                tamtext -= (arrAMPM[0].Length + 1);
                        }
                        var expectedLength = MaskedEditCommon.GetValidMask(maskExt.Mask).Length;
                        if(maskExt.MaskType != MaskedEditType.Time) {
                            var currentCultureDateSeparatorLength =
                                (String.IsNullOrEmpty(maskExt.CultureName) ? CultureInfo.CurrentCulture : CultureInfo.GetCultureInfo(maskExt.CultureName)).DateTimeFormat.DateSeparator.Length;
                            // there are always 2 separators, and each separator adds to the expected length by the amount over size 1 that it is.
                            expectedLength += (currentCultureDateSeparatorLength - 1) * 2;
                        }
                        if(expectedLength != tamtext)
                            ok = false;

                        if(ok)
                            try {
                                var dtval = DateTime.Parse(target.Text, ControlCulture);
                            }
                            catch {
                                ok = false;
                            }

                        break;
                }

                if(!ok) {
                    base.ErrorMessage = InvalidValueMessage;
                    if(String.IsNullOrEmpty(InvalidValueBlurredMessage))
                        base.Text = base.ErrorMessage;
                    else
                        base.Text = InvalidValueBlurredMessage;

                    cssError = maskExt.OnInvalidCssClass;
                }

                if(ok && (!String.IsNullOrEmpty(MaximumValue) || !String.IsNullOrEmpty(MinimumValue))) {
                    switch(maskExt.MaskType) {
                        case MaskedEditType.None: {
                                int lenvalue;
                                if(!String.IsNullOrEmpty(MaximumValue)) {
                                    try {
                                        lenvalue = Int32.Parse(MaximumValue, ControlCulture);
                                        ok = (lenvalue >= target.Text.Length);
                                    }
                                    catch {
                                        base.ErrorMessage = InvalidValueMessage;
                                        if(String.IsNullOrEmpty(InvalidValueBlurredMessage))
                                            base.Text = base.ErrorMessage;
                                        else
                                            base.Text = InvalidValueBlurredMessage;

                                        ok = false;
                                    }

                                    if(!ok) {
                                        base.ErrorMessage = MaximumValueMessage;
                                        if(String.IsNullOrEmpty(MaximumValueBlurredMessage))
                                            base.Text = base.ErrorMessage;
                                        else {
                                            base.Text = MaximumValueBlurredMessage;
                                        }

                                        cssError = maskExt.OnInvalidCssClass;
                                    }
                                }

                                if(ok && !String.IsNullOrEmpty(MinimumValue)) {
                                    try {
                                        lenvalue = Int32.Parse(MinimumValue, ControlCulture);
                                        ok = (lenvalue <= target.Text.Length);
                                    }
                                    catch {
                                        base.ErrorMessage = InvalidValueMessage;
                                        if(String.IsNullOrEmpty(InvalidValueBlurredMessage))
                                            base.Text = base.ErrorMessage;
                                        else
                                            base.Text = InvalidValueBlurredMessage;

                                        ok = false;
                                    }
                                    if(!ok) {
                                        base.ErrorMessage = MinimumValueMessage;
                                        if(String.IsNullOrEmpty(MinimumValueBlurredText))
                                            base.Text = base.ErrorMessage;
                                        else
                                            base.Text = MinimumValueBlurredText;

                                        cssError = maskExt.OnInvalidCssClass;
                                    }
                                }
                                break;
                            }
                        case MaskedEditType.Number: {
                                var numval = Decimal.Parse(target.Text, ControlCulture);
                                decimal compval;

                                if(!String.IsNullOrEmpty(MaximumValue)) {
                                    try {
                                        compval = Decimal.Parse(MaximumValue, ControlCulture);
                                        ok = (compval >= numval);
                                    }
                                    catch {
                                        ok = false;
                                    }
                                    if(!ok) {
                                        base.ErrorMessage = MaximumValueMessage;
                                        if(String.IsNullOrEmpty(MaximumValueBlurredMessage))
                                            base.Text = base.ErrorMessage;
                                        else
                                            base.Text = MaximumValueBlurredMessage;

                                        cssError = maskExt.OnInvalidCssClass;
                                    }
                                }

                                if(ok && !String.IsNullOrEmpty(MinimumValue)) {
                                    try {
                                        compval = Decimal.Parse(MinimumValue, ControlCulture);
                                        ok = (compval <= numval);
                                    }
                                    catch {
                                        ok = false;
                                    }

                                    if(!ok) {
                                        base.ErrorMessage = MinimumValueMessage;
                                        if(String.IsNullOrEmpty(MinimumValueBlurredText))
                                            base.Text = base.ErrorMessage;
                                        else
                                            base.Text = MinimumValueBlurredText;

                                        cssError = maskExt.OnInvalidCssClass;
                                    }
                                }
                                break;
                            }
                        case MaskedEditType.DateTime:
                        case MaskedEditType.Date:
                        case MaskedEditType.Time: {
                                var dtval = DateTime.Parse(target.Text, ControlCulture);
                                DateTime dtCompval;

                                if(!String.IsNullOrEmpty(MaximumValue)) {
                                    try {
                                        dtCompval = DateTime.Parse(MaximumValue, ControlCulture);
                                        ok = (dtCompval >= dtval);
                                    }
                                    catch {
                                        ok = false;
                                    }

                                    if(!ok) {
                                        base.ErrorMessage = MaximumValueMessage;
                                        if(String.IsNullOrEmpty(MaximumValueBlurredMessage))
                                            base.Text = base.ErrorMessage;
                                        else
                                            base.Text = MaximumValueBlurredMessage;

                                        cssError = maskExt.OnInvalidCssClass;
                                    }
                                }
                                if(ok && !String.IsNullOrEmpty(MinimumValue)) {
                                    try {
                                        dtCompval = DateTime.Parse(MinimumValue, ControlCulture);
                                        ok = (dtCompval <= dtval);
                                    }
                                    catch {
                                        ok = false;
                                    }
                                    if(!ok) {
                                        base.ErrorMessage = MinimumValueMessage;
                                        if(String.IsNullOrEmpty(MinimumValueBlurredText))
                                            base.Text = base.ErrorMessage;
                                        else
                                            base.Text = MinimumValueBlurredText;

                                        cssError = maskExt.OnInvalidCssClass;
                                    }
                                }
                                break;
                            }
                    }
                }
            }

            if(ok && MaskedEditServerValidator != null) {
                var serverValidateEventArgs = new ServerValidateEventArgs(target.Text, ok);
                MaskedEditServerValidator(target, serverValidateEventArgs);
                ok = serverValidateEventArgs.IsValid;
                if(!ok) {
                    cssError = maskExt.OnInvalidCssClass;
                    base.ErrorMessage = InvalidValueMessage;
                    if(String.IsNullOrEmpty(InvalidValueBlurredMessage))
                        base.Text = base.ErrorMessage;
                    else
                        base.Text = InvalidValueBlurredMessage;
                }
            }
            if(!ok) {
                // set CSS at server for browser with not implement client validator script (FF, others)
                //MaskedEditSetCssClass(value,CSS)
                var script = "MaskedEditSetCssClass(" + ClientID + ",'" + cssError + "');";
                ScriptManager.RegisterStartupScript(this, typeof(MaskedEditValidator), "MaskedEditServerValidator_" + ID, script, true);
            }
            return ok;
        }