| public AddBusinessRuleValidationResult ( IBusinessRuleValidationResult businessRuleValidationResult ) : void | ||
| businessRuleValidationResult | IBusinessRuleValidationResult | The business rule validation result. |
| Результат | void | |
public IValidationContext Validate(string machineIdToValidate)
{
Argument.IsNotNullOrWhitespace(() => machineIdToValidate);
var validationContext = new ValidationContext();
Log.Debug("Retrieving machine id");
var machineId = _identificationService.GetMachineId();
Log.Debug("Validating machine id '{0}' against expected machine id '{1}'", machineId, machineIdToValidate);
var machineSplitted = machineId.Split(new[] { LicenseElements.IdentificationSeparator }, StringSplitOptions.None);
var expectedSplitter = machineIdToValidate.Split(new[] { LicenseElements.IdentificationSeparator }, StringSplitOptions.None);
if (machineSplitted.Length != expectedSplitter.Length)
{
var error = "The number of items inside the license differ too much, assuming machine ids do not match";
Log.Error(error);
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError(error));
return validationContext;
}
var invalidEntries = 0;
for (var i = 0; i < machineSplitted.Length; i++)
{
if (!string.Equals(expectedSplitter[i], machineSplitted[i], StringComparison.OrdinalIgnoreCase))
{
invalidEntries++;
}
}
if (invalidEntries > Threshold)
{
var error = string.Format("{0} values are not equal, not accepting the machine id, maximum threshold is '{1}'", invalidEntries, Threshold);
Log.Error(error);
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError(error));
return validationContext;
}
if (invalidEntries > 0)
{
var warning = string.Format("One of the values is not equal, but we have a threshold of {0} so accepting machine id", Threshold);
Log.Warning(warning);
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateWarning(warning));
}
return validationContext;
}
/// <summary>
/// Synchronizes the current with the specified context. This means that the current contains will become the same as the
/// specified context.
/// </summary>
/// <param name="validationContext">The validation context.</param>
/// <param name="additionalValidationContext">The additional validation context.</param>
/// <param name="onlyAddValidation">if set to <c>true</c>, validation is only added, not removed. This is great to build up summaries.</param>
/// <returns>The list of changes.</returns>
/// <exception cref="System.ArgumentOutOfRangeException"></exception>
/// <exception cref="ArgumentNullException">The <paramref name="validationContext" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="validationContext" /> is <c>null</c>.</exception>
public static List <ValidationContextChange> SynchronizeWithContext(this ValidationContext validationContext, IValidationContext additionalValidationContext, bool onlyAddValidation = false)
{
Argument.IsNotNull("validationContext", validationContext);
Argument.IsNotNull("additionalValidationContext", additionalValidationContext);
var changes = ValidationContextHelper.GetChanges(validationContext, additionalValidationContext);
foreach (var change in changes)
{
var validationResultAsField = change.ValidationResult as IFieldValidationResult;
var validationResultAsBusinessRule = change.ValidationResult as IBusinessRuleValidationResult;
switch (change.ChangeType)
{
case ValidationContextChangeType.Added:
if (validationResultAsField != null)
{
validationContext.AddFieldValidationResult(validationResultAsField);
}
else if (validationResultAsBusinessRule != null)
{
validationContext.AddBusinessRuleValidationResult(validationResultAsBusinessRule);
}
break;
case ValidationContextChangeType.Removed:
if (!onlyAddValidation)
{
if (validationResultAsField != null)
{
validationContext.RemoveFieldValidationResult(validationResultAsField);
}
else if (validationResultAsBusinessRule != null)
{
validationContext.RemoveBusinessRuleValidationResult(validationResultAsBusinessRule);
}
}
break;
default:
throw new ArgumentOutOfRangeException("change.ChangeType");
}
}
return(changes);
}
/// <summary>
/// Sets the business rule validation result.
/// </summary>
/// <param name="validationResult">The business rule validation result.</param>
/// <exception cref="ArgumentNullException">The <paramref name="validationResult"/> is <c>null</c>.</exception>
protected void SetBusinessRuleValidationResult(IBusinessRuleValidationResult validationResult)
{
Argument.IsNotNull("validationResult", validationResult);
if (string.IsNullOrEmpty(validationResult.Message))
{
return;
}
var previousValidations = _internalValidationContext.GetBusinessRuleValidations();
// First, check if the same error already exists
bool alreadyExists = (from previousFieldValidation in previousValidations
where string.Compare(previousFieldValidation.Message, validationResult.Message) == 0
select previousFieldValidation).Any();
if (alreadyExists)
{
return;
}
_internalValidationContext.AddBusinessRuleValidationResult(validationResult);
if (!IsValidating)
{
switch (validationResult.ValidationResultType)
{
case ValidationResultType.Warning:
NotifyWarningsChanged(string.Empty, true);
break;
case ValidationResultType.Error:
NotifyErrorsChanged(string.Empty, true);
break;
}
}
}
/// <summary>
/// Validates the current object for field and business rule errors.
/// </summary>
/// <param name="force">If set to <c>true</c>, a validation is forced (even if the object knows it is already validated).</param>
/// <param name="validateDataAnnotations">If set to <c>true</c>, the data annotations will be checked. This value is only used if <paramref name="force"/> is set to <c>true</c>.</param>
/// <remarks>
/// To check whether this object contains any errors, use the <see cref="INotifyDataErrorInfo.HasErrors"/> property.
/// </remarks>
internal void Validate(bool force, bool validateDataAnnotations)
{
if (SuspendValidation)
{
return;
}
if (IsValidating)
{
return;
}
IsValidating = true;
var existingValidationContext = (ValidationContext)_validationContext;
bool hasErrors = existingValidationContext.HasErrors;
bool hasWarnings = existingValidationContext.HasWarnings;
var validationContext = new ValidationContext();
var changes = new List<ValidationContextChange>();
var validator = GetValidator();
if (validator != null)
{
validator.BeforeValidation(this, existingValidationContext.GetFieldValidations(), existingValidationContext.GetBusinessRuleValidations());
}
OnValidating(validationContext);
CatchUpWithSuspendedAnnotationsValidation();
if (force && validateDataAnnotations)
{
var type = GetType();
var ignoredOrFailedPropertyValidations = _propertyValuesIgnoredOrFailedForValidation[type];
// In forced mode, validate all registered properties for annotations
var catelTypeInfo = PropertyDataManager.GetCatelTypeInfo(type);
foreach (var propertyData in catelTypeInfo.GetCatelProperties())
{
var propertyInfo = propertyData.Value.GetPropertyInfo(type);
if (propertyInfo == null || !propertyInfo.HasPublicGetter)
{
// Note: non-public getter, do not validate
ignoredOrFailedPropertyValidations.Add(propertyData.Key);
continue;
}
var propertyValue = GetValue(propertyData.Value);
ValidatePropertyUsingAnnotations(propertyData.Key, propertyValue, propertyData.Value);
}
#if !WINDOWS_PHONE && !NETFX_CORE && !PCL && !NET35
// Validate non-catel properties as well for attribute validation
foreach (var propertyInfo in catelTypeInfo.GetNonCatelProperties())
{
if (_firstAnnotationValidation)
{
if (propertyInfo.Value.IsDecoratedWithAttribute(typeof(ExcludeFromValidationAttribute)))
{
ignoredOrFailedPropertyValidations.Add(propertyInfo.Key);
}
}
if (!propertyInfo.Value.HasPublicGetter)
{
// Note: non-public getter, do not validate
ignoredOrFailedPropertyValidations.Add(propertyInfo.Key);
continue;
}
// TODO: Should we check for annotations attributes?
if (ignoredOrFailedPropertyValidations.Contains(propertyInfo.Key))
{
continue;
}
try
{
var propertyValue = propertyInfo.Value.PropertyInfo.GetValue(this, null);
ValidatePropertyUsingAnnotations(propertyInfo.Key, propertyValue, null);
}
catch (Exception ex)
{
Log.Warning(ex, "Failed to validate property '{0}.{1}', adding it to the ignore list", type.Name, propertyInfo.Key);
ignoredOrFailedPropertyValidations.Add(propertyInfo.Key);
}
}
_firstAnnotationValidation = false;
#endif
}
if (!IsValidated || force)
{
lock (_validationLock)
{
var fieldValidationResults = new List<IFieldValidationResult>();
var businessRuleValidationResults = new List<IBusinessRuleValidationResult>();
#region Fields
if (validator != null)
{
validator.BeforeValidateFields(this, validationContext.GetFieldValidations());
}
OnValidatingFields(validationContext);
if (validator != null)
{
validator.ValidateFields(this, fieldValidationResults);
}
#if !WINDOWS_PHONE && !NETFX_CORE && !PCL && !NET35
// Support annotation validation
fieldValidationResults.AddRange(from fieldAnnotationValidation in _dataAnnotationValidationResults
where !string.IsNullOrEmpty(fieldAnnotationValidation.Value)
select (IFieldValidationResult)FieldValidationResult.CreateError(fieldAnnotationValidation.Key, fieldAnnotationValidation.Value));
#endif
ValidateFields(fieldValidationResults);
OnValidatedFields(validationContext);
if (validator != null)
{
validator.AfterValidateFields(this, fieldValidationResults);
}
// As the last step, sync the field validation results with the context
foreach (var fieldValidationResult in fieldValidationResults)
{
validationContext.AddFieldValidationResult(fieldValidationResult);
}
#endregion
#region Business rules
if (validator != null)
{
validator.BeforeValidateBusinessRules(this, validationContext.GetBusinessRuleValidations());
}
OnValidatingBusinessRules(validationContext);
if (validator != null)
{
validator.ValidateBusinessRules(this, businessRuleValidationResults);
}
ValidateBusinessRules(businessRuleValidationResults);
OnValidatedBusinessRules(validationContext);
if (validator != null)
{
validator.AfterValidateBusinessRules(this, businessRuleValidationResults);
}
// As the last step, sync the field validation results with the context
foreach (var businessRuleValidationResult in businessRuleValidationResults)
{
validationContext.AddBusinessRuleValidationResult(businessRuleValidationResult);
}
#endregion
if (validator != null)
{
validator.Validate(this, validationContext);
}
IsValidated = true;
// Manual sync to get the changes
changes = existingValidationContext.SynchronizeWithContext(validationContext);
}
}
OnValidated(validationContext);
if (validator != null)
{
validator.AfterValidation(this, validationContext.GetFieldValidations(), validationContext.GetBusinessRuleValidations());
}
#region Notify changes
bool hasNotifiedBusinessWarningsChanged = false;
bool hasNotifiedBusinessErrorsChanged = false;
foreach (var change in changes)
{
var changeAsFieldValidationResult = change.ValidationResult as IFieldValidationResult;
var changeAsBusinessRuleValidationResult = change.ValidationResult as IBusinessRuleValidationResult;
if (changeAsFieldValidationResult != null)
{
switch (change.ValidationResult.ValidationResultType)
{
case ValidationResultType.Warning:
NotifyWarningsChanged(changeAsFieldValidationResult.PropertyName, false);
break;
case ValidationResultType.Error:
NotifyErrorsChanged(changeAsFieldValidationResult.PropertyName, false);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
else if (changeAsBusinessRuleValidationResult != null)
{
switch (change.ValidationResult.ValidationResultType)
{
case ValidationResultType.Warning:
if (!hasNotifiedBusinessWarningsChanged)
{
hasNotifiedBusinessWarningsChanged = true;
NotifyWarningsChanged(string.Empty, false);
}
break;
case ValidationResultType.Error:
if (!hasNotifiedBusinessErrorsChanged)
{
hasNotifiedBusinessErrorsChanged = true;
NotifyErrorsChanged(string.Empty, false);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
if (_validationContext.HasWarnings != hasWarnings)
{
RaisePropertyChanged(HasWarningsMessageProperty);
}
if (_validationContext.HasErrors != hasErrors)
{
RaisePropertyChanged(HasErrorsMessageProperty);
}
#endregion
IsValidating = false;
}
/// <summary>
/// Validates the license.
/// </summary>
/// <param name="license">The license key the user has given to be validated.</param>
/// <returns>The validation context containing all the validation results.</returns>
public IValidationContext ValidateLicense(string license)
{
Argument.IsNotNullOrWhitespace(() => license);
var validationContext = new ValidationContext();
Log.Info("Validating license");
try
{
var licenseObject = License.Load(license);
var failureList = licenseObject.Validate()
.Signature(_applicationIdService.ApplicationId)
.AssertValidLicense().ToList();
if (failureList.Count > 0)
{
foreach (var failure in failureList)
{
var businessRuleValidationResult = BusinessRuleValidationResult.CreateErrorWithTag(failure.Message, failure.HowToResolve);
validationContext.AddBusinessRuleValidationResult(businessRuleValidationResult);
}
}
var licenseAttributes = licenseObject.AdditionalAttributes;
if (licenseAttributes != null)
{
foreach (var licenseAttribute in licenseAttributes.GetAll())
{
if (string.Equals(licenseAttribute.Key, LicenseElements.MachineId))
{
Log.Debug("Validating license using machine ID");
var machineLicenseValidationContext = _machineLicenseValidationService.Validate(licenseAttribute.Value);
validationContext.SynchronizeWithContext(machineLicenseValidationContext, true);
if (machineLicenseValidationContext.HasErrors)
{
Log.Error("The license can only run on machine with ID '{0}'", licenseAttribute.Value);
}
}
// TODO: add additional attribute checks here
}
}
// Also validate the xml, very important for expiration date and version
var xmlValidationContext = ValidateXml(license);
validationContext.SynchronizeWithContext(xmlValidationContext, true);
}
catch (Exception ex)
{
Log.Error(ex, "An error occurred while loading the license");
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError("An unknown error occurred while loading the license, please contact support"));
}
finally
{
if (validationContext.GetErrors().Count > 0)
{
Log.Warning("License is not valid:");
Log.Indent();
foreach (var error in validationContext.GetErrors())
{
Log.Warning("- {0}\n{1}", error.Message, error.Tag as string);
}
Log.Unindent();
}
else
{
Log.Info("License is valid");
}
}
return validationContext;
}
/// <summary>
/// Validates the XML
/// </summary>
/// <param name="license">The license.</param>
/// <returns>The validation context containing all the validation results.</returns>
/// <exception cref="ArgumentException">The <paramref name="license" /> is <c>null</c> or whitespace.</exception>
/// <exception cref="XmlException">The license text is not valid XML.</exception>
/// <exception cref="Exception">The root element is not License.</exception>
/// <exception cref="Exception">There were no inner nodes found.</exception>
public IValidationContext ValidateXml(string license)
{
var validationContext = new ValidationContext();
if (string.IsNullOrWhiteSpace(license))
{
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError("No license available"));
}
var xmlDataList = new List<XmlDataModel>();
try
{
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(license);
var xmlRoot = xmlDoc.DocumentElement;
if (!string.Equals(xmlRoot.Name, "License"))
{
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError("Please make sure that you pasted the complete license, including the <License> tags"));
}
var xmlNodes = xmlRoot.ChildNodes;
foreach (XmlNode node in xmlNodes)
{
if (!string.Equals(node.Name, "ProductFeatures"))
{
xmlDataList.Add(new XmlDataModel
{
Name = node.Name,
Value = node.InnerText
});
}
else
{
foreach (XmlNode featureNode in node.ChildNodes)
{
xmlDataList.Add(new XmlDataModel
{
Name = featureNode.Attributes[0].Value,
Value = featureNode.InnerText
});
}
}
}
if (xmlDataList.Count == 0)
{
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError("License contains no valid data"));
}
var expData = xmlDataList.FirstOrDefault(x => string.Equals(x.Name, LicenseElements.Expiration));
if (expData != null)
{
DateTime expirationDateTime;
if (DateTime.TryParse(expData.Value, out expirationDateTime))
{
Log.Debug("Using expiration behavior '{0}'", _expirationBehavior.GetType().Name);
var portableLicense = License.Load(license);
if (_expirationBehavior.IsExpired(portableLicense, expirationDateTime, DateTime.Now))
{
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError("The license is expired"));
}
}
else
{
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError("The expiration date was not a valid date / tim value"));
}
}
var xmlDataVersion = xmlDataList.FirstOrDefault(x => string.Equals(x.Name, LicenseElements.Version));
if (xmlDataVersion != null)
{
Version licenseVersion;
if (Version.TryParse(xmlDataVersion.Value, out licenseVersion))
{
var productVersion = Assembly.GetExecutingAssembly().GetName().Version;
if (productVersion > licenseVersion)
{
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError("Your license only supports versions up to '{0}' while the current version of this product is '{1}'", licenseVersion, productVersion));
}
}
else
{
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError("The version was not a valid version value"));
}
}
}
catch (XmlException xmlex)
{
Log.Debug(xmlex);
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError("The license data is not a license"));
}
catch (Exception ex)
{
Log.Debug(ex);
//var innermessage = string.Empty;
//if (ex.InnerException != null)
//{
// innermessage = ex.InnerException.Message;
//}
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError(ex.Message));
}
if (validationContext.HasErrors || validationContext.HasWarnings)
{
Log.Warning("The XML is invalid");
}
return validationContext;
}
public void CorrectlyHandlesRemovalOfExistingValidationResult()
{
var validationContext = new ValidationContext();
var businessRuleValidation = BusinessRuleValidationResult.CreateError("MyError");
validationContext.AddBusinessRuleValidationResult(businessRuleValidation);
Assert.AreEqual(1, validationContext.GetBusinessRuleValidationCount());
validationContext.RemoveBusinessRuleValidationResult(businessRuleValidation);
Assert.AreEqual(0, validationContext.GetBusinessRuleValidationCount());
}
public void AddsValidationResultTwice()
{
var validationContext = new ValidationContext();
var businessRuleValidation = BusinessRuleValidationResult.CreateError("MyProperty");
validationContext.AddBusinessRuleValidationResult(businessRuleValidation);
Assert.AreEqual(1, validationContext.GetBusinessRuleValidationCount());
validationContext.AddBusinessRuleValidationResult(businessRuleValidation);
Assert.AreEqual(2, validationContext.GetBusinessRuleValidationCount());
}
public void ThrowsArgumentNullExceptionForNullValidationResult()
{
var validationContext = new ValidationContext();
ExceptionTester.CallMethodAndExpectException<ArgumentNullException>(() => validationContext.AddBusinessRuleValidationResult(null));
}
/// <summary>
/// Validates the current object for field and business rule errors.
/// </summary>
/// <param name="force">If set to <c>true</c>, a validation is forced (even if the object knows it is already validated).</param>
/// <param name="validateDataAnnotations">If set to <c>true</c>, the data annotations will be checked. This value is only used if <paramref name="force"/> is set to <c>true</c>.</param>
/// <remarks>
/// To check whether this object contains any errors, use the ValidationContext property.
/// </remarks>
internal void Validate(bool force, bool validateDataAnnotations)
{
if (IsValidating)
{
return;
}
if (IsValidationSuspended)
{
return;
}
IsValidating = true;
var existingValidationContext = _validationContext;
if (existingValidationContext == null)
{
existingValidationContext = new ValidationContext();
}
var hasErrors = existingValidationContext.HasErrors;
var hasWarnings = existingValidationContext.HasWarnings;
var validationContext = new ValidationContext();
var changes = new List <ValidationContextChange>();
var validator = GetValidator();
if (validator != null)
{
validator.BeforeValidation(this, existingValidationContext.GetFieldValidations(), existingValidationContext.GetBusinessRuleValidations());
}
OnValidating(validationContext);
if (force && validateDataAnnotations)
{
var type = GetType();
var ignoredOrFailedPropertyValidations = PropertiesNotCausingValidation[type];
// In forced mode, validate all registered properties for annotations
var catelTypeInfo = PropertyDataManager.GetCatelTypeInfo(type);
foreach (var propertyData in catelTypeInfo.GetCatelProperties())
{
if (propertyData.Value.IsModelBaseProperty)
{
continue;
}
var propertyInfo = propertyData.Value.GetPropertyInfo(type);
if (propertyInfo == null || !propertyInfo.HasPublicGetter)
{
// Note: non-public getter, do not validate
ignoredOrFailedPropertyValidations.Add(propertyData.Key);
continue;
}
ValidatePropertyUsingAnnotations(propertyData.Key);
}
#if !NETFX_CORE && !PCL
// Validate non-catel properties as well for attribute validation
foreach (var propertyInfo in catelTypeInfo.GetNonCatelProperties())
{
if (_firstAnnotationValidation)
{
if (propertyInfo.Value.IsDecoratedWithAttribute <ExcludeFromValidationAttribute>())
{
ignoredOrFailedPropertyValidations.Add(propertyInfo.Key);
}
}
if (!propertyInfo.Value.HasPublicGetter)
{
// Note: non-public getter, do not validate
ignoredOrFailedPropertyValidations.Add(propertyInfo.Key);
continue;
}
// TODO: Should we check for annotations attributes?
if (ignoredOrFailedPropertyValidations.Contains(propertyInfo.Key))
{
continue;
}
try
{
ValidatePropertyUsingAnnotations(propertyInfo.Key);
}
catch (Exception ex)
{
Log.Warning(ex, "Failed to validate property '{0}.{1}', adding it to the ignore list", type.Name, propertyInfo.Key);
ignoredOrFailedPropertyValidations.Add(propertyInfo.Key);
}
}
_firstAnnotationValidation = false;
#endif
}
if (!_isValidated || force)
{
lock (_validationContext)
{
var fieldValidationResults = new List <IFieldValidationResult>();
var businessRuleValidationResults = new List <IBusinessRuleValidationResult>();
#region Fields
if (validator != null)
{
validator.BeforeValidateFields(this, validationContext.GetFieldValidations());
}
OnValidatingFields(validationContext);
if (validator != null)
{
validator.ValidateFields(this, fieldValidationResults);
}
#if !NETFX_CORE && !PCL
// Support annotation validation
fieldValidationResults.AddRange(from fieldAnnotationValidation in _dataAnnotationValidationResults
where !string.IsNullOrEmpty(fieldAnnotationValidation.Value)
select(IFieldValidationResult) FieldValidationResult.CreateError(fieldAnnotationValidation.Key, fieldAnnotationValidation.Value));
#endif
ValidateFields(fieldValidationResults);
OnValidatedFields(validationContext);
if (validator != null)
{
validator.AfterValidateFields(this, fieldValidationResults);
}
// As the last step, sync the field validation results with the context
foreach (var fieldValidationResult in fieldValidationResults)
{
validationContext.AddFieldValidationResult(fieldValidationResult);
}
#endregion
#region Business rules
if (validator != null)
{
validator.BeforeValidateBusinessRules(this, validationContext.GetBusinessRuleValidations());
}
OnValidatingBusinessRules(validationContext);
if (validator != null)
{
validator.ValidateBusinessRules(this, businessRuleValidationResults);
}
ValidateBusinessRules(businessRuleValidationResults);
OnValidatedBusinessRules(validationContext);
if (validator != null)
{
validator.AfterValidateBusinessRules(this, businessRuleValidationResults);
}
// As the last step, sync the field validation results with the context
foreach (var businessRuleValidationResult in businessRuleValidationResults)
{
validationContext.AddBusinessRuleValidationResult(businessRuleValidationResult);
}
#endregion
if (validator != null)
{
validator.Validate(this, validationContext);
}
_isValidated = true;
// Manual sync to get the changes
changes = existingValidationContext.SynchronizeWithContext(validationContext);
}
}
OnValidated(validationContext);
if (validator != null)
{
validator.AfterValidation(this, validationContext.GetFieldValidations(), validationContext.GetBusinessRuleValidations());
}
#region Notify changes
var hasNotifiedBusinessWarningsChanged = false;
var hasNotifiedBusinessErrorsChanged = false;
foreach (var change in changes)
{
var changeAsFieldValidationResult = change.ValidationResult as IFieldValidationResult;
var changeAsBusinessRuleValidationResult = change.ValidationResult as IBusinessRuleValidationResult;
if (changeAsFieldValidationResult != null)
{
switch (change.ValidationResult.ValidationResultType)
{
case ValidationResultType.Warning:
NotifyWarningsChanged(changeAsFieldValidationResult.PropertyName, false);
break;
case ValidationResultType.Error:
NotifyErrorsChanged(changeAsFieldValidationResult.PropertyName, false);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
else if (changeAsBusinessRuleValidationResult != null)
{
switch (change.ValidationResult.ValidationResultType)
{
case ValidationResultType.Warning:
if (!hasNotifiedBusinessWarningsChanged)
{
hasNotifiedBusinessWarningsChanged = true;
NotifyWarningsChanged(string.Empty, false);
}
break;
case ValidationResultType.Error:
if (!hasNotifiedBusinessErrorsChanged)
{
hasNotifiedBusinessErrorsChanged = true;
NotifyErrorsChanged(string.Empty, false);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
if (_validationContext.HasWarnings != hasWarnings)
{
RaisePropertyChanged(this, new PropertyChangedEventArgs(nameof(HasWarnings)), false, false);
RaisePropertyChanged(this, new PropertyChangedEventArgs(HasWarningsMessageProperty), false, false);
}
if (_validationContext.HasErrors != hasErrors)
{
RaisePropertyChanged(this, new PropertyChangedEventArgs(nameof(HasErrors)), false, false);
RaisePropertyChanged(this, new PropertyChangedEventArgs(HasErrorsMessageProperty), false, false);
}
#endregion
IsValidating = false;
}
public IValidationContext Parse(List<string> commandLineArguments, IContext targetContext)
{
var validationContext = new ValidationContext();
targetContext.OriginalCommandLine = string.Join(" ", commandLineArguments);
var isHelp = commandLineArguments.Any(commandLineArgument => commandLineArgument.IsHelp());
if (isHelp)
{
targetContext.IsHelp = true;
return validationContext;
}
var optionDefinitions = _optionDefinitionService.GetOptionDefinitions(targetContext);
var handledOptions = new HashSet<char>();
Log.Debug("Parsing command line");
for (var i = 0; i < commandLineArguments.Count; i++)
{
var commandLineArgument = commandLineArguments[i];
try
{
// Allow the first one to be a non-switch
if (i == 0)
{
if (!commandLineArguments[i].IsSwitch())
{
var emptyOptionDefinition = (from x in optionDefinitions
where !x.HasSwitch()
select x).FirstOrDefault();
if (emptyOptionDefinition == null)
{
var message = string.Format(_languageService.GetString("CommandLine_CannotParseNoEmptySwitch"), commandLineArgument);
Log.Error(message);
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError(message));
continue;
}
UpdateContext(targetContext, emptyOptionDefinition, commandLineArgument);
handledOptions.Add(emptyOptionDefinition.ShortName);
continue;
}
}
if (!commandLineArgument.IsSwitch())
{
var message = string.Format(_languageService.GetString("CommandLine_CannotParseNoSwitch"), commandLineArgument);
Log.Warning(message);
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateWarning(message));
continue;
}
var optionDefinition = (from x in optionDefinitions
where x.IsSwitch(commandLineArgument)
select x).FirstOrDefault();
if (optionDefinition == null)
{
var message = string.Format(_languageService.GetString("CommandLine_CannotParseSwitchNotRecognized"), commandLineArgument);
Log.Warning(message);
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateWarning(message));
continue;
}
var value = string.Empty;
if (!optionDefinition.AcceptsValue)
{
// Assume boolean switch
value = "true";
}
else
{
if (commandLineArguments.Count <= i + 1)
{
var message = string.Format(_languageService.GetString("CommandLine_CannotParseValueMissing"), commandLineArgument);
Log.Warning(message);
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateWarning(message));
continue;
}
value = commandLineArguments[++i];
}
UpdateContext(targetContext, optionDefinition, value);
handledOptions.Add(optionDefinition.ShortName);
}
catch (Exception ex)
{
validationContext.AddBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError(_languageService.GetString("CommandLine_CannotParseExceptionOccurred"), commandLineArgument, ex.Message));
}
}
Log.Debug("Checking if all required options are specified");
foreach (var optionDefinition in optionDefinitions)
{
if (optionDefinition.IsMandatory)
{
if (!handledOptions.Contains(optionDefinition.ShortName))
{
var message = string.Format(_languageService.GetString("CommandLine_RequiredSwitchNotSpecified"), optionDefinition);
Log.Error(message);
validationContext.AddFieldValidationResult(FieldValidationResult.CreateError(optionDefinition.GetSwitchDisplay(), message));
}
}
}
Log.Debug("Finishing the context");
targetContext.Finish();
return validationContext;
}
