private async Task HandlePublish(ProductDto product)
{
Guid id = Guid.Empty;
if (product.IsPublished)
{
id = await ProductAppService.UnPublishAsync(product.Id);
}
else
{
id = await ProductAppService.PublishAsync(product.Id);
}
if (id != Guid.Empty)
{
var message = !product.IsPublished ? "Published " : "UnPublished";
await Message.Success($"Product successfully {message}");
}
else
{
var message = product.IsPublished ? "Published " : "UnPublished";
await Message.Error("Failed to " + message);
}
await InvokeAsync(StateHasChanged);
await GetProductsAsync();
}
public virtual async Task HandleEventAsync(CreateFlashSaleOrderCompleteEto eventData)
{
if (eventData.Success)
{
return;
}
if (eventData.Reason != FlashSaleResultFailedReason.InvalidHashToken)
{
return;
}
var plan = await FlashSalePlanRepository.GetAsync(eventData.PlanId);
var product = await ProductAppService.GetAsync(plan.ProductId);
if (!await FlashSaleInventoryManager.TryRollBackInventoryAsync(
plan.TenantId, product.InventoryProviderName,
plan.StoreId, plan.ProductId, plan.ProductSkuId, 1, true
))
{
Logger.LogWarning("Try roll back inventory failed.");
return;
}
await RemoveUserFlashSaleResultCacheAsync(plan, eventData.UserId);
}
public override async Task <FlashSalePlanDto> UpdateAsync(Guid id, FlashSalePlanUpdateDto input)
{
var flashSalePlan = await GetEntityByIdAsync(id);
var product = await ProductAppService.GetAsync(input.ProductId);
var productSku = product.GetSkuById(input.ProductSkuId);
await CheckMultiStorePolicyAsync(product.StoreId, UpdatePolicyName);
await ValidateProductAsync(input.ProductId, product, flashSalePlan.StoreId);
if (await ExistRelatedFlashSaleResultsAsync(id) && (input.ProductId != flashSalePlan.ProductId || input.ProductSkuId != flashSalePlan.ProductSkuId))
{
throw new RelatedFlashSaleResultsExistException(id);
}
flashSalePlan.SetTimeRange(input.BeginTime, input.EndTime);
flashSalePlan.SetProductSku(flashSalePlan.StoreId, product.Id, productSku.Id);
flashSalePlan.SetPublished(input.IsPublished);
flashSalePlan.SetConcurrencyStampIfNotNull(input.ConcurrencyStamp);
await FlashSalePlanRepository.UpdateAsync(flashSalePlan, autoSave : true);
return(await MapToGetOutputDtoAsync(flashSalePlan));
}
public override async Task <FlashSalePlanDto> CreateAsync(FlashSalePlanCreateDto input)
{
await CheckMultiStorePolicyAsync(input.StoreId, CreatePolicyName);
var product = await ProductAppService.GetAsync(input.ProductId);
var productSku = product.GetSkuById(input.ProductSkuId);
await ValidateProductAsync(input.ProductId, product, input.StoreId);
var flashSalePlan = new FlashSalePlan(
GuidGenerator.Create(),
CurrentTenant.Id,
input.StoreId,
input.BeginTime,
input.EndTime,
product.Id,
productSku.Id,
input.IsPublished
);
await FlashSalePlanRepository.InsertAsync(flashSalePlan, autoSave : true);
return(await MapToGetOutputDtoAsync(flashSalePlan));
}
public OrderAppService(IRepository <Order> orderRepository, IMapper mapper, ProductAppService productAppService, IRepository <OrderItem> orderItemRepository, IUnitOfWorkManager unitOfWorkManager)
{
this.orderRepository = orderRepository;
this.mapper = mapper;
this.productAppService = productAppService;
this.orderItemRepository = orderItemRepository;
this.unitOfWorkManager = unitOfWorkManager;
}
private async Task DeleteProductAsync(ProductDto product)
{
var confirmMessage = L["ProductDeletionConfirmationMessage", product.Title];
if (!await Message.Confirm(confirmMessage))
{
return;
}
await ProductAppService.DeleteAsync(product.Id);
await GetProductsAsync();
}
private async Task GetProductsAsync()
{
var result = await ProductAppService.GetListAsync(
new PagedProductRequestDto
{
MaxResultCount = PageSize,
SkipCount = CurrentPage * PageSize,
Sorting = CurrentSorting
}
);
ProductList = result.Items;
TotalCount = (int)result.TotalCount;
}
public void Create_NullParamater_ThrowsException()
{
var mockRepo = new Mock <IRepository <Product> >();
mockRepo.Setup(x => x.Insert(It.IsAny <Product>())).Returns(new Product());
var mockUow = new Mock <IUnitOfWork>();
mockUow.Setup(x => x.Commit()).Returns(1);
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(x => x.Map <Product, ProductDetailsOutput>(It.IsAny <Product>())).Returns(new ProductDetailsOutput());
var productService = new ProductAppService(mockUow.Object, mockRepo.Object, mockMapper.Object);
productService.Create(null);
}
public virtual async Task <FlashSalePlanPreOrderDto> PreOrderAsync(Guid id)
{
var plan = await GetFlashSalePlanCacheAsync(id);
var product = await ProductAppService.GetAsync(plan.ProductId);
var productSku = product.GetSkuById(plan.ProductSkuId);
var expiresTime = DateTimeOffset.Now.Add(Options.PreOrderExpires);
await ValidatePreOrderAsync(plan, product, productSku);
await SetPreOrderCacheAsync(plan, product, productSku, expiresTime);
return(new FlashSalePlanPreOrderDto {
ExpiresTime = Clock.Normalize(expiresTime.LocalDateTime), ExpiresInSeconds = Options.PreOrderExpires.TotalSeconds
});
}
public virtual async Task HandleEventAsync(CreateFlashSaleOrderEto eventData)
{
var product = await ProductAppService.GetAsync(eventData.Plan.ProductId);
var productSku = product.GetSkuById(eventData.Plan.ProductSkuId);
if (!await ValidateHashTokenAsync(eventData.Plan, product, productSku, eventData.HashToken))
{
await DistributedEventBus.PublishAsync(new CreateFlashSaleOrderCompleteEto()
{
TenantId = eventData.TenantId,
PlanId = eventData.PlanId,
OrderId = null,
UserId = eventData.UserId,
StoreId = eventData.StoreId,
PendingResultId = eventData.PendingResultId,
Success = false,
Reason = FlashSaleResultFailedReason.InvalidHashToken
});
return;
}
var input = await ConvertToCreateOrderDtoAsync(eventData);
var productDict = await GetProductDictionaryAsync(product);
var productDetailDict = await GetProductDetailDictionaryAsync(product, productSku);
var order = await NewOrderGenerator.GenerateAsync(eventData.UserId, input, productDict, productDetailDict);
await OrderRepository.InsertAsync(order, autoSave : true);
await DistributedEventBus.PublishAsync(new CreateFlashSaleOrderCompleteEto()
{
TenantId = eventData.TenantId,
PlanId = eventData.PlanId,
OrderId = order.Id,
UserId = eventData.UserId,
StoreId = eventData.StoreId,
PendingResultId = eventData.PendingResultId,
Success = true,
Reason = null
});
}
public void Create_ValidParamater_ReturnsNewInstance()
{
var mockRepo = new Mock <IRepository <Product> >();
mockRepo.Setup(x => x.Insert(It.IsAny <Product>())).Returns(new Product());
var mockUow = new Mock <IUnitOfWork>();
mockUow.Setup(x => x.Commit()).Returns(1);
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(x => x.Map <Product, ProductDetailsOutput>(It.IsAny <Product>())).Returns(new ProductDetailsOutput());
var productService = new ProductAppService(mockUow.Object, mockRepo.Object, mockMapper.Object);
var result = productService.Create(new ProductCreateInput());
mockRepo.Verify(x => x.Insert(It.IsAny <Product>()));
mockUow.Verify(x => x.Commit());
Assert.IsNotNull(result);
}
public ProductControllerTest()
{
this.fixture = new Fixture();
this.productAppServiceMock = new Mock <IProductAppService>();
this.productServiceMock = new Mock <IProductService>();
this.productRepositoryMock = new Mock <IProductRepository>();
var options = new DbContextOptionsBuilder <ProductContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
this.productContextMock = new ProductContext(options);
this.productContextMock.Database.EnsureCreated();
//auto mapper configuration
var mockMapper = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new AutoMapperConfig());
cfg.AddProfile(new Infra.Data.AutoMapper.AutoMapperConfig());
});
var mapper = mockMapper.CreateMapper();
this.productController = new ProductController(
this.productAppServiceMock.Object);
this.productAppService = new ProductAppService(
this.productServiceMock.Object, mapper);
this.productService = new ProductService(
this.productRepositoryMock.Object);
this.productRepository = new ProductRepository(
this.productContextMock, mapper);
}
public ProductsController(ProductAppService productAppService)
{
_productAppService = productAppService;
}
public void Initial()
{
productAppService = new ProductAppService();
}
public ProductTest()
{
_service = new ProductAppService(_mockRepository.Object, _mockProductRepository.Object);
}
//REALIZAR A INJEÇÃO DE DEPENDÊCIA
public ClientProductController(ClientProductAppService clientProductAppService, ClientAppService clientAppService, ProductAppService productAppService)
{
_clientProductAppService = clientProductAppService;
_clientAppService = clientAppService;
_productAppService = productAppService;
}
public HomeController(ProductAppService productAppService)
{
_productAppService = productAppService;
}
