public async Task <Result <ManufacturerDto> > Handle(UpdateManufacturerCommand request, CancellationToken cancellationToken) { var cacheKey = $"Manufacturer-{request.ManufacturerId}"; Manufacturer manufacturerInDb; if (!await _cacheService.IsExistsAsync(cacheKey)) { manufacturerInDb = await _manufacturerRepository.GetAsync(m => m.Id == request.ManufacturerId); manufacturerInDb.CheckForNull(); } var manufacturerDto = _mapper.Map <ManufacturerDto>(request.Manufacturer) with { Id = request.ManufacturerId }; manufacturerInDb = _mapper.Map <Manufacturer>(manufacturerDto); LogDto log = new(Guid.NewGuid().ToString(), request.UserName, "edited manufacturer", JsonSerializer.Serialize(manufacturerDto, CommandExtensions.JsonSerializerOptions), DateTime.UtcNow); await _manufacturerRepository.UpdateAsync(m => m.Id == manufacturerInDb.Id, manufacturerInDb); await _sender.PublishAsync(new UpdatedManufacturer(manufacturerInDb), cancellationToken); await _sender.PublishAsync(log, cancellationToken); await _cacheService.UpdateAsync(cacheKey, manufacturerInDb, _manufacturerSettings); return(Result <ManufacturerDto> .Success(manufacturerDto)); } }
public async Task <Result <ProductDto> > Handle(UpdateProductCommand request, CancellationToken cancellationToken) { var cacheKey = $"Product-{request.ProductId}"; Product productInDb; if (!await _cacheService.IsExistsAsync(cacheKey)) { productInDb = await _productRepository.GetAsync(p => p.Id == request.ProductId); productInDb.CheckForNull(); } productInDb = await _productService.GetManufacturersAndCustomer(request.Product, request.Product.ManufacturerIds.ToList()); productInDb.Id = request.ProductId; var result = _mapper.Map <ProductDto>(productInDb) with { Id = request.ProductId }; LogDto log = new(Guid.NewGuid().ToString(), request.UserName, "edited product", JsonSerializer.Serialize(result, CommandExtensions.JsonSerializerOptions), DateTime.UtcNow); await _cacheService.SetCacheAsync(cacheKey, productInDb, _productSettings); await _sender.PublishAsync(log, cancellationToken); await _productRepository.UpdateAsync(p => p.Id == productInDb.Id, productInDb); return(Result <ProductDto> .Success(result)); } }
public async Task <Result <object> > Handle(DeleteUserCommand request, CancellationToken cancellationToken) { var cacheKey = $"User-{request.UserId}"; if (!await _cacheService.IsExistsAsync(cacheKey)) { var userInDb = await _userRepository.GetAsync(u => u.Id == request.UserId); userInDb.CheckForNull(); } var token = await _tokenRepository.GetAsync(t => t.Id == request.UserId); if (token is not null) { await _tokenRepository.DeleteAsync(t => t.Id == token.Id); await _sender.PublishAsync(token, cancellationToken); } await _userRepository.DeleteAsync(u => u.Id == request.UserId); await _cacheService.RemoveAsync(cacheKey); return(Result <object> .Success()); }
public async Task <Result <ManufacturerDto> > Handle(CreateManufacturerCommand request, CancellationToken cancellationToken) { var manufacturerDto = _mapper.Map <ManufacturerDto>(request.Manufacturer); var manufacturerToDb = _mapper.Map <Manufacturer>(manufacturerDto); var cacheKey = $"Manufacturer-{manufacturerToDb.Id}"; LogDto log = new(Guid.NewGuid().ToString(), request.UserName, "added manufacturer", JsonSerializer.Serialize(manufacturerDto, CommandExtensions.JsonSerializerOptions), DateTime.UtcNow); await _cacheService.SetCacheAsync(cacheKey, manufacturerToDb, _manufacturerSettings); await _manufacturerRepository.CreateAsync(manufacturerToDb); await _sender.PublishAsync(new CreatedManufacturer(manufacturerToDb), cancellationToken); await _sender.PublishAsync(log, cancellationToken); return(Result <ManufacturerDto> .Success(manufacturerDto)); }
public async Task <Result <CustomerDto> > Handle(CreateCustomerCommand request, CancellationToken cancellationToken) { var customerToDb = _mapper.Map <Customer>(request.Customer); var cacheKey = $"Customer-{customerToDb.Id}"; LogDto log = new(Guid.NewGuid().ToString(), request.UserName, "added customer", JsonSerializer.Serialize( customerToDb, CommandExtensions.JsonSerializerOptions), DateTime.UtcNow); await _cacheService.SetCacheAsync(cacheKey, customerToDb, _customerSettings); await _customerRepository.CreateAsync(customerToDb); await _sender.PublishAsync(new CreatedCustomer(customerToDb), cancellationToken); await _sender.PublishAsync(log, cancellationToken); return(Result <CustomerDto> .Success(request.Customer with { Id = customerToDb.Id })); }
public async Task <Result <object> > Handle(DeleteManufacturerCommand request, CancellationToken cancellationToken) { var cacheKey = $"Manufacturer-{request.Id}"; if (!await _cacheService.IsExistsAsync(cacheKey)) { var manufacturerInDb = await _manufacturerRepository.GetAsync(m => m.Id == request.Id); manufacturerInDb.CheckForNull(); } await _sender.PublishAsync(new DeletedManufacturer(request.Id), cancellationToken); await _manufacturerRepository.DeleteAsync(m => m.Id == request.Id); await _cacheService.RemoveAsync(cacheKey); return(Result <object> .Success()); }
public async Task <Result <ProductDto> > Handle(CreateProductCommand request, CancellationToken cancellationToken) { var productToDb = await _productService.GetManufacturersAndCustomer(request.Product, request.Product.ManufacturerIds.ToList()); var cacheKey = $"Product-{productToDb.Id}"; await _cacheService.SetCacheAsync(cacheKey, productToDb, _productSettings); var result = _mapper.Map <ProductDto>(productToDb); LogDto log = new(Guid.NewGuid().ToString(), request.UserName, "added product", JsonSerializer.Serialize(result, CommandExtensions.JsonSerializerOptions), DateTime.UtcNow); await _sender.PublishAsync(log, cancellationToken); await _productRepository.CreateAsync(productToDb); return(Result <ProductDto> .Success(result)); }
public async Task <Result <UserDto> > Handle(UpdateUserCommand request, CancellationToken cancellationToken) { var cacheKey = $"User-{request.UserId}"; User userInDb; if (!await _cacheService.IsExistsAsync(cacheKey)) { userInDb = await _userRepository.GetAsync(u => u.Id == request.UserId); userInDb.CheckForNull(); } var userDto = _mapper.Map <UserDto>(request.User) with { Id = request.UserId }; userInDb = _mapper.Map <User>(userDto); var token = await _tokenRepository.GetAsync(t => t.User.Id == request.UserId); LogDto log = new(Guid.NewGuid().ToString(), request.UserName, "edited user", JsonSerializer.Serialize(userDto, CommandExtensions.JsonSerializerOptions), DateTime.UtcNow); if (token is not null) { token.User = userInDb; await _tokenRepository.UpdateAsync(t => t.Id == token.Id, token); } await _userRepository.UpdateAsync(u => u.Id == userInDb.Id, userInDb); await _cacheService.UpdateAsync(cacheKey, userInDb, _userSettings); await _sender.PublishAsync(log, cancellationToken); return(Result <UserDto> .Success(userDto)); } }