コード例 #1
0
 protected void AddErrors(ValidationResult result)
 {
     foreach (var error in result.Errors)
     {
         ModelState.AddModelError("", error.ErrorMessage);
     }
 }
コード例 #2
0
 private void Validate(object sender, PropertyChangedEventArgs e)
 {
     //var propertyChain = new PropertyChain();
     //propertyChain.Add(e.PropertyName);
     //validationResult = validator.Validate(new ValidationContext(target, propertyChain, new DefaultValidatorSelector()));
     validationResult = validator.Validate(target);
 }
コード例 #3
0
 public ValidatorError(String errorTitle, HttpStatusCode statusCode, ValidationResult result, HttpRequestMessage request)
 {
     _errorTitle = errorTitle;
     _result = result;
     _request = request;
     _statusCode = statusCode;
 }
コード例 #4
0
        public void Setup()
        {
            _riskAssessmentService = new Mock<IFireRiskAssessmentService>();
            _fireRiskAssessmentChecklistService = new Mock<IFireRiskAssessmentChecklistService>();
            _target = new FireRiskAssessmentChecklistViewModelFactory(_riskAssessmentService.Object, _fireRiskAssessmentChecklistService.Object);

            _riskAssessmentId = 123L;
            _companyId = 456L;

            var validationResult = new ValidationResult
                (
                   new List<ValidationFailure>
                       {
                           new ValidationFailure
                               (
                                "10",
                                "error 10"
                               ),
                               new ValidationFailure
                               (
                                "20",
                                "error 20"
                               ),
                               new ValidationFailure
                               (
                                "30",
                                "error 30"
                               )
                       }
                );

            _fireRiskAssessmentChecklistService
                .Setup(x => x.ValidateFireRiskAssessmentChecklist(It.IsAny<ValidateCompleteFireRiskAssessmentChecklistRequest>()))
                .Returns(validationResult);
        }
コード例 #5
0
		protected virtual IEnumerable<ModelValidationResult> ConvertValidationResultToModelValidationResults(ValidationResult result) {
			return result.Errors.Select(x => new ModelValidationResult
			{
				MemberName = x.PropertyName,
				Message = x.ErrorMessage
			});
		}
コード例 #6
0
		public ValidationResultExtensionTests()
		{
			result = new ValidationResult(new[] {
				new ValidationFailure("foo", "A foo error occurred", "x"),
				new ValidationFailure("bar", "A bar error occurred", "y"),
			});
		}
コード例 #7
0
 private void Validate(object sender, PropertyChangedEventArgs e)
 {
     if (validator != null)
     {
         validationResult = validator.Validate(target);
     }
 }
コード例 #8
0
ファイル: ValidationTemplate.cs プロジェクト: Fody/Validar
 public ValidationTemplate(INotifyPropertyChanged target)
 {
     this.target = target;
     validator = GetValidator(target.GetType());
     validationResult = validator.Validate(target);
     target.PropertyChanged += Validate;
 }
コード例 #9
0
        public ValidationResult ValidateFireRiskAssessmentChecklist(ValidateCompleteFireRiskAssessmentChecklistRequest request)
        {
            var result = new ValidationResult();
            var correspondingAnswers = _fireAnswerRepository.GetByChecklistIdAndQuestionIds(request.ChecklistId, request.QuestionIds);

            foreach (var questionId in request.QuestionIds)
            {
                var answer = correspondingAnswers.SingleOrDefault(x => x.Question != null && x.Question.Id == questionId);
                
                if(answer == null)
                {
                    result.Errors.Add(new ValidationFailure(questionId.ToString(), "Please select a response"));
                }else if(!answer.IsValidateForCompleteChecklist())
                {
                    string errorMessage = string.Empty;
                    switch(answer.YesNoNotApplicableResponse)
                    {
                        case YesNoNotApplicableEnum.No:
                            errorMessage = "Please add a Further Control Measure Task";
                            break;
                        case YesNoNotApplicableEnum.Yes:
                            errorMessage = "Please enter a comment";
                            break;
                    }
                    result.Errors.Add(new ValidationFailure(questionId.ToString(), errorMessage));
                }
            }
            
            return result;
        }
コード例 #10
0
 public ValidatorError(String errorTitle, ValidationResult result, HttpRequestMessage request)
 {
     _errorTitle = errorTitle;
     _result = result;
     _request = request;
     _statusCode = HttpStatusCode.InternalServerError;
 }
 protected override void Context()
 {
     _createCustomerRequestValidator = new CreateCustomerRequestValidator();
     _expectedResult = new ValidationResult(new List<ValidationFailure>
                                                {
                                                    new ValidationFailure("Name", "'Name' cannot be empty."),
                                                });
 }
コード例 #12
0
        public void ResultIndicatesValidWhenNoValidationErrorsFound()
        {
            var innerResult = new ValidationResult();
            validationResult = new FluentValidationResult(innerResult);

            bool isModelValid = validationResult.IsModelValid();

            Assert.True(isModelValid);
        }
コード例 #13
0
 public void OnPropertyChanged(string propertyName)
 {
     validationResult = validator.Validate(this);
     var handler = PropertyChanged;
     if (handler != null)
     {
         handler(this, new PropertyChangedEventArgs(propertyName));
     }
 }
コード例 #14
0
 protected override bool PreValidate(ValidationContext <Rate> context, FluentValidation.Results.ValidationResult result)
 {
     if (context.InstanceToValidate == null)
     {
         result.Errors.Add(new ValidationFailure("", "Object null"));
         return(false);
     }
     return(true);
 }
コード例 #15
0
        public void ResultShowNoErrorsForValidProperty()
        {
            var innerResult = new ValidationResult();
            validationResult = new FluentValidationResult(innerResult);

            var errorsForProperty = validationResult.GetErrorsForProperty("NewProperty");

            Assert.That(errorsForProperty.Count() == 0);
        }
コード例 #16
0
        static FluentValidation.Results.ValidationResult BuildResult(FluentValidation.Results.ValidationResult rawResult)
        {
            var cleanedErrors = rawResult.Errors.Select(error => new ValidationFailure(CleanPropertyName(error.PropertyName), error.ErrorMessage, error.AttemptedValue)
            {
                CustomState = error.CustomState
            }).ToList();

            return(new FluentValidation.Results.ValidationResult(cleanedErrors));
        }
コード例 #17
0
ファイル: Base.cs プロジェクト: Coft/NobleProg.RentBikes
 private static string GetErrors(ValidationResult results)
 {
     if (results != null && results.Errors.Any())
     {
         var errors = string.Join(Environment.NewLine, results.Errors.Select(x => x.ErrorMessage).ToArray());
         return errors;
     }
     return string.Empty;
 }
コード例 #18
0
        public void ResultShowsNoErrorsWhenNoneWereFound()
        {
            var innerResult = new ValidationResult();
            validationResult = new FluentValidationResult(innerResult);

            int totalErrorCount = validationResult.GetErrorCount();

            Assert.That(totalErrorCount == 0);
        }
コード例 #19
0
            public void It_should_map_error_message()
            {
                var fluentValidationResult = new FluentValidation.Results.ValidationResult();

                fluentValidationResult.Errors.Add(new ValidationFailure("property", "error"));

                var validationErrors = FluentConverter.ToProjectValidationResult(fluentValidationResult);

                Assert.AreEqual(fluentValidationResult.Errors.Single().ErrorMessage, validationErrors.ValidationErrors.Single().ErrorMessage);
            }
コード例 #20
0
 /// <summary>
 /// return http message 400 Bad Request, with the content of the validation
 /// </summary>
 /// <param name="_results"></param>
 /// <returns></returns>
 public static HttpResponseMessage FailedValidationMessage(ValidationResult _results)
 {
     var validationErrors = _results.Errors.Select(error => error.ErrorMessage).ToList();
     var errors = JsonConvert.SerializeObject(validationErrors);
     return new HttpResponseMessage
     {
         Content = new StringContent(errors),
         StatusCode = HttpStatusCode.BadRequest
     };
 }
コード例 #21
0
        private bool ValidateDataService()
        {
            ServiceValidator serviceValidator = new ServiceValidator();

            FluentValidation.Results.ValidationResult dataValidationResult = serviceValidator.Validate(Service);
            IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
            UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);

            userFeedback.ShowFeedback();
            return(dataValidationResult.IsValid && ValidateCity() && ValidateState());
        }
コード例 #22
0
        private bool ValidateDataReport()
        {
            ReportValidator reportValidator = new ReportValidator();

            FluentValidation.Results.ValidationResult dataValidationResult = reportValidator.Validate(report);
            IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
            UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);

            userFeedback.ShowFeedback();
            return(dataValidationResult.IsValid);
        }
        private bool ValidateDataAccount()
        {
            MemberATEValidator memberATEValidator = new MemberATEValidator(PasswordBoxConfirmPassword.Password);

            FluentValidation.Results.ValidationResult dataValidationResult = memberATEValidator.Validate(memberATE);
            IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
            UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);

            userFeedback.ShowFeedback();
            return(dataValidationResult.IsValid && ValidateCity() && ValidateState());
        }
コード例 #24
0
        private bool IsValidData()
        {
            CoordinatorValidator coordinatorDataValidator = new CoordinatorValidator();

            FluentValidation.Results.ValidationResult dataValidationResult = coordinatorDataValidator.Validate(Coordinator);
            IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
            UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);

            userFeedback.ShowFeedback();
            return(dataValidationResult.IsValid);
        }
コード例 #25
0
        /// <inheritdoc />
        public async ValueTask <ValidationResult> ValidateAsync(object model, CancellationToken cancellationToken)
        {
            FV.Results.ValidationResult result = await _validator.ValidateAsync(model, cancellationToken);

            if (!result.IsValid)
            {
                return(new ValidationResult(result.Errors.Select(CreateValidationError)));
            }

            return(ValidationResult.Success);
        }
コード例 #26
0
        private bool IsValidData()
        {
            TeacherValidator teacherDataValidator = new TeacherValidator();

            FluentValidation.Results.ValidationResult dataValidationResult = teacherDataValidator.Validate(_teacher);
            IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
            UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);

            userFeedback.ShowFeedback();
            return(dataValidationResult.IsValid);
        }
コード例 #27
0
        public bool Validate <TModel, TValidator>(TModel model, TValidator validator, ModelStateDictionary modelState)
            where TValidator : AbstractValidator <TModel>
        {
            FluentValidation.Results.ValidationResult result = validator.Validate(model);

            foreach (var error in result.Errors)
            {
                modelState.AddModelError(error.PropertyName, error.ErrorMessage);
            }

            return(result.IsValid);
        }
コード例 #28
0
        public ActionResult CreateForGame([Bind(Include = "ProductInGameID,ProductID, ReferencePrice, PriceInGame,GameID,Quantity,CurrencyID,DateInserted,DateUpdated,USR")] ProductInGame productInGame)
        {
            ProductInGameValidator validator = new ProductInGameValidator();

            if (ModelState.IsValid)
            {
                //Deduct quantity from Product table if stock available
                //@Patrick 6) Depletes the product Quantity from the "Available Stock" amount on the Product record.
                //Available Stock must not go negative (Validator checks for this)
                //Get Product
                var product = db.Products.Where(x => x.ProductID == productInGame.ProductID).First();
                //Deplete available stock on hand
                product.AvailableSOH -= productInGame.Quantity;


                //Save
                if (product.AvailableSOH >= 0)
                {
                    db.Entry(product).State = EntityState.Modified;
                    db.SaveChanges();
                }
                else
                {
                    ModelState.AddModelError("QuantityError", "Not enough stock on hand for this product");
                    ViewBag.CurrencyID = new SelectList(db.Currencies, "CurrencyID", "CurrencyCode", productInGame.CurrencyID);
                    ViewBag.GameID     = new SelectList(db.Games, "GameID", "GameCode", productInGame.GameID);
                    ViewBag.ProductID  = new SelectList(db.Products, "ProductID", "ProductSKUCode", productInGame.ProductID);
                    return(View(productInGame));
                }


                db.ProductInGames.Add(productInGame);
                db.SaveChanges();


                return(RedirectToAction("EditMakeGame", "Games", new { id = productInGame.GameID }));
            }

            FluentValidation.Results.ValidationResult results = validator.Validate(productInGame);
            IList <ValidationFailure> failures = results.Errors;
            StringBuilder             sb       = new StringBuilder();

            foreach (var e in results.Errors)
            {
                ModelState.AddModelError(e.PropertyName + "Error", e.ErrorMessage);
                sb.AppendLine(e.ErrorMessage);
            }

            ViewBag.CurrencyID = new SelectList(db.Currencies, "CurrencyID", "CurrencyCode", productInGame.CurrencyID);
            ViewBag.GameID     = new SelectList(db.Games, "GameID", "GameCode", productInGame.GameID);
            ViewBag.ProductID  = new SelectList(db.Products, "ProductID", "ProductSKUCode", productInGame.ProductID);
            return(View(productInGame));
        }
コード例 #29
0
        private void InsertUpdateAccount()
        {
            dhAccount objInsert = new dhAccount();

            objInsert = (dhAccount)this.AccountDt.DataContext;



            dhAccountValidator validator = new dhAccountValidator();

            FluentValidation.Results.ValidationResult results = validator.Validate(objInsert);

            bool validationSucceeded           = results.IsValid;
            IList <ValidationFailure> failures = results.Errors;

            if (validationSucceeded)
            {
                if (this.vAccountType.SelectedValue != null)
                {
                    objInsert.IFinaceType = Convert.ToInt32(this.vAccountType.SelectedValue.ToString());
                }
                else
                {
                    throw new ApplicationException("Please Select Account Type.");
                }
                DataSet ds = iFacede.InsertUpdateAccount(Globalized.ObjDbName, objInsert);
                if (ds.Tables[0].Rows.Count > 0)
                {
                    if (objInsert.IUpdate == 1)
                    {
                        string msg = "Account  '" + objInsert.AccountName + "' information is updated successfully.";
                        Globalized.setException(msg, lblErrorMsg, DataHolders.MsgType.Info);
                        //Globalized.SetMsg(msg, DataHolders.MsgType.Info);
                        //Globalized.ShowMsg(lblErrorMsg);
                    }
                    else
                    {
                        System.Media.SystemSounds.Beep.Play();
                        lblErrorMsg.Visibility = Visibility.Hidden;
                        Globalized.SetMsg("New Acount '" + objInsert.AccountName + "' is added successfully.", DataHolders.MsgType.Info);
                        objTodisplay.IUpdate = 1;
                        this.DataContext     = objTodisplay;
                        Globalized.ShowMsg(lblErrorMsg);
                    }
                }
                Globalized.AccountListOptimizated();
            }
            else
            {
                throw new ApplicationException(failures.First().ErrorMessage);
            }
        }
コード例 #30
0
        public void ResultShowErrorsForInvalidProperty()
        {
            var innerResult = new ValidationResult();
            string propertyName = "AnyProperty";
            string errorMessage = "Just some error message, doesnt matter";
            innerResult.Errors.Add(new ValidationFailure(propertyName, errorMessage));
            validationResult = new FluentValidationResult(innerResult);

            var errorsForProperty = validationResult.GetErrorsForProperty(propertyName);

            Assert.That(errorsForProperty.Count() == 1);
            Assert.That(errorsForProperty.First() == errorMessage);
        }
コード例 #31
0
 private void AssertInvalidResult(
     FluentValidation.Results.ValidationResult validationResult,
     string propertyName,
     string message = null)
 {
     validationResult.IsValid.Should().BeFalse();
     validationResult.Errors
     .Should()
     .ContainSingle(
         error => error.PropertyName.Equals(propertyName) &&
         error.ErrorMessage.Equals(message)
         );
 }
コード例 #32
0
        protected override void OnValidated(FluentValidation.Results.ValidationResult res)
        {
            if (this is ITreeConfigNode)
            {
                var cfg = this.GetConfig();
                if (cfg == null)
                {
                    return;
                }
                bool isValid = true;
                foreach (var ts in cfg.GroupAppSolutions.ListAppSolutions)
                {
                    foreach (var tp in ts.ListAppProjects)
                    {
                        foreach (var tg in tp.ListAppProjectGenerators)
                        {
                            if (tg.PluginGenerator != null)
                            {
                                var lst = tg.PluginGenerator.ValidateNode(this as ITreeConfigNode, tg.Guid);
                                foreach (var t in lst)
                                {
                                    Debug.Assert(!string.IsNullOrWhiteSpace(t.PropertyName));
                                    Debug.Assert(!string.IsNullOrWhiteSpace(t.Message));
                                    var r = new ValidationFailure(t.PropertyName, t.Message);
                                    switch (t.Level)
                                    {
                                    case ValidationPluginMessage.EnumValidationMessage.Error:
                                        r.Severity = Severity.Error;
                                        isValid    = false;
                                        break;

                                    case ValidationPluginMessage.EnumValidationMessage.Warning:
                                        r.Severity = Severity.Warning;
                                        break;

                                    case ValidationPluginMessage.EnumValidationMessage.Info:
                                        r.Severity = Severity.Info;
                                        break;

                                    default:
                                        throw new Exception();
                                    }
                                    res.Errors.Add(r);
                                }
                            }
                        }
                    }
                }
                Debug.Assert(isValid || (!isValid && !res.IsValid));
            }
        }
        protected override void Context()
        {
            base.Context();

            _expectedResult = new ValidationResult(new List<ValidationFailure>
                                                 {
                                                     new ValidationFailure("FirstName", "First Name cannot be empty."),
                                                     new ValidationFailure("LastName", "Last Name cannot be empty."),
                                                     new ValidationFailure("EmailAddress", "Email Address cannot be empty."),
                                                     new ValidationFailure("Username", "Username cannot be empty."),
                                                     new ValidationFailure("Role", "Role cannot be empty.", Role.Undefined),

                                                 });
        }
コード例 #34
0
        private void ModifyButtonClicked(object sender, RoutedEventArgs e)
        {
            LinkedOrganizationValidator linkedOrganizationValidator = new LinkedOrganizationValidator();

            FluentValidation.Results.ValidationResult dataValidationResult = linkedOrganizationValidator.Validate(LinkedOrganizationToBeModified);
            IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
            UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);

            userFeedback.ShowFeedback();
            if (dataValidationResult.IsValid)
            {
                ModifyLinkedOrganization();
            }
        }
コード例 #35
0
        /// <summary>
        /// Validates any object
        /// </summary>
        /// <typeparam name="TObject">The type of the object.</typeparam>
        /// <param name="validate">The validate.</param>
        /// <returns></returns>
        public ValidationResult Validate <TObject>(TObject validate)
        {
            FluentValidation.Results.ValidationResult validationResult;
            if (validate == null)
            {
                validationResult = new FluentValidation.Results.ValidationResult();
                validationResult.Errors.Add(new ValidationFailure("ActionObject", "Please provide some input"));
            }
            else
            {
                var validator = GetValidator <TObject>();
                validationResult = validator.Validate(validate);
            }

            return(FluentConverter.ToProjectValidationResult(validationResult));
        }
        protected override void Context()
        {
            base.Context();

            _createAccountRequest = new CreateAccountRequest
                                        {
                                            EmailAddress = "someinvalidemailaddress",
                                            Username = "******",
                                        };

            _expectedResult = new ValidationResult(new List<ValidationFailure>
                                                       {
                                                           new ValidationFailure("EmailAddress", "Email address is not valid."),
                                                           new ValidationFailure("Username", "Username has some invalid characters."),
                                                       });
        }
コード例 #37
0
        public void Handle_InvokesDecoratedHandle_WhenValidationPasses()
        {
            var query = new FakeQueryWithoutValidator();
            var decorated = new Mock<IHandleQuery<FakeQueryWithoutValidator, string>>(MockBehavior.Strict);
            var validator = new Mock<IValidator<FakeQueryWithoutValidator>>(MockBehavior.Strict);
            var expectedResult = new ValidationResult();
            validator.Setup(x => x.Validate(query)).Returns(expectedResult);
            decorated.Setup(x => x.Handle(query)).Returns("faked");

            var decorator = new ValidateQueryDecorator<FakeQueryWithoutValidator, string>(decorated.Object, validator.Object);
            var result = decorator.Handle(query);

            Assert.Equal("faked", result);
            validator.Verify(x => x.Validate(query), Times.Once);
            decorated.Verify(x => x.Handle(query), Times.Once);
        }
コード例 #38
0
        public void Handle_InvokesDecoratedHandle_WhenValidationPasses()
        {
            var command = new FakeCommandWithValidator();
            var decorated = new Mock<IHandleCommand<FakeCommandWithValidator>>(MockBehavior.Strict);
            var validator = new Mock<IValidator<FakeCommandWithValidator>>(MockBehavior.Strict);
            Expression<Func<FakeCommandWithValidator, bool>> expectedCommand = x => ReferenceEquals(x, command);
            var expectedResult = new ValidationResult();
            validator.Setup(x => x.Validate(It.Is(expectedCommand))).Returns(expectedResult);
            decorated.Setup(x => x.Handle(It.Is(expectedCommand))).Returns(Task.FromResult(0));
            var decorator = new ValidateCommandDecorator<FakeCommandWithValidator>(decorated.Object, validator.Object);

            decorator.Handle(command).Wait();

            validator.Verify(x => x.Validate(It.Is(expectedCommand)), Times.Once);
            decorated.Verify(x => x.Handle(It.Is(expectedCommand)), Times.Once);
        }
コード例 #39
0
        public void Handle_ThrowsValidationException_AndDoesNotInvokeDecoratedHandle_WhenValidationFails()
        {
            var command = new FakeCommandWithValidator();
            var decorated = new Mock<IHandleCommand<FakeCommandWithValidator>>(MockBehavior.Strict);
            var validator = new Mock<IValidator<FakeCommandWithValidator>>(MockBehavior.Strict);
            Expression<Func<FakeCommandWithValidator, bool>> expectedCommand = x => ReferenceEquals(x, command);
            var expectedResult = new ValidationResult(new[] { new ValidationFailure("Name", "Invalid.", command.ReturnValue), });
            validator.Setup(x => x.Validate(It.Is(expectedCommand))).Returns(expectedResult);
            var decorator = new ValidateCommandDecorator<FakeCommandWithValidator>(decorated.Object, validator.Object);

            var exception = Assert.Throws<ValidationException>(() => decorator.Handle(command));

            exception.ShouldNotBeNull();
            validator.Verify(x => x.Validate(It.Is(expectedCommand)), Times.Once);
            decorated.Verify(x => x.Handle(It.IsAny<FakeCommandWithValidator>()), Times.Never);
        }
コード例 #40
0
        public ActionResult EditFromProductInGame(ProductLocationViewModel plvm)
        {
            StringBuilder sb = new StringBuilder();

            if (ModelState.IsValid)
            {
                db.Entry(plvm.ProductLocation).State = EntityState.Modified;

                foreach (var s in plvm.ProductLocation.SerialNumbers)
                {
                    SerialNumberValidator validator = new SerialNumberValidator();

                    FluentValidation.Results.ValidationResult results = validator.Validate(s);
                    IList <ValidationFailure> failures = results.Errors;

                    foreach (var e in results.Errors)
                    {
                        ModelState.AddModelError(e.PropertyName + "Error", e.ErrorMessage);
                        sb.AppendLine(e.ErrorMessage);
                    }


                    db.Entry(s).State = EntityState.Modified;
                }
                foreach (var v in plvm.ProductLocation.Vouchers)
                {
                    db.Entry(v).State = EntityState.Modified;
                }

                if (ModelState.IsValid)
                {
                    db.SaveChanges();
                    return(RedirectToAction("Edit", "ProductInGames", new { id = plvm.ProductLocation.ProductInGameID }));
                }
                else
                {
                    ViewBag.ProductInGameID            = plvm.ProductLocation.ProductInGameID;
                    ViewBag.ErrorMessage               = sb.ToString();
                    plvm.ProductLocation.ProductInGame = db.ProductInGames.Find(plvm.ProductLocation.ProductInGameID);
                    return(View(plvm));
                }
            }
            ViewBag.ErrorMessage               = sb.ToString();
            ViewBag.ProductInGameID            = plvm.ProductLocation.ProductInGameID;
            plvm.ProductLocation.ProductInGame = db.ProductInGames.Find(plvm.ProductLocation.ProductInGameID);
            return(View(plvm));
        }
コード例 #41
0
        public void Handle_ThrowsValidationException_AndDoesNotInvokeDecoratedHandle_WhenValidationFails()
        {
            var query = new FakeQueryWithoutValidator();
            var decorated = new Mock<IHandleQuery<FakeQueryWithoutValidator, string>>(MockBehavior.Strict);
            var validator = new Mock<IValidator<FakeQueryWithoutValidator>>(MockBehavior.Strict);
            Expression<Func<FakeQueryWithoutValidator, bool>> expectedQuery = x => ReferenceEquals(x, query);

            var expectedResult = new ValidationResult(new[] { new ValidationFailure("Name", "Invalid."), });
            validator.Setup(x => x.Validate(It.Is(expectedQuery))).Returns(expectedResult);

            var decorator = new ValidateQueryDecorator<FakeQueryWithoutValidator, string>(decorated.Object, validator.Object);
            var exception = Assert.Throws<ValidationException>(() => decorator.Handle(query));

            Assert.NotNull(exception);
            validator.Verify(x => x.Validate(It.Is(expectedQuery)), Times.Once);
            decorated.Verify(x => x.Handle(It.IsAny<FakeQueryWithoutValidator>()), Times.Never);
        }
コード例 #42
0
        public override async Task <FluentValidation.Results.ValidationResult> ValidateAsync(ValidationContext <ModificarEmailCommand> context, CancellationToken cancellation = default)
        {
            var result = new FluentValidation.Results.ValidationResult();
            var entity = context.InstanceToValidate;

            string normalizedEmail = entity.NuevoEmail.ToUpper();

            bool oldUser = await db
                           .Usuario
                           .AnyAsync(el => el.NormalizedEmail == normalizedEmail, cancellation);

            if (oldUser)
            {
                result.Errors.Add(new ValidationFailure(nameof(entity.NuevoEmail), "El email ya se encuentra registrado"));
            }

            return(result);
        }
コード例 #43
0
        public void given_an_exception_thrown_check_that_the_controller_throws_correct_exception_and_500_status_code()
        {
            var expectedStatusCode = 500;
            var request            = new PostProcessImageRequest(); //an empty request will be invalid

            var fakeValidationResult = new FV.ValidationResult();   //Need to create ValidationResult so that I could setup Validator mock to return it upon '.Validate()' call. Also this is the only place where it's possible to manipulate the validation result - You can only make the validation result invalid by inserting a list of validation errors as a parameter through a constructor. The boolean '.IsValid' comes from expression 'IsValid => Errors.Count == 0;', so it can't be set manually.

            _mockPostValidator.Setup(v => v.Validate(It.IsAny <PostProcessImageRequest>())).Returns(fakeValidationResult);
            _mockUsecase.Setup(x => x.ExecutePost(request)).Throws <ImageNotInsertedToS3>();
            //act
            var controllerResponse = _processImageController.PostProcessImage(request);
            var result             = controllerResponse as ObjectResult;

            //assert
            Assert.NotNull(controllerResponse);
            Assert.NotNull(result);
            Assert.AreEqual(expectedStatusCode, result.StatusCode);
        }
コード例 #44
0
        public override async Task <FluentValidation.Results.ValidationResult> ValidateAsync(ValidationContext <CreateUserCommand> context, CancellationToken cancellation = default)
        {
            var result = new FluentValidation.Results.ValidationResult();
            var entity = context.InstanceToValidate;

            string normalizedUser = entity.UserName.ToUpper();

            bool nombreUsuarioRegistrado = await db
                                           .User
                                           .AnyAsync(el => el.NormalizedUserName == normalizedUser, cancellation);


            if (nombreUsuarioRegistrado)
            {
                result.Errors.Add(new ValidationFailure(nameof(entity.UserName), "El nombre de usuario ya se encuentra registrado"));
            }

            return(result);
        }
コード例 #45
0
        private void SendMessageButtonClicked(object sender, RoutedEventArgs routedEvent)
        {
            messagesSend            = new Models.Message();
            messagesSend.message    = TextBoxMessage.Text;
            messagesSend.idChat     = ChatSelect.idChat;
            messagesSend.memberType = Login.tokenAccount.memberATEType;
            MessageValidator messageValidator = new MessageValidator();

            FluentValidation.Results.ValidationResult dataValidationResult = messageValidator.Validate(messagesSend);
            IList <ValidationFailure> validationFailures = dataValidationResult.Errors;

            if (dataValidationResult.IsValid)
            {
                RegisterMessage();
            }
            else
            {
                MessageBox.Show("Por favor ingrese un mensaje correcto", "Mensaje invalido", MessageBoxButton.OK, MessageBoxImage.Warning);
            }
        }
コード例 #46
0
        public async Task <IActionResult> UserRegister([Required][FromBody] CustomerDetails userDetails)
        {
            CustomerValidator customerValidator = new CustomerValidator();

            FluentValidation.Results.ValidationResult validationResult = customerValidator.Validate(userDetails);
            if (!validationResult.IsValid)
            {
                return(BadRequest(validationResult.ToString("; ")));
            }
            var result = await Task <int> .Run(() => _customerBusiness.UserRegisteration(userDetails));

            if (result > 0)
            {
                return(Ok("User Added Successfully"));
            }
            else
            {
                return(BadRequest("User is not added"));
            }
        }
コード例 #47
0
ファイル: BuilderFacts.cs プロジェクト: Allann/Modeller
    public void Builder_Create_WhenContextIsValid()
    {
        var result = new FluentValidation.Results.ValidationResult();

        var context = Substitute.For <IContext>();

        context.ValidateConfiguration(Arg.Any <IGeneratorConfiguration>())
        .Returns(result);
        var codeGenerator = Substitute.For <ICodeGenerator>();
        var output        = Substitute.For <IOutputStrategy>();
        var logger        = Substitute.For <ILogger <Builder> >();
        var configuration = Substitute.For <IGeneratorConfiguration>();

        var sut = new Builder(context, codeGenerator, output, logger);

        sut.Create(configuration);

        logger.ReceivedCalls().Should().HaveCount(2);
        codeGenerator.ReceivedCalls().Should().HaveCount(1);
    }
コード例 #48
0
        public void Assign_NullOrWhitespace_to_SongTitleAlbumComposer_ReturnsError(string whitespace)
        {
            Song fakeSong = new Song()
            {
                Title    = whitespace,
                Album    = whitespace,
                Composer = whitespace
            };

            SongValidator    validator = new SongValidator();
            ValidationResult results   = validator.Validate(fakeSong);

            bool isValid = results.IsValid;
            IList <ValidationFailure> failures = results.Errors;

            Assert.False(isValid);
            foreach (var failure in failures)
            {
                _output.WriteLine(failure.ErrorMessage);
            }
        }
コード例 #49
0
        public static Dictionary<string, object> GetErrors(ValidationResult r)
        {
            Dictionary<string, object> dic = null;
            Dictionary<string, List<string>> m = new Dictionary<string, List<string>>();

            if (!r.IsValid)
            {
                foreach (ValidationFailure e in r.Errors)
                {
                    SetError(e.PropertyName, e.ErrorMessage, m);
                }

                dic = new Dictionary<string, object>
                {
                    { "error", 1 },
                    { "errors", m }
                };
            }

            return dic;
        }
コード例 #50
0
        public async Task <IActionResult> UpdateCustomerDetails([Required][FromBody] CustomerDetails customerDetails)
        {
            //_msgObj.RegisterOnMessageHandlerAndReceiveMessages();
            CustomerValidator customerValidator = new CustomerValidator();

            FluentValidation.Results.ValidationResult validationResult = customerValidator.Validate(customerDetails);
            if (!validationResult.IsValid)
            {
                return(BadRequest(validationResult.ToString("; ")));
            }
            var result = await Task <int> .Run(() => _customerBusiness.UpdateCustomerDetails(customerDetails));

            if (result > 0)
            {
                return(Ok("Customer data updated successfully"));
            }
            else
            {
                return(BadRequest("Customer data cannot be updated.Please try again later"));
            }
        }
コード例 #51
0
        private void BtnUpdatePerson_Click(object sender, RoutedEventArgs e)
        {
            SelectedPersonne.Nom = txtbUpdatePersonName.Text;

            PersonneValidator validator = new PersonneValidator();

            FluentValidation.Results.ValidationResult results = validator.Validate(SelectedPersonne);

            if (results.IsValid == false)
            {
                foreach (ValidationFailure failure in results.Errors)
                {
                    MessageBox.Show($"{failure.ErrorMessage}", "Erreur", MessageBoxButton.OK, MessageBoxImage.Error);
                }
                return;
            }

            DAL.UpdatePerson(SelectedPersonne);

            this.Close();
        }
        protected override void Context()
        {
            base.Context();

            _createAccountRequest = new CreateAccountRequest();

            AuthorizationService.Stub(
                x => x.CanExecute(Arg<string>.Is.Equal(Username), Arg<Type>.Is.Equal(typeof (CreateAccountRequest)))).
                Return(true);

            _validationResultReturnedFromValidator = new ValidationResult(new List<ValidationFailure>
                                                                              {
                                                                                  new ValidationFailure("FirstName",
                                                                                                        "First Name cannot be empty."),
                                                                                  new ValidationFailure("LastName",
                                                                                                        "Last Name cannot be empty."),
                                                                                  new ValidationFailure("EmailAddress",
                                                                                                        "Email Address cannot be empty."),
                                                                                  new ValidationFailure("Username",
                                                                                                        "Username cannot be empty."),
                                                                                  new ValidationFailure("Role",
                                                                                                        "Role cannot be empty."),

                                                                              });

            _createAccountRequestValidator = MockRepository.GenerateStub<CreateAccountRequestValidator>();
            _createAccountRequestValidator.Stub(
                x => x.Validate(Arg<CreateAccountRequest>.Is.Equal(_createAccountRequest)))
                .Return(_validationResultReturnedFromValidator);

            ValidatorFactory.Stub(
                x => x.GetValidator<CreateAccountRequest>())
                .Return(_createAccountRequestValidator);

            _expectedCreateAccountResponse = new CreateAccountResponse
                                                 {
                                                     Success = false,
                                                     Errors = _validationResultReturnedFromValidator.Errors.Select(x=>x.ErrorMessage),
                                                 };
        }
コード例 #53
0
        protected override void Context()
        {
            base.Context();

            _document = Builder<Document>.CreateNew().Build();

            AuthorizationService.Stub(
                x => x.CanExecute(Arg<string>.Is.Equal(Username), Arg<string>.Is.Equal("CreateDocument")))
                .Return(true);

            _validationResultReturnedFromValidator = new ValidationResult();
            Validator.Stub(x => x.Validate(Arg<Document>.Is.Equal(_document)))
                .Return(_validationResultReturnedFromValidator);

            _documentReturnedFromRepository = new Document
                                                  {
                                                      Body = _document.Body,
                                                      CreatedByUsername = Username,
                                                      CreatedDate = new DateTime(2011, 1, 1),
                                                      CustomerId = 7,
                                                      CustomerName = "some customer name",
                                                      DocumentId = 123,
                                                      Title = _document.Title,
                                                  };

            DocumentRepository.Stub(x => x.Save(Arg<string>.Is.Equal(Username), Arg<Document>.Is.Anything))
                .Return(_documentReturnedFromRepository);

            _expectedDocument = new Document
                                    {
                                        Body = _documentReturnedFromRepository.Body,
                                        CreatedByUsername = _documentReturnedFromRepository.CreatedByUsername,
                                        CreatedDate = _documentReturnedFromRepository.CreatedDate,
                                        CustomerId = _documentReturnedFromRepository.CustomerId,
                                        CustomerName = _documentReturnedFromRepository.CustomerName,
                                        DocumentId = _documentReturnedFromRepository.DocumentId,
                                        Title = _documentReturnedFromRepository.Title,
                                    };
        }
コード例 #54
0
        public static Contracts.Domain.BusinessRules.ValidationResult Map(this FluentValidation.Results.ValidationResult validationResult)
        {
            if (validationResult.IsValid)
            {
                return(Contracts.Domain.BusinessRules.ValidationResult.Success);
            }

            var result = new Contracts.Domain.BusinessRules.ValidationResult();

            foreach (var validationFailure in validationResult.Errors)
            {
                var error =
                    new BusinessError(
                        validationFailure.ErrorCode,
                        validationFailure.ErrorMessage,
                        _severtyMapper[validationFailure.Severity]);

                result.AddError(error);
            }

            return(result);
        }
コード例 #55
0
        private void RegisterButtonClicked(object sender, RoutedEventArgs e)
        {
            CreateLinkedOrganizationFromUserInput();
            LinkedOrganizationValidator linkedOrganizationValidator = new LinkedOrganizationValidator();

            FluentValidation.Results.ValidationResult dataValidationResult = linkedOrganizationValidator.Validate(LinkedOrganization);
            IList <ValidationFailure> validationFailures = dataValidationResult.Errors;
            UserFeedback userFeedback = new UserFeedback(FormGrid, validationFailures);

            userFeedback.ShowFeedback();
            if (dataValidationResult.IsValid)
            {
                ProfessionalPracticesContext professionalPracticesContext = new ProfessionalPracticesContext();
                UnitOfWork unitOfWork = new UnitOfWork(professionalPracticesContext);
                try
                {
                    if (ThereIsAnotherLinkedOrganizationWithSameData(unitOfWork))
                    {
                        MessageBox.Show("Existe una organización vinculada con el mismo nombre, correo o teléfono registrado");
                    }
                    else
                    {
                        unitOfWork.LinkedOrganizations.Add(LinkedOrganization);
                        MessageBox.Show("La organización vinculada se registró exitosamente");
                        GoBackToCoordinatorMenu();
                    }
                }
                catch (SqlException)
                {
                    MessageBox.Show("No se pudo obtener la información de la base de datos");
                    this.Close();
                }
                finally
                {
                    unitOfWork.Complete();
                    unitOfWork.Dispose();
                }
            }
        }
コード例 #56
0
        public BaseResponse <TransferResponse> Transfer(string userId, TransferRequest transferRequest)
        {
            var response = new BaseResponse <TransferResponse>();

            try
            {
                transferRequest.UserId = userId;
                TransferValidator transferValidator = new TransferValidator(_checkingAccountService);
                FluentValidation.Results.ValidationResult validationResult = transferValidator.Validate(transferRequest);

                if (!validationResult.IsValid)
                {
                    response.AddErrors(validationResult.Errors);
                    return(response);
                }

                var from = _checkingAccountService.UpdateBalance(transferRequest.NumberFrom, transferRequest.Amount * -1);
                var to   = _checkingAccountService.UpdateBalance(transferRequest.NumberTo, transferRequest.Amount);

                _transactionService.Add(new Transaction
                {
                    Amount = transferRequest.Amount,
                    FromCheckingAccountId = from.Id,
                    ToCheckingAccountId   = to.Id
                });

                _checkingAccountService.Commit();

                response.Data = new TransferResponse {
                    Balance = from.Balance
                };
            }
            catch (Exception ex)
            {
                _checkingAccountService.Rollback();
                response.AddError(1, "Erro inesperado");
            }
            return(response);
        }
コード例 #57
0
        public void given_an_invalid_request_object_controller_should_return_bad_request()
        {
            var requestObject = new MatProcessData();
            var request       = new UpdateProcessDataRequest()
            {
                processDataToUpdate = new MatUpdateProcessData()
            };
            var validationErrorList = new List <ValidationFailure>();

            validationErrorList.Add(new ValidationFailure(faker.Random.Word(), faker.Random.Word()));
            var fakeValidationResult = new FV.ValidationResult(validationErrorList); //Need to create ValidationResult so that I could setup Validator mock to return it upon '.Validate()' call. Also this is the only place where it's possible to manipulate the validation result - You can only make the validation result invalid by inserting a list of validation errors as a parameter through a constructor. The boolean '.IsValid' comes from expression 'IsValid => Errors.Count == 0;', so it can't be set manually.

            _mockValidatorUpdate.Setup(x => x.Validate(request)).Returns(fakeValidationResult);
            var response      = _processDataController.UpdateExistingProcessDocument(request);
            var okResult      = (ObjectResult)response;
            var resultContent = okResult.Value;

            Assert.NotNull(response);
            Assert.NotNull(okResult);
            Assert.NotNull(resultContent);
            Assert.AreEqual(400, okResult.StatusCode);
        }
コード例 #58
0
            public void GiveAIdWhichUserHasNoPermission_ShouldThrowException()
            {
                const int aValidId = 1;
                var genres = new List<Genre>
                                 {
                                     new Genre
                                         {
                                             Id = aValidId
                                         }
                                 };

                var dbSet = new FakeDbSet<Genre>();

                foreach (Genre genre in genres)
                {
                    dbSet.Add(genre);
                }

                var entitiesContext = A.Fake<IEntitiesContext>();
                A.CallTo(() => entitiesContext.Set<Genre>()).Returns(dbSet);

                var fakeValidator = A.Fake<IValidator<Genre>>();
                var validationFailure = new List<ValidationFailure> { new ValidationFailure("Id", "fake error") };
                var validationResult = new ValidationResult(validationFailure);

                A.CallTo(() => fakeValidator.Validate(A<Genre>.Ignored)).Returns(validationResult);

                var repo = new EntityRepository<Genre>(entitiesContext);
                IValidatorFactory factory = A.Fake<IValidatorFactory>();
                var fakeMapping = A.Fake<IMappingEngine>();
                var genreService = new GenreService(repo, factory, fakeMapping);

                //Genre result = genreService.GetGenre(aValidId);

                Action act = () => genreService.GetGenre(aValidId);

                act.ShouldThrow<ValidationException>();
            }
        protected override void Context()
        {
            base.Context();

            _createCustomerRequest = Builder<CreateCustomerRequest>.CreateNew().Build();

            AuthorizationService.Stub(
                x => x.CanExecute(Arg<string>.Is.Equal(Username), Arg<Type>.Is.Equal(typeof (CreateCustomerRequest)))).
                Return(true);

            _validationResponse = new ValidationResult(new List<ValidationFailure>
                                                           {
                                                               new ValidationFailure("some property", "some error")
                                                           });
            CreateCustomerRequestValidator.Stub(
                x => x.Validate(Arg<CreateCustomerRequest>.Is.Equal(_createCustomerRequest)))
                .Return(_validationResponse);

            _expectedResponse = new CreateCustomerResponse(_validationResponse.Errors.Select(x => x.ErrorMessage))
                                    {
                                        Success = false,
                                    };
        }
コード例 #60
0
ファイル: ValidationTemplate.cs プロジェクト: Fody/Validar
 void Validate(object sender, PropertyChangedEventArgs e)
 {
     validationResult = validator.Validate(target);
     foreach (var error in validationResult.Errors)
     {
         RaiseErrorsChanged(error.PropertyName);
     }
 }