/// <summary>
/// Validate the query parameters if there are any.
/// </summary>
/// <param name="validationEvent"></param>
/// <returns></returns>
public override bool Validate(ValidationEvent validationEvent)
{
object target = validationEvent.Target;
IValidationResults results = validationEvent.Results;
bool valid = ValidateInternal(validationEvent);
if (!valid)
{
return(valid);
}
// Has paremeters?
NamedQuery query = (NamedQuery)target;
if (string.IsNullOrEmpty(query.Parameters))
{
return(true);
}
IList <NamedQueryParam> queryParams = NamedQueryParamsParser.ParseParams(query.Parameters);
NamedQueryParamsValidator validator = new NamedQueryParamsValidator(queryParams);
bool isValid = validator.Validate(results).IsValid;
return(isValid);
}
/// <summary>
/// Validate the target object( text ).
/// </summary>
/// <param name="target"></param>
/// <param name="results"></param>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
object target = validationEvent.Target;
IValidationResults results = validationEvent.Results;
bool useTarget = validationEvent.Target != null;
string text = useTarget ? (string)target : _text;
// Not required and email not supplied.
if (!_isRequired && string.IsNullOrEmpty(text))
{
return(true);
}
int initialErrorCount = results.Count;
bool isNullOrEmpty = string.IsNullOrEmpty(text);
ValidationUtils.Validate(isNullOrEmpty, results, _key, _messageIfEmptyAndRequired, text);
if (!isNullOrEmpty)
{
// Now check the format.
Regex regex = new Regex(_regEx);
if (!regex.IsMatch(text))
{
results.Add(_key, _messageIfRegExFails, null);
}
}
return(results.Count == initialErrorCount);
}
/// <summary>
/// Validate that the size is valid.
/// </summary>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
object target = validationEvent.Target;
IValidationResults results = validationEvent.Results;
bool useTarget = validationEvent.Target != null;
HtmlInputFile file = useTarget ? (HtmlInputFile)target : _file;
// Validate.
if (!ValidationUtils.Validate(file == null, results, string.Empty, _errorMessageNoFile, null))
{
return(false);
}
if (!ValidationUtils.Validate(file.PostedFile == null, results, string.Empty, _errorMessageNoFile, null))
{
return(false);
}
if (!ValidationUtils.Validate(file.PostedFile.ContentLength == 0, results, string.Empty, _errorMessageEmptyFileContent, null))
{
return(false);
}
int initialErrorCount = results.Count;
if (_restrictSize)
{
int fileSizeInKiloBytes = file.PostedFile.ContentLength / 1000;
if (fileSizeInKiloBytes > _restrictedFileSizeInKiloBytes)
{
results.Add(string.Empty, "File exceeds " + _restrictedFileSizeInKiloBytes + "K.", null);
}
}
return(results.Count == initialErrorCount);
}
public async Task ReturnsIncompleteIfAuditHasNoFailedOrSucceededEvents(ValidationEvent validationEvent)
{
// Arrange
_validationAuditor
.Setup(x => x.ReadAuditAsync(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(new PackageValidationAudit
{
Entries = new List <PackageValidationAuditEntry>
{
new PackageValidationAuditEntry
{
ValidatorName = ValidatorName,
EventId = validationEvent,
},
},
});
// Act
var actual = await _target.GetStatusAsync(_validationRequest.Object);
// Assert
Assert.Equal(ValidationStatus.Incomplete, actual);
_validationAuditor.Verify(
x => x.ReadAuditAsync(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <string>()),
Times.Once);
_validationAuditor.Verify(
x => x.ReadAuditAsync(ValidationId, NormalizedPackageId, NormalizedPackageVersion),
Times.Once);
_validationService.Verify(
x => x.StartValidationProcessAsync(It.IsAny <NuGetPackage>(), It.IsAny <string[]>(), It.IsAny <Guid>()),
Times.Never);
}
/// <summary>
/// Do some basic validation. This is just a DUMMY validator
/// to show how to incorporation the validator into the code generator.
/// </summary>
/// <param name="validationEvent"></param>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
Address address = validationEvent.Target as Address;
IValidationResults errors = validationEvent.Results;
int initialErrorCount = errors.Count;
if (string.IsNullOrEmpty(address.City))
{
errors.Add("City is empty");
}
if (string.IsNullOrEmpty(address.State))
{
errors.Add("State is empty");
}
if (string.IsNullOrEmpty(address.Country))
{
errors.Add("Country is emtpy");
}
else if (address.Country.Trim().ToLower() != "usa")
{
errors.Add("Only supports 'usa' for now.");
}
return(initialErrorCount == errors.Count);
}
/// <summary>
/// Validate all the params and collect all the errors.
/// </summary>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
object target = validationEvent.Target;
IValidationResults results = validationEvent.Results;
string message = string.Empty;
bool success = true;
foreach (NamedQueryParam param in _namedQueryParams)
{
BoolMessage result = ValidateParam(param);
if (!result.Success)
{
success = false;
message += Environment.NewLine + result.Message;
}
}
// Don't create instance, return reaon-only singleton.
if (success)
{
return(BoolMessage.True.Success);
}
return(new BoolMessage(false, message).Success);
}
public bool MakePayment(string paymentName, decimal amount, Account backupAccount = null)
{
if (amount <= 0)
{
ValidationEvent?.Invoke(this, "You try to Pay 0. Are you kidding ?");
return(false);
}
// Ensures we have enough money
if (Balance >= amount)
{
_transactions.Add($"Withdrew { string.Format("{0:C2}", amount) } for { paymentName }");
Balance -= amount;
TransactionApprovedEvent?.Invoke(this, paymentName);
return(true);
}
else
{
// We don't have enough money so we check to see if we have a backup account
if (backupAccount != null)
{
// Checks to see if we have enough money in the backup account
if ((backupAccount.Balance + Balance) >= amount)
{
// We have enough backup funds so transfar the amount to this account
// and then complete the transaction.
decimal amountNeeded = amount - Balance;
bool overdraftSucceeded = backupAccount.MakePayment("Overdraft Protection", amountNeeded);
// This should always be true but we will check anyway
if (overdraftSucceeded == false)
{
ValidationEvent?.Invoke(this, "The overdraft failed so this transaction failed");
return(false);
}
AddDeposit("Overdraft Protection Deposit", amountNeeded);
_transactions.Add($"Withdrew { string.Format("{0:C2}", amount) } for { paymentName }");
Balance -= amount;
TransactionApprovedEvent?.Invoke(this, paymentName);
OverdraftEvent?.Invoke(this, new OverDraftEventArgs(amountNeeded, "Extra Info"));
return(true);
}
else
{
ValidationEvent?.Invoke(this, "Not enough backup funds to do anything");
return(false);
}
}
else
{
ValidationEvent?.Invoke(this, "You don't have enough money in the backup account");
return(false);
}
}
}
/// <summary>
/// Implement this method.
/// </summary>
/// <param name="validationEvent">Validation event.</param>
/// <returns>Validation result.</returns>
protected virtual bool ValidateInternal(ValidationEvent validationEvent)
{
if (_validatorLamda != null)
{
return(_validatorLamda(validationEvent));
}
return(true);
}
/// <summary>
/// Validate the category.
/// </summary>
/// <param name="validationEvent"></param>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
object target = validationEvent.Target;
IValidationResults results = validationEvent.Results;
bool useTarget = validationEvent.Target != null;
int initialErrorCount = results.Count;
Category category = useTarget ? (Category)target : _category;
ValidationUtils.Validate(string.IsNullOrEmpty(category.Name), results, "Title", "Category title can not be empty");
return(initialErrorCount == results.Count);
}
/// <summary>
/// Do some custom validation on a user name(string).
/// </summary>
/// <param name="validationEvent"></param>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
int originalErrorCount = validationEvent.Results.Count;
Meeting meeting = validationEvent.TargetT <Meeting>();
if (string.IsNullOrEmpty(meeting.Title))
{
validationEvent.Results.Add("Title must be specified.");
}
return(originalErrorCount == validationEvent.Results.Count);
}
/// <summary>
/// Is valid - text doesn't contain any word that has
/// more than maxChars specified.
/// </summary>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
object target = validationEvent.Target;
IValidationResults results = validationEvent.Results;
bool useTarget = validationEvent.Target != null;
string text = useTarget ? (string)target : _text;
if (string.IsNullOrEmpty(text))
{
return(true);
}
bool isSpacerNewLine = false;
int currentPosition = 0;
int ndxSpace = StringHelpers.GetIndexOfSpacer(text, currentPosition, ref isSpacerNewLine);
//Check if single very long word ( no spaces )
if (ndxSpace < 0 && text.Length > _maxCharsInWord)
{
results.Add(_errorMessage + _maxCharsInWord + " chars.");
return(false);
}
while ((currentPosition < text.Length && ndxSpace > 0))
{
//Lenght of word
int wordLength = ndxSpace - (currentPosition + 1);
if (wordLength > _maxCharsInWord)
{
results.Add(_errorMessage + _maxCharsInWord + " chars.");
return(false);
}
currentPosition = ndxSpace;
ndxSpace = StringHelpers.GetIndexOfSpacer(text, (currentPosition + 1), ref isSpacerNewLine);
}
// Final check.. no space found but check complete length now.
if (currentPosition < text.Length && ndxSpace < 0)
{
//Lenght of word
int wordLength = (text.Length - 1) - currentPosition;
if (wordLength > _maxCharsInWord)
{
results.Add(_errorMessage + _maxCharsInWord + " chars.");
return(false);
}
}
return(true);
}
/// <summary>
/// Validation method for the entity.
/// </summary>
/// <param name="validationEvent"></param>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
int initialErrorCount = validationEvent.Results.Count;
IValidationResults results = validationEvent.Results;
ConfigItem entity = (ConfigItem)validationEvent.Target;
Validation.IsStringLengthMatch(entity.App, true, false, true, -1, 50, results, "App");
Validation.IsStringLengthMatch(entity.Name, true, false, true, -1, 50, results, "Name");
Validation.IsStringLengthMatch(entity.Section, true, false, true, -1, 20, results, "Section");
Validation.IsStringLengthMatch(entity.Key, false, false, true, -1, 20, results, "Key");
Validation.IsStringLengthMatch(entity.Val, false, false, false, -1, -1, results, "Val");
Validation.IsStringLengthMatch(entity.ValType, true, false, true, -1, 20, results, "ValType");
return(initialErrorCount == validationEvent.Results.Count);
}
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
Person p = validationEvent.Target as Person;
if (string.IsNullOrEmpty(p.Name))
{
validationEvent.Results.Add("Name is not supplied.");
return(false);
}
else if (p.Name.Length > ((PersonSettings)p.Settings).MaxLength)
{
validationEvent.Results.Add("Name exceeds max lenght.");
return(false);
}
return(true);
}
/// <summary>
/// Validates all the rules in the internal rule list.
/// </summary>
/// <param name="validationEvent"></param>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
// Should this even be here?
if (_validatorLamda != null)
{
return(_validatorLamda(validationEvent));
}
// Run the validations against all the rules.
int initialErrorCount = validationEvent.Results.Count;
foreach (var rule in _rules)
{
rule.Rule(validationEvent);
}
return(validationEvent.Results.Count == initialErrorCount);
}
/// <summary>
/// Get the entity action from the validation event's context.
/// </summary>
/// <param name="validationEvent"></param>
/// <returns></returns>
public EntityAction GetEntityAction(ValidationEvent validationEvent)
{
EntityAction action = EntityAction.Create;
if (validationEvent.Context == null)
{
IEntity entity = (IEntity)validationEvent.Target;
if (entity.IsPersistant())
{
action = EntityAction.Update;
}
}
else if (validationEvent.Context is EntityAction)
{
action = (EntityAction)validationEvent.Context;
}
return(action);
}
/// <summary>
/// Validation method for the entity.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="useTarget">if set to <c>true</c> [use target].</param>
/// <param name="results">The results.</param>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
object target = validationEvent.Target;
IValidationResults results = validationEvent.Results;
int initialErrorCount = results.Count;
NamedQuery entity = (NamedQuery)target;
Validation.IsStringLengthMatch(entity.Name, false, true, true, 1, 100, results, "Name");
Validation.IsStringLengthMatch(entity.Description, true, false, true, -1, 200, results, "Description");
Validation.IsStringLengthMatch(entity.Sql, false, true, true, 1, 500, results, "Sql");
Validation.IsStringLengthMatch(entity.Parameters, true, false, true, -1, 250, results, "Parameters");
Validation.IsNumericWithinRange(entity.OrderId, false, false, -1, -1, results, "OrderId");
Validation.IsStringLengthMatch(entity.ItemType, true, false, true, -1, 50, results, "ItemType");
Validation.IsStringLengthMatch(entity.Roles, true, false, true, -1, 50, results, "Roles");
return(initialErrorCount == results.Count);
}
/// <summary>
/// Validation method for the entity.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="useTarget">if set to <c>true</c> [use target].</param>
/// <param name="results">The results.</param>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
object target = validationEvent.Target;
IValidationResults results = validationEvent.Results;
int initialErrorCount = results.Count;
Account entity = (Account)target;
Validation.IsStringLengthMatch(entity.SecurityQuestion, true, true, true, 0, 100, results, "SecurityQuestion");
Validation.IsStringLengthMatch(entity.SecurityAnswer, true, true, true, 0, 100, results, "SecurityAnswer");
Validation.IsStringLengthMatch(entity.Comment, true, true, true, 0, 100, results, "Comment");
Validation.IsStringLengthMatch(entity.LockOutReason, true, true, true, 0, 100, results, "LockOutReason");
Validation.IsDateWithinRange(entity.LastLoginDate, false, false, DateTime.MinValue, DateTime.MaxValue, results, "LastLoginDate");
Validation.IsDateWithinRange(entity.LastPasswordChangedDate, false, false, DateTime.MinValue, DateTime.MaxValue, results, "LastPasswordChangedDate");
Validation.IsDateWithinRange(entity.LastPasswordResetDate, false, false, DateTime.MinValue, DateTime.MaxValue, results, "LastPasswordResetDate");
Validation.IsDateWithinRange(entity.LastLockOutDate, false, false, DateTime.MinValue, DateTime.MaxValue, results, "LastLockOutDate");
return(initialErrorCount == results.Count);
}
/// <summary>
/// Validation method for the entity.
/// </summary>
/// <param name="validationEvent">The event containing the object to validate.</param>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
object target = validationEvent.Target;
IValidationResults results = validationEvent.Results;
int initialErrorCount = results.Count;
User entity = (User)target;
Validation.IsStringLengthMatch(entity.UserName, false, true, true, 3, 20, results, "UserName");
Validation.IsStringLengthMatch(entity.UserNameLowered, false, true, true, 3, 20, results, "UserNameLowered");
Validation.IsEmail(entity.Email, false, results, "Email");
Validation.IsStringLengthMatch(entity.Email, false, true, true, 6, 50, results, "Email");
Validation.IsStringLengthMatch(entity.Password, false, true, true, 5, 100, results, "Password");
Validation.IsStringLengthMatch(entity.Roles, true, false, false, -1, 50, results, "Roles");
Validation.IsStringLengthMatch(entity.MobilePhone, true, true, true, 10, 20, results, "MobilePhone");
Validation.IsStringLengthMatch(entity.SecurityQuestion, true, false, true, -1, 150, results, "SecurityQuestion");
Validation.IsStringLengthMatch(entity.SecurityAnswer, true, false, true, -1, 150, results, "SecurityAnswer");
Validation.IsStringLengthMatch(entity.Comment, true, false, true, -1, 50, results, "Comment");
Validation.IsStringLengthMatch(entity.LockOutReason, true, false, true, -1, 50, results, "LockOutReason");
return(initialErrorCount == results.Count);
}
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
object target = validationEvent.Target;
IValidationResults results = validationEvent.Results;
bool useTarget = validationEvent.Target != null;
string fileName = useTarget ? (string)target : _fileName;
int initialErrorCount = results.Count;
// Check file name was provided.
bool isNullOrEmpty = string.IsNullOrEmpty(fileName);
if (!ValidationUtils.Validate(isNullOrEmpty, results, string.Empty, "File not provided.", null))
{
return(false);
}
// Check that the file has an extension.
int ndxExtensionPeriod = fileName.LastIndexOf(".");
if (!ValidationUtils.Validate(ndxExtensionPeriod < 0, results, string.Empty, _errorMessagePrefix, null))
{
return(false);
}
// Error could occurr with file name = test. (ok for now)
// Check for .txt extension.
string fileExtension = fileName.Substring(ndxExtensionPeriod + 1);
fileExtension = fileExtension.Trim().ToLower();
// Check if valid format.
if (!IsValidFormat(fileExtension))
{
results.Add(string.Empty, _errorMessagePrefix, null);
}
return(results.Count == initialErrorCount);
}
/// <summary>
/// Validate the rule against the data.
/// </summary>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
object target = validationEvent.Target;
IValidationResults results = validationEvent.Results;
// No need to validate location if online.
if (_isOnline)
{
return(true);
}
// Clear out errors and keep track of initial error count.
int initialErrorCount = results.Count;
// Check for names instead of ids.
CheckCountryStateNames();
bool isCountryUSA = _countryId == LocationConstants.CountryId_USA;
// Check fields, city, stateid, countryId, zip
ValidationUtils.Validate(string.IsNullOrEmpty(_city), results, "City", "City is required.");
ValidationUtils.Validate(string.IsNullOrEmpty(_zip), results, "Zip", "Zip code is invalid");
ValidationUtils.Validate(_countryId <= 0, results, "Country", "Country is required.");
ValidationUtils.Validate((isCountryUSA && _stateId <= 0), results, "State", "State is not selected");
// Any errors ?
if (results.Count > initialErrorCount)
{
return(false);
}
// Check Country - State combination.
bool validStateCountryCombo = LocationHelper.IsValidStateCountryRelation(_stateLookup, _countryLookup, _stateId, _countryId);
ValidationUtils.Validate(!validStateCountryCombo, results, string.Empty, "State and country not a valid combination.");
// We found the city. Now compare that
return(results.Count == initialErrorCount);
}
/// <summary>
/// Validate the rule against the data.
/// </summary>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
object target = validationEvent.Target;
IValidationResults results = validationEvent.Results;
bool useTarget = validationEvent.Target != null;
string[] sentences = useTarget ? (string[])target : _sentences;
int initialErrorCount = results.Count;
foreach (string sentence in sentences)
{
if (!string.IsNullOrEmpty(sentence))
{
string lowerKeyWords = sentence.ToLower();
if (ContainsAnySqlWords(sentence))
{
results.Add("Invalid search criteria in keywords.");
}
}
}
return(initialErrorCount == results.Count);
}
/// <summary>
/// Validation method for the entity.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="useTarget">if set to <c>true</c> [use target].</param>
/// <param name="results">The results.</param>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
object target = validationEvent.Target;
IValidationResults results = validationEvent.Results;
int initialErrorCount = results.Count;
StatusUpdate entity = (StatusUpdate)target;
Validation.IsStringLengthMatch(entity.Computer, false, false, true, -1, 30, results, "Computer");
Validation.IsStringLengthMatch(entity.ExecutionUser, false, true, true, 1, 30, results, "ExecutionUser");
Validation.IsDateWithinRange(entity.BusinessDate, false, false, DateTime.MinValue, DateTime.MaxValue, results, "BusinessDate");
Validation.IsStringLengthMatch(entity.BatchName, false, true, true, 1, 30, results, "BatchName");
Validation.IsNumericWithinRange(entity.BatchId, false, false, -1, -1, results, "BatchId");
Validation.IsDateWithinRange(entity.BatchTime, false, false, DateTime.MinValue, DateTime.MaxValue, results, "BatchTime");
Validation.IsStringLengthMatch(entity.Task, false, true, true, 1, 50, results, "Task");
Validation.IsStringLengthMatch(entity.Status, false, true, true, 1, 30, results, "Status");
Validation.IsDateWithinRange(entity.StartTime, false, false, DateTime.MinValue, DateTime.MaxValue, results, "StartTime");
Validation.IsDateWithinRange(entity.EndTime, false, false, DateTime.MinValue, DateTime.MaxValue, results, "EndTime");
Validation.IsStringLengthMatch(entity.Ref, true, false, true, -1, 30, results, "Ref");
Validation.IsStringLengthMatch(entity.Comment, true, false, true, -1, 150, results, "Comment");
return(initialErrorCount == results.Count);
}
private ValidationStatus?GetValidationStatus(IValidationRequest request, ValidationEvent validationEvent)
{
switch (validationEvent)
{
case ValidationEvent.ValidatorException:
case ValidationEvent.BeforeVirusScanRequest:
case ValidationEvent.VirusScanRequestSent:
case ValidationEvent.VirusScanRequestFailed:
return(ValidationStatus.Incomplete);
case ValidationEvent.PackageClean:
return(ValidationStatus.Succeeded);
case ValidationEvent.PackageNotClean:
case ValidationEvent.NotCleanReason:
case ValidationEvent.ScanFailed:
case ValidationEvent.ScanFailureReason:
_logger.LogError(
Error.VcsValidationFailureAuditFound,
"A failed audit result was found for {validationId} ({packageId} {packageVersion}): {validationEvent}.",
request.ValidationId,
request.PackageId,
request.PackageVersion,
validationEvent);
return(ValidationStatus.Failed);
default:
_logger.LogError(
Error.VcsValidationUnexpectedAuditFound,
"An unexpected audit result was found for {validationId} ({packageId} {packageVersion}): {validationEvent}.",
request.ValidationId,
request.PackageId,
request.PackageVersion,
validationEvent);
return(ValidationStatus.Failed);
}
}
/// <summary>
/// Do some custom validation on a user name(string).
/// </summary>
/// <param name="validationEvent"></param>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
string id = (string)validationEvent.Target;
if (string.IsNullOrEmpty(id))
{
validationEvent.Results.Add("Must supply a userid.");
return(false);
}
id = id.ToLower();
if (id == "admin" || id == "administrator")
{
validationEvent.Results.Add("Admin user name is reserved, you can not use it.");
return(false);
}
if (id.Length < 2 || id.Length > 15)
{
validationEvent.Results.Add("Must be between 2 >= username <= 15.");
return(false);
}
return(true);
}
/// <summary>
/// Validation method for the entity.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="useTarget">if set to <c>true</c> [use target].</param>
/// <param name="results">The results.</param>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
var val = new Validator((valEvent) =>
{
int initialErrorCount = validationEvent.Results.Count;
IValidationResults results = validationEvent.Results;
Event entity = (Event)validationEvent.Target;
Validation.IsStringLengthMatch(entity.Title, false, true, true, 10, 150, results, "Title");
Validation.IsStringLengthMatch(entity.Summary, false, false, true, -1, 200, results, "Summary");
Validation.IsStringLengthMatch(entity.Description, false, false, false, -1, -1, results, "Description");
Validation.IsDateWithinRange(entity.StartDate, false, false, DateTime.MinValue, DateTime.MaxValue, results, "StartDate");
Validation.IsDateWithinRange(entity.EndDate, false, false, DateTime.MinValue, DateTime.MaxValue, results, "EndDate");
Validation.IsNumericWithinRange(entity.StartTime, false, false, -1, -1, results, "StartTime");
Validation.IsNumericWithinRange(entity.EndTime, false, false, -1, -1, results, "EndTime");
Validation.IsStringRegExMatch(entity.Email, false, RegexPatterns.Email, results, "Email");
Validation.IsStringRegExMatch(entity.Phone, false, RegexPatterns.PhoneUS, results, "Phone");
Validation.IsStringRegExMatch(entity.Url, false, RegexPatterns.Url, results, "Url");
Validation.IsStringLengthMatch(entity.Keywords, true, false, true, -1, 100, results, "Keywords");
return(initialErrorCount == validationEvent.Results.Count);
});
return(val.IsValid);
}
/// <summary>
/// This Method will call the ValidateInternal method of this validator.
/// </summary>
/// <remarks>
/// The reason that the ValidateInternal method is NOT called directly by the
/// other Validate methods is because the CodeGenerator generates the Validation
/// code inside of the ValidateInternal method.
/// If a client wants to override the validation while sill leveraging the autogenerated
/// validation code, it can be done by overrideing this method and calling the
/// ValidateInternal method.
/// This allows a lot of flexibility for codegeneration.
/// </remarks>
/// <param name="target"></param>
/// <param name="useTarget"></param>
/// <param name="results"></param>
/// <returns></returns>
public virtual bool Validate(ValidationEvent validationEvent)
{
return ValidateInternal(validationEvent);
}
/// <summary>
/// Nothing in the base class.
/// </summary>
/// <param name="validationEvent"></param>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
return(true);
}
protected void WriteAuditEntry(List <PackageValidationAuditEntry> auditEntries, string message, ValidationEvent validationEvent)
{
auditEntries.Add(new PackageValidationAuditEntry
{
Timestamp = DateTimeOffset.UtcNow,
ValidatorName = Name,
Message = message,
EventId = validationEvent,
});
}
public void InvokeValidationEvent()
{
ValidationEvent.Invoke();
}
/// <summary>
/// This Method will call the ValidateInternal method of this validator.
/// </summary>
/// <remarks>
/// The reason that the ValidateInternal method is NOT called directly by the
/// other Validate methods is because the CodeGenerator generates the Validation
/// code inside of the ValidateInternal method.
/// If a client wants to override the validation while sill leveraging the autogenerated
/// validation code, it can be done by overrideing this method and calling the
/// ValidateInternal method.
/// This allows a lot of flexibility for codegeneration.
/// </remarks>
/// <param name="validationEvent">Validation event.</param>
/// <returns>Validation result.</returns>
public virtual bool Validate(ValidationEvent validationEvent)
{
return(ValidateInternal(validationEvent));
}
/// <summary>
/// Implement this method.
/// </summary>
/// <param name="validationEvent"></param>
/// <returns></returns>
protected virtual bool ValidateInternal(ValidationEvent validationEvent)
{
if (_validatorLamda != null)
return _validatorLamda(validationEvent);
return true;
}
/// <summary>
/// Validates all the rules in the internal rule list.
/// </summary>
/// <param name="validationEvent"></param>
/// <returns></returns>
protected override bool ValidateInternal(ValidationEvent validationEvent)
{
// Should this even be here?
if (_validatorLamda != null)
return _validatorLamda(validationEvent);
// Run the validations against all the rules.
int initialErrorCount = validationEvent.Results.Count;
foreach (var rule in _rules)
{
rule.Rule(validationEvent);
}
return validationEvent.Results.Count == initialErrorCount;
}
/// <summary> /// Implement this method. /// </summary> /// <param name="validationEvent"></param> /// <returns></returns> protected abstract bool ValidateInternal(ValidationEvent validationEvent);
