internal override void RegisterClientRules(InputControlBase ctlInputControl) { if (!string.IsNullOrEmpty(this.Rule)) { DoRegisterValidator(ctlInputControl, this.Rule, this.Params, null); } }
/// <summary> /// 1) Script to automatically check the associated button when the value in the input control is /// manipulated by the user. /// 2) Script to prevent all other validations if the filter is being disabled /// </summary> /// <param name="ctlInputControl">The control with which the filter is associated</param> /// <exception cref="NotImplementedException"></exception> /// <remarks> /// <para> /// A dummy validation rule, which always returns true, called <c>filter</c> is associated with the input control. /// A client script is associated with the <see cref="InputControlBase.ClientChangeEventName"/> event of the control /// specified in <see cref="ValidatorBase.DependsOn"/>. This client script toggles the /// <see cref="JQueryScriptManager.CssClassIgnoreValidation"/> depending on whether the dependency is satisfied or not. /// </para> /// </remarks> internal override void RegisterClientRules(InputControlBase ctlInputControl) { const string NEW_RULE = @" $.validator.addMethod('filter', function() { return true; }); function filter_fixDependent(elementSelector) { var $element = $(elementSelector); var filter = $element.closest('form').validate().settings.rules[$element.attr('name')].filter; var keepRule = filter.depends.call($element[0], $element[0]); $element.toggleClass('val-ignore', !keepRule); } "; JQueryScriptManager.Current.RegisterScriptBlock("filter_validator", NEW_RULE); //ctlInputControl.ClientIdRequired = true; // Since we are referencing it in the function DoRegisterValidator(ctlInputControl, "filter", true, null); string onDependeeChange = string.Format(@"function (e) {{ filter_fixDependent('{0}'); }}", ctlInputControl.GetClientCode(ClientCodeType.InputSelector)); if (this.DependsOnState == DependsOnState.Custom) { //TODO: The programmer is responsible for creating the client side vent handler throw new NotImplementedException(); } InputControlBase ctlRadio = GetDependsOnControl(ctlInputControl); if (ctlRadio != null) { ctlRadio.ClientEvents.Add(ctlRadio.ClientChangeEventName, onDependeeChange); } return; }
/// <summary> /// Performs server side valdiation /// </summary> /// <param name="ctlInputControl">The control to be validated</param> /// <returns>true if validation succeeds</returns> /// <remarks> /// Accesses the abstract <see cref="P:EclipseLibrary.Web.JQuery.Input.InputControlBase.Value"/> property /// of <see cref="InputControlBase"/> base class and returns true if the returned value in non empty after trimming. /// </remarks> protected override bool OnServerValidate(InputControlBase ctlInputControl) { if (ctlInputControl.Value == null || string.IsNullOrEmpty(ctlInputControl.Value.Trim())) { ctlInputControl.ErrorMessage = string.Format("{0} is required", ctlInputControl.FriendlyName); ctlInputControl.IsValid = false; } return(base.OnServerValidate(ctlInputControl)); }
// ReSharper restore EventNeverSubscribedTo.Global /// <summary> /// This is called during the server validation cycle and performs the same validation on server side. /// Derived classes should override this function and call the base class first. If the base class /// returns false, they should do nothing else. Otherwise they must perform their validations. /// </summary> /// <param name="ctlInputControl"></param> /// <returns>true if validation should continue for this control, false otherwise</returns> public bool Validate(InputControlBase ctlInputControl) { bool bNeedsToBeValidated = string.IsNullOrEmpty(this.DependsOn) || PerformDependencyCheck(ctlInputControl); if (bNeedsToBeValidated) { ctlInputControl.IsValid = true; return(OnServerValidate(ctlInputControl)); } return(ServerValidationBypassed(ctlInputControl)); }
// ReSharper restore EventNeverSubscribedTo.Global /// <summary> /// Provide code to perform server side validation /// </summary> /// <param name="ctlInputControl"></param> /// <returns>true if other validators should be invoked</returns> /// <remarks> /// <para> /// Validation is stopped if the validator fails /// </para> /// </remarks> protected virtual bool OnServerValidate(InputControlBase ctlInputControl) { if (ServerValidate != null) { ServerValidateEventArgs args = new ServerValidateEventArgs { ControlToValidate = ctlInputControl }; ServerValidate(this, args); } return(ctlInputControl.IsValid); }
/// <summary> /// Helper function to register the validation rule with the script manager. /// If ID has been specified, cloneScript is used to clone the rule /// </summary> /// <param name="ctlInputControl">The control for which client validation needs to be registered</param> /// <param name="ruleName">The name of the client validation rule</param> /// <param name="jqRuleParams">Parameters to pass to the rule in javascript syntax</param> /// <param name="defaultMsg">Used only if MessageFormatString is empty</param> protected void DoRegisterValidator(InputControlBase ctlInputControl, string ruleName, object jqRuleParams, object defaultMsg) { object script = GetDependencyFunction(ctlInputControl); if (script != null) { JQueryOptions options = new JQueryOptions(); options.Add("param", jqRuleParams); options.Add("depends", script); jqRuleParams = options; } object msg; if (!string.IsNullOrEmpty(this.ClientMessageFunction)) { msg = new JScriptCode(this.ClientMessageFunction); } else if (!string.IsNullOrEmpty(this.ClientMessage)) { // Special handling. Show row number when control within grid. GridViewRow row = ctlInputControl.NamingContainer as GridViewRow; if (row == null) { msg = this.ClientMessage; } else { msg = string.Format("Row {0}: ", row.RowIndex + 1) + this.ClientMessage; } } else if (defaultMsg is string) { // Special handling. Show row number when control within grid. GridViewRow row = ctlInputControl.NamingContainer as GridViewRow; if (row == null) { msg = defaultMsg; } else { msg = string.Format("Row {0}: ", row.RowIndex + 1) + defaultMsg; } } else { msg = defaultMsg; } JQueryScriptManager.Current.AddValidationRule(ctlInputControl, ruleName, jqRuleParams, msg); }
/// <summary> /// Crete rules for Min and Max. /// </summary> /// <param name="ctlInputControl"></param> private void RegisterNumericRules(InputControlBase ctlInputControl) { string script; if (this.Min.HasValue) { // Sharad 21 Sep 2010: making min numeric specific. Tolerates commas script = @"$.validator.addMethod('greaterthan', function(value, element, params) { if (this.optional(element)) { return true; } var val = Number(value.replace(/,/g, '')); return isNaN(val) || val >= params; });"; JQueryScriptManager.Current.RegisterScriptBlock("greaterthan_validator", script); DoRegisterValidator(ctlInputControl, "greaterthan", this.Min, string.Format("{0} must be {{0}} or more", ctlInputControl.FriendlyName)); } if (this.Max.HasValue) { // Sharad 21 Sep 2010: making min numeric specific. Tolerates commas script = @"$.validator.addMethod('lessthan', function(value, element, params) { if (this.optional(element)) { return true; } var val = Number(value.replace(/,/g, '')); return isNaN(val) || val <= params; });"; JQueryScriptManager.Current.RegisterScriptBlock("lessthan_validator", script); DoRegisterValidator(ctlInputControl, "max", this.Max, string.Format("{0} must be {{0}} or less", ctlInputControl.FriendlyName)); } if (!string.IsNullOrEmpty(this.MinControlID)) { // param is the selector of the associated control script = @"if (this.optional(element)) return true; var thisVal = Number(value); var otherVal = Number($(param).val()); if (isNaN(otherVal) || isNaN(thisVal)) return true; return thisVal >= otherVal;"; string newRule = "$.validator.addMethod('minfromctl', function(value, element, param) {" + script + "});"; JQueryScriptManager.Current.RegisterScriptBlock("minfromctl_validator", newRule); InputControlBase ctlMin = (InputControlBase)ctlInputControl.NamingContainer.FindControl(this.MinControlID); string jqParam = ctlMin.ClientSelector; string jqMsg = string.Format("'{0} must be same as or more than {1}'", ctlInputControl.FriendlyName, ctlMin.FriendlyName); DoRegisterValidator(ctlInputControl, "minfromctl", jqParam, jqMsg); } }
/// <summary> /// /// </summary> /// <param name="ctlInputControl"></param> /// <returns>true if dependency check succeeds</returns> internal bool PerformDependencyCheck(InputControlBase ctlInputControl) { bool bNeedsToBeValidated; InputControlBase ctlDependsOn; switch (this.DependsOnState) { case DependsOnState.Checked: // Validate only of value is non empty ctlDependsOn = GetDependsOnControl(ctlInputControl); bNeedsToBeValidated = !string.IsNullOrWhiteSpace(ctlDependsOn.Value); break; case DependsOnState.Unchecked: // Validate only if value is empty ctlDependsOn = GetDependsOnControl(ctlInputControl); bNeedsToBeValidated = string.IsNullOrWhiteSpace(ctlDependsOn.Value); break; case DependsOnState.Value: ctlDependsOn = GetDependsOnControl(ctlInputControl); bNeedsToBeValidated = ctlDependsOn.Value.Trim() == this.DependsOnValue; break; case DependsOnState.AnyValue: ctlDependsOn = GetDependsOnControl(ctlInputControl); bNeedsToBeValidated = this.DependsOnValue.Contains(ctlDependsOn.Value.Trim()); break; case DependsOnState.Selector: case DependsOnState.Custom: DependencyCheckEventArgs args = new DependencyCheckEventArgs { ControlToValidate = ctlInputControl }; OnServerDependencyCheck(args); bNeedsToBeValidated = args.NeedsToBeValdiated; break; case DependsOnState.NotSet: bNeedsToBeValidated = false; break; default: throw new NotImplementedException(); } return(bNeedsToBeValidated); }
/// <summary> /// Returns the associated From control /// </summary> /// <param name="ctlInputControl"></param> /// <returns></returns> public TextBoxEx GetFromControl(InputControlBase ctlInputControl) { TextBoxEx tbFrom; if (string.IsNullOrEmpty(this.AssociatedControlID)) { // Previous control is From Date tbFrom = ctlInputControl.Parent.Controls.OfType <TextBoxEx>().Reverse() .SkipWhile(p => p != ctlInputControl).Skip(1).First(); } else { tbFrom = (TextBoxEx)ctlInputControl.FindControl(this.AssociatedControlID); } return(tbFrom); }
/// <summary> /// Attach a datepicker with the textbox /// </summary> /// <param name="ctlInputControl"></param> private void RegisterDatePicker(InputControlBase ctlInputControl) { JQueryOptions options = new JQueryOptions(); options.Add("showOn", "button"); string script; if (this.Min.HasValue) { options.Add("minDate", this.Min.Value); options.Add("origMinDays", this.Min.Value); } if (this.Max.HasValue) { options.Add("maxDate", this.Max.Value); options.Add("origMaxDays", this.Max.Value); } script = string.Format("$('{0}').datepicker({1});", ctlInputControl.ClientSelector, options); JQueryScriptManager.Current.RegisterReadyScript(script); }
/// <summary> /// Attempts to find the control in the naming container of the passed control and all naming containers /// above it. Throws an exception if the control cannot be resolved. /// </summary> /// <param name="ctl"></param> /// <exception cref="NotImplementedException"></exception> /// <returns></returns> protected InputControlBase GetDependsOnControl(InputControlBase ctl) { switch (this.DependsOnState) { case DependsOnState.Checked: case DependsOnState.Unchecked: case DependsOnState.Value: case DependsOnState.AnyValue: break; case DependsOnState.NotSet: case DependsOnState.Custom: case DependsOnState.Selector: return(null); default: throw new NotImplementedException(); } if (_dependsOnControl == null && !string.IsNullOrEmpty(this.DependsOn)) { InputControlBase ctlReturn = null; Control curContainer = ctl; while (ctlReturn == null && !(curContainer is Page)) { curContainer = curContainer.NamingContainer; ctlReturn = (InputControlBase)curContainer.FindControl(this.DependsOn); } if (ctlReturn == null) { string str = string.Format("Control {0} could not be found in any of the naming containers above {1}", this.DependsOn, ctl.ID); throw new ArgumentException(str); } _dependsOnControl = ctlReturn; } return(_dependsOnControl); }
internal void CreateCascadeScripts(InputControlBase ctlPassed) { if (string.IsNullOrEmpty(this.WebMethod)) { // We are not cascadable. Nothing to do. return; } string loadData = ctlPassed.GetClientCode(ClientCodeType.LoadData); // If there is no way to load data, then we are not cascadable even if web method has been specified. // AutoComplete provides its own implementation for cascadable properties if (string.IsNullOrEmpty(loadData)) { return; } string str; // JSON stringifies data passed to the web method JQueryScriptManager.Current.RegisterScripts(ScriptTypes.Json | ScriptTypes.Core | ScriptTypes.Cascade); JQueryOptions options = new JQueryOptions(); if (!string.IsNullOrEmpty(this.CascadeParentId)) { InputControlBase ctlParent = (InputControlBase)ctlPassed.NamingContainer.FindControl(this.CascadeParentId); if (ctlParent == null) { str = string.Format("Could not find cascade parent {0}", this.CascadeParentId); throw new InvalidOperationException(str); } options.Add("parentChangeEventName", ctlParent.ClientChangeEventName); options.AddRaw("parentValue", ctlParent.GetClientCode(ClientCodeType.GetValue)); options.Add("cascadeParentSelector", ctlParent.ClientSelector); //ctlParent.ClientIdRequired = true; } if (string.IsNullOrEmpty(this.WebServicePath)) { options.Add("webServicePath", ctlPassed.Page.Request.Path); } else { options.Add("webServicePath", ctlPassed.Page.ResolveUrl(this.WebServicePath)); } options.Add("webMethodName", this.WebMethod); options.AddRaw("loadData", loadData); str = ctlPassed.GetClientCode(ClientCodeType.PreLoadData); if (!string.IsNullOrEmpty(str)) { options.AddRaw("preLoadData", str); } options.Add("interestEvent", ctlPassed.GetClientCode(ClientCodeType.InterestEvent)); //if (!ctlPassed.Page.IsPostBack && this.InitializeAtStartup) if (this.InitializeAtStartup) { options.Add("initializeAtStartup", this.InitializeAtStartup); } //if (this.HideParentsFromChildren) //{ // options.Add("hideParentsFromChildren", true); //} str = string.Format(".cascade({0})", options.ToJson()); ctlPassed.ReadyScripts.Add(str); }
protected virtual bool ServerValidationBypassed(InputControlBase ctlInputControl) { return(false); }
/// <summary> /// Registers the rules for client validation /// </summary> /// <param name="ctlInputControl"></param> internal override void RegisterClientRules(InputControlBase ctlInputControl) { string msg; if (_isDirty && !ctlInputControl.EnableViewState) { msg = string.Format("Since you are updating validator property values dynamically, EnableViewState must be true for {0}", ctlInputControl.ID); throw new HttpException(msg); } //string script; switch (this.ValueType) { case ValidationValueType.String: if (this.Min.HasValue || this.Max.HasValue) { throw new NotSupportedException(ctlInputControl.ID + ": Min and Max are not supported for string values"); } break; case ValidationValueType.Integer: if (this.Min.HasValue && this.Min >= 0) { DoRegisterValidator(ctlInputControl, "digits", true, string.Format("{0} must contain only digits", ctlInputControl.FriendlyName)); } else { // Creating a new rule which allows leading negative character string newRule = @"$.validator.addMethod('integer', function(value, element, params) { return this.optional(element) || /^-{0,1}\d+$/.test(value); });"; JQueryScriptManager.Current.RegisterScriptBlock("integer_validator", newRule); DoRegisterValidator(ctlInputControl, "integer", true, string.Format("{0} must contain only digits, with an optional leading minus sign", ctlInputControl.FriendlyName)); } RegisterNumericRules(ctlInputControl); break; case ValidationValueType.Decimal: DoRegisterValidator(ctlInputControl, "number", true, string.Format("{0} must be a valid decimal number", ctlInputControl.FriendlyName)); RegisterNumericRules(ctlInputControl); break; default: throw new NotImplementedException(); } if (this.MinLength > 0) { msg = ctlInputControl.GetClientCode(ClientCodeType.MinLengthErrorMessage); DoRegisterValidator(ctlInputControl, "minlength", this.MinLength, msg); } if (this.MaxLength > 0) { msg = ctlInputControl.GetClientCode(ClientCodeType.MaxLengthErrorMessage); DoRegisterValidator(ctlInputControl, "maxlength", this.MaxLength, msg); } }
/// <summary> /// TODO: Date validation /// </summary> /// <param name="ctlInputControl"></param> /// <returns></returns> protected override bool OnServerValidate(InputControlBase ctlInputControl) { if (string.IsNullOrEmpty(ctlInputControl.Value)) { return(true); // Empty values are valid } if (this.MinLength > 0) { if (ctlInputControl is CheckBoxListEx) { ctlInputControl.IsValid = ctlInputControl.Value.Split(new char[] { ',' }).Length >= this.MinLength; ctlInputControl.ErrorMessage = string.Format("Select at least {1} {0}", ctlInputControl.FriendlyName, this.MinLength); } else { ctlInputControl.IsValid = ctlInputControl.Value.Length >= this.MinLength; ctlInputControl.ErrorMessage = string.Format("{0} must contain at least {1} characters", ctlInputControl.FriendlyName, this.MinLength); } } if (!ctlInputControl.IsValid) { return(base.OnServerValidate(ctlInputControl)); } if (this.MaxLength > 0) { if (ctlInputControl is CheckBoxListEx) { ctlInputControl.IsValid = ctlInputControl.Value.Split(new char[] { ',' }).Length <= this.MaxLength; ctlInputControl.ErrorMessage = string.Format("Select at most {1} {0}", ctlInputControl.FriendlyName, this.MaxLength); } else { ctlInputControl.IsValid = ctlInputControl.Value.Length <= this.MaxLength; ctlInputControl.ErrorMessage = string.Format("{0} must contain at most {1} characters", ctlInputControl.FriendlyName, this.MaxLength); } } if (!ctlInputControl.IsValid) { return(base.OnServerValidate(ctlInputControl)); } decimal d; switch (this.ValueType) { case ValidationValueType.String: ctlInputControl.IsValid = true; d = 0; break; case ValidationValueType.Integer: Int64 n; ctlInputControl.IsValid = Int64.TryParse(ctlInputControl.Value, out n); if (ctlInputControl.IsValid) { d = n; } else { ctlInputControl.ErrorMessage = string.Format("{0} must be a valid integer", ctlInputControl.FriendlyName); d = 0; } break; case ValidationValueType.Decimal: ctlInputControl.IsValid = decimal.TryParse(ctlInputControl.Value, out d); if (!ctlInputControl.IsValid) { ctlInputControl.ErrorMessage = string.Format("{0} must be a valid decimal", ctlInputControl.FriendlyName); } break; default: throw new NotImplementedException(); } if (!ctlInputControl.IsValid) { return(base.OnServerValidate(ctlInputControl)); } if (this.Min.HasValue || this.Max.HasValue) { if (this.Min.HasValue && this.Max.HasValue) { ctlInputControl.IsValid = d >= this.Min.Value && d <= this.Max.Value; if (!ctlInputControl.IsValid) { ctlInputControl.ErrorMessage = string.Format(MSG2_BETWEEN, ctlInputControl.FriendlyName); } } else if (this.Min.HasValue) { ctlInputControl.IsValid = d >= this.Min.Value; if (!ctlInputControl.IsValid) { ctlInputControl.ErrorMessage = string.Format(MSG1_MIN, ctlInputControl.FriendlyName, this.Min); } } else if (this.Max.HasValue) { ctlInputControl.IsValid = d <= this.Max.Value; if (!ctlInputControl.IsValid) { ctlInputControl.ErrorMessage = string.Format(MSG1_MAX, ctlInputControl.FriendlyName, this.Max); } } } if (!ctlInputControl.IsValid) { return(base.OnServerValidate(ctlInputControl)); } if (!string.IsNullOrEmpty(this.MinControlID)) { InputControlBase ctlMin = (InputControlBase)ctlInputControl.NamingContainer.FindControl(this.MinControlID); decimal otherVal; if (decimal.TryParse(ctlMin.Value, out otherVal)) { ctlInputControl.IsValid = d >= otherVal; if (!ctlInputControl.IsValid) { ctlInputControl.ErrorMessage = string.Format("{0} must be greater than or equal to {1}", ctlInputControl.FriendlyName, ctlMin.FriendlyName); return(base.OnServerValidate(ctlInputControl)); } } } return(base.OnServerValidate(ctlInputControl)); }
/// <summary> /// Set <see cref="InputControlBase.FilterDisabled"/> to true. /// </summary> /// <param name="ctlInputControl"></param> /// <returns>false to indicate that validation should not continue</returns> protected override bool ServerValidationBypassed(InputControlBase ctlInputControl) { ctlInputControl.FilterDisabled = true; return(false); }
/// <summary> /// Always returns true. /// </summary> /// <param name="ctlInput"></param> /// <returns>true</returns> /// <remarks> /// <para> /// This valdiator does not perform any server side validation so this function always returns true. /// The base class is not called to prevent arising hte <see cref="ValidatorBase.ServerValidate"/> event. /// </para> /// </remarks> protected override bool OnServerValidate(InputControlBase ctlInput) { return(true); }
private object GetDependencyFunction(InputControlBase ctlInputControl) { switch (this.DependsOnState) { case DependsOnState.Custom: // DependsOn is the custom function if (string.IsNullOrEmpty(this.DependsOn)) { string msg = string.Format("Control {0}: DependsOn must be specified when DependsOnState=Custom", ctlInputControl.ID); throw new InvalidOperationException(msg); } return(new JScriptCode(this.DependsOn)); case DependsOnState.Selector: // DependsOn is the custom function if (string.IsNullOrEmpty(this.DependsOn)) { string msg = string.Format("Control {0}: DependsOn must be specified when DependsOnState=Custom", ctlInputControl.ID); throw new InvalidOperationException(msg); } return(this.DependsOn); case DependsOnState.NotSet: return(null); } InputControlBase ctlDependsOn = GetDependsOnControl(ctlInputControl); if (ctlDependsOn == null) { return(null); } StringBuilder sb = new StringBuilder("function(element) {"); // We must ensure that the client id of ctlDependsOn is generated because our script will be referencing it //ctlDependsOn.ClientIdRequired = true; sb.AppendFormat("var $dependee = $('#{0}', $(element).closest('form'));", ctlDependsOn.ClientID); sb.AppendFormat("var valDependee = ({0}).call($dependee[0]);", ctlDependsOn.GetClientCode(ClientCodeType.GetValue)); switch (this.DependsOnState) { case DependsOnState.Checked: sb.Append("var okToValidate = (valDependee != '');"); break; case DependsOnState.Unchecked: sb.Append("var okToValidate = (valDependee == '');"); break; case DependsOnState.Value: sb.AppendFormat("var okToValidate = (valDependee == '{0}');", this.DependsOnValue); break; case DependsOnState.AnyValue: JavaScriptSerializer ser = new JavaScriptSerializer(); string str = ser.Serialize(this.DependsOnValue.Split(',')); sb.AppendFormat("var okToValidate = ($.inArray(valDependee, {0}) >= 0);", str); break; default: throw new NotImplementedException(); } sb.Append("return okToValidate;"); sb.Append("}"); return(new JScriptCode(sb.ToString())); }
/// <summary> /// You can set the control directly instead of setting <see cref="DependsOn"/> /// </summary> /// <param name="dependsOnControl"></param> public void SetDependsOnControl(InputControlBase dependsOnControl) { _dependsOnControl = dependsOnControl; }
/// <summary> /// We only validate that to is less than from. There is no need to validate that from is greter than to. /// </summary> /// <param name="ctlInput"></param> /// <exception cref="NotImplementedException"></exception> /// <returns></returns> protected override bool OnServerValidate(InputControlBase ctlInput) { // We only expect to be associated with a text box TextBoxEx tb = (TextBoxEx)ctlInput; if (string.IsNullOrEmpty(tb.Text)) { return(true); // Empty values are valid } DateTime?value = tb.ValueAsDate; if (!value.HasValue) { ctlInput.ErrorMessage = string.Format(MSG1_VALID, ctlInput.FriendlyName); ctlInput.IsValid = false; return(false); } switch (this.DateType) { case DateType.Default: break; case DateType.ToDate: // Get the previous TextBoxEx TextBoxEx tbFrom = GetFromControl(ctlInput); DateTime? dateFrom = tbFrom.ValueAsDate; if (dateFrom.HasValue) { if (value < dateFrom) { ctlInput.ErrorMessage = string.Format(MSG2_TO_GE_FROM, ctlInput.FriendlyName, tbFrom.FriendlyName); ctlInput.IsValid = false; return(false); } if (this.MaxRange > 0 && (value.Value - dateFrom.Value).TotalDays > this.MaxRange) { ctlInput.IsValid = false; return(false); } } break; default: throw new NotImplementedException(); } if (this.Min.HasValue) { DateTime minDate = DateTime.Today + TimeSpan.FromDays(this.Min.Value); if (value < minDate) { ctlInput.ErrorMessage = string.Format(CultureInfo.CurrentUICulture, MSG2_MINDATE, ctlInput.FriendlyName, minDate); ctlInput.IsValid = false; return(false); } } if (this.Max.HasValue) { DateTime maxDate = DateTime.Today + TimeSpan.FromDays(this.Max.Value); if (value > maxDate) { ctlInput.ErrorMessage = string.Format(CultureInfo.CurrentUICulture, MSG2_MAX, ctlInput.FriendlyName, maxDate); ctlInput.IsValid = false; return(false); } } return(true); }
/// <summary> /// Add client rules for main and max values. Also add a compare validator to the to date /// </summary> /// <param name="ctlInputControl"></param> /// <exception cref="NotImplementedException"></exception> internal override void RegisterClientRules(InputControlBase ctlInputControl) { string param; // date picker utility function provides robust date validation string script = @" if (this.optional(element)) return true; var fmt = $(element).datepicker('option', 'dateFormat'); try { var dt = $.datepicker.parseDate(fmt, value); return true; } catch (err) { return false; } "; string newRule = "$.validator.addMethod('checkdate', function(value, element, param) {" + script + "});"; JQueryScriptManager.Current.RegisterScriptBlock("checkdate_validator", newRule); string msg = string.Format(MSG1_VALID, ctlInputControl.FriendlyName); DoRegisterValidator(ctlInputControl, "checkdate", true, msg); if (this.Min.HasValue) { script = @" if (this.optional(element)) return true; try { var fmt = $(element).datepicker('option', 'dateFormat'); var dt = $.datepicker.parseDate(fmt, value); var minDate = $.datepicker.parseDate(fmt, param); return dt >= minDate; } catch (err) { // If any of the dates is not parseable, we deem ourselves to be valid return true; } "; newRule = "$.validator.addMethod('mindate', function(value, element, param) {" + script + "});"; JQueryScriptManager.Current.RegisterScriptBlock("mindate_validator", newRule); DateTime minDate = DateTime.Today + TimeSpan.FromDays(this.Min.Value); param = string.Format(CultureInfo.CurrentUICulture, "{0:d}", minDate); msg = string.Format(CultureInfo.CurrentUICulture, MSG2_MINDATE, ctlInputControl.FriendlyName, minDate); DoRegisterValidator(ctlInputControl, "mindate", param, msg); } if (this.Max.HasValue) { script = @" if (this.optional(element)) return true; try { var fmt = $(element).datepicker('option', 'dateFormat'); var dt = $.datepicker.parseDate(fmt, value); var maxDate = $.datepicker.parseDate(fmt, param); return dt <= maxDate; } catch (err) { return true; } "; newRule = "$.validator.addMethod('maxdate', function(value, element, param) {" + script + "});"; JQueryScriptManager.Current.RegisterScriptBlock("maxdate_validator", newRule); DateTime maxdate = DateTime.Today + TimeSpan.FromDays(this.Max.Value); param = string.Format(CultureInfo.CurrentUICulture, "{0:d}", maxdate); msg = string.Format(CultureInfo.CurrentUICulture, MSG2_MAX, ctlInputControl.FriendlyName, maxdate); DoRegisterValidator(ctlInputControl, "maxdate", param, msg); } switch (this.DateType) { case DateType.Default: break; case DateType.ToDate: // Ensure to date is more than from date script = @" if (this.optional(element)) return true; try { var fmt = $(element).datepicker('option', 'dateFormat'); var val = $.datepicker.parseDate(fmt, value); var from = $.datepicker.parseDate(fmt, $(param).textBoxEx('getval')); if (from == '') return true; var fromDate = new Date(from); return val >= fromDate; } catch (err) { return true; } "; // Creating a new rule which ensures to date is greater than from date newRule = "$.validator.addMethod('todate', function(value, element, param) {" + script + "});"; JQueryScriptManager.Current.RegisterScriptBlock("todate_validator", newRule); TextBoxEx tbFrom = GetFromControl(ctlInputControl); param = tbFrom.ClientSelector; msg = string.Format(MSG2_TO_GE_FROM, ctlInputControl.FriendlyName, tbFrom.FriendlyName); DoRegisterValidator(ctlInputControl, "todate", param, msg); if (this.MaxRange > 0) { // getDate can return a garbage date if any input control contains an invalid date. // This is OK since the checkdate validator will fail first. newRule = @"$.validator.addMethod('maxdaterange', function(value, element, param) { var val = $(element).datepicker('getDate'); var fromDate = $(param[0]).datepicker('getDate'); return !val || !fromDate || (val.getTime() - fromDate.getTime()) <= (param[1] * 1000*60*60*24); });"; JQueryScriptManager.Current.RegisterScriptBlock("maxdaterange_validator", newRule); object[] ruleParams = new object[2]; ruleParams[0] = tbFrom.ClientSelector; ruleParams[1] = string.Format("{0}", this.MaxRange); msg = string.Format("{0} must be within {1} days of {2}", ctlInputControl.FriendlyName, this.MaxRange, tbFrom.FriendlyName); DoRegisterValidator(ctlInputControl, "maxdaterange", ruleParams, msg); } break; default: throw new NotImplementedException(); } //RegisterDatePicker(ctlInputControl); }
/// <summary> /// This function is called by InputControlBase to give us a chance to register our client scripts. /// Derived classes must register their validation rules. They can use the helper DoRegisterValidator() /// which will add the dependency, if any, to the validation rule /// </summary> /// <param name="ctlInputControl"></param> internal abstract void RegisterClientRules(InputControlBase ctlInputControl);
internal override void RegisterClientRules(InputControlBase ctlInputControl) { DoRegisterValidator(ctlInputControl, "required", true, string.Format("{0} is required", ctlInputControl.FriendlyName)); }