public void Add_InvalidObjectPassed_ReturnsBadRequest1() { // Arrange var request = new AddProductRequest() { ExpirationDate = DateTime.Now, CategoryIds = new int[] { 10 }, }; _productController.ModelState.AddModelError("Name", "Name required"); _productController.ModelState.AddModelError("Rating", "Rating required"); _productController.ModelState.AddModelError("BrandId", "Invalid Brand"); _productController.ModelState.AddModelError("CategoryIds", "Invalid category"); _productController.ModelState.AddModelError("ExpirationDate", "Expiration date should expire not less than 30 days since now"); // Act var badResponse = _productController.Add(request).Result; // Assert Assert.IsType <BadRequestObjectResult>(badResponse); var response = (badResponse as BadRequestObjectResult).Value as SerializableError; Assert.Equal(5, response.Count); }
public async Task <Product> AddProduct(AddProductRequest p) { var property = JsonConvert.DeserializeObject <List <PropertyForRequest> >(p.Properties); var fileName = $"img_{p.Photo.FileName.Substring(0, p.Photo.FileName.LastIndexOf("."))}_{DateTime.Now.ToString("dd-MM-yyyy-hh-mm-ss")}"; var mime = p.Photo.FileName.Substring(p.Photo.FileName.LastIndexOf(".")); string url = $"{_env.WebRootPath}\\Uploads\\{fileName + mime}"; string urlForPhoto = $"\\Uploads\\{fileName + mime}"; if (p.Photo.Length > 0) { using (FileStream fileStream = File.Create(url)) { await p.Photo.CopyToAsync(fileStream); fileStream.Flush(); } } var product = new Product() { Name = p.Name, Description = p.Description, Properties = property.Select(x => new Property() { PropertyName = x.propertyname, PropertyValue = x.PropertyValue }).ToList(), PhotoUrl = urlForPhoto }; _context.Products.Add(product); _context.SaveChanges(); return(product); }
public JsonResult AddProduct(AddProductRequest parameter) { if (!ModelState.IsValid) { var validation_errors = ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage).ToList(); return(Json(new { success = false, validation_errors })); } Product product_parameter = new Product(); product_parameter.ProductName = parameter.ProductName; product_parameter.CategoryId = parameter.CategoryId; product_parameter.ManufactureId = parameter.ManufactureId; product_parameter.ProductPrice = parameter.ProductPrice; product_parameter.StockStatus = parameter.StockStatus; iproduct_repository.Insert(product_parameter); int created_product_id = context.Products.First(x => x.ProductName.Equals(parameter.ProductName)).ProductId; //bool check_having_detail = iproduct_repository.CheckProductHavingDetail(created_product_id); //if (check_having_detail) //{ //} return(Json(new { success = true, id = created_product_id, type = "add-product", message = "Tạo mới sản phẩm thành công! Xin vui lòng tạo thông tin chi tiết sản phẩm" })); }
public async Task TestAddProductAsync() { // Arrange var dbContext = DbContextMocker.GetStoreDbContext(nameof(TestAddProductAsync)); var service = ServiceMocker.GetWarehouseService(dbContext); var controller = new WarehouseController(service, null); var request = new AddProductRequest { ProductID = 100, ProductName = "Coca Cola Zero 24 fl Oz Bottle Special Edition", ProductDescription = "Enjoy Coca-Cola’s crisp.", Price = 2.15m }; controller.MockControllerContext(); // Act var response = await controller.AddProductAsync(request) as ObjectResult; var value = response.Value as ISingleResponse <AddProductRequest>; service.Dispose(); // Assert Assert.False(value?.DidError); }
public IActionResult AddProduct([FromBody] AddProductRequest addProductRequest) { _logger.Info("Handling api request: create event subscription :" + addProductRequest); IActionResult result = null; try { if (RequestValidator.Validate <AddProductRequest>(Request, addProductRequest, new AddProductRequestValidator(), ref result)) { var command = AddProductRequestMapper.ToCommand(addProductRequest); _addProductCommandHandler.Handle(command); } } catch (CommandNotValidException ex) { _logger.Warn("CommandNotValidException caught handling a AddProductCommand", ex); result = new BadRequest(ex.ErrorMessages.ToList(), Request); } catch (CommandTimeoutException ex) { _logger.Warn("CommandTimeoutException caught handling a AddProductCommand", ex); //result = new GatewayTimeout(new List<string>() { "Upstream Timeout", ex.Message },new HttpRequestMessage()); } return(result); }
public void UpdateProduct(AddProductRequest request) { Product model = this._productRepository.FindBy(request.Id); if (model == null) { throw new EntityIsInvalidException <string>(request.Id.ToString()); } //首先判断类型是否改变,然后再去更新 if (!request.ProductTypeId.Equals(model.Type.Id)) { ProductType type = this._productTypeRepository.FindBy(request.ProductTypeId); if (type == null) { throw new EntityIsInvalidException <string>(request.Id.ToString()); } model.Type = type; } model.ChineseName = request.ChineseName; model.EnglishName = request.EnglishName; model.Price = request.Price; model.Currency = request.Currency; model.Note = request.Note; this._productRepository.Save(model); this._uow.Commit(); }
public override async Task <ProductModel> AddProduct(AddProductRequest request, ServerCallContext context) { //var product = new Product //{ // ProductId = request.Product.ProductId, // Name = request.Product.Name, // Description = request.Product.Description, // Price = request.Product.Price, // Status = Enums.ProductStatus.INSTOCK, // CreatedTime = request.Product.CreatedTime.ToDateTime() //}; var product = _mapper.Map <Product>(request.Product); _productContext.Products.Add(product); await _productContext.SaveChangesAsync(); //var productModel = new ProductModel //{ // ProductId = product.ProductId, // Name = product.Name, // Description = product.Description, // Price = product.Price, // Status = ProductStatus.Instock, // CreatedTime = Timestamp.FromDateTime(product.CreatedTime) //}; var productModel = _mapper.Map <ProductModel>(product); _logger.LogInformation("Add Product Response :{Product}", productModel.ToString()); return(productModel); }
public async Task add_response_badrequest_if_default_deployment_name_length_is_lower_than_5() { var permission = Builders.Permission() .WithManagementPermission() .Build(); await _fixture.Given .AddPermission(permission); var productRequest = new AddProductRequest() { Name = "fooproduct", Description = "some description", DefaultDeploymentName = new string('d', 4) }; var response = await _fixture.TestServer .CreateRequest(ApiDefinitions.V5.Product.Add()) .WithIdentity(Builders.Identity().WithDefaultClaims().Build()) .PostAsJsonAsync(productRequest); response.StatusCode .Should() .Be(StatusCodes.Status400BadRequest); }
public async Task add_response_forbidden_if_user_is_not_authorized() { var permission = Builders.Permission() .WithAllPrivilegesForDefaultIdentity() .WithWritePermission(false) .Build(); await _fixture.Given .AddPermission(permission); var productRequest = new AddProductRequest() { Name = "product#1", Description = "some description" }; var response = await _fixture.TestServer .CreateRequest(ApiDefinitions.V1.Product.Add()) .WithIdentity(Builders.Identity().WithDefaultClaims().Build()) .PostAsJsonAsync(productRequest); response.StatusCode .Should() .Be(StatusCodes.Status403Forbidden); }
public async Task <CommonResponse> AddProduct(AddProductRequest productValues, int userId) { using (var uow = this.unitOfWorkFactory.GetUnitOfWork()) { var product = new Product { ProductName = productValues.ProductName }; uow.Repository <Product>().Add(product); var responseProduct = uow.SaveChanges(); if (responseProduct.Response.status == false) { return(CommonResponse.CreateError("Error occured while adding supplier products.", "ERR001", "")); } var supplierProduct = new SupplierProduct { ProductId = product.ProductId, Quantity = productValues.Quantity, Composition = productValues.Composition, SupplierId = userId, AvailableStatus = "a" }; uow.Repository <SupplierProduct>().Add(supplierProduct); var response = uow.SaveChanges(); if (response.Response.status == false) { return(CommonResponse.CreateError("Error occured while adding supplier products.", "ERR001", "")); } return(CommonResponse.CreateSuccess("Success", "SUC001", "")); } }
public void AddProduct(AddProductRequest request) { Product model = new Product(request.ChineseName, request.EnglishName, request.Price, request.Currency, request.Note, request.ProductTypeId); this._productRepository.Add(model); this._uow.Commit(); }
public async Task add_response_created_when_success() { var permission = Builders.Permission() .WithManagementPermission() .Build(); await _fixture.Given .AddPermission(permission); var productRequest = new AddProductRequest() { Name = "fooproduct", Description = "some description", DefaultDeploymentName = "Tests" }; var response = await _fixture.TestServer .CreateRequest(ApiDefinitions.V5.Product.Add()) .WithIdentity(Builders.Identity().WithDefaultClaims().Build()) .PostAsJsonAsync(productRequest); response.StatusCode .Should() .Be(StatusCodes.Status201Created); }
public async Task add_response_badrequest_when_ringname_is_not_valid() { var permission = Builders.Permission() .WithManagementPermission() .Build(); await _fixture.Given .AddPermission(permission); var productRequest = new AddProductRequest() { Name = "fooproduct~#4", Description = "some description", DefaultDeploymentName = "X" }; var response = await _fixture.TestServer .CreateRequest(ApiDefinitions.V3.Product.Add()) .WithIdentity(Builders.Identity().WithDefaultClaims().Build()) .PostAsJsonAsync(productRequest); response.StatusCode .Should() .Be(StatusCodes.Status400BadRequest); }
public async Task add_response_badrequest_if_product_name_already_exist() { var permission = Builders.Permission() .WithManagementPermission() .Build(); await _fixture.Given .AddPermission(permission); var product = Builders.Product() .WithName("fooproduct") .Build(); await _fixture.Given .AddProduct(product); var productRequest = new AddProductRequest() { Name = product.Name, Description = "some description" }; var response = await _fixture.TestServer .CreateRequest(ApiDefinitions.V3.Product.Add()) .WithIdentity(Builders.Identity().WithDefaultClaims().Build()) .PostAsJsonAsync(productRequest); response.StatusCode .Should() .Be(StatusCodes.Status400BadRequest); }
private async void AddProductClicked(object obj) { AddProductRequest addProductRequest = new AddProductRequest(); addProductRequest.AuthToken = SessionHelper.AccessToken; ProductDTO productDTO = new ProductDTO(); productDTO.AddedOn = DateTime.Now.ToString(); productDTO.IsAvailable = true; productDTO.Name = Name; productDTO.Price = Price; productDTO.ProductID = ProductID; productDTO.RecieptID = GlobalRecieptID; productDTO.Quantity = Quantity; productDTO.UpdatedOn = DateTime.Now.ToString(); addProductRequest.productDTO = productDTO; JsonValue AddProductResponse = await HttpRequestHelper <AddProductRequest> .POSTreq(ServiceTypes.AddProduct, addProductRequest); AddProductResponce addProductResponce = JsonConvert.DeserializeObject <AddProductResponce>(AddProductResponse.ToString()); if (addProductResponce.IsSuccess) { var mdp = (Application.Current.MainPage as MasterDetailPage); var navPage = mdp.Detail as NavigationPage; await navPage.PushAsync(new ProductList(Convert.ToInt32(GlobalRecieptID)), true); } }
public AddProductResponse AddProduct(AddProductRequest request) { var response = new AddProductResponse { Errors = new List <Error>() }; try { Repository.AddProduct(request.ProductEntity); response.Message = "Product added successfully!"; } catch (Exception ex) { response.Errors.Add( new Error { CustomisedMessage = "Unable to add product", StackTrace = ex.StackTrace, SystemMessage = ex.Message, }); Logger.Fatal(request); Logger.Fatal(response, ex); } return(response); }
public IHttpActionResult Add(AddProductRequest request) { Thread.Sleep(1000); var searchQuery = new SearchQuery { Filters = new List <KeyValuePair <string, List <string> > > { new KeyValuePair <string, List <string> >("pid_s", new List <string> { request.ProductId }) }, TemplateName = SearchConstants.Templates.ProductTemplateName, Language = Sitecore.Context.Language.ToString(), ContextDatabase = Sitecore.Context.Database.Name }; var searchResults = SolrNetProductsHandle.Handle(searchQuery); var product = searchResults.Results.First(x => x.Id == request.ProductId); AddProduct(product, request.Quantity); return(Json(new UpdateCartResponse { Success = true, Message = "Add cart success" })); }
public async Task AddGetProductAsync(AddProductRequest addProductRequest) { await _restClient.Put($"{_serviceUrl}/add", addProductRequest); // Expire cache manually to update product list on next call _lastUpdate = _clock.GetCurrentInstant() - _productlistValidFor; }
public async Task <IActionResult> AddProduct([FromBody] AddProductRequest request) { return(await HandleAsync(async() => { var client = clientFactory.Create <AddProductRequest, AddProductResponse>(); return await client.Request(request); })); }
public async Task <ApiResult <int> > AddAsync(AddProductRequest request) { var command = _mapper.Map <AddProductRequest, AddProductCommand>(request); var result = await _mediator.Send(command); return(new ApiResult <int>(result)); }
public async Task AddAsync(AddProductRequest request) { var product = mapper.Map <Product>(request); product.CreationDate = DateTime.Now; await productRepository.AddAsync(product); }
public async Task <AddProductResponse> Post([FromBody] AddProductRequest request) { Product product = await _productService.AddProduct(request.Description, request.Price); return(new AddProductResponse { ProductId = product.ProductId }); }
/// <summary> /// /// </summary> /// <param name="addProductRequest"></param> /// <returns></returns> public static AddProductCommand ToCommand(AddProductRequest addProductRequest) { return(new AddProductCommand { Name = addProductRequest.Name, Description = addProductRequest.Description, Price = addProductRequest.Price }); }
public async Task <IActionResult> AddProduct([FromBody] AddProductRequest request) { var(version, order) = await _aggregateService.GetAggregate <Order>(request.OrderId.ToString()); order.AddProduct(request.ProductId); await _aggregateService.SaveAggregate(order, version); return(Ok(order)); }
private StringContent GetItemJson(string name) { var request = new AddProductRequest() { Name = name }; var jsonContent = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json"); return(jsonContent); }
public async Task <IActionResult> Add([FromBody] AddProductRequest request) { var product = _mapper.Map <Product>(request); await _context.Products.AddAsync(product); await _context.SaveChangesAsync(); return(CreatedAtAction(nameof(Get), new { Id = product.Id }, _mapper.Map <ProductResponse>(product))); }
public async Task <bool> AddProduct(ShoppingCartDTO cart, ShoppingCartProductDTO product) { var request = new AddProductRequest(cart.Id, product); var response = await restClient.Put <AddProductRequest, AddProductResponse>( routing.URL, routing.AddProduct, request, HeaderAccept.Json); return(response.IsSuccess); }
public async Task <IActionResult> Post([FromBody] AddProductRequest request) { var response = await _addProduct.AddProductDb(request); if (!response.Success) { return(BadRequest()); } return(Ok(response)); }
public async Task <AddProductResponse> AddProductDb(AddProductRequest request) { var productId = await _repository.AddProductAsync(request); if (productId > 0) { return(new AddProductResponse(true, productId)); } return(new AddProductResponse(false, 0)); }
public bool AddProduct(AddProductRequest product) { var p = new Product() { Id = product.Id, Name = product.Name, Price = product.Price, AvailableQuantity = product.Quantity }; productRepository.Add(p); return(true); }
public AddProductModel Query(AddProductRequest model) { return new AddProductModel(); }