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]);
}
}
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");
}
}
/// <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));
}
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 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 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);
}
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));
}
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);
}
}
/// <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);
}
}
private void WriteResultToConsole(IValidateResult vr)
{
foreach (var key in vr.ErrorKeys)
{
//Console.WriteLine("{0}-->{1}", key, vr[key]);
}
}
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();
}
/// <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);
}
}
