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();
}
