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); }