internal override bool Validate(ValidationContext context)
{
BuiltinLanguageType globalVariableType = context.GetGlobalVariableType(GlobalIndex);
if (0 == globalVariableType)
{
return(false);
}
if (IsGetter)
{
context.StackPush(globalVariableType);
return(true);
}
BuiltinLanguageType poppedType = context.StackPop();
if (0 == poppedType)
{
context.AddError("Attempt to pop an empty stack.");
}
if (globalVariableType != poppedType)
{
context.AddError(string.Format("Attempt to set a {0} global variable with a {1} value.",
globalVariableType, poppedType));
return(false);
}
return(true);
}
public void Validate(Type type, ValidationContext context)
{
if (!type.IsEnum)
{
var typeName = context.GetTypeName(type);
context.AddError($"type mismatch, expected enum but found {typeName}");
return;
}
var actualIsFlagsEnum = type.GetCustomAttributes(typeof(FlagsAttribute), false).Any();
if (actualIsFlagsEnum != _expectedIsFlagsEnum)
{
var expectedKind = _expectedIsFlagsEnum ? "flags" : "values";
var actualKind = actualIsFlagsEnum ? "flags" : "values";
context.AddError($"enum kind mismatch, expected {expectedKind} but found {actualKind}");
}
var underlyingType = System.Enum.GetUnderlyingType(type);
var actualValues = System.Enum.GetValues(type).Cast <object>().Select(x => Convert.ChangeType(x, underlyingType).ToString()).ToList();
if (actualValues.Except(_expectedValues).Concat(_expectedValues.Except(actualValues)).Any())
{
var expectedValuesString = string.Join(",", _expectedValues);
var actualValuesString = string.Join(",", actualValues);
context.AddError($"enum values mismatch, expected [{expectedValuesString}] but found [{actualValuesString}]");
}
}
internal override bool Validate(ValidationContext context)
{
BuiltinLanguageType expectedType = context.FunctionReturnType;
if (BuiltinLanguageType.EmptyBlock != expectedType)
{
BuiltinLanguageType effectiveType = context.StackPeek(0);
if (0 == effectiveType)
{
return(false);
}
if (effectiveType != expectedType)
{
context.AddError(string.Format(
"Expected function return type is {0}. Returned value is {1}.",
expectedType, effectiveType));
return(false);
}
BuiltinLanguageType poppedType = context.StackPop();
if (0 == poppedType)
{
return(false);
}
}
int stackSize = context.StackSize;
if (0 != stackSize)
{
context.AddError(string.Format(
"{0} items remaining on stack on function return.",
stackSize));
return(false);
}
return(true);
}
internal override bool Validate(ValidationContext context)
{
BuiltinLanguageType poppedType = context.StackPop();
if (0 == poppedType)
{
return(false);
}
if (BuiltinLanguageType.I32 != poppedType)
{
context.AddError(string.Format(
"Expected an I32 index on the stack. Found an {0}.",
poppedType));
return(false);
}
poppedType = context.StackPop();
if (0 == poppedType)
{
return(false);
}
BuiltinLanguageType otherArgument = context.StackPeek(0);
if (0 == otherArgument)
{
return(false);
}
if (otherArgument != poppedType)
{
context.AddError(string.Format(
"Unconsistent select instruction parameters. Found an {0} and an {1}.",
poppedType, otherArgument));
return(false);
}
return(true);
}
/// <summary>
/// Validate attributes on AlternateContent, Choice and Fallback element.
/// </summary>
/// <param name="validationContext"></param>
/// <param name="acElement">The element to be validated.</param>
private static void ValidateMcAttributesOnAcb(ValidationContext validationContext, OpenXmlElement acElement)
{
ValidationErrorInfo errorInfo;
// AlternateContent elements might include the attributes Ignorable, MustUnderstand, ProcessContent, PreserveElements, and PreserveAttributes
// These attributes’ qualified names shall be prefixed when associated with an AlternateContent / Choice / Fallback element.
// A markup consumer shall generate an error if it encounters an unprefixed attribute name associated with an AlternateContent element.
if (acElement.ExtendedAttributes != null)
{
foreach (var exAttribute in acElement.ExtendedAttributes)
{
if (string.IsNullOrEmpty(exAttribute.Prefix))
{
// error on any unprefixed attributes
errorInfo = validationContext.ComposeMcValidationError(acElement, ValidationResources.MC_ErrorOnUnprefixedAttributeName, exAttribute.XmlQualifiedName.ToString());
validationContext.AddError(errorInfo);
}
// Markup consumers shall generate an error if they encounter the xml:lang or xml:space attributes on an AlternateContent element.
// Markup consumers shall generate an error if they encounter the xml:lang or xml:space attributes on a Choice element, regardless of whether the element is preceded by a selected Choice element.
// Markup consumers shall generate an error if they encounter the xml:lang or xml:space attributes on a Fallback element, regardless of whether the element is preceded by a selected Choice element.
if (IsXmlSpaceOrXmlLangAttribue(exAttribute))
{
// report error.
errorInfo = validationContext.ComposeMcValidationError(acElement, "MC_InvalidXmlAttribute", acElement.LocalName);
validationContext.AddError(errorInfo);
}
}
}
// validate MC attribues (Ignorable, PreserveElements, etc.) of this element.
CompatibilityRuleAttributesValidator.ValidateMcAttributes(validationContext);
if (acElement is AlternateContentChoice choice)
{
// All Choice elements shall have a Requires attribute whose value contains a whitespace-delimited list of namespace prefixes
if (choice.Requires == null)
{
// report error
errorInfo = validationContext.ComposeMcValidationError(acElement, "MC_MissedRequiresAttribute");
validationContext.AddError(errorInfo);
}
else
{
var prefixes = new ListValue <StringValue>();
prefixes.InnerText = choice.Requires;
foreach (var prefix in prefixes.Items)
{
var ignorableNamespace = choice.LookupNamespace(prefix);
if (string.IsNullOrEmpty(ignorableNamespace))
{
// report error, the prefix is not defined.
errorInfo = validationContext.ComposeMcValidationError(choice, "MC_InvalidRequiresAttribute", choice.Requires);
validationContext.AddError(errorInfo);
}
}
}
}
}
public void Validate(ValidationContext context)
{
if (string.IsNullOrWhiteSpace(this.EmailAddress) || this.EmailAddress.IndexOf('@') < 1)
{
context.AddError(nameof(this.EmailAddress), "Invalid email address.");
}
if (string.IsNullOrWhiteSpace(this.Password) || this.Password.Length < 8)
{
context.AddError(nameof(this.Password), "The password must be at least 8 characters long.");
}
}
public void Validate(Type type, ValidationContext context)
{
var actualProperties = type.GetProperties();
var expectedProperties = _dataContract is Type dataContractType
? dataContractType.GetProperties().ToDictionary(x => x.Name, x => (object)x.PropertyType)
: _dataContract.GetType().GetProperties().ToDictionary(x => x.Name, x => x.GetValue(_dataContract, null));
var names = actualProperties
.Select(x => x.Name)
.Concat(expectedProperties.Keys)
.OrderBy(x => x)
.Distinct();
foreach (var name in names)
{
using (context.CreateScope(name))
{
var actualProperty = actualProperties.FirstOrDefault(x => x.Name == name);
if (actualProperty == null)
{
context.AddError("expected property not found");
continue;
}
var actualPropertyIsIgnored = actualProperty.GetCustomAttributes(false)
.Any(x => x.GetType().Name == "JsonIgnoreAttribute");
if (!expectedProperties.TryGetValue(name, out var expectedProperty))
{
if (actualPropertyIsIgnored)
{
continue;
}
context.AddError("unexpected property");
continue;
}
if (actualPropertyIsIgnored)
{
context.AddError("expected property found but decorated with ignore attribute");
continue;
}
context.Validate(actualProperty.PropertyType, expectedProperty);
}
}
}
internal override bool Validate(ValidationContext context)
{
BuiltinLanguageType variableType = context.GetLocalVariableType(LocalIndex);
if (0 == variableType)
{
return(false);
}
BuiltinLanguageType topOfStackType;
switch (OpCode)
{
case OpCodes.GetLocal:
context.StackPush(variableType);
return(true);
case OpCodes.SetLocal:
topOfStackType = context.StackPop();
if (0 == topOfStackType)
{
return(false);
}
if (topOfStackType != variableType)
{
context.AddError(string.Format(
"Local variable setter type mismatch. On stack {0], variable type is {1}.",
topOfStackType, variableType));
return(false);
}
return(true);
case OpCodes.TeeLocal:
topOfStackType = context.StackPeek(0);
if (0 == topOfStackType)
{
return(false);
}
if (topOfStackType != variableType)
{
context.AddError(string.Format(
"Local variable tee type mismatch. On stack {0], variable type is {1}.",
topOfStackType, variableType));
return(false);
}
return(true);
default:
throw new InvalidOperationException();
}
}
public async Task <ValidationContext <UserLoginCommandResult> > Handle(RefreshTokenCommand request, CancellationToken cancellationToken)
{
_logger.LogDebug("Attempting to refresh users token");
var resultContext = new ValidationContext <UserLoginCommandResult>();
if (string.IsNullOrWhiteSpace(request.RefreshToken) || string.IsNullOrWhiteSpace(request.AccessToken))
{
resultContext
.AddError("Invalid Token");
_logger.LogDebug("RefreshToken or AccessToken was not specified when attempting to refresh a token");
return(resultContext);
}
var principal = _tokenService.GetPrincipalFromAccessToken(request.AccessToken);
var userIdClaim = principal?.Claims?.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier);
var user = await ValidateAndReturnUser(userIdClaim, resultContext);
if (!IsUserRefreshTokenValid(user?.UserRefreshTokens, request.RefreshToken))
{
resultContext.AddError("Invalid Token");
_logger.LogDebug("Refresh token has either expired or does not match the users current refresh token");
}
if (!resultContext.IsSuccessful)
{
return(resultContext);
}
_logger.LogDebug("Refresh token is valid, re-creating tokens for user.");
var accessToken = _tokenService.CreateToken(user);
var refreshToken = _tokenService.CreateRefreshToken();
// ReSharper disable once PossibleNullReferenceException
user.UserRefreshTokens.Add(refreshToken);
await _unitOfWork.CommitAsync();
resultContext.Data = new UserLoginCommandResult
{
AccessToken = accessToken,
RefreshToken = refreshToken.Token
};
return(resultContext);
}
public async Task <ValidationContext <UserLoginCommandResult> > Handle(UserLoginCommand request, CancellationToken cancellationToken)
{
_logger.LogDebug("Attempting Plex SignIn");
var result = new ValidationContext <UserLoginCommandResult>();
PlexRequests.Plex.Models.User plexUser;
try
{
plexUser = await _plexApi.SignIn(request.Username, request.Password);
}
catch (PlexRequestException)
{
result.AddError("Invalid Plex Credentials", "Unable to login to Plex with the given credentials");
_logger.LogInformation("Unable to login to Plex with the given credentials");
return(result);
}
_logger.LogDebug("Plex SignIn Successful");
_logger.LogDebug("Getting PlexRequests User from PlexAccountId");
var plexRequestsUser = await _userService.GetUserFromPlexId(plexUser.Id);
if (plexRequestsUser == null || plexRequestsUser.IsDisabled)
{
result.AddError("Unrecognised user", "The user is not recognised or has been disabled.");
_logger.LogInformation($"Successful login from a Plex account that was either not found within our users list or has been disabled [IsDisabled={plexRequestsUser?.IsDisabled}]");
return(result);
}
_logger.LogDebug("Found matching PlexRequests User");
var refreshToken = _tokenService.CreateRefreshToken();
var accessToken = _tokenService.CreateToken(plexRequestsUser);
plexRequestsUser.LastLoginUtc = DateTime.UtcNow;
plexRequestsUser.UserRefreshTokens.Add(refreshToken);
await _unitOfWork.CommitAsync();
result.Data = new UserLoginCommandResult
{
AccessToken = accessToken,
RefreshToken = refreshToken.Token
};
return(result);
}
public override void Validate(ValidationContext context)
{
if (Resource == null)
{
context.AddError("Resource is null");
}
}
internal static bool AddMemberNameToHashSet(IEdmNamedElement item, HashSetInternal <string> memberNameList, ValidationContext context, EdmErrorCode errorCode, string errorString, bool suppressError)
{
string name;
IEdmSchemaElement edmSchemaElement = item as IEdmSchemaElement;
if (edmSchemaElement != null)
{
name = edmSchemaElement.FullName();
}
else
{
name = item.Name;
}
string str = name;
if (memberNameList.Add(str))
{
return(true);
}
else
{
if (!suppressError)
{
context.AddError(item.Location(), errorCode, errorString);
}
return(false);
}
}
/// <summary>
/// Validate the attributes constraint.
/// </summary>
/// <param name="validationContext">The validation context.</param>
private static void ValidateAttributes(ValidationContext validationContext)
{
var element = validationContext.Stack.Current?.Element;
if (element is null)
{
return;
}
foreach (var attribute in element.ParsedState.Attributes)
{
ValidateValue(validationContext, attribute.Property.Validators, attribute.Value, attribute.Property, true);
}
// all unknown attributes (attributes not defined in schema) are in ExtendedAttributes.
// they should be errors
foreach (var extendedAttribute in element.ExtendedAttributes)
{
if (validationContext.McContext.IsIgnorableNs(extendedAttribute.NamespaceUri))
{
// Ignorable attribute, no error.
}
// xml:space is always allowed
else if (extendedAttribute.NamespaceUri == "http://www.w3.org/XML/1998/namespace")
{
}
else
{
// emit error
validationContext.AddError(validationContext.ComposeSchemaValidationError(element, null, "Sch_UndeclaredAttribute", extendedAttribute.XmlQualifiedName.ToString()));
}
}
}
/// <summary>
/// Validate the attributes constraint.
/// </summary>
/// <param name="validationContext">The validation context.</param>
private static void ValidateAttributes(ValidationContext validationContext)
{
var element = validationContext.Element;
ValidationErrorInfo errorInfo;
foreach (var attribute in element.Attributes)
{
ValidateValue(validationContext, attribute.Property.Validators, attribute.Value, attribute.Property.GetQName().ToString(), attribute.Property, true);
}
// all unknown attributes (attributes not defined in schema) are in ExtendedAttributes.
// they should be errors
foreach (var extendedAttribute in element.ExtendedAttributes)
{
if (validationContext.McContext.IsIgnorableNs(extendedAttribute.NamespaceUri))
{
// Ignorable attribute, no error.
}
// xml:space is always allowed
else if (extendedAttribute.NamespaceUri == "http://www.w3.org/XML/1998/namespace")
{
}
else
{
// emit error
string attributeQname = extendedAttribute.XmlQualifiedName.ToString();
errorInfo = validationContext.ComposeSchemaValidationError(element, null, "Sch_UndeclaredAttribute", attributeQname);
errorInfo.SetDebugField(attributeQname, "Sch_UndeclaredAttribute");
validationContext.AddError(errorInfo);
}
}
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
var timeout = this.GetTimeoutToken();
var validationContext = new ValidationContext();
model.Validate(validationContext);
if (validationContext.HasErrors)
{
this.AddModelStateError(validationContext);
return await this.View(model, timeout);
}
var account = new Account
{
IdentityType = IdentityType.EmailAddress,
IdentityValue = model.EmailAddress.Trim().ToLowerInvariant(),
CreationTime = Clock.UtcNow,
Name = model.Name.Trim(),
PasswordHash = BCrypt.Net.BCrypt.HashPassword(model.Password),
};
try
{
await this.accountStore.Insert(account, this.GetTimeoutToken());
await this.CreateNewSession(account, false, timeout);
return this.RedirectToAction("Index", "Home");
}
catch (DuplicateKeyException)
{
validationContext.AddError(nameof(model.EmailAddress), "This email address is already in use.");
this.AddModelStateError(validationContext);
return await this.View(model, timeout);
}
}
protected override void EmitInvalidElementError(ValidationContext validationContext, ParticleMatchInfo particleMatchInfo)
{
var element = validationContext.Stack.Current?.Element;
if (element is null)
{
return;
}
var child = particleMatchInfo.LastMatchedElement is null
? validationContext.GetFirstChildMc()
: validationContext.GetNextChildMc(particleMatchInfo.LastMatchedElement);
if (child is null)
{
return;
}
string expectedChildren;
ValidationErrorInfo errorInfo;
switch (particleMatchInfo.Match)
{
case ParticleMatch.Nomatch:
expectedChildren = GetExpectedChildrenMessage(element, GetExpectedElements());
errorInfo = validationContext.ComposeSchemaValidationError(element, child, "Sch_InvalidElementContentExpectingComplex", child.XmlQualifiedName.ToString(), expectedChildren);
validationContext.AddError(errorInfo);
break;
case ParticleMatch.Partial:
case ParticleMatch.Matched:
if (_childrenParticles.ContainsKey(child.GetType()))
{
// more than one occurs of a child.
errorInfo = validationContext.ComposeSchemaValidationError(element, child, "Sch_AllElement", child.XmlQualifiedName.ToString());
validationContext.AddError(errorInfo);
}
else
{
expectedChildren = GetExpectedChildrenMessage(element, particleMatchInfo.ExpectedChildren);
errorInfo = validationContext.ComposeSchemaValidationError(element, child, "Sch_InvalidElementContentExpectingComplex", child.XmlQualifiedName.ToString(), expectedChildren);
validationContext.AddError(errorInfo);
}
break;
}
}
protected override Task Validate(ValidationContext validationContext)
{
if (string.Compare(Command.Name, "foo", StringComparison.OrdinalIgnoreCase) == 0)
{
validationContext.AddError("UserId", "Validation Failed");
}
return(Task.FromResult(0));
}
protected override Task Validate(ValidationContext validationContext)
{
if (Command.Id == 999)
{
validationContext.AddError("UserId", "Validation Failed");
}
return(Task.FromResult(0));
}
internal override bool Validate(ValidationContext context)
{
BuiltinLanguageType poppedType;
if (Conditional)
{
poppedType = context.StackPop();
if (0 == poppedType)
{
return(false);
}
if (BuiltinLanguageType.I32 != poppedType)
{
context.AddError(string.Format(
"Expected an I32 for conditional branch evaluation. Found an {0}",
poppedType.ToString()));
return(false);
}
}
Tuple <BuiltinLanguageType, int, bool> label;
if (!context.GetLabel(Depth, out label))
{
context.AddError(string.Format(
"Attempt to retrieve label having relative index {0} while there is only {1} labels",
Depth, context.LabelsCount));
return(false);
}
if (BuiltinLanguageType.EmptyBlock != label.Item1)
{
poppedType = (Conditional) ? context.StackPeek(0) : context.StackPop();
if (0 == poppedType)
{
return(false);
}
if (label.Item1 != poppedType)
{
context.AddError(string.Format(
"Attempt to exit label having relative index {0} with value having type {1} on top of stack while expecting type {2}",
Depth, poppedType.ToString(), label));
return(false);
}
}
return(true);
}
public override void Validate(ValidationContext context)
{
base.Validate(context);
if (this.Element == DamageEnergyType.Fire || this.Element == DamageEnergyType.Cold || (this.Element == DamageEnergyType.Acid || this.Element == DamageEnergyType.Electricity))
{
return;
}
context.AddError("Only Fire, Cold, Acid or Electricity are allowed", (object[])Array.Empty <object>());
}
internal override bool Validate(ValidationContext context)
{
if (0 == context.StackPop())
{
context.AddError("Drop instruction encountered while stack is empty.");
return(false);
}
return(true);
}
/// <summary>
/// Add further validation logic.
/// </summary>
protected override void OnValidate(ValidationContext <PerformanceReview> context)
{
if (!context.HasError(x => x.EmployeeId))
{
// Ensure that the EmployeeId has not be changed (change back) as it is immutable.
if (ExecutionContext.Current.OperationType == OperationType.Update)
{
var prm = (IPerformanceReviewManager)context.ServiceProvider.GetService(typeof(IPerformanceReviewManager));
var prv = prm.GetAsync(context.Value.Id).GetAwaiter().GetResult();
if (prv == null)
{
throw new NotFoundException();
}
if (context.Value.EmployeeId != prv.EmployeeId)
{
context.AddError(x => x.EmployeeId, ValidatorStrings.ImmutableFormat);
return;
}
}
// Check that the referenced Employee exists, and the review data is within the bounds of their employment.
var em = (IEmployeeManager)context.ServiceProvider.GetService(typeof(IEmployeeManager));
var ev = em.GetAsync(context.Value.EmployeeId).GetAwaiter().GetResult();
if (ev == null)
{
context.AddError(x => x.EmployeeId, ValidatorStrings.ExistsFormat);
}
else
{
if (!context.HasError(x => x.Date))
{
if (context.Value.Date < ev.StartDate)
{
context.AddError(x => x.Date, "{0} must not be prior to the Employee starting.");
}
else if (ev.Termination != null && context.Value.Date > ev.Termination.Date)
{
context.AddError(x => x.Date, "{0} must not be after the Employee has terminated.");
}
}
}
}
}
/// <summary>
/// Add further validation logic.
/// </summary>
protected override async Task OnValidateAsync(ValidationContext <PerformanceReview> context)
{
if (!context.HasError(x => x.EmployeeId))
{
// Ensure that the EmployeeId has not be changed as it is immutable.
if (ExecutionContext.Current.OperationType == OperationType.Update)
{
var prv = await _performanceReviewManager.GetAsync(context.Value.Id).ConfigureAwait(false);
if (prv == null)
{
throw new NotFoundException();
}
if (context.Value.EmployeeId != prv.EmployeeId)
{
context.AddError(x => x.EmployeeId, ValidatorStrings.ImmutableFormat);
return;
}
}
// Check that the referenced Employee exists, and the review data is within the bounds of their employment.
var ev = await _employeeManager.GetAsync(context.Value.EmployeeId).ConfigureAwait(false);
if (ev == null)
{
context.AddError(x => x.EmployeeId, ValidatorStrings.ExistsFormat);
}
else
{
if (!context.HasError(x => x.Date))
{
if (context.Value.Date < ev.StartDate)
{
context.AddError(x => x.Date, "{0} must not be prior to the Employee starting.");
}
else if (ev.Termination != null && context.Value.Date > ev.Termination.Date)
{
context.AddError(x => x.Date, "{0} must not be after the Employee has terminated.");
}
}
}
}
}
private void ValidateElement(ValidationContext context)
{
if (_curReg != null)
{
foreach (var error in _curReg.CheckConstraints(context))
{
context.AddError(error);
}
}
}
internal override bool Validate(ValidationContext context)
{
for (int index = 0; index < 2; index++)
{
BuiltinLanguageType poppedType = context.StackPop();
if (0 == poppedType)
{
context.AddError("Attempt to pop an empty stack.");
}
if (ArgumentsType != poppedType)
{
context.AddError(string.Format("Popped an {0} for a relational instruction on {1}.",
poppedType, ArgumentsType));
return(false);
}
}
context.StackPush(BuiltinLanguageType.I32);
return(true);
}
private async Task <UserRow> ValidateAndReturnUser(Claim userIdClaim, ValidationContext <UserLoginCommandResult> context)
{
if (userIdClaim?.Value == null)
{
context.AddError("Invalid Token");
_logger.LogDebug("UserId could not be extracted from the claim");
return(null);
}
var user = await _userService.GetUser(Guid.Parse(userIdClaim.Value));
if (user != null && !user.IsDisabled)
{
return(user);
}
context.AddError("Invalid Token");
_logger.LogDebug("User either no longer exists or has been disabled");
return(null);
}
public void Validate(Type type, ValidationContext context)
{
if (!type.TryGetInterfaceClosing(typeof(IEnumerable <>), out var @interface))
{
context.AddError($"type mismatch, expected enumerable but found {context.GetTypeName(type)}");
return;
}
using (context.CreateScope("Item"))
context.Validate(@interface.GetGenericArguments().Single(), _itemDataContract);
}
internal override bool Validate(ValidationContext context)
{
Tuple <BuiltinLanguageType, int, bool> label;
uint defaultLabel = Targets[Targets.Length - 1];
if (!context.GetLabel(defaultLabel, out label))
{
context.AddError(string.Format("Table based branching as undefined default label {0}.", defaultLabel));
return(false);
}
BuiltinLanguageType defaultType = label.Item1;
foreach (uint target in Targets)
{
if (!context.GetLabel(target, out label))
{
context.AddError(string.Format("Table based branching as undefined label {0}.", target.ToString()));
return(false);
}
if (label.Item1 != defaultType)
{
context.AddError(string.Format("Unconsistent label {0} typing. Default type {1}, current type {2}.",
target.ToString(), defaultType.ToString(), label.Item1.ToString()));
return(false);
}
}
BuiltinLanguageType poppedType = context.StackPop();
if (0 == poppedType)
{
context.AddError("Table based branching found with empty stack.");
return(false);
}
if (BuiltinLanguageType.I32 != poppedType)
{
context.AddError("Table based branching requires I32 argument.");
return(false);
}
if (BuiltinLanguageType.EmptyBlock != defaultType)
{
poppedType = context.StackPop();
if (0 == poppedType)
{
context.AddError(string.Format("Table based branching found with missing {0} value on stack.",
defaultType.ToString()));
return(false);
}
if (defaultType != poppedType)
{
context.AddError(string.Format("Table based branching expected an {0} value on stack. Found a {1}",
defaultType.ToString(), poppedType.ToString()));
return(false);
}
}
return(true);
}
public void Validate(Type type, ValidationContext context)
{
if (type == _type)
{
return;
}
var expected = context.GetTypeName(_type);
var actual = context.GetTypeName(type);
context.AddError($"type mismatch, expected {expected} but found {actual}");
}
public void Validate(Type type, ValidationContext context)
{
var actualType = GetActualTypeString(type, context, out var enumType);
var expectedType = GetExpectedTypeString();
if (actualType != expectedType)
{
context.AddError($"type mismatch, expected {expectedType} but found {actualType}");
return;
}
var underlyingType = System.Enum.GetUnderlyingType(enumType);
var actualValues = System.Enum.GetValues(enumType).Cast <object>().Select(x => Convert.ChangeType(x, underlyingType).ToString()).ToList();
if (actualValues.Except(_expectedValues).Concat(_expectedValues.Except(actualValues)).Any())
{
var expectedValuesString = string.Join(",", _expectedValues);
var actualValuesString = string.Join(",", actualValues);
context.AddError($"enum values mismatch, expected [{expectedValuesString}] but found [{actualValuesString}]");
}
}
public void Validate(Type type, ValidationContext context)
{
if (!type.TryGetInterfaceClosing(typeof(IDictionary <,>), out var @interface))
{
context.AddError($"type mismatch, expected dictionary but found {context.GetTypeName(type)}");
return;
}
using (context.CreateScope("Key"))
context.Validate(@interface.GetGenericArguments()[0], _keyDataContract);
using (context.CreateScope("Value"))
context.Validate(@interface.GetGenericArguments()[1], _valueDataContract);
}
internal static void Validate(ValidationContext validationContext)
{
var element = (OpenXmlCompositeElement)validationContext.Element;
ValidationErrorInfo errorInfo;
foreach (var child in element.ChildElements)
{
if (!(child is OpenXmlMiscNode))
{
errorInfo = validationContext.ComposeSchemaValidationError(element, null, "Sch_InvalidChildinLeafElement", element.XmlQualifiedName.ToString());
validationContext.AddError(errorInfo);
return; // just return one error is enough.
}
}
}
internal static bool AddMemberNameToHashSet(IEdmNamedElement item, HashSetInternal<string> memberNameList, ValidationContext context, EdmErrorCode errorCode, string errorString, bool suppressError)
{
IEdmSchemaElement schemaElement = item as IEdmSchemaElement;
string name = (schemaElement != null) ? schemaElement.FullName() : item.Name;
if (!memberNameList.Add(name))
{
if (!suppressError)
{
context.AddError(item.Location(), errorCode, errorString);
}
return false;
}
return true;
}
public async Task<ActionResult> Login(LoginViewModel model)
{
var timeout = this.GetTimeoutToken();
var validationContext = new ValidationContext();
model.Validate(validationContext);
if (validationContext.HasErrors)
{
this.AddModelStateError(validationContext);
return await this.View(model, timeout);
}
var account = new Account
{
IdentityType = IdentityType.EmailAddress,
IdentityValue = model.EmailAddress.Trim().ToLowerInvariant(),
};
account = await this.accountStore.Get(account.PartitionKey, account.RowKey, timeout);
if (account == null || BCrypt.Net.BCrypt.Verify(model.Password, account.PasswordHash) == false)
{
validationContext.AddError("Cannot find a matching account and password. Please try again!");
this.AddModelStateError(validationContext);
return await this.View(model, timeout);
}
await this.CreateNewSession(account, model.RememberMe, timeout);
return this.RedirectToAction("Index", "Home");
}
