//输入产品名称和描述创建产品
private static void TestCreateProduct()
{
IClientProfile clientProfile = DefaultProfile.GetProfile("<your-region-id>", "<your-access-key-id>", "<your-access-key-secret>");
DefaultAcsClient client = new DefaultAcsClient(clientProfile);
CreateProductRequest request = new CreateProductRequest();
request.Name = "<productName>";
request.Desc = "<product description>";
try
{
CreateProductResponse response = client.GetAcsResponse(request);
Console.WriteLine(response.Success);
Console.WriteLine(response.ErrorMessage);
CreateProductResponse.CreateProduct_ProductInfo ProductInfo = response.ProductInfo;
Console.WriteLine("product name: " + ProductInfo.ProductName);
Console.WriteLine("product key: " + ProductInfo.ProductKey);
Console.WriteLine("product description: " + ProductInfo.ProductDesc);
}
catch (ServerException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
}
catch (ClientException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
}
Console.ReadKey();
}
public async Task <ValidationResultModel <ProductResponse> > Save(CreateProductRequest model)
{
var result = new ValidationResultModel <ProductResponse>();
if (!result.Succeeded)
{
return(result);
}
Products product = null;
if (!string.IsNullOrWhiteSpace(model.Id))
{
product = (await _productRepository.GetProducts(new GetProductRequest {
Id = model.Id
})).Single();
}
var productDbModel = model.Map <CreateProductRequest, Products>(product);
productDbModel = await _productRepository.Save(productDbModel);
//Save Revision with RabbitMQ
await _rabbitMqService.RabbitMqSender(product, RabbitMqConstants.ProductRevisionQueue);
result.Model = productDbModel.Map <Products, ProductResponse>();
return(result);
}
public async Task CreateProduct_ValidRequest_ReturnsResponse()
{
var createRequest = new CreateProductRequest
{
Code = "ABC",
Description = "My desc",
UnitPrice = 123.56m,
};
var createResponse = await Fixture.Products.CreateProductAsync(createRequest);
AssertUtilities.NotEmpty(createResponse.Id);
Assert.Equal(createRequest.Code, createResponse.Code);
Assert.Equal(createRequest.Description, createResponse.Description);
Assert.Equal(createRequest.UnitPrice, createResponse.UnitPrice);
Assert.True(createResponse.IsListed);
var findRequest = new FindProductRequest {
Id = createResponse.Id
};
var findResponse = await Fixture.Products.FindProductAsync(findRequest);
Assert.Equal(findRequest.Id, findResponse.Id);
Assert.Equal(createRequest.Code, findResponse.Code);
Assert.Equal(createRequest.Description, findResponse.Description);
Assert.Equal(createRequest.UnitPrice, findResponse.UnitPrice);
Assert.True(findResponse.IsListed);
}
public async Task <MessageResponse> Create(CreateProductRequest request)
{
try
{
using (UnitOfWork uow = new UnitOfWork())
{
var category = await uow.Categories.GetAsync(request.CategoryId);
var product = mapper.Map <CreateProductRequest, Product>(request);
product.Category = category;
product.CreatedDate = DateTime.Today;
product.Status = Data.Enums.ProductStatus.OutOfStock;
product.Image = await fileService.UploadFileAsync(request.ThumbnailImage);
await uow.Products.AddAsync(product);
await uow.SaveAsync();
return(new MessageResponse("success", "Tạo mới thành công"));
}
}
catch (Exception e)
{
return(new MessageResponse("error", "Tạo mới thất bại", $"Lỗi: {e.Message}"));
}
}
public async Task <ProductResponce> CreateAsync(CreateProductRequest request)
{
if (!m_authService.IsAuthUser())
{
throw new AuthenticationException();
}
if (!m_authService.AuthUserInRole(Roles.AdminRoleName))
{
throw new UserNotAdminException();
}
var categoryDb = await m_db.LeafCategories.FirstOrDefaultAsync(x => x.Id == request.CategoryId);
if (categoryDb is null)
{
throw new CategoryLeafNotFoundException();
}
var newProduct = m_mapper.Map <ProductDbModel>(request);
categoryDb.Products.Add(newProduct);
await m_db.SaveChangesAsync();
return(m_mapper.Map <ProductResponce>(newProduct));
}
public async Task <IActionResult> CreateProduct([FromBody] CreateProductRequest request)
{
var command = new CreateProductRequestCommand(request.Name, request.Price, request.ExpirationDate);
var result = await _mediator.Send(command);
return(CreatedAtAction("GetProduct", new { productId = result.Id, token = CancellationToken.None }, result));
}
public Product Create([FromBody] CreateProductRequest model)
{
_bus.Send <SubmitProduct>(new { ProductName = model.ProductName, SupplierId = model.SupplierId, Package = model.Package }).GetAwaiter().GetResult();
var result = _productService.Create(model);
return(result);
}
public async Task <int> Add(CreateProductRequest request)
{
Product product = _mapper.Map <CreateProductRequest, Product>(request);
await _productRepository.Add(product);
return(product.Id);
}
public async Task <BaseResponseDto <bool> > Handle(CreateProductRequest request, CancellationToken cancellationToken)
{
BaseResponseDto <bool> response = new BaseResponseDto <bool>();
if (request.Price <= 0)
{
throw new ArgumentException($"{nameof(request.Price)} should greater than 0");
}
try
{
var product = new Product
{
ProductCode = request.ProductCode,
Price = request.Price,
Stock = request.Stock
};
await _repository.CreateAsync(product);
response.Data = true;
await _mediator.Publish(new ProductCreatedEvent(productName : product.ProductCode));
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
response.Errors.Add("An error occurred while creating the product.");
}
return(response);
}
private CreateProductResponse Response(CreateProductRequest request)
{
var response = new CreateProductResponse(1, "basketball");
Logger.LogInformation($"接收消息：{System.Text.Json.JsonSerializer.Serialize(request)} 时间:{DateTimeOffset.Now}{Environment.NewLine}响应消息:{System.Text.Json.JsonSerializer.Serialize(response)}");
return(response);
}
public IHttpActionResult Create(CreateProductRequest product)
{
if (product == null || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newProduct = new Product();
if (_products.Any())
{
newProduct.Id = _products.Max(p => p.Id) + 1;
}
else
{
newProduct.Id = 1;
}
newProduct.ManufacturerId =
product.ManufacturerId > 0 ? product.ManufacturerId : null;
newProduct.Name = product.Name.Trim(' ');
newProduct.Quantity = product.Quantity;
_products.Add(newProduct);
return(Ok(newProduct));
}
public Product Create(CreateProductRequest model)
{
var product = _mapper.Map <Product>(model);
_productRepository.Create(product);
return(product);
}
public void Should_Delete_Product()
{
string randomString = $"{DateTime.Now:yyyyMMddHHmmssfff}";
CreateProductRequest createProductRequest = new CreateProductRequest
{
Description = "product-description",
Locale = Locale.TR.ToString(),
Name = $"product-name-{randomString}",
ConversationId = "123456789"
};
ProductResource productResource = Product.Create(createProductRequest, _options).Data;
DeleteProductRequest updateProductRequest = new DeleteProductRequest
{
Locale = Locale.TR.ToString(),
ConversationId = "123456789",
ProductReferenceCode = productResource.ReferenceCode
};
IyzipayResourceV2 response = Product.Delete(updateProductRequest, _options);
PrintResponse(response);
Assert.AreEqual(response.Status, Status.SUCCESS.ToString());
Assert.IsNotNull(response.SystemTime);
Assert.Null(response.ErrorMessage);
}
public void Should_RetrieveAll_Product()
{
string randomString = $"{DateTime.Now:yyyyMMddHHmmssfff}";
CreateProductRequest createProductRequest = new CreateProductRequest
{
Description = "product-description",
Locale = Locale.TR.ToString(),
Name = $"product-name-{randomString}",
ConversationId = "123456789"
};
Product.Create(createProductRequest, _options);
PagingRequest pagingRequest = new PagingRequest
{
Locale = Locale.TR.ToString(),
ConversationId = "123456789",
Page = 1,
Count = 1
};
ResponsePagingData <ProductResource> response = Product.RetrieveAll(pagingRequest, _options);
PrintResponse(response);
Assert.AreEqual(response.Status, Status.SUCCESS.ToString());
Assert.AreEqual(1, response.Data.Items.Count);
Assert.AreEqual(1, response.Data.CurrentPage);
Assert.IsNotNull(response.SystemTime);
Assert.Null(response.ErrorMessage);
}
public async Task Products_Create_ReturnsCreatedResponse()
{
var model = new CreateProductRequest
(
sku: random.Next(1, int.MaxValue)
, name: "TEST"
, inventory: new CreateProductInventoryRequest
(
warehouses: new CreateProductWarehouseRequest[]
{
new CreateProductWarehouseRequest(quantity: 10, locality: "SP", type: "MAIN_STORAGE"),
new CreateProductWarehouseRequest(quantity: 2, locality: "RJ", type: "ECOMMERCE")
}
)
);
var result = await _controller.Create(new ApiVersion(1, 0), model);
var actual = Assert.IsType <CreatedAtActionResult>(result);
var output = Assert.IsType <CreateProductResult>(actual.Value);
var expectStatusCode = (int)HttpStatusCode.Created;
var expectSku = model.Sku;
var expectIsMarketable = true;
var expectInventoryQuantity = 12;
var expectName = "TEST";
var expectWarehousesCount = 2;
Assert.Equal(expectStatusCode, actual.StatusCode);
Assert.Equal(expectSku, output.Sku);
Assert.Equal(expectName, output.Name);
Assert.Equal(expectIsMarketable, output.Inventory.IsMarketable);
Assert.Equal(expectInventoryQuantity, output.Inventory.Quantity);
Assert.Equal(expectWarehousesCount, output.Inventory.Warehouses.Count());
}
public async Task <CreateProductResponse> AddAsync(CreateProductRequest product)
{
try
{
var obj = new Product()
{
Id = Guid.NewGuid(),
Name = product.Name,
Description = product.Description,
Price = product.Price,
Quantity = product.Quantity,
Image = product.Image,
CreateDate = DateTime.Now,
CategoryId = product.CategoryId,
BrandId = product.BrandId
};
await _productRepository.AddAsync(obj);
var result = _mapper.Map <CreateProductResponse>(obj);
return(result);
}
catch (ArgumentException ex)
{
throw new ArgumentNullException(ex.Message);
}
}
public async Task Products_Create_DuplicatedSku_ThrowsApiException()
{
var model = new CreateProductRequest
(
sku: 43264
, name: "TEST"
, inventory: new CreateProductInventoryRequest
(
warehouses: new CreateProductWarehouseRequest[]
{
new CreateProductWarehouseRequest(quantity: 1, locality: "SP", type: "MAIN_STORAGE")
}
)
);
var actual = await Assert.ThrowsAsync <ApiException>(() => _controller.Create(apiVersion: new ApiVersion(1, 0), model));
var expectCode = ErrorConstants.ProductAlreadyExists.Code;
var expectName = ErrorConstants.ProductAlreadyExists.Name;
var expectMessage = ErrorConstants.ProductAlreadyExists.Message;
Assert.Equal(expectCode, actual.Code);
Assert.Equal(expectName, actual.Name);
Assert.Equal(expectMessage, actual.Message);
}
public async Task CreateProduct_Creates_Product_Successfully()
{
//Arrange
Mock <IProductRepository> mockProductRepository = new Mock <IProductRepository>();
Mock <ILogger <ProductService> > mockLogger = new Mock <ILogger <ProductService> >();
mockProductRepository.Setup(m => m.CreateProduct(It.IsAny <Product>()))
.ReturnsAsync(true)
.Verifiable();
CreateProductRequest createProductRequest = new CreateProductRequest
{
Name = "Test product",
Description = "This is a desc",
Price = 100,
DeliveryPrice = 10
};
ProductService productService = new ProductService(mockProductRepository.Object, mockLogger.Object);
//Act
var result = await productService.CreateProduct(createProductRequest);
//Assert
Assert.True(result.IsSuccessful);
mockProductRepository.VerifyAll();
mockLogger.VerifyAll();
}
/// <inheritdoc />
Task <ApiResponse <ProductResponse> > IStorageApi.CreateProductAsync(CreateProductRequest createProductRequest)
{
var arguments = new object[] { createProductRequest };
var func = requestBuilder.BuildRestResultFuncForMethod("CreateProductAsync", new Type[] { typeof(CreateProductRequest) });
return((Task <ApiResponse <ProductResponse> >)func(Client, arguments));
}
public ActionResult Create(CreateProductRequest request)
{
if (!ModelState.IsValid)
{
return View();
}
var product = new Product
{
CategoryId = request.CategoryId,
Description = request.Description,
MSRP = request.MSRP,
Name = request.Name,
Price = request.Price,
SKU = request.SKU,
Summary = request.Summary,
LastUpdated = DateTime.UtcNow,
LastUpdatedUserId = GetUserId(this),
};
_context.Products.Add(product);
_context.SaveChanges();
TempData.SuccessMessage($"Successfully created \"{product.Name}\"");
return RedirectToAction(nameof(Index));
}
public void can_create_product()
{
//// ARRANGE
var request = new CreateProductRequest("TestName", 12.5, 11);
var handler = new CreateProductRequestHandler();
var productRepository = MockRepository.GenerateStub <IGenericRepository <Product> >();
productRepository
.Expect(repo => repo.SaveAsync())
.Return(Task.FromResult(
new Product
{
Id = 12
}));
handler.ProductRepository = productRepository;
//// ACT
var result = handler.ExecuteAsync(request).Result;
//// ASSERT
Assert.IsTrue(result.IsSuccessful);
Assert.IsNull(result.ErrorMessage);
}
public void Create_Product()
{
CreateProductRequest request = new CreateProductRequest
{
Name = "A new Product",
Channel = "API",
Price = 10,
Currency = Currency.TRY,
EnabledInstallments = new HashSet <long> {
1, 2, 3, 6
}
};
ProductResponse response = _craftgateClient.PayByLink().CreateProduct(request);
Assert.AreEqual(response.Status, Status.ACTIVE);
Assert.AreEqual(response.Name, request.Name);
Assert.AreEqual(response.Price, request.Price);
Assert.AreEqual(response.Channel, request.Channel);
Assert.AreEqual(response.Currency, request.Currency);
Assert.AreEqual(response.EnabledInstallments, request.EnabledInstallments);
Assert.NotNull(response.Url);
Assert.NotNull(response.Token);
Assert.NotNull(response.QrCodeUrl);
}
public async Task <IActionResult> Create([FromForm] CreateProductRequest model)
{
var createdProductUserId = int.Parse(HttpContext.GetUserIdFromRequest());
var productEntity = _mapper.Map <Product>(model);
var productTierEntity = _mapper.Map <ProductTier>(model);
var result = await _productService.CreateAsync(
productEntity,
productTierEntity,
createdProductUserId,
model.Images,
_appSettings.Value.ProductImageDir,
_env.ContentRootPath);
if (!result.IsSuccess)
{
return(BadRequest(new CreateProductFailedResponse
{
Errors = result.Errors
}));
}
var productResponse = _mapper.Map <ProductResponse>(productEntity);
var locationUri = _uriService.GetByIdUri(
ApiRoutes.Product.GetById.Replace("{productId}", productEntity.Id.ToString())
);
return(Created(locationUri,
new Response <ProductResponse>(productResponse)));
}
public async Task <BaseResponse <bool> > Handle(CreateProductRequest request, CancellationToken cancellationToken)
{
BaseResponse <bool> response = new BaseResponse <bool>();
try
{
var product = new Product
{
CategoryId = request.CategoryId,
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now,
Id = Guid.NewGuid().ToString(),
Name = request.Name,
Price = request.Price
};
await _repository.CreateAsync(product);
response.PayLoad = true;
await _mediator.Publish(new NewProductCreatedEvent(productName : request.Name));
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
response.IsSuccessful = false;
response.ReturnMessage = "An error occurred while creating the product.";
}
return(response);
}
public Product AddProduct(CreateProductRequest createRequest)
{
createRequest.UnitPrice = System.Convert.ToDecimal(createRequest.UnitPrice);
using (var db = new SqlConnection(ConnectionString))
{
var newProduct = db.QueryFirstOrDefault <Product>(@"
Insert into products (name, imageUrl, unitPrice, categoryId, description, isOnSale, isDeleted, partnerId)
Output inserted.*
Values(@name, @imageUrl, @unitPrice,@categoryId, @description,@isOnSale, @isDeleted, @partnerId)",
new {
createRequest.Name,
createRequest.ImageUrl,
createRequest.UnitPrice,
createRequest.CategoryId,
createRequest.Description,
createRequest.IsOnSale,
createRequest.IsDeleted,
createRequest.PartnerId
});
if (newProduct != null)
{
return(newProduct);
}
}
throw new Exception("Sorry. No Parting Pets Product Was Created.");
}
public Product Create([FromBody] CreateProductRequest model)
{
_bus.Send <SubmitProduct>(new { Id = Guid.Empty });
var result = _productService.Create(model);
return(result);
}
public Either <Error, Product> Update(long id, CreateProductRequest req)
=> SetCategory(req)
.Bind(SetWerehouse)
.Bind(SetTax)
.Map(FromRequestDto)
.Bind(c => c.ToEither(() => Error.New("Fail mapping in from requestDto")))
.Bind(c => base.Update(id, c));
public async Task <IActionResult> CreateProduct([FromBody] CreateProductRequest request)
{
try
{
if (!ModelState.IsValid)
{
throw new Exception(string.Join("; ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage)));
}
if (request == null)
{
throw new Exception("Product model is null");
}
if (request.Photo.Length > 1 * 1024 * 1024)
{
return(BadRequest("Max file size exceeded. Only 1 MB allowed"));
}
if (_acceptedFileTypes.All(e => e != request.PhotoName.Split('.')[1].ToLower()))
{
return(BadRequest("Invalid file type"));
}
var client = _bus.CreateRequestClient <ICreateProductCommand, IProductCreatedEvent>(_serviceAddress, TimeSpan.FromSeconds(20));
var createProductCommand = new CreateProductCommand(request);
var response = await client.Request(createProductCommand);
return(Ok(response));
}
catch (Exception e)
{
return(BadRequest($"Can't create the product: {e.Message}"));
}
}
public async Task CreateProduct_Returns_BadResponse_If_Exception_Is_Thrown()
{
//Arrange
Mock <ILogger <ProductsController> > mockLogger = new Mock <ILogger <ProductsController> >();
Mock <IProductService> mockProductService = new Mock <IProductService>();
CreateProductRequest createProductRequest = new CreateProductRequest
{
Name = "Test Product 1",
Description = "Description 1",
Price = 2000M,
DeliveryPrice = 10M
};
mockProductService.Setup(m => m.CreateProduct(It.IsAny <CreateProductRequest>()))
.ThrowsAsync(new Exception("Error occured!"))
.Verifiable();
ProductsController productsController = new ProductsController(mockLogger.Object, mockProductService.Object);
//Act
var response = await productsController.CreateProduct(createProductRequest) as BadRequestObjectResult;
var responseObject = response.Value as ApiResult;
//Assert
Assert.Equal("An error has occured", responseObject.Error);
mockLogger.VerifyAll();
mockProductService.VerifyAll();
}
public async Task CreateProduct_Returns_OkResponse_Successfully()
{
//Arrange
Mock <ILogger <ProductsController> > mockLogger = new Mock <ILogger <ProductsController> >();
Mock <IProductService> mockProductService = new Mock <IProductService>();
CreateProductRequest createProductRequest = new CreateProductRequest
{
Name = "Test Product 1",
Description = "Description 1",
Price = 2000M,
DeliveryPrice = 10M
};
mockProductService.Setup(m => m.CreateProduct(It.IsAny <CreateProductRequest>()))
.ReturnsAsync(new CreateProductResponse
{
IsSuccessful = true
})
.Verifiable();
ProductsController productsController = new ProductsController(mockLogger.Object, mockProductService.Object);
//Act
var response = await productsController.CreateProduct(createProductRequest) as OkObjectResult;
var responseObject = response.Value as CreateProductResponse;
//Assert
Assert.True(responseObject.IsSuccessful);
mockLogger.VerifyAll();
mockProductService.VerifyAll();
}
public CreateProductModel Create(CreateProductRequest request)
{
return new CreateProductModel();
}
