private static void ValidateSpecialProperties(string name, ValidationContext <Property> cntx, Property p, Catalog c, IGroupListCatalogs gc)
{
if (c.GetUseCodeProperty())
{
if (gc.PropertyCodeName == name)
{
var vf = new ValidationFailure(nameof(p.Name),
$"Catalog parameter 'UseCodeProperty' is set to 'true'. Property name '{gc.PropertyCodeName}' is reserved for auto generated property");
vf.Severity = Severity.Error;
cntx.AddFailure(vf);
}
}
if (c.GetUseNameProperty())
{
if (gc.PropertyNameName == name)
{
var vf = new ValidationFailure(nameof(p.Name),
$"Catalog parameter 'UseNameProperty' is set to 'true'. Property name '{gc.PropertyNameName}' is reserved for auto generated property");
vf.Severity = Severity.Error;
cntx.AddFailure(vf);
}
}
if (c.GetUseDescriptionProperty())
{
if (gc.PropertyDescriptionName == name)
{
var vf = new ValidationFailure(nameof(p.Name),
$"Catalog parameter 'UseDescriptionProperty' is set to 'true'. Property name '{gc.PropertyDescriptionName}' is reserved for auto generated property");
vf.Severity = Severity.Error;
cntx.AddFailure(vf);
}
}
}
private static void CheckObjectsWithDbTables(ValidationContext <Model> cntx, string recom, Model m, bool isCheckTabs)
{
var dic = new Dictionary <string, ITreeConfigNode>();
foreach (var t in m.GroupCatalogs.ListCatalogs)
{
if (string.IsNullOrWhiteSpace(t.CompositeName))
{
continue;
}
if (dic.ContainsKey(t.CompositeName))
{
var sb = GenMessage(dic, t, t.CompositeName);
sb.Append("'.");
sb.Append(recom);
cntx.AddFailure(sb.ToString());
}
else
{
dic[t.CompositeName] = t;
}
if (isCheckTabs)
{
CheckTabs(cntx, dic, t.GroupPropertiesTabs, recom);
}
}
foreach (var t in m.GroupDocuments.GroupListDocuments.ListDocuments)
{
if (string.IsNullOrWhiteSpace(t.CompositeName))
{
continue;
}
if (dic.ContainsKey(t.CompositeName))
{
var sb = GenMessage(dic, t, t.CompositeName);
sb.Append("'.");
sb.Append(recom);
cntx.AddFailure(sb.ToString());
}
else
{
dic[t.CompositeName] = t;
}
if (isCheckTabs)
{
CheckTabs(cntx, dic, t.GroupPropertiesTabs, recom);
}
}
}
private void ValidateUserDisplayName(string displayName, ValidationContext <CreateUserProfileCommand> context)
{
// Checks whether the display name is not null, empty or contains only white spaces.
if (string.IsNullOrWhiteSpace(displayName))
{
context.AddFailure("The display name must not be null or empty.");
return;
}
// Checks whether the display name does not exceed 64 characters.
if (displayName.Length > 30)
{
context.AddFailure("The display name must not exceed 64 characters.");
}
}
public static void AddValidationResults(ValidationContext <AppProjectGenerator> cntx, List <ValidationPluginMessage> lst)
{
foreach (var t in lst)
{
var r = new ValidationFailure(cntx.PropertyName, t.Message);
switch (t.Level)
{
case ValidationPluginMessage.EnumValidationMessage.Error:
r.Severity = Severity.Error;
break;
case ValidationPluginMessage.EnumValidationMessage.Warning:
r.Severity = Severity.Warning;
break;
case ValidationPluginMessage.EnumValidationMessage.Info:
r.Severity = Severity.Info;
break;
default:
throw new Exception();
}
cntx.AddFailure(r);
}
}
private static bool MatchChecksums(RomToProjectAssociation container, Project?project,
ValidationContext <RomToProjectAssociation> validationContext)
{
if (project?.Data == null)
{
return(false);
}
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
var checksumToVerify =
ByteUtil.ConvertByteArrayToUInt32(container.RomBytes, project.Data.RomComplementOffset);
if (checksumToVerify == project.InternalCheckSum)
{
return(true);
}
validationContext.AddFailure($"The linked ROM's checksums '{checksumToVerify:X8}' " +
$"doesn't match the project's checksums of '{project.InternalCheckSum:X8}'.");
return(false);
}
private void ValidateBucketName(string input, ValidationContext <T> context)
{
if (!_validator.TryValidateBucketName(input, _cfg.BucketNameValidationMode, out ValidationStatus status, out string?allowed))
{
context.AddFailure("Invalid bucket name: " + ValidationMessages.GetMessage(status, allowed));
}
}
private void ValidateObjectKey(string input, ValidationContext <T> context)
{
if (!_validator.TryValidateObjectKey(input, _cfg.ObjectKeyValidationMode, out ValidationStatus status, out string?allowed))
{
context.AddFailure("Invalid object key: " + ValidationMessages.GetMessage(status, allowed));
}
}
private void ValidateKeyId(string input, ValidationContext <IAccessKey> context)
{
if (!_inputValidator.TryValidateKeyId(input, out ValidationStatus status, out string?allowed))
{
context.AddFailure("Invalid key id: " + ValidationMessages.GetMessage(status, allowed));
}
}
private void ValidateSecretKey(byte[] input, ValidationContext <IAccessKey> context)
{
if (!_inputValidator.TryValidateAccessKey(input, out ValidationStatus status, out string?allowed))
{
context.AddFailure("Invalid secret key: " + ValidationMessages.GetMessage(status, allowed));
}
}
/// <inheritdoc/>
public override bool IsValid(ValidationContext <WorkflowDefinition> context, List <StateDefinition> value)
{
var index = 0;
foreach (var state in value)
{
if (!StateValidatorTypes.TryGetValue(state.GetType(), out var validatorTypes))
{
continue;
}
var validators = validatorTypes !.Select(t => (IValidator)Activator.CreateInstance(t, (WorkflowDefinition)context.InstanceToValidate) !);
foreach (IValidator validator in validators)
{
var args = new object[] { state };
var validationMethod = typeof(IValidator <>).MakeGenericType(state.GetType())
.GetMethods()
.Single(m =>
m.Name == nameof(IValidator.Validate) &&
m.GetParameters().Length == 1 &&
m.GetParameters().First().ParameterType != typeof(IValidationContext));
var validationResult = (ValidationResult)validationMethod.Invoke(validator, args) !;
if (validationResult.IsValid)
{
continue;
}
foreach (var failure in validationResult.Errors)
{
context.AddFailure(failure);
}
return(false);
}
index++;
}
return(true);
}
/// <inheritdoc/>
public override bool IsValid(ValidationContext <WorkflowDefinition> context, IEnumerable <TElement>?value)
{
int index = 0;
if (value == null)
{
return(true);
}
foreach (TElement elem in value)
{
IEnumerable <IValidator <TElement> > validators = this.ServiceProvider.GetServices <IValidator <TElement> >();
foreach (IValidator <TElement> validator in validators)
{
ValidationResult validationResult = validator.Validate(elem);
if (validationResult.IsValid)
{
continue;
}
foreach (var failure in validationResult.Errors)
{
context.AddFailure(failure);
}
return(false);
}
index++;
}
return(true);
}
private void ValidateMethod(string value, ValidationContext <TestStringModel> ctx)
{
if (UnallowedValues.Contains(value, StringComparer.InvariantCultureIgnoreCase))
{
ctx.AddFailure("Value is not allowed");
}
}
private async Task CheckUserIdUniquenessAsync(Guid proposedUserId, ValidationContext <CreateUserProfileCommand> context, CancellationToken cancellationToken)
{
// Checks whether the user id is empty.
if (proposedUserId == Guid.Empty)
{
context.AddFailure("The user id can not be empty.");
return;
}
// Checks whether the user id already exists.
UserProfileAggregate userAggregate = await _userRepository.GetAsync(proposedUserId, cancellationToken);
if (userAggregate != default)
{
context.AddFailure("A user with the proposed user id already exists.");
return;
}
}
private void CheckUserIdExistsAsync(Guid proposedId, ValidationContext <CreateKweetCommand> context)
{
// Checks whether the user id is empty.
if (proposedId == Guid.Empty)
{
context.AddFailure("The user id can not be empty.");
return;
}
}
private async Task <bool> ValidateUserAsync(CreateAccountCommand cmd, long userId,
ValidationContext <CreateAccountCommand> ctx, CancellationToken cancellationToken)
{
var user = await _userService.GetByIdAsync(userId);
if (user == null)
{
ctx.AddFailure("UserId", "User does not exist");
return(false);
}
if (user.MonthlySalary - user.MonthlyExpenses < 1000)
{
ctx.AddFailure("UserId", "User does not meet account requirements");
return(false);
}
return(true);
}
private void HaveValidHeaders <T>(BulkRegisterOdsInstancesModel model, ValidationContext <T> context)
{
var missingHeaders = model.MissingHeaders();
if (missingHeaders == null || !missingHeaders.Any())
{
return;
}
ValidHeadersRuleFailed = true;
context.AddFailure($"Missing Headers: {string.Join(",", model.MissingHeaders())}");
}
private void ValidateInstallments(IList <Installment> list, ValidationContext <Payment> context)
{
if (list != null)
{
if (list.Any(p => p.Value <= 0))
{
context.AddFailure(ValidatorMessages.Payment.InstallmentWithInvalidValue);
}
if (list.Any(p => p.Date == default(DateTime)))
{
context.AddFailure(ValidatorMessages.Payment.InstallmentWithInvalidDate);
}
if (list.Any(p => p.PaidDate == default(DateTime)))
{
context.AddFailure(ValidatorMessages.Payment.InstallmentWithInvalidPaidDate);
}
if (list.Any(p => p.Number <= 0 || p.Number > 72))
{
context.AddFailure(ValidatorMessages.Payment.InstallmentWithInvalidNumber);
}
if (list.Select(p => p.Number).Distinct().Count() != list.Count)
{
context.AddFailure(ValidatorMessages.Payment.InstallmentWithRepeatedNumbers);
}
if (list.Count > 72)
{
context.AddFailure(ValidatorMessages.Payment.InstallmentWithMaxLengthExceded);
}
}
}
protected virtual void ApplyRuleForItems(CartValidationContext cartContext, ValidationContext <CartValidationContext> context)
{
cartContext.CartAggregate.Cart.Items?.Apply(item =>
{
var lineItemContext = new LineItemValidationContext
{
LineItem = item,
AllCartProducts = cartContext.AllCartProducts ?? cartContext.CartAggregate.CartProducts.Values
};
var result = LineItemValidator.Validate(lineItemContext);
result.Errors.Apply(x => context.AddFailure(x));
});
}
protected virtual void ApplyRuleForShipments(CartValidationContext cartContext, ValidationContext <CartValidationContext> context)
{
cartContext.CartAggregate.Cart.Shipments?.Apply(shipment =>
{
var shipmentContext = new ShipmentValidationContext
{
Shipment = shipment,
AvailShippingRates = cartContext.AvailShippingRates
};
var result = ShipmentValidator.Validate(shipmentContext);
result.Errors.Apply(x => context.AddFailure(x));
});
}
protected virtual void ApplyRuleForPayments(CartValidationContext cartContext, ValidationContext <CartValidationContext> context)
{
cartContext.CartAggregate.Cart.Payments?.Apply(payment =>
{
var paymentContext = new PaymentValidationContext
{
Payment = payment,
AvailPaymentMethods = cartContext.AvailPaymentMethods
};
var result = PaymentValidator.Validate(paymentContext);
result.Errors.Apply(x => context.AddFailure(x));
});
}
private async Task <bool> ValidateEmailAsync(CreateUserCommand cmd, string email,
ValidationContext <CreateUserCommand> ctx, CancellationToken cancellationToken)
{
var user = await _userService.GetUserByEmailAsync(email);
if (user != null)
{
ctx.AddFailure("Email", $"User with such email [{email}] already exists");
return(false);
}
return(true);
}
private void ValidateRangeValuesRequirements(ValidationContext <Property> cntx, Property p)
{
var req = PropertyValidator.GetRangeValidation(p);
if (req.IsHasErrors)
{
foreach (var t in req.ListErrors)
{
var vf = new ValidationFailure(nameof(p.RangeValuesRequirementStr), t);
vf.Severity = Severity.Error;
cntx.AddFailure(vf);
}
}
}
private static bool MatchCartTitle(string requiredGameNameMatch, string gameNameFromRomBytes,
ValidationContext <RomToProjectAssociation> validationContext)
{
if (requiredGameNameMatch == gameNameFromRomBytes)
{
return(true);
}
validationContext.AddFailure(
$"Verification check: The project file requires the linked ROM's SNES header " +
$"to have a cartridge title name of:'{requiredGameNameMatch}'. \n" +
$"But, this doesn't match the title in the ROM file, which is:\n'{gameNameFromRomBytes}'.");
return(false);
}
private static bool HaveValidRomSize(RomToProjectAssociation container, Project?project, ValidationContext <RomToProjectAssociation> validationContext)
{
if (project == null)
{
return(false);
}
if (container.RomBytes?.Length > project.Data?.RomSettingsOffset + 10)
{
return(true);
}
validationContext.AddFailure("The linked ROM is too small. It can't be opened.");
return(false);
}
private void CheckUserIdExists(Guid proposedId, ValidationContext <CreatedFollowerCommand> context)
{
// Checks whether the user id is empty.
if (proposedId == Guid.Empty)
{
context.AddFailure("The user id can not be empty.");
return;
}
// Checks whether the user id already exists.
// TODO Check if user ids already exists.
//KweetAggregate kweetAggregate = await _kweetRepository.GetAsync(proposedId, cancellationToken);
//if (kweetAggregate != default)
//{
// context.AddFailure("A user with the proposed user id already exists.");
// return;
//}
}
private static void CheckTabs(ValidationContext <Model> cntx, Dictionary <string, ITreeConfigNode> dic, IGroupListPropertiesTabs tabs, string recom)
{
foreach (var t in tabs.ListPropertiesTabs)
{
if (string.IsNullOrWhiteSpace(t.CompositeName))
{
continue;
}
if (dic.ContainsKey(t.CompositeName))
{
var sb = GenMessage(dic, t, t.CompositeName);
sb.Append("'.");
sb.Append(recom);
cntx.AddFailure(sb.ToString());
}
else
{
dic[t.CompositeName] = t;
}
CheckTabs(cntx, dic, t.GroupPropertiesTabs, recom);
}
}
/// <inheritdoc/>
public override bool IsValid(ValidationContext <WorkflowDefinition> context, IEnumerable <FunctionDefinition> value)
{
WorkflowDefinition workflow = context.InstanceToValidate;
int index = 0;
IValidator <FunctionDefinition> validator = new FunctionDefinitionValidator(workflow);
foreach (FunctionDefinition function in value)
{
ValidationResult validationResult = validator.Validate(function);
if (validationResult.IsValid)
{
index++;
continue;
}
foreach (var failure in validationResult.Errors)
{
context.AddFailure(failure);
}
return(false);
}
return(true);
}
public override ValidationResult Validate(ValidationContext <ResourceElement> context)
{
EnsureArg.IsNotNull(context, nameof(context));
var failures = new List <ValidationFailure>();
if (context.InstanceToValidate is ResourceElement resourceElement)
{
var fhirContext = _contextAccessor.RequestContext;
var profileValidation = _runProfileValidation;
if (fhirContext.RequestHeaders.ContainsKey(KnownHeaders.ProfileValidation) &&
fhirContext.RequestHeaders.TryGetValue(KnownHeaders.ProfileValidation, out var hValue))
{
if (bool.TryParse(hValue, out bool headerValue))
{
profileValidation = headerValue;
}
}
if (profileValidation)
{
var errors = _profileValidator.TryValidate(resourceElement.Instance);
foreach (var error in errors.Where(x => x.Severity == IssueSeverity.Error || x.Severity == IssueSeverity.Fatal))
{
var validationFailure = new FhirValidationFailure(
resourceElement.InstanceType,
error.DetailsText,
error);
failures.Add(validationFailure);
}
}
var baseValidation = base.Validate(context);
failures.AddRange(baseValidation.Errors);
}
failures.ForEach(x => context.AddFailure(x));
return(new ValidationResult(failures));
}
public override FluentValidation.Results.ValidationResult Validate(ValidationContext <ResourceElement> context)
{
EnsureArg.IsNotNull(context, nameof(context));
var failures = new List <ValidationFailure>();
if (context.InstanceToValidate is ResourceElement resourceElement)
{
var results = new List <ValidationResult>();
if (!_modelAttributeValidator.TryValidate(resourceElement, results, false))
{
foreach (var error in results)
{
var fullFhirPath = resourceElement.InstanceType;
fullFhirPath += string.IsNullOrEmpty(error.MemberNames?.FirstOrDefault()) ? string.Empty : "." + error.MemberNames?.FirstOrDefault();
var validationFailure = new ValidationFailure(fullFhirPath, error.ErrorMessage);
failures.Add(validationFailure);
}
}
}
failures.ForEach(x => context.AddFailure(x));
return(new FluentValidation.Results.ValidationResult(failures));
}
public override ValidationResult Validate(ValidationContext <ResourceElement> context)
{
EnsureArg.IsNotNull(context, nameof(context));
var failures = new List <ValidationFailure>();
if (context.InstanceToValidate is ResourceElement resourceElement)
{
if (resourceElement.IsDomainResource)
{
failures.AddRange(ValidateResource(resourceElement.Instance));
}
else if (resourceElement.InstanceType.Equals(KnownResourceTypes.Bundle, System.StringComparison.OrdinalIgnoreCase))
{
var bundleEntries = resourceElement.Instance.Select(KnownFhirPaths.BundleEntries);
if (bundleEntries != null)
{
failures.AddRange(bundleEntries.SelectMany(ValidateResource));
}
}
}
failures.ForEach(x => context.AddFailure(x));
return(new ValidationResult(failures));
}