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;
                }
            }
        }
Example #2
0
        //[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);
            }
        }
Example #4
0
        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);
        }
Example #6
0
        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);
        }
Example #8
0
        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()))}");
                }
            }
        }
Example #12
0
        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;
 }
Example #15
0
        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);
        }
Example #16
0
        public void SetUp()
        {
            _internalCommandService.ResetCalls();
            _productQuery.ResetCalls();

            _productValidator = new ProductValidator(_internalCommandService.Object, _productQuery.Object);
        }
Example #17
0
        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));
            }
        }
Example #18
0
        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)));
        }
Example #19
0
        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
            });
        }
    }
Example #22
0
        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));
            }
        }
Example #24
0
        /// <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));
        }
Example #25
0
        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));
        }
Example #26
0
        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);
        }
Example #27
0
        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;
 }
Example #29
0
        public void IsSKUWeightRequired_ShouldBeFalse_WhenNotRequired()
        {
            var product = GetProductNotRequiringWeight();

            var isRequired = new ProductValidator().IsSKUWeightRequired(product);

            Assert.False(isRequired);
        }
Example #30
0
        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;
            }
        }
Example #34
0
 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 }));
 }