public void SetsValuesCorrectlyUsingEmptyMessage()
{
var validationResult = new BusinessRuleValidationResult(ValidationResultType.Error, string.Empty);
Assert.AreEqual(ValidationResultType.Error, validationResult.ValidationResultType);
Assert.AreEqual(string.Empty, validationResult.Message);
}
public void ReturnsChangesForAddedFieldWarning()
{
var fieldValidationResults1 = new List <IFieldValidationResult>();
fieldValidationResults1.Add(FieldValidationResult.CreateError("MyProperty", "FieldError"));
var businessRuleValidationResults1 = new List <IBusinessRuleValidationResult>();
businessRuleValidationResults1.Add(BusinessRuleValidationResult.CreateWarning("BusinessRuleWarning"));
businessRuleValidationResults1.Add(BusinessRuleValidationResult.CreateError("BusinessRuleError"));
var context1 = new ValidationContext(fieldValidationResults1, businessRuleValidationResults1);
var fieldValidationResults2 = new List <IFieldValidationResult>();
fieldValidationResults2.Add(FieldValidationResult.CreateWarning("MyProperty", "FieldWarning"));
fieldValidationResults2.Add(FieldValidationResult.CreateError("MyProperty", "FieldError"));
var businessRuleValidationResults2 = new List <IBusinessRuleValidationResult>();
businessRuleValidationResults2.Add(BusinessRuleValidationResult.CreateWarning("BusinessRuleWarning"));
businessRuleValidationResults2.Add(BusinessRuleValidationResult.CreateError("BusinessRuleError"));
var context2 = new ValidationContext(fieldValidationResults2, businessRuleValidationResults2);
var changes = ValidationContextHelper.GetChanges(context1, context2);
Assert.AreEqual(1, changes.Count);
Assert.AreEqual("MyProperty", ((IFieldValidationResult)changes[0].ValidationResult).PropertyName);
Assert.AreEqual("FieldWarning", changes[0].ValidationResult.Message);
Assert.AreEqual(ValidationResultType.Warning, changes[0].ValidationResult.ValidationResultType);
Assert.AreEqual(ValidationContextChangeType.Added, changes[0].ChangeType);
}
public void ReturnsEmptyCollectionForEqualValidationContexts()
{
var fieldValidationResults1 = new List <IFieldValidationResult>();
fieldValidationResults1.Add(FieldValidationResult.CreateWarning("MyProperty", "FieldWarning"));
fieldValidationResults1.Add(FieldValidationResult.CreateError("MyProperty", "FieldError"));
var businessRuleValidationResults1 = new List <IBusinessRuleValidationResult>();
businessRuleValidationResults1.Add(BusinessRuleValidationResult.CreateWarning("BusinessRuleWarning"));
businessRuleValidationResults1.Add(BusinessRuleValidationResult.CreateError("BusinessRuleError"));
var context1 = new ValidationContext(fieldValidationResults1, businessRuleValidationResults1);
var fieldValidationResults2 = new List <IFieldValidationResult>();
fieldValidationResults2.Add(FieldValidationResult.CreateWarning("MyProperty", "FieldWarning"));
fieldValidationResults2.Add(FieldValidationResult.CreateError("MyProperty", "FieldError"));
var businessRuleValidationResults2 = new List <IBusinessRuleValidationResult>();
businessRuleValidationResults2.Add(BusinessRuleValidationResult.CreateWarning("BusinessRuleWarning"));
businessRuleValidationResults2.Add(BusinessRuleValidationResult.CreateError("BusinessRuleError"));
var context2 = new ValidationContext(fieldValidationResults2, businessRuleValidationResults2);
var changes = ValidationContextHelper.GetChanges(context1, context2);
Assert.AreEqual(0, changes.Count);
}
public void SetsValuesCorrectlyUsingFormattedMessage()
{
var validationResult = BusinessRuleValidationResult.CreateError("my message with {0}", "format");
Assert.AreEqual(ValidationResultType.Error, validationResult.ValidationResultType);
Assert.AreEqual("my message with format", validationResult.Message);
}
public void SetsValuesCorrectlyUsingNormalMessage()
{
var validationResult = BusinessRuleValidationResult.CreateError("my message");
Assert.AreEqual(ValidationResultType.Error, validationResult.ValidationResultType);
Assert.AreEqual("my message", validationResult.Message);
}
protected override void ValidateBusinessRules(List <IBusinessRuleValidationResult> validationResults)
{
base.ValidateBusinessRules(validationResults);
if (EditablePackageSources != null && EditablePackageSources.Any(x => x.IsValid.HasValue && !x.IsValid.Value))
{
validationResults.Add(BusinessRuleValidationResult.CreateError("Some package sources are invalid."));
}
}
protected override void ValidateBusinessRules(List <IBusinessRuleValidationResult> validationResults)
{
if (!string.IsNullOrWhiteSpace(XAxis) && !string.IsNullOrWhiteSpace(YAxis))
{
if (ObjectHelper.AreEqual(XAxis, YAxis))
{
validationResults.Add(BusinessRuleValidationResult.CreateError("X and Y axis cannot be the same"));
}
}
}
public static void AddValidationError(this IValidationContext validationContext, string message, string tag = null)
{
Argument.IsNotNull(() => validationContext);
var businessRuleValidationResult = new BusinessRuleValidationResult(ValidationResultType.Error, message)
{
Tag = tag
};
validationContext.Add(businessRuleValidationResult);
}
protected override void ValidateBusinessRules(List <IBusinessRuleValidationResult> validationResults)
{
if (SelectedFeed is null || !IsNamesNotUniqueRule(out var names))
{
return;
}
var results = names.Select(name => BusinessRuleValidationResult.CreateError($"Two or more feeds have same name '{name}'")).Cast <IBusinessRuleValidationResult>();
validationResults.AddRange(results);
}
public override async Task <IValidationContext> ValidateProjectAsync(IProject project)
{
var validationContext = await base.ValidateProjectAsync(project);
if (string.Equals(project.Location, "cannotload"))
{
validationContext.Add(BusinessRuleValidationResult.CreateError("this is a dummy error"));
}
return(validationContext);
}
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);
}
protected override void ValidateBusinessRules(List <IBusinessRuleValidationResult> validationResults)
{
if (string.IsNullOrEmpty(FirstName) || string.IsNullOrEmpty(LastName))
{
validationResults.Add(BusinessRuleValidationResult.CreateError("Both first and last name are required"));
}
if (string.IsNullOrEmpty(MiddleName))
{
validationResults.Add(BusinessRuleValidationResult.CreateWarning("No middle name"));
}
}
protected override void ValidateBusinessRules(List <IBusinessRuleValidationResult> validationResults)
{
if (string.IsNullOrEmpty(BusinessRuleErrorWhenEmpty))
{
validationResults.Add(BusinessRuleValidationResult.CreateError("BusinessRuleErrorWhenEmpty should not be empty"));
}
if (string.IsNullOrEmpty(BusinessRuleWarningWhenEmpty))
{
validationResults.Add(BusinessRuleValidationResult.CreateWarning("BusinessRuleWarningWhenEmpty should not be empty"));
}
}
/// <summary>
/// Validates the business rules.
/// </summary>
protected override void ValidateBusinessRules(List <IBusinessRuleValidationResult> validationResults)
{
if (ValueToValidate == ValueThatCausesBusinessWarning)
{
validationResults.Add(BusinessRuleValidationResult.CreateWarning("Business rule warning"));
}
if (ValueToValidate == ValueThatCausesBusinessError)
{
validationResults.Add(BusinessRuleValidationResult.CreateError("Business rule error"));
}
}
protected override void ValidateBusinessRules(List <IBusinessRuleValidationResult> validationResults)
{
base.ValidateBusinessRules(validationResults);
var components = Components;
if (components != null)
{
if (!components.Any(x => x.IsSelected))
{
validationResults.Add(BusinessRuleValidationResult.CreateError("Select at least 1 component"));
}
}
}
protected override void ValidateBusinessRules(List <IBusinessRuleValidationResult> validationResults)
{
base.ValidateBusinessRules(validationResults);
var skills = Skills;
if (skills != null)
{
if (!skills.Any(x => x.IsSelected))
{
validationResults.Add(BusinessRuleValidationResult.CreateError("Select at least 1 skill"));
}
}
}
private void ValidateDependency(IPackageDetails package, PackageDependency dependency)
{
SemanticVersion currentVersion;
lock (_syncObj)
{
if (!_apiPackages.TryGetValue(dependency.Id, out currentVersion))
{
return;
}
}
var versionSpec = dependency.VersionSpec;
var minVersion = versionSpec.MinVersion;
if (minVersion != null)
{
if (versionSpec.IsMinInclusive && currentVersion < minVersion)
{
package.ValidationContext.Add(BusinessRuleValidationResult.CreateErrorWithTag(string.Format(_languageService.GetString("NuGetExplorer_ApiPackageRegistry_Validation_Error_Message_Pattern_1"), package.Id, dependency.Id, dependency.VersionSpec.MinVersion, currentVersion), ValidationTags.Api));
}
if (!versionSpec.IsMinInclusive && currentVersion <= minVersion)
{
package.ValidationContext.Add(BusinessRuleValidationResult.CreateErrorWithTag(string.Format(_languageService.GetString("NuGetExplorer_ApiPackageRegistry_Validation_Error_Message_Pattern_2"), package.Id, dependency.Id, dependency.VersionSpec.MinVersion, currentVersion), ValidationTags.Api));
}
}
var maxVersion = versionSpec.MaxVersion;
if (maxVersion == null)
{
return;
}
if (versionSpec.IsMaxInclusive && currentVersion > maxVersion)
{
package.ValidationContext.Add(BusinessRuleValidationResult.CreateErrorWithTag(string.Format(_languageService.GetString("NuGetExplorer_ApiPackageRegistry_Validation_Error_Message_Pattern_3"), package.Id, dependency.Id, dependency.VersionSpec.MaxVersion, currentVersion), ValidationTags.Api));
}
if (!versionSpec.IsMaxInclusive && currentVersion >= maxVersion)
{
package.ValidationContext.Add(BusinessRuleValidationResult.CreateErrorWithTag(string.Format(_languageService.GetString("NuGetExplorer_ApiPackageRegistry_Validation_Error_Message_Pattern_4"), package.Id, dependency.Id, dependency.VersionSpec.MaxVersion, currentVersion), ValidationTags.Api));
}
}
/// <summary>
/// Called when the object is validating the business rules.
/// </summary>
/// <param name="validationContext">The validation context.</param>
protected override void OnValidatingBusinessRules(IValidationContext validationContext)
{
base.OnValidatingBusinessRules(validationContext);
lock (_modelLock)
{
foreach (var modelObject in _modelObjects)
{
if (!_modelObjectsInfo[modelObject.Key].SupportValidation)
{
continue;
}
// IDataErrorInfo
var dataErrorInfo = modelObject.Value as IDataErrorInfo;
if (dataErrorInfo != null && !string.IsNullOrEmpty(dataErrorInfo.Error))
{
validationContext.Add(BusinessRuleValidationResult.CreateError(dataErrorInfo.Error));
}
// IDataWarningInfo
var dataWarningInfo = modelObject.Value as IDataWarningInfo;
if (dataWarningInfo != null && !string.IsNullOrEmpty(dataWarningInfo.Warning))
{
validationContext.Add(BusinessRuleValidationResult.CreateWarning(dataWarningInfo.Warning));
}
// INotifyDataErrorInfo & INotifyDataWarningInfo
ModelErrorInfo modelErrorInfo;
if (_modelErrorInfo.TryGetValue(modelObject.Key, out modelErrorInfo))
{
foreach (var error in modelErrorInfo.GetErrors(string.Empty))
{
validationContext.Add(BusinessRuleValidationResult.CreateError(error));
}
foreach (var warning in modelErrorInfo.GetWarnings(string.Empty))
{
validationContext.Add(BusinessRuleValidationResult.CreateWarning(warning));
}
}
}
}
}
protected override Task InitializeAsync()
{
var context = new ValidationContext();
var result1 = BusinessRuleValidationResult.CreateErrorWithTag("Error1 message", "A");
var result2 = BusinessRuleValidationResult.CreateWarningWithTag("Warning1 message", "B");
var result3 = FieldValidationResult.CreateWarningWithTag("Property1", "Warning2 message", "C");
var tag = new { Name = "A", Line = (int?)2 };
var result4 = BusinessRuleValidationResult.CreateErrorWithTag("Error2 message with object tag", tag);
var result5 = BusinessRuleValidationResult.CreateErrorWithTag("Error3 message", "B");
var result6 = BusinessRuleValidationResult.CreateError("Error3 message");
var result7 = BusinessRuleValidationResult.CreateError("Error4 message");
var result8 = FieldValidationResult.CreateWarningWithTag("Property2", "Warning3 message", new { Name = "A", Line = 1 });
var result9 = FieldValidationResult.CreateWarningWithTag("Property2", "Warning4 message", new { Name = "A", Line = 2 });
var result10 = FieldValidationResult.CreateWarningWithTag("Property2", "Warning5 message", new { Name = "A", Line = 3, ColumnName = "ColA" });
var result11 = FieldValidationResult.CreateWarningWithTag("Property2", "Warning6 message", new { Name = "A", Line = 20, ColumnIndex = 2 });
var result12 = FieldValidationResult.CreateWarningWithTag("Property2", "Warning7 message", new { Name = "A", Line = 12, ColumnName = "ColC", ColumnIndex = 3 });
var result13 = FieldValidationResult.CreateWarningWithTag("Property2", "Warning8 message", new { Name = "A", Line = 10 });
var result14 = FieldValidationResult.CreateWarningWithTag("Property2", "Warning9 message", new { Name = "A", Line = 24 });
context.Add(result1);
context.Add(result2);
context.Add(result3);
context.Add(result4);
context.Add(result5);
context.Add(result6);
context.Add(result7);
context.Add(result8);
context.Add(result9);
context.Add(result10);
context.Add(result11);
context.Add(result12);
context.Add(result13);
context.Add(result14);
ValidationContext = context;
return(base.InitializeAsync());
}
protected override Task InitializeAsync()
{
var context = new ValidationContext();
var result1 = BusinessRuleValidationResult.CreateErrorWithTag("Error1 message", "A");
var result2 = BusinessRuleValidationResult.CreateWarningWithTag("Warning1 message", "B");
var result3 = FieldValidationResult.CreateWarningWithTag("Property1", "Warning2 message", "C");
var tag = new { Name = "A", Line = new Nullable <int>(2) };
var result4 = BusinessRuleValidationResult.CreateErrorWithTag("Error2 message with object tag", tag);
var result5 = BusinessRuleValidationResult.CreateErrorWithTag("Error3 message", "B");
var result6 = BusinessRuleValidationResult.CreateError("Error3 message");
var result7 = BusinessRuleValidationResult.CreateError("Error4 message");
var result8 = FieldValidationResult.CreateWarningWithTag("Property2", "Warning3 message", new { Name = "A", Line = new Nullable <int>(1) });
var result9 = FieldValidationResult.CreateWarningWithTag("Property2", "Warning4 message", new { Name = "A", Line = new Nullable <int>(2) });
var result10 = FieldValidationResult.CreateWarningWithTag("Property2", "Warning5 message", new { Name = "A", Line = new Nullable <int>(3) });
var result11 = FieldValidationResult.CreateWarningWithTag("Property2", "Warning6 message", new { Name = "A", Line = new Nullable <int>(20) });
var result12 = FieldValidationResult.CreateWarningWithTag("Property2", "Warning7 message", new { Name = "A", Line = new Nullable <int>(12) });
var result13 = FieldValidationResult.CreateWarningWithTag("Property2", "Warning8 message", new { Name = "A", Line = new Nullable <int>(10) });
var result14 = FieldValidationResult.CreateWarningWithTag("Property2", "Warning9 message", new { Name = "A", Line = new Nullable <int>(24) });
context.AddBusinessRuleValidationResult(result1);
context.AddBusinessRuleValidationResult(result2);
context.AddFieldValidationResult(result3);
context.AddBusinessRuleValidationResult(result4);
context.AddBusinessRuleValidationResult(result5);
context.AddBusinessRuleValidationResult(result6);
context.AddBusinessRuleValidationResult(result7);
context.AddFieldValidationResult(result8);
context.AddFieldValidationResult(result9);
context.AddFieldValidationResult(result10);
context.AddFieldValidationResult(result11);
context.AddFieldValidationResult(result12);
context.AddFieldValidationResult(result13);
context.AddFieldValidationResult(result14);
ValidationContext = context;
return(base.InitializeAsync());
}
/// <summary>
/// Called when the object is validating the business rules.
/// </summary>
protected override void OnValidatingBusinessRules()
{
base.OnValidatingBusinessRules();
lock (_modelObjects)
{
foreach (KeyValuePair <string, object> modelObject in _modelObjects)
{
// IDataErrorInfo
var dataErrorInfo = modelObject.Value as IDataErrorInfo;
if ((dataErrorInfo != null) && !string.IsNullOrEmpty(dataErrorInfo.Error))
{
SetBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError(dataErrorInfo.Error));
}
// IDataWarningInfo
var dataWarningInfo = modelObject.Value as IDataWarningInfo;
if ((dataWarningInfo != null) && !string.IsNullOrEmpty(dataWarningInfo.Warning))
{
SetBusinessRuleValidationResult(BusinessRuleValidationResult.CreateWarning(dataWarningInfo.Warning));
}
// INotifyDataErrorInfo & INotifyDataWarningInfo
if (_modelErrorInfo.ContainsKey(modelObject.Key))
{
var modelErrorInfo = _modelErrorInfo[modelObject.Key];
foreach (string error in modelErrorInfo.GetErrors(string.Empty))
{
SetBusinessRuleValidationResult(BusinessRuleValidationResult.CreateError(error));
}
foreach (string warning in modelErrorInfo.GetWarnings(string.Empty))
{
SetBusinessRuleValidationResult(BusinessRuleValidationResult.CreateWarning(warning));
}
}
}
}
}
private async Task <IProject> SyncedLoadProjectAsync(string location)
{
Argument.IsNotNullOrWhitespace("location", location);
var project = Projects.FirstOrDefault(x => location.EqualsIgnoreCase(x.Location));
if (project != null)
{
return(project);
}
var projectLocation = location;
using (new DisposableToken(null, token => _loadingProjects.Add(projectLocation), token => _loadingProjects.Remove(projectLocation)))
{
Log.Debug($"Going to load project from '{location}', checking if an upgrade is required");
if (await _projectUpgrader.RequiresUpgradeAsync(location))
{
Log.Debug($"Upgrade is required for '{location}', upgrading...");
location = await _projectUpgrader.UpgradeAsync(location);
Log.Debug($"Upgraded project, final location is '{location}'");
}
Log.Debug($"Loading project from '{location}'");
_projectStateSetter.SetProjectLoading(location, true);
var cancelEventArgs = new ProjectCancelEventArgs(location);
await ProjectLoadingAsync.SafeInvokeAsync(this, cancelEventArgs, false).ConfigureAwait(false);
if (cancelEventArgs.Cancel)
{
Log.Debug("Canceled loading of project from '{0}'", location);
_projectStateSetter.SetProjectLoading(location, false);
await ProjectLoadingCanceledAsync.SafeInvokeAsync(this, new ProjectEventArgs(location)).ConfigureAwait(false);
return(null);
}
Exception error = null;
IValidationContext validationContext = null;
try
{
if (_projects.Count > 0 && ProjectManagementType == ProjectManagementType.SingleDocument)
{
throw Log.ErrorAndCreateException <SdiProjectManagementException>("Cannot load project '{0}', currently in SDI mode", location);
}
if (!await _projectValidator.CanStartLoadingProjectAsync(location))
{
validationContext = new ValidationContext();
validationContext.Add(BusinessRuleValidationResult.CreateError("Project validator informed that project could not be loaded"));
throw new ProjectException(location, $"Cannot load project from '{location}'");
}
validationContext = await _projectValidator.ValidateProjectBeforeLoadingAsync(location);
if (validationContext.HasErrors)
{
throw Log.ErrorAndCreateException <InvalidOperationException>($"Project could not be loaded from '{location}', validator returned errors");
}
project = await QuietlyLoadProjectAsync(location, true).ConfigureAwait(false);
validationContext = await _projectValidator.ValidateProjectAsync(project);
if (validationContext.HasErrors)
{
throw Log.ErrorAndCreateException <InvalidOperationException>($"Project data was loaded from '{location}', but the validator returned errors");
}
RegisterProject(project);
}
catch (Exception ex)
{
error = ex;
Log.Error(ex, "Failed to load project from '{0}'", location);
}
if (error != null)
{
_projectStateSetter.SetProjectLoading(location, false);
await ProjectLoadingFailedAsync.SafeInvokeAsync(this, new ProjectErrorEventArgs(location, error, validationContext)).ConfigureAwait(false);
return(null);
}
_projectStateSetter.SetProjectLoading(project?.Location, false);
await ProjectLoadedAsync.SafeInvokeAsync(this, new ProjectEventArgs(project)).ConfigureAwait(false);
Log.Info("Loaded project from '{0}'", location);
}
return(project);
}
/// <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);
}
protected override void ValidateBusinessRules(ClassWithValidator instance, List <IBusinessRuleValidationResult> validationResults)
{
ValidateBusinessRulesCount++;
validationResults.Add(BusinessRuleValidationResult.CreateError("Error"));
}
public void ReturnsChangesForComplexScenario()
{
var fieldValidationResults1 = new List <IFieldValidationResult>();
fieldValidationResults1.Add(FieldValidationResult.CreateWarning("MyProperty", "FieldWarning"));
fieldValidationResults1.Add(FieldValidationResult.CreateError("MyProperty", "FieldError"));
var businessRuleValidationResults1 = new List <IBusinessRuleValidationResult>();
businessRuleValidationResults1.Add(BusinessRuleValidationResult.CreateWarning("BusinessRuleWarning"));
businessRuleValidationResults1.Add(BusinessRuleValidationResult.CreateError("BusinessRuleError"));
var context1 = new ValidationContext(fieldValidationResults1, businessRuleValidationResults1);
var fieldValidationResults2 = new List <IFieldValidationResult>();
fieldValidationResults2.Add(FieldValidationResult.CreateWarning("MyProperty", "FieldWarningTextHasChanged"));
fieldValidationResults2.Add(FieldValidationResult.CreateError("NewProperty", "FieldErrorForNewProperty"));
var businessRuleValidationResults2 = new List <IBusinessRuleValidationResult>();
businessRuleValidationResults2.Add(BusinessRuleValidationResult.CreateWarning("BusinessRuleWarningTextHasChanged"));
var context2 = new ValidationContext(fieldValidationResults2, businessRuleValidationResults2);
var changes = ValidationContextHelper.GetChanges(context1, context2);
Assert.AreEqual(7, changes.Count);
int counter;
// Field warning text has changed, thus removed
counter = 0;
Assert.AreEqual("MyProperty", ((IFieldValidationResult)changes[counter].ValidationResult).PropertyName);
Assert.AreEqual("FieldWarning", changes[counter].ValidationResult.Message);
Assert.AreEqual(ValidationResultType.Warning, changes[counter].ValidationResult.ValidationResultType);
Assert.AreEqual(ValidationContextChangeType.Removed, changes[counter].ChangeType);
// Field error has been removed
counter++;
Assert.AreEqual("MyProperty", ((IFieldValidationResult)changes[counter].ValidationResult).PropertyName);
Assert.AreEqual("FieldError", changes[counter].ValidationResult.Message);
Assert.AreEqual(ValidationResultType.Error, changes[counter].ValidationResult.ValidationResultType);
Assert.AreEqual(ValidationContextChangeType.Removed, changes[counter].ChangeType);
// Field warning text has changed, thus added
counter++;
Assert.AreEqual("MyProperty", ((IFieldValidationResult)changes[counter].ValidationResult).PropertyName);
Assert.AreEqual("FieldWarningTextHasChanged", changes[counter].ValidationResult.Message);
Assert.AreEqual(ValidationResultType.Warning, changes[counter].ValidationResult.ValidationResultType);
Assert.AreEqual(ValidationContextChangeType.Added, changes[counter].ChangeType);
// Field error added
counter++;
Assert.AreEqual("NewProperty", ((IFieldValidationResult)changes[counter].ValidationResult).PropertyName);
Assert.AreEqual("FieldErrorForNewProperty", changes[counter].ValidationResult.Message);
Assert.AreEqual(ValidationResultType.Error, changes[counter].ValidationResult.ValidationResultType);
Assert.AreEqual(ValidationContextChangeType.Added, changes[counter].ChangeType);
// Business rule text has changed, thus removed
counter++;
Assert.AreEqual("BusinessRuleWarning", changes[counter].ValidationResult.Message);
Assert.AreEqual(ValidationResultType.Warning, changes[counter].ValidationResult.ValidationResultType);
Assert.AreEqual(ValidationContextChangeType.Removed, changes[counter].ChangeType);
// Business rule error has been removed
counter++;
Assert.AreEqual("BusinessRuleError", changes[counter].ValidationResult.Message);
Assert.AreEqual(ValidationResultType.Error, changes[counter].ValidationResult.ValidationResultType);
Assert.AreEqual(ValidationContextChangeType.Removed, changes[counter].ChangeType);
// Business rule text has changed, thus added
counter++;
Assert.AreEqual("BusinessRuleWarningTextHasChanged", changes[counter].ValidationResult.Message);
Assert.AreEqual(ValidationResultType.Warning, changes[counter].ValidationResult.ValidationResultType);
Assert.AreEqual(ValidationContextChangeType.Added, changes[counter].ChangeType);
}
public IValidationContext Parse(List <string> commandLineArguments, IContext targetContext)
{
var validationContext = new ValidationContext();
var quoteSplitCharacters = targetContext.QuoteSplitCharacters.ToArray();
targetContext.OriginalCommandLine = string.Join(" ", commandLineArguments);
var isHelp = commandLineArguments.Any(commandLineArgument => commandLineArgument.IsHelp(quoteSplitCharacters));
if (isHelp)
{
targetContext.IsHelp = true;
return(validationContext);
}
var optionDefinitions = _optionDefinitionService.GetOptionDefinitions(targetContext);
var handledOptions = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
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 && !commandLineArguments[i].IsSwitch(quoteSplitCharacters))
{
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.Debug(message);
validationContext.Add(BusinessRuleValidationResult.CreateError(message));
continue;
}
UpdateContext(targetContext, emptyOptionDefinition, commandLineArgument);
handledOptions.Add(emptyOptionDefinition.ShortName);
continue;
}
if (!commandLineArgument.IsSwitch(quoteSplitCharacters))
{
var message = string.Format(_languageService.GetString("CommandLine_CannotParseNoSwitch"), commandLineArgument);
Log.Debug(message);
validationContext.Add(BusinessRuleValidationResult.CreateWarning(message));
continue;
}
var value = string.Empty;
var optionDefinition = (from x in optionDefinitions
where x.IsSwitch(commandLineArgument, quoteSplitCharacters)
select x).FirstOrDefault();
var isKnownDefinition = (optionDefinition != null);
if (!isKnownDefinition)
{
var message = string.Format(_languageService.GetString("CommandLine_CannotParseSwitchNotRecognized"), commandLineArgument);
Log.Debug(message);
validationContext.Add(BusinessRuleValidationResult.CreateWarning(message));
// Try to read the next value, but keep in mind that some options might
// not have a value passed into it
var potentialValue = (i < commandLineArguments.Count - 1) ? commandLineArguments[i + 1] : string.Empty;
if (!string.IsNullOrWhiteSpace(potentialValue) && potentialValue.IsSwitch(quoteSplitCharacters))
{
potentialValue = string.Empty;
}
value = potentialValue;
}
targetContext.RawValues[commandLineArgument.TrimSwitchPrefix()] = value;
if (!isKnownDefinition)
{
continue;
}
if (!optionDefinition.AcceptsValue)
{
// Assume boolean switch
value = "true";
}
else
{
if (commandLineArguments.Count <= i + 1)
{
var message = string.Format(_languageService.GetString("CommandLine_CannotParseValueMissing"), commandLineArgument);
Log.Info(message);
validationContext.Add(BusinessRuleValidationResult.CreateWarning(message));
continue;
}
value = commandLineArguments[++i];
}
UpdateContext(targetContext, optionDefinition, value);
handledOptions.Add(optionDefinition.ShortName);
}
catch (Exception ex)
{
validationContext.Add(BusinessRuleValidationResult.CreateError(_languageService.GetString("CommandLine_CannotParseExceptionOccurred"), commandLineArgument, ex.Message));
}
}
ValidateMandatorySwitches(validationContext, optionDefinitions, handledOptions);
Log.Debug("Finishing the context");
targetContext.Finish();
return(validationContext);
}
protected override void ValidateBusinessRules(List <IBusinessRuleValidationResult> validationResults)
{
validationResults.Add(BusinessRuleValidationResult.CreateError("Error 1"));
validationResults.Add(BusinessRuleValidationResult.CreateError("Error 2"));
validationResults.Add(BusinessRuleValidationResult.CreateError("Error 3"));
}
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);
}