public void Handle(DeleteProductCommand command)
{
var matchedProduct = context.Set <BaseProduct>()
.FirstOrDefault(x => x.Id == command.Id);
if (matchedProduct == null)
{
throw new NullReferenceException();
}
context.Set <BaseProduct>().Remove(matchedProduct);
context.SaveChanges();
}
public CustomerDetailsDto[] Handle(GetAllCustomerQuery query)
{
var customers = context.Set <CustomerBase>().Where(x => x.Id != null).ToArray();
var customerDtos = mapper.Map <CustomerDetailsDto[]>(customers);
return(customerDtos);
}
public UpdateProductValidationResult ValidListOfProductResult(IEnumerable <UpdatedProductSnapshot> productSnapshotDtos)
{
var allProductNumber = context.Set <BaseProduct>()
.Where(x => x.Id != null)
.Select(x => new UpdatedProduct
{
ProductNumber = x.ProductNumber,
Amount = x.Quantity
}).ToList();
return(new UpdateProductValidationResult
{
IsValid = CheckValidProduct(productSnapshotDtos, allProductNumber),
InvalidProdcutNumbers = GetInValidProductNumber(productSnapshotDtos, allProductNumber)
});
}
public IEnumerable <BaseProductDto> Handle(GetAllProductsQuery query)
{
var modelProducts = context.Set <BaseProduct>().Where(x => x.Id != null).ToArray();
var listProductDtos = MapModelProductToDto(modelProducts);
return(listProductDtos);
}
public BaseProductDto Handle(GetProductByNumberQuery query)
{
var baseProduct = context.Set <BaseProduct>()
.AsNoTracking()
.FirstOrDefault(x => x.ProductNumber.Contains(query.ProductNumber));
return(mapper.Map <BaseProductDto>(baseProduct));
}
public TransactionDto[] Handle(GetAllTransactionsQuery query)
{
var transactions = context.Set <Transaction>()
.Where(x => x.Id != null).ToArray()
.OrderByDescending(x => x.CreatedAt);
return(mapper.Map <TransactionDto[]>(transactions));
}
public string Handle(CreateBaseProductCommand command)
{
var existingProduct = context.Set <BaseProduct>()
.FirstOrDefault(x => x.ProductNumber == command.ProductNumber);
if (existingProduct != null)
{
throw new DuplicateProductException(command.ProductNumber);
}
var newProduct = mapper.Map <BaseProduct>(command);
context.Set <BaseProduct>().Add(newProduct);
context.SaveChangesAsync();
return(newProduct.ProductNumber);
}
public string Handle(DeleteTransactionCommand command)
{
var existingTransaction = context.Set <Transaction>()
.Include(x => x.ProductSnapshot)
.FirstOrDefault(x => x.TransactionNumber == command.TransactionId);
if (existingTransaction == null)
{
throw new TransactionIsNotExistException(command.TransactionId);
}
productUpdater.DeleteExistingProductSnapshot(existingTransaction.Id);
context.Set <Transaction>().Remove(existingTransaction);
context.SaveChanges();
return(command.TransactionId);
}
public CustomerDetailsDto Handle(GetCustomerByIdQuery query)
{
var customer = context.Set <Customerbase>()
.AsNoTracking()
.FirstOrDefault(x => x.CustomerId == query.CustomerId);
var customerDto = mapper.Map <CustomerDetailsDto>(customer);
return(customerDto);
}
public string Handle(CreateCustomerCommand command)
{
var existingCustomer = context.Set <CustomerModel>()
.AsNoTracking()
.FirstOrDefault(x => x.CustomerId == command.CustomerId);
if (existingCustomer != null)
{
throw new DuplicateCustomerException(command.CustomerId);
}
var newCustomer = mapper.Map <CustomerModel>(command);
context.Set <CustomerModel>().Add(newCustomer);
context.SaveChanges();
return(newCustomer.CustomerId);
}
public CustomerDetailsDto[] Handle(SearchCustomerQuery query)
{
var predicate = MatchBySearchTerm(query.SearchTerm);
var customers = context.Set <MasterCustomer>()
.AsNoTracking()
.Where(predicate)
.ToArray();
return(mapper.Map <CustomerDetailsDto[]>(customers));
}
public TransactionDto Handle(GetTransactionByIdQuery query)
{
var transaction = context.Set <Transaction>()
.Include(x => x.ProductSnapshot)
.AsNoTracking()
.FirstOrDefault(x => x.Id == query.Id);
var transactionDto = mapper.Map <TransactionDto>(transaction);
return(transactionDto);
}
public BaseProductDto Handle(GetBaseProductByIdQuery query)
{
var product = context.Set <BaseProduct>().SingleOrDefault(x => x.Id == query.ProductId);
if (product == null)
{
throw new Exception();
}
var dto = mapper.Map <BaseProductDto>(product);
return(dto);
}
public string Handle(CreateTransactionCommand command)
{
var existingTransaction = context.Set <Transaction>()
.FirstOrDefault(x => x.TransactionNumber == command.TransactionNumber);
if (existingTransaction != null)
{
throw new DuplicateTransactionNumerException(command.TransactionNumber);
}
var transaction = mapper.Map <Transaction>(command);
var customer = customerUpdater.GetCustomerByCustomerNumber(command.CustomerId);
if (customer != null)
{
transaction.CustomerId = customer.Id;
customerUpdater.UpdateCustomerEmotion(customer, command);
}
if (productUpdater.ValidListOfProductResult(mapper.Map <IEnumerable <UpdatedProductSnapshot> >(command.ProductSnapshotDto)).IsValid)
{
transaction.ProductSnapshot = productUpdater.CreateNewListofProductSnapshot(
mapper.Map <IEnumerable <UpdatedProductSnapshot> >(command.ProductSnapshotDto),
transaction.Id);
context.Set <Transaction>().Add(transaction);
context.SaveChangesAsync();
//TODO: Move this function after implementing background jobs.
productUpdater.UpdateProductQuantity(mapper.Map <IEnumerable <UpdatedProductSnapshot> >(command.ProductSnapshotDto));
}
return(transaction.TransactionNumber);
}
public string Handle(EditCustomerCommand command)
{
var existingCustomer = context.Set <CustomerBase>()
.FirstOrDefault(x => x.CustomerId == command.CustomerId);
if (existingCustomer == null)
{
throw new CustomerNotFoundException(command.CustomerId);
}
existingCustomer.Update(mapper.Map <Model.Customer.UpdatedCustomer>(command));
context.SaveChanges();
return(existingCustomer.CustomerId);
}
public Guid Handle(UpdateTransactionCommand command)
{
var existingtransaction = context.Set <Transaction>()
.FirstOrDefault(x => x.TransactionNumber == command.TransactionNumber);
if (existingtransaction == null)
{
throw new TransactionIsNotExistException(command.TransactionNumber);
}
existingtransaction.Update(mapper.Map <UpdatedTransaction>(command));
UpdateProduct(existingtransaction, command);
context.SaveChanges();
return(existingtransaction.Id);
}
public string Handle(EditProductCommnand commnand)
{
var existingProduct = context.Set <BaseProduct>()
.SingleOrDefault(x => x.ProductNumber == commnand.ProductNumber);
if (existingProduct == null)
{
throw new NullReferenceException($"The product with ID {commnand.ProductNumber} does not exist.");
}
existingProduct.Update(
commnand.Name,
commnand.Price,
commnand.Quantity,
commnand.ExpiryDate,
commnand.ManufacturingDate);
context.SaveChanges();
return(existingProduct.ProductNumber);
}
public CustomerModel GetCustomerByCustomerNumber(string customerNumber)
{
return(context.Set <CustomerModel>()
.FirstOrDefault(x => x.CustomerId == customerNumber));
}
public CustomerDetailsDto Handle(SearchCustomerByCustomerNumberQuery query)
{
var customer = context.Set <CustomerMaster>().SingleOrDefault(c => c.CustomerId.Contains(query.CustomerNumber));
return(mapper.Map <CustomerDetailsDto>(customer));
}
