public IHttpActionResult CreateProductWithProductDetail([FromBody] CreateNReadModel databody) { using (var db = new DB_context()) { try { ProductValidator val = new ProductValidator(); //Dictionary<string, ProductViewModel> dict = new Dictionary<string, ProductViewModel>(); Dictionary <string, object> result = new Dictionary <string, object>(); //Product product = dict.Add(, databody); Product product = databody.CreateProductDictionary(); db.Products.Add(product); db.SaveChanges(); if (val.isValidProductDetail(product.ProductDetail, product.ProductType) == true) { result.Add("Message", "Insert Data Success"); } else { result.Add("Message", "Data is invalid "); } return(Ok(result)); } catch (Exception) { throw; } } }
//[LogAspect]-->AOP //[Validate] //[RemoveCache] //[Transaction] //[Performance] public IResult Add(Product product) { #region Fluent Validation Oncesi //FLUENT VALIDATION //Aşağıdaki if bloklarında bulunan iş kontrollerininden fluent validation ile kurtuluyoruz. //VALIDATION RULES KLASÖRÜ //if (product.UnitPrice <= 0) //{ // return new ErrorResult(Messages.ProductUnitPriceInvalid); //} //if (product.ProductName.Length < 2) //{ // //magic strings // aslında bu şekilde direk string göndermek iyi değildir. // return new ErrorResult(message: Messages.ProductNameInValid); //} #endregion var context = new ValidationContext <Product>(product); ProductValidator productValidator = new ProductValidator(); var result = productValidator.Validate(context); if (!result.IsValid) { throw new ValidationException(result.Errors); } _productManager.Add(product); return(new SuccessResult(message: Messages.ProductAdded)); }
public HttpStatusCode Update([FromBody] Product product) { var validationResult = new ProductValidator(ValidateFor.Update).Validate(product); if (!validationResult.IsValid) { throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest) { ReasonPhrase = "Data is invalid", Content = new StringContent(JsonConvert.SerializeObject(validationResult.Errors)) }); } using (var session = Raven.Instance.Store.OpenSession()) { var prod = session.Load <Product>(product.Id); if (prod == null) { return(HttpStatusCode.NotFound); } prod.Name = product.Name; prod.Categories = product.Categories; session.SaveChanges(); return(HttpStatusCode.OK); } }
public ProductDTO Create(ProductDTO product) { var productValidator = new ProductValidator(); var results = productValidator.Validate(product); var dto = new Product { DeliveryPrice = product.DeliveryPrice, Price = product.Price, Description = product.Description, Id = product.Id, Name = product.Name, }; if (!results.IsValid) { results.AddToModelState(ModelState, "Product"); throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, ModelState)); } base._RefactorMeProvider.Products.Add(dto); product.Id = dto.Id; return(product); }
public void ProductValidator_Throw_Exception_When_Name_Is_Empty() { var validator = new ProductValidator(); var product = new Product(); validator.ShouldHaveValidationErrorFor(y => y.Name, product); }
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext) { var validator = new ProductValidator(); var result = validator.Validate(this); return(result.Errors.Select(item => new ValidationResult(item.ErrorMessage, new[] { item.PropertyName }))); }
public void EditProduct(Product product) { IValidator validator = ProductValidator.CreateValidator(product, true); validator.Validate(); repository.EditProduct(product); }
public async Task <Guid> Handle(CreateProductCommand request, CancellationToken cancellationToken) { var newProduct = new Product { Name = request.Name, Description = request.Description, Price = request.Price, IsAnimal = request.IsAnimal, CreateDateUtc = DateTime.UtcNow, DeletedDateUtc = null, }; var doesProductExist = _context.Products.FirstOrDefault(x => x.Name.Equals(newProduct.Name)) != null; if (doesProductExist) { return(await Task.FromResult(Guid.Empty)); } await _context.Products.AddAsync(newProduct, cancellationToken); var productValidator = new ProductValidator(); var productValidationResult = await productValidator.ValidateAsync(newProduct, cancellationToken); if (!productValidationResult.IsValid) { return(await Task.FromResult(Guid.Empty)); } await _context.SaveChangesAsync(cancellationToken); return(await Task.FromResult(newProduct.Id)); }
public ResultModel <Product> ProductSave(Product model) { var validator = new ProductValidator().Validate(model); if (validator.IsValid) { _productRepository.Add(model); if (_messageService != null) { MessageTemplate m = new MessageTemplate(); m.From = "*****@*****.**"; m.To = new List <string>(); m.To.Add("*****@*****.**"); m.MessageBody = "Yazilim16 Deneme"; m.MessageSubject = "Test"; _messageService.SendMessage(m); } return(new ResultModel <Product> { Errors = null, IsValid = true, Message = "Kayıt Başarılı" }); } return(new ResultModel <Product> { Errors = validator.Errors.Select(x => x.ErrorMessage).ToList(), IsValid = false, Message = "Kayıt Başarısız" }); }
public void NewProduct(Product product, string clientId) { IValidator validator = ProductValidator.CreateValidator(product, false); validator.Validate(); repository.NewProduct(product, clientId); }
protected virtual void ValidateProducts(CatalogProduct[] products) { if (products == null) { throw new ArgumentNullException(nameof(products)); } //Validate products var validator = new ProductValidator(); foreach (var product in products) { validator.ValidateAndThrow(product); } LoadDependencies(products, false); ApplyInheritanceRules(products, false); var targets = products.OfType <IHasProperties>(); foreach (var item in targets) { var validatioResult = _hasPropertyValidator.Validate(item); if (!validatioResult.IsValid) { throw new ValidationException($"Product properties has validation error: {string.Join(Environment.NewLine, validatioResult.Errors.Select(x => x.ToString()))}"); } } }
public void Test_ProductValidator_Same_Name_Or_Sku_Warehouse() { var fakeContext = new FakeContext("Test_ProductValidator_Same_Name_Or_Sku_Warehouse"); fakeContext.FillWith <Product>(); using (var context = new MainContext(fakeContext.FakeOptions, fakeContext.FakeConfiguration().Object)) { validator = new ProductValidator(context); var repository = new ProductRepository(context); var messageMock = new Mock <IMessageHandler>(); messageMock .Setup(x => x .SendMessageAsync(It.IsAny <MessageType>(), It.IsAny <Product>())) .Returns(Task.CompletedTask); var service = new ProductService(repository, messageMock.Object); var product = new Product(); product.Sku = "1001"; product.Name = "Product 1"; product.Price = 15M; product.Quantity = 150; service.Create(product); var result = validator.TestValidate(product); result.ShouldHaveAnyValidationError(); Assert.Equal("Produto já cadastrado.", result.Errors[0].ErrorMessage); } }
public async Task <Product> Handle(UpdateProductInfoCommand request, CancellationToken cancellationToken) { var product = await _context.Products.FindAsync(request.Id); if (product is null) { return(await Task.FromResult <Product>(null)); } product.Name = request.Name ?? product.Name; product.Description = request.Description ?? product.Description; product.Price = request.Price ?? product.Price; product.IsAnimal = request.IsAnimal ?? product.IsAnimal; var productValidator = new ProductValidator(); var validationResult = await productValidator.ValidateAsync(product, cancellationToken); if (!validationResult.IsValid) { return(await Task.FromResult <Product>(null)); } await _context.SaveChangesAsync(cancellationToken); return(await Task.FromResult(product)); }
public ProductsController(IMapper mapper, IProductRepository repository, IUnitOfWork unitOfWork, ProductValidator _productValidator) { _mapper = mapper; _repository = repository; _unitOfWork = unitOfWork; this._productValidator = _productValidator; }
public void Add(Product product) { ProductValidator productValidator = new ProductValidator(); var result = productValidator.Validate(product); // burraya gönderilen ürün için validate işlemlerini uyguladık. _productDal.Add(product); }
public void SetUp() { _internalCommandService.ResetCalls(); _productQuery.ResetCalls(); _productValidator = new ProductValidator(_internalCommandService.Object, _productQuery.Object); }
public async Task <ActionResult> UpdateProduct(CreateProductViewModel model) { var validator = new ProductValidator(); var result = validator.Validate(model); if (result.IsValid) { var product = mapper.Map <CreateProductDTO>(model); await productService.UpdateProductAsync(product); return(RedirectToAction("Index", "Home")); } else { model.Categories = categoryService.GetAll().Result.Select(x => new SelectListItem() { Text = x.Name, Value = x.Id.ToString() }); foreach (ValidationFailure _error in result.Errors) { ModelState.AddModelError(_error.PropertyName, _error.ErrorMessage); } return(View(model)); } }
public ActionResult UpdateProduct(ProductModel data) { if (data == null) { return(Jsend(JsendResult <List <ValidationFailure> > .Error("Product data can't be null"))); } var validator = new ProductValidator(); ValidationResult validateResult = validator.Validate(data); if (validateResult.IsValid) { try { var result = RequestHelper.MakePostWebRequest <ProductModel, Jsend <ProductModel> >( $"{apiDomain}/api/Product", data, "PUT"); return(Jsend(result)); } catch (WebException ex) { Console.WriteLine(ex); return(Jsend(JsendResult.Error("更新產品發生錯誤"))); } } List <ValidationFailure> failures = validateResult.Errors.ToList(); return(Jsend(JsendResult <List <ValidationFailure> > .Fail(failures))); }
public ProductController(IProductService productService) : base(productService) { _productService = productService; _productValidator = new ProductValidator(_productService); }
public SavedProductResponse SaveProduct(SaveProductRequest productRequest) { var product = mapper.Map <SaveProductRequest, Product>(productRequest); IValidator productValidator = new ProductValidator(product); if (!productValidator.IsValid()) { return new SavedProductResponse { ErrorMessages = productValidator.Erros } } ; if (productRepository.GetByCode(product.Code) != null) { var savedProductResponse = mapper.Map <Product, SavedProductResponse>(product); savedProductResponse.ErrorMessages.Add("A product with this code already exists"); return(savedProductResponse); } try { productRepository.Save(product); } catch (Exception ex) { throw ex; } return(mapper.Map <Product, SavedProductResponse>(product)); }
public UpdateProductResponse UpdateProduct(string id, UpdateProductRequest productToUpdate) { var product = mapper.Map <UpdateProductRequest, Product>(productToUpdate); IValidator productValidator = new ProductValidator(product); if (!productValidator.IsValid()) { return new UpdateProductResponse { ErrorMessages = productValidator.Erros } } ; try { productRepository.Update(id, product); } catch (Exception ex) { throw ex; } return(new UpdateProductResponse { Id = id }); } }
public ActionResult Put([FromBody] Order order) { var product = new Product { Name = null // will fail validation }; var validationResult = new ProductValidator().Validate(product); /* * foreach( var er in validationResult.Errors) * { * er. * } * the FluentValidation.AspNet middleware is preferred, * as it “catches” this exception, * unpacks the validation errors, * and returns a 400 (Bad Request) with a nice response model */ return(validationResult.IsValid ? (ActionResult)Ok("Success!") : BadRequest("Validation failed")); }
public async Task <BaseResponseDto <string> > AddProduct(Product product, IFormFile file) { try { BaseResponseDto <string> productResponse = new BaseResponseDto <string>(); var result = new ProductValidator().Validate(product); if (!result.IsValid) { foreach (var validationFailure in result.Errors) { productResponse.Errors.Add(validationFailure.PropertyName, validationFailure.ErrorMessage); } return(productResponse); } bool resultFileUpload = FileConfiguration.FileUpload(file); if (!resultFileUpload) { productResponse.Errors.Add("File Upload :", "While upload file, occured an error"); return(productResponse); } product.Image = file.FileName; await _repository.CreateAsync(product); productResponse.Data = "Added product succesfully"; return(productResponse); } catch (Exception e) { return(CreateThrowMessage(e)); } }
/// <summary>Updates a product.</summary> /// <param name="product">The product to update.</param> /// <returns>The updated product.</returns> public Product Update(Product product) { if (product.Id <= 0) { throw new ArgumentOutOfRangeException(nameof(product.Id), "Id must be > 0."); } if (product == null) { throw new ArgumentNullException(nameof(product)); } var results = ProductValidator.TryValidateObject(product); if (results.Count() > 0) { throw new ValidationException(results.FirstOrDefault().ErrorMessage); } var existing = GetByNameCore(product.Name); if (existing != null && existing.Id != product.Id) { throw new ArgumentException("Product must be unique"); } //Get existing product existing = GetCore(product.Id); return(UpdateCore(existing, product)); }
public Jsend <List <ValidationFailure> > AddProduct(ProductModel data) { if (data == null) { return(JsendResult <List <ValidationFailure> > .Error("Product data can't be null")); } var validator = new ProductValidator(); ValidationResult validateResult = validator.Validate(data); if (validateResult.IsValid) { try { _uow.ProductTRepository.Add(new ProductT { CompanyID = data.CompanyID, ProductName = data.ProductName, ProductType = data.ProductType, Price = data.Price, Unit = data.Unit }); _uow.Commit(); return(JsendResult <List <ValidationFailure> > .Success()); } catch (SqlException ex) { _logger.Error(ex); return(JsendResult <List <ValidationFailure> > .Error("Insert Product occured error")); } } List <ValidationFailure> failures = validateResult.Errors.ToList(); return(JsendResult <List <ValidationFailure> > .Fail(failures)); }
public void Setup() { var _timeMock = new Mock <ITimeProvider>(); _timeMock.Setup(m => m.GetToday()).Returns(_currentDate); _timeMock.Setup(m => m.GetDaysUntilEndOfWeek()).Returns(6); _uut = new ProductValidator(_timeMock.Object); }
public override Result <bool> ValidateEntity(Product entity) { var validator = new ProductValidator(); var result = validator.Validate(entity); return(new Result <bool>(result.IsValid, true)); }
public DeleteProductService( IDefaultDbContext context, ProductValidator entityValidator, DeleteProductSpecificationsValidator domainValidator ) : base(entityValidator, domainValidator) { Context = context; }
public void IsSKUWeightRequired_ShouldBeFalse_WhenNotRequired() { var product = GetProductNotRequiringWeight(); var isRequired = new ProductValidator().IsSKUWeightRequired(product); Assert.False(isRequired); }
public void Setup() { var options = new DbContextOptionsBuilder <CatalogDbContext>().UseInMemoryDatabase(Guid.NewGuid().ToString()).Options; _catalogDbContext = new CatalogDbContext(options); _validator = new ProductValidator(_catalogDbContext); }
public FormProduct(string productId) { InitializeComponent(); validator = new ProductValidator(productRepo); persister = new GenericPersister<Product>(productRepo, validator, caster); if(productId != null) { Product product = productRepo.FindById(productId); txtProductName.Text = product.Name; txtPrice.Text = product.Price.ToString(); txtAmount.Text = product.Amount.ToString(); caster.SetModel(product); } }
public HttpResponseMessage CreateProduct([FromBody]Product product) { var validationResult = new ProductValidator(ValidateFor.Create).Validate(product); if (!validationResult.IsValid) throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest) { ReasonPhrase = "Data is invalid", Content = new StringContent(JsonConvert.SerializeObject(validationResult.Errors)) }); using (var session = Raven.Instance.Store.OpenSession()) { session.Store(product); session.SaveChanges(); var response = this.Request.CreateResponse<Product>(HttpStatusCode.Created, product); return response; } }
public HttpStatusCode Update([FromBody]Product product) { var validationResult = new ProductValidator(ValidateFor.Update).Validate(product); if (!validationResult.IsValid) throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest) { ReasonPhrase = "Data is invalid", Content = new StringContent(JsonConvert.SerializeObject(validationResult.Errors)) }); using (var session = Raven.Instance.Store.OpenSession()) { var prod = session.Load<Product>(product.Id); if (prod == null) return HttpStatusCode.NotFound; prod.Name = product.Name; prod.Categories = product.Categories; session.SaveChanges(); return HttpStatusCode.OK; } }
public CreateCommand(TheInternet internet, String baseUrl, ProductValidator validator) : base(internet, baseUrl) { _validator = validator; }
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext) { var validator = new ProductValidator(); var result = validator.Validate(this); return result.Errors.Select(item => new ValidationResult(item.ErrorMessage, new[] { item.PropertyName })); }