Example #1
0
            public void SetsValuesCorrectlyUsingEmptyMessage()
            {
                var validationResult = new BusinessRuleValidationResult(ValidationResultType.Error, string.Empty);

                Assert.AreEqual(ValidationResultType.Error, validationResult.ValidationResultType);
                Assert.AreEqual(string.Empty, validationResult.Message);
            }
Example #2
0
            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);
            }
Example #3
0
            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);
            }
Example #4
0
            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);
            }
Example #5
0
            public void SetsValuesCorrectlyUsingNormalMessage()
            {
                var validationResult = BusinessRuleValidationResult.CreateError("my message");

                Assert.AreEqual(ValidationResultType.Error, validationResult.ValidationResultType);
                Assert.AreEqual("my message", validationResult.Message);
            }
Example #6
0
        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);
        }
Example #9
0
        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);
        }
Example #10
0
        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);
        }
Example #11
0
        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);
        }
Example #12
0
        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"));
            }
        }
Example #13
0
        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"));
            }
        }
Example #14
0
        /// <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"));
            }
        }
Example #15
0
        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"));
                }
            }
        }
Example #16
0
        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));
            }
        }
Example #18
0
        /// <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));
                        }
                    }
                }
            }
        }
Example #19
0
        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());
        }
Example #20
0
        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);
        }
Example #23
0
        /// <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);
        }
Example #24
0
        /// <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);
        }
Example #25
0
        protected override void ValidateBusinessRules(ClassWithValidator instance, List <IBusinessRuleValidationResult> validationResults)
        {
            ValidateBusinessRulesCount++;

            validationResults.Add(BusinessRuleValidationResult.CreateError("Error"));
        }
Example #26
0
            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);
            }
Example #27
0
        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"));
 }
Example #29
0
        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);
        }