protected override void OnValidated(ActionExecutingContext filterContext, IValidateResult result) { // Check if user must be enqueued if (result is EnqueueResult) { // Optional action } // Check if user has been through the queue (will be invoked for every page request after the user has been validated) if (result is AcceptedConfirmedResult) { AcceptedConfirmedResult confirmedResult = result as AcceptedConfirmedResult; if (!confirmedResult.IsInitialValidationRequest) { return; // data has already been persisted } PersistModel model = new PersistModel( confirmedResult.Queue.CustomerId, confirmedResult.Queue.EventId, confirmedResult.KnownUser.QueueId, confirmedResult.KnownUser.PlaceInQueue, confirmedResult.KnownUser.TimeStamp); model.Persist(); } base.OnValidated(filterContext, result); }
public void SessionValidateResultRepository_GetValidationResult_Expired_Test() { string sessionKey = "QueueITAccepted-SDFrts345E-customerid-eventid"; SessionStateModel model = new SessionStateModel() { OriginalUri = "http://original.url/", PlaceInQueue = 5486, QueueId = Guid.NewGuid(), RedirectType = RedirectType.Queue, TimeStamp = DateTime.UtcNow, Expiration = DateTime.UtcNow.AddMinutes(-1) }; HttpContext.Current.Session[sessionKey] = model; this._queue.Stub(queue => queue.CustomerId).Return("CustomerId"); this._queue.Stub(queue => queue.EventId).Return("EventId"); SessionValidateResultRepository repository = new SessionValidateResultRepository(); IValidateResult actualValidationResult = repository.GetValidationResult(this._queue); Assert.IsNull(actualValidationResult); }
public override void Check(IValidateResult result, object instance) { instance.ThrowIfNullArgument(nameof(instance)); result.ThrowIfNullArgument(nameof(result)); _method.Invoke(instance, new object[] { result }); }
public void SelfCheck(IValidateResult result) { if (Salary <= 0) { result.Set("Salary", "Validate Error : Salary <= 0"); } }
protected override void OnValidated(ActionExecutingContext filterContext, IValidateResult result) { // Check if user must be enqueued if (result is EnqueueResult) { // Optional action } // Check if user has been through the queue (will be invoked for every page request after the user has been validated) if (result is AcceptedConfirmedResult) { AcceptedConfirmedResult confirmedResult = result as AcceptedConfirmedResult; if (!confirmedResult.IsInitialValidationRequest) return; // data has already been persisted PersistModel model = new PersistModel( confirmedResult.Queue.CustomerId, confirmedResult.Queue.EventId, confirmedResult.KnownUser.QueueId, confirmedResult.KnownUser.PlaceInQueue, confirmedResult.KnownUser.TimeStamp); model.Persist(); } base.OnValidated(filterContext, result); }
/// <summary> /// Queue validation /// </summary> /// <remarks> /// Please be aware that this this implementation is not done on error handling pages (e.g. Error.aspx) which will cause users to get looped arround. /// </remarks> private void QueueITValidation() { try { this._result = SessionValidationController.ValidateRequest(); var enqueue = this._result as EnqueueResult; // Check if user must be enqueued if (enqueue != null) { Response.Redirect(enqueue.RedirectUrl); } } catch (ExpiredValidationException ex) { // Known user has has expired - Show error page and use GetCancelUrl to get user back in the queue Response.Redirect("Error.aspx?queuename=default&t=" + HttpUtility.UrlEncode(ex.KnownUser.OriginalUrl)); } catch (KnownUserValidationException ex) { // Known user is invalid - Show error page and use GetCancelUrl to get user back in the queue Response.Redirect( "Error.aspx?queuename=default&t=" + HttpUtility.UrlEncode((ex.InnerException as KnownUserException).OriginalUrl)); } }
private void WriteResultToConsole(IValidateResult vr) { foreach (var key in vr.ErrorKeys) { //Console.WriteLine("{0}-->{1}", key, vr[key]); } }
/// <summary> /// Queue validation /// </summary> /// <remarks> /// Please be aware that this this implementation is not done on error handling pages (e.g. Error.aspx) which will cause users to get looped arround. /// </remarks> private void QueueITValidation() { try { this._result = SessionValidationController.ValidateRequest("ticketania", "codeonly", includeTargetUrl: true); var enqueue = this._result as EnqueueResult; // Check if user must be enqueued if (enqueue != null) { Response.Redirect(enqueue.RedirectUrl); } } catch (ExpiredValidationException ex) { // Known user has has expired - Show error page and use GetCancelUrl to get user back in the queue Response.Redirect("Error.aspx?queuename=codeonly&t=" + HttpUtility.UrlEncode(ex.KnownUser.OriginalUrl)); } catch (KnownUserValidationException ex) { // Known user is invalid - Show error page and use GetCancelUrl to get user back in the queue Response.Redirect( "Error.aspx?queuename=codeonly&t=" + HttpUtility.UrlEncode((ex.InnerException as KnownUserException).OriginalUrl)); } }
public override void SetValidationResult(IQueue queue, IValidateResult validationResult, DateTime?expirationTime = null) { AcceptedConfirmedResult acceptedResult = validationResult as AcceptedConfirmedResult; if (acceptedResult != null) { var key = GenerateKey(queue.CustomerId, queue.EventId); SessionStateModel model = new SessionStateModel() { QueueId = acceptedResult.KnownUser.QueueId, OriginalUri = acceptedResult.KnownUser.OriginalUrl, PlaceInQueue = acceptedResult.KnownUser.PlaceInQueue, TimeStamp = acceptedResult.KnownUser.TimeStamp, RedirectType = acceptedResult.KnownUser.RedirectType, }; if (expirationTime != null) { model.Expiration = expirationTime; } else if (acceptedResult.KnownUser.RedirectType == RedirectType.Idle) { model.Expiration = DateTime.UtcNow.Add(IdleExpiration); } else if (!ExtendValidity) { model.Expiration = DateTime.UtcNow.AddMinutes(HttpContext.Current.Session.Timeout); } HttpContext.Current.Session[key] = model; } }
protected override void DoCheck(IValidateResult result, object instance, object propertyValue) { if (propertyValue == null) { string msg = string.Format(MSG, _pInfo.Name, instance.GetType().Name); this.LogValidateResult(result, msg); } }
public override Task <IValidateResult> ValidateAsync(IValidateResult result, TProperty value, string name, string error) { if (!Compare(m_EqualEalue, value)) { AddFailure(result, name, value, error ?? string.Format("The value is not equal {0}", m_EqualEalue)); } return(Task.FromResult(result)); }
public override Task <IValidateResult> ValidateAsync(IValidateResult result, TProperty value, string name, string error) { if (!m_Value.Any(i => Compare(i, value))) { AddFailure(result, name, value, error ?? "Not in data array"); } return(Task.FromResult(result)); }
public override Task <IValidateResult> ValidateAsync(IValidateResult result, TProperty?value, string name, string error) { if (!value.HasValue) { AddFailure(result, name, value, error ?? "Can't be null"); } return(Task.FromResult(result)); }
public override Task <IValidateResult> ValidateAsync(IValidateResult result, TProperty value, string name, string error) { if (value == null || !value.GetEnumerator().MoveNext()) { AddFailure(result, name, value, error ?? "Can't be null or empty"); } return(Task.FromResult(result)); }
public override Task <IValidateResult> ValidateAsync(IValidateResult result, string value, string name, string error) { if (string.IsNullOrEmpty(value) || !m_Regex.IsMatch(value)) { AddFailure(result, name, value, error ?? "The value no match regex"); } return(Task.FromResult(result)); }
public override Task <IValidateResult> ValidateAsync(IValidateResult result, string value, string name, string error) { if (string.IsNullOrWhiteSpace(value)) { AddFailure(result, name, value, error ?? "Can't be null or empty or whitespace"); } return(Task.FromResult(result)); }
public override Task <IValidateResult> ValidateAsync(IValidateResult result, TProperty value, string name, string error) { if (m_MustBeTrue(value)) { AddFailure(result, name, value, error); } return(Task.FromResult(result)); }
public void AddFailure(IValidateResult result, string name, object value, string error) { result.Failures.Add(new ValidateFailure() { Name = name, Value = value, Error = error }); }
/// <summary> /// When overridden it provides access to the validation request. /// E.g. to persist Queue ID details to the database. /// Call base to redirect to the queue on EnqueueResult. /// </summary> /// <param name="filterContext">The Action Executing Filter Context</param> /// <param name="result">The validation result</param> /// <example> /// <code> /// protected override void OnValidated(ActionExecutingContext filterContext, IValidateResult result) /// { /// // Check if user must be enqueued /// if (result is EnqueueResult) /// { /// // Optional action /// } /// /// // Check if user has been through the queue (will be invoked for every page request after the user has been validated) /// if (result is AcceptedConfirmedResult) /// { /// AcceptedConfirmedResult confirmedResult = result as AcceptedConfirmedResult; /// /// if (!confirmedResult.IsInitialValidationRequest) /// return; // data has already been persisted /// /// PersistModel model = new PersistModel( /// confirmedResult.Queue.CustomerId, /// confirmedResult.Queue.EventId, /// confirmedResult.KnownUser.QueueId, /// confirmedResult.KnownUser.PlaceInQueue, /// confirmedResult.KnownUser.TimeStamp); /// /// model.Persist(); /// } /// /// base.OnValidated(filterContext, result); /// } /// </code> /// </example> protected virtual void OnValidated(ActionExecutingContext filterContext, IValidateResult result) { EnqueueResult enqueueResult = result as EnqueueResult; if (enqueueResult != null) { filterContext.Result = new RedirectResult(enqueueResult.RedirectUrl); } }
public override Task <IValidateResult> ValidateAsync(IValidateResult result, decimal value, string name, string error) { if (m_Min >= value || m_Max <= value) { AddFailure(result, name, value, error ?? string.Format("The value is not between {0} and {1}", m_Min, m_Max)); } return(Task.FromResult(result)); }
public override Task <IValidateResult> ValidateAsync(IValidateResult result, int value, string name, string error) { if (value >= m_Value) { AddFailure(result, name, value, error ?? string.Format("The value must less than {0}", m_Value)); } return(Task.FromResult(result)); }
public override Task <IValidateResult> ValidateAsync(IValidateResult result, float value, string name, string error) { if (value < m_Value) { AddFailure(result, name, value, error ?? string.Format("The value must greater than or equal {0}", m_Value)); } return(Task.FromResult(result)); }
public override Task <IValidateResult> ValidateAsync(IValidateResult result, TProperty value, string name, string error) { var res = m_Func(value); if (res != null) { result.Merge(res); } return(Task.FromResult(result)); }
public override Task <IValidateResult> ValidateAsync(IValidateResult result, string value, string name, string error) { var len = string.IsNullOrEmpty(value) ? 0 : value.Length; if ((m_Max != -1 && m_Max < len) || m_Min > len) { AddFailure(result, name, value, error ?? string.Format("The length {0} is not between {1} and {2}", len, m_Min, m_Max)); } return(Task.FromResult(result)); }
public override void Check(IValidateResult result, object instance) { Assertion.IsNotNull(_pInfo, "Property info not set."); instance.ThrowIfNullArgument(nameof(instance)); result.ThrowIfNullArgument(nameof(result)); object val = _pInfo.GetValue(instance, null); DoCheck(result, instance, val); }
protected void Page_Load(object sender, EventArgs e) { IValidateResult result = SessionValidationController.ValidateRequest( QueueFactory.CreateQueue("ticketania", Request.QueryString["eventid"])); var accepted = result as AcceptedConfirmedResult; if (accepted != null) { accepted.Cancel(); } }
private void ValidateElement(ValidateContext context, IValidateResult result, int index) { foreach (var rule in NextRuleList) { if (result.IsValid || context.Option == ValidateOption.Continue) { ValidateNextRule(context, result, index, rule); } else break; } }
private async void ValidateNextRule(ValidateContext context, IValidateResult result, int index, IValidateRule rule) { var nextResult = await rule.ValidateAsync(context); if (!nextResult.IsValid) { foreach (var failure in nextResult.Failures) { failure.Name = string.Format(string.IsNullOrEmpty(failure.Name) ? "{0}[{1}]{2}" : "{0}[{1}].{2}", ValueName, index, failure.Name); } } result.Merge(nextResult.Failures); }
public async Task <IValidateResult> ValidateAsyncByFunc(ValidateContext context) { IValidateResult result = await ValidateAsyncFunc(context, ValueName, Error); if (NextRuleList.IsEmptyOrNull() || (!result.IsValid && context.Option != ValidateOption.Continue)) { return(result); } ValidateNextRuleList(context, result); return(result); }
private async void ValidateNextRuleList(ValidateContext context, IValidateResult result) { foreach (var nextRule in NextRuleList) { if (result.IsValid || context.Option == ValidateOption.Continue) { var nextResult = await nextRule.ValidateAsync(context); result.Merge(nextResult.Failures); } else break; } }
protected override void DoCheck(IValidateResult result, object instance, object propertyValue) { //Extend:use cache to improve performance. ExpressionLanguageEngineConfig cfg = new ExpressionLanguageEngineConfig(EvalExceptionHandlingPolicy.IgnorePolicy); ExpressionLanguageEngine engine = ExpressionLanguageEngine.CreateEngine(cfg); engine.Assign(INSTANCE, instance); engine.Assign(VALUE, propertyValue); object b = engine.Eval(_expr); if (!engine.EvalToBool(b)) { string msg = string.Format(MSG, _pInfo.Name, instance.GetType().Name, propertyValue, _expr); this.LogValidateResult(result, msg); } }
private void ValidateElement(ValidateContext context, IValidateResult result, int index) { foreach (var rule in NextRuleList) { if (result.IsValid || context.Option == ValidateOption.Continue) { ValidateNextRule(context, result, index, rule); } else { break; } } }
public void CookieValidateResultRepository_GetValidationResult_NoCookie_Test() { string secretKey = "acb"; this._queue.Stub(queue => queue.CustomerId).Return("CustomerId"); this._queue.Stub(queue => queue.EventId).Return("EventId"); KnownUserFactory.Configure(secretKey); CookieValidateResultRepository repository = new CookieValidateResultRepository(); IValidateResult actualResult = repository.GetValidationResult(this._queue); Assert.IsNull(actualResult); }
private void ValidateElementList(ValidateContext context, IValidateResult result, IEnumerable list) { var index = 0; foreach (var item in list) { if (result.IsValid || context.Option == ValidateOption.Continue) { var ct = Validation.CreateContext(item, context.Option, context.RuleSetList.ToArray()); ValidateElement(ct, result, index); } else break; index++; } }
public override Task <IValidateResult> ValidateAsync(ValidateContext context) { ParamHelper.CheckParamNull(context, "context", "Can't be null"); IValidateResult result = Validation.Provider.GetService <IValidateResult>(); var list = context.ValidateObject as IEnumerable; if (Condition == null || Condition(context)) { if (list != null) { ValidateElementList(context, result, list); } } return(Task.FromResult(result)); }
/// <summary> /// Queue validation /// </summary> /// <remarks> /// Please be aware that this this implementation is not done on error handling pages (e.g. Error.aspx) which will cause users to get looped arround. /// </remarks> private void QueueITValidation() { try { this._result = SessionValidationController.ValidateRequest(QueueFactory.CreateQueue("advanced")); var enqueue = this._result as EnqueueResult; // Check if user must be enqueued (new users) if (enqueue != null) { if (QueueIsHealthy(enqueue.Queue)) //Is Queue-it service online for my queue? Response.Redirect(enqueue.RedirectUrl); } // This part checks if user has been through the queue and persists the users queue details for later tracking var accepted = this._result as AcceptedConfirmedResult; if (accepted != null) { if (!accepted.IsInitialValidationRequest) return; // data has already been persisted PersistModel model = new PersistModel( accepted.Queue.CustomerId, accepted.Queue.EventId, accepted.KnownUser.QueueId, accepted.KnownUser.PlaceInQueue, accepted.KnownUser.TimeStamp); model.Persist(); //Persist users queue details } } catch (ExpiredValidationException ex) { // Known user has has expired - Show error page and use GetCancelUrl to get user back in the queue Response.Redirect("Error.aspx?queuename=advanced&t=" + HttpUtility.UrlEncode(ex.KnownUser.OriginalUrl)); } catch (KnownUserValidationException ex) { // The known user url or hash is not valid - Show error page and use GetCancelUrl to get user back in the queue Response.Redirect("Error.aspx?queuename=advanced&t=" + HttpUtility.UrlEncode((ex.InnerException as KnownUserException).OriginalUrl)); } }
protected override void DoCheck(IValidateResult result, object instance, object propertyValue) { if (propertyValue == null) { string msg = string.Format(MSG, _pInfo.Name, instance.GetType().Name, _regex, propertyValue); this.LogValidateResult(result, msg); return; } if (!(propertyValue is string)) { ExceptionHelper.ThrowInvalidPropertyAttribute(this, _pInfo); } bool match = _regex.IsMatch((string)propertyValue); if (!match) { string msg = string.Format(MSG, _pInfo.Name, instance.GetType().Name, _regex, propertyValue); this.LogValidateResult(result, msg); } }
public override void SetValidationResult(IQueue queue, IValidateResult validationResult, DateTime? expirationTime = null) { AcceptedConfirmedResult acceptedResult = validationResult as AcceptedConfirmedResult; if (acceptedResult != null) { var key = GenerateKey(queue.CustomerId, queue.EventId); SessionStateModel model = new SessionStateModel() { QueueId = acceptedResult.KnownUser.QueueId, OriginalUri = acceptedResult.KnownUser.OriginalUrl, PlaceInQueue = acceptedResult.KnownUser.PlaceInQueue, TimeStamp = acceptedResult.KnownUser.TimeStamp, RedirectType = acceptedResult.KnownUser.RedirectType, }; if (expirationTime != null) model.Expiration = expirationTime; else if (acceptedResult.KnownUser.RedirectType == RedirectType.Idle) model.Expiration = DateTime.UtcNow.Add(IdleExpiration); else if (!ExtendValidity) model.Expiration = DateTime.UtcNow.AddMinutes(HttpContext.Current.Session.Timeout); HttpContext.Current.Session[key] = model; } }
public override void SetValidationResult(IQueue queue, IValidateResult validationResult, DateTime? expirationTime = null) { AcceptedConfirmedResult acceptedResult = validationResult as AcceptedConfirmedResult; if (acceptedResult != null) { string queueId = acceptedResult.KnownUser.QueueId.ToString(); string originalUrl = acceptedResult.KnownUser.OriginalUrl; int placeInQueue = acceptedResult.KnownUser.PlaceInQueue.HasValue ? acceptedResult.KnownUser.PlaceInQueue.Value : 0; RedirectType redirectType = acceptedResult.KnownUser.RedirectType; string timeStamp = Hashing.GetTimestamp(acceptedResult.KnownUser.TimeStamp).ToString(); if (!expirationTime.HasValue) expirationTime = DateTime.UtcNow.Add(redirectType == RedirectType.Idle ? IdleExpiration : CookieExpiration); string hash = GenerateHash(queueId, originalUrl, placeInQueue.ToString(), redirectType, timeStamp, expirationTime.Value); SetCookie(queue, queueId, originalUrl, placeInQueue, redirectType, timeStamp, hash, expirationTime.Value); } }
public abstract void Check(IValidateResult result, object instance);
public override void Cancel(IQueue queue, IValidateResult validationResult) { var key = GenerateKey(queue.CustomerId, queue.EventId); HttpContext.Current.Session.Remove(key); }
public void SetValidationResult(IQueue queue, IValidateResult validationResult, DateTime? expirationTime = null) { this._results.Add(queue.CustomerId + queue.EventId, validationResult); }
public override void Cancel(IQueue queue, IValidateResult validationResult) { SetValidationResult(queue, validationResult, DateTime.UtcNow.AddDays(-1)); }
public abstract void Cancel(IQueue queue, IValidateResult validationResult);
public abstract void SetValidationResult(IQueue queue, IValidateResult validationResult, DateTime? expirationTime = null);
public void Cancel(IQueue queue, IValidateResult validationResult) { throw new NotImplementedException(); }