public override async Task <UpdateTaskResponse> Handle(UpdateTaskRequest request,
CancellationToken cancellationToken)
{
var commandRepository = UnitOfWork.Repository <Project>();
var queryRepository = QueryRepositoryFactory.QueryEfRepository <Project>();
var taskQueryRepository = QueryRepositoryFactory.QueryEfRepository <Domain.Task>();
var project = await queryRepository.GetByIdAsync(request.ProjectId, q => q.Include(x => x.Tasks));
if (project == null)
{
throw new Exception($"Could not find project#{request.ProjectId}.");
}
var task = await taskQueryRepository.GetByIdAsync(request.TaskId);
task.ChangeTitle(request.Title)
.ChangeOrder(request.Order ?? 1);
if (request.Completed.HasValue && request.Completed.Value)
{
task.ChangeToCompleted();
}
project.UpdateTask(task);
var updated = await commandRepository.UpdateAsync(project);
await UnitOfWork.SaveChangesAsync(cancellationToken);
return(new UpdateTaskResponse {
Result = updated.ToDto()
});
}
public override async Task <ClearTasksResponse> Handle(ClearTasksRequest request,
CancellationToken cancellationToken)
{
var projectRepository = UnitOfWork.Repository <Project>();
var taskRepository = UnitOfWork.Repository <Task>();
var queryRepository = QueryRepositoryFactory.QueryEfRepository <Project>();
var project = await queryRepository.GetByIdAsync(request.ProjectId, q => q.Include(x => x.Tasks));
if (project == null)
{
throw new Exception($"Couldn't found the project#{request.ProjectId}.");
}
foreach (var projectTask in project.Tasks)
{
await taskRepository.DeleteAsync(projectTask);
}
await UnitOfWork.SaveChangesAsync(cancellationToken);
project.ClearTasks();
await projectRepository.UpdateAsync(project);
await UnitOfWork.SaveChangesAsync(cancellationToken);
return(new ClearTasksResponse());
}
public override async Task <DeleteItemResponse> Handle(DeleteItemRequest request, CancellationToken cancellationToken)
{
var cartCommander = UnitOfWork.Repository <Domain.Cart>();
var cartItemCommander = UnitOfWork.Repository <CartItem>();
var cartQuery = QueryRepositoryFactory.QueryEfRepository <Domain.Cart>();
var cart = await cartQuery
.GetFullCartAsync(request.CartId)
.ToObservable()
.SelectMany(c => c.InitCart(_catalogGateway));
var cartItem = cart.CartItems.FirstOrDefault(x => x.Product.ProductId == request.ProductId);
if (cartItem == null)
{
throw new Exception($"Could not find Product {request.ProductId}.");
}
await cartItemCommander.DeleteAsync(cartItem);
await UnitOfWork.SaveChangesAsync(cancellationToken);
cart = cart.RemoveCartItem(cartItem.Id);
await cartCommander.UpdateAsync(cart);
await UnitOfWork.SaveChangesAsync(cancellationToken);
return(new DeleteItemResponse {
ProductId = cartItem.Product.ProductId
});
}
public override async Task <DeleteItemResponse> Handle(DeleteItemRequest request, CancellationToken cancellationToken)
{
var cartRepository = UnitOfWork.Repository <Domain.Cart>();
var cartItemRepository = UnitOfWork.Repository <CartItem>();
var cart = await QueryRepositoryFactory
?.QueryEfRepository <Domain.Cart>()
?.GetFullCart(request.CartId)
?.ToObservable()
?.SelectMany(c => c.InitCart(_catalogGateway));
var cartItem = cart.CartItems.FirstOrDefault(x => x.Product.ProductId == request.ProductId);
if (cartItem == null)
{
throw new Exception($"Could not find CartItem {cartItem.Id}");
}
cart = cart.RemoveCartItem(cartItem.Id);
var isSucceed = await cartRepository.UpdateAsync(cart) != null;
await cartItemRepository.DeleteAsync(cartItem);
return(new DeleteItemResponse {
ProductId = cartItem.Product.ProductId
});
}
public override async Task <GetReviewsResponse> Handle(GetReviewsRequest request,
CancellationToken cancellationToken)
{
var reviewQueryRepo = QueryRepositoryFactory.QueryEfRepository <Domain.Review>();
var reviews = await reviewQueryRepo
.ListAsync(
queryable => queryable
.Include(x => x.ReviewAuthor)
.Include(x => x.ReviewProduct));
var result = reviews.Where(x => x.ReviewProduct?.Id == request.ProductId);
if (reviews == null)
{
throw new Exception($"Couldn't find a review with product#{request.ProductId}.");
}
return(new GetReviewsResponse
{
Reviews = result
.Select(x => x.ToDto())
.ToList()
});
}
public override async Task <DeleteTaskResponse> Handle(DeleteTaskRequest request,
CancellationToken cancellationToken)
{
var projectRepository = UnitOfWork.Repository <Project>();
var taskRepository = UnitOfWork.Repository <Task>();
var queryRepository = QueryRepositoryFactory.QueryEfRepository <Project>();
var project = await queryRepository.GetByIdAsync(request.ProjectId, q => q.Include(x => x.Tasks));
if (project == null)
{
throw new Exception($"Couldn't find the project#{request.ProjectId}.");
}
foreach (var projectTask in project.Tasks)
{
if (request.TaskId == projectTask.Id)
{
await taskRepository.DeleteAsync(projectTask);
}
}
project.RemoveTask(request.TaskId);
var result = await projectRepository.UpdateAsync(project);
await UnitOfWork.SaveChangesAsync(cancellationToken);
return(new DeleteTaskResponse {
Result = result.Id
});
}
public override async Task <AddTaskResponse> Handle(AddTaskRequest request, CancellationToken cancellationToken)
{
var projectRepository = UnitOfWork.Repository <Project>();
var taskRepository = UnitOfWork.Repository <Task>();
var projectQueryRepository = QueryRepositoryFactory.QueryEfRepository <Project>();
var project = await projectQueryRepository.GetByIdAsync(request.ProjectId, q => q.Include(x => x.Tasks));
if (project == null)
{
throw new Exception($"Couldn't found the project#{request.ProjectId}.");
}
var author = await _userGateway.GetAuthorAsync();
if (author == null)
{
throw new Exception("Couldn't found the default author.");
}
var task = Task.Load(request.Title);
task = task.SetAuthor(author.Id, author.GetFullName());
task = await taskRepository.AddAsync(task);
project.AddTask(task);
project = await projectRepository.UpdateAsync(project);
await UnitOfWork.SaveChangesAsync(cancellationToken);
return(new AddTaskResponse {
Result = project.ToDto()
});
}
public override async Task <GetInventoryResponse> Handle(GetInventoryRequest request, CancellationToken cancellationToken)
{
var repo = QueryRepositoryFactory?.QueryEfRepository <Domain.Inventory>();
var inv = await repo.FindOneAsync(x => x.Id == request.InventoryId);
return(new GetInventoryResponse {
Result = inv.ToDto()
});
}
public override async Task <GetTodosResponse> Handle(GetTodosRequest request, CancellationToken cancellationToken)
{
var queryRepository = QueryRepositoryFactory.QueryEfRepository <Domain.Todo>();
var result = await queryRepository.ListAsync();
return(new GetTodosResponse
{
Result = result.Select(x => x.ToDto()).ToList()
});
}
public override async Task <GetTodoResponse> Handle(GetTodoRequest request, CancellationToken cancellationToken)
{
var queryRepository = QueryRepositoryFactory.QueryEfRepository <Domain.Todo>();
var result = await queryRepository.GetByIdAsync(request.Id);
return(new GetTodoResponse
{
Result = result.ToDto()
});
}
public override async Task <UpdateItemInCartResponse> Handle(UpdateItemInCartRequest request,
CancellationToken cancellationToken)
{
var cartCommander = UnitOfWork.Repository <Domain.Cart>();
var cartItemCommander = UnitOfWork.Repository <CartItem>();
var cartQuery = QueryRepositoryFactory.QueryEfRepository <Domain.Cart>();
var isNewItem = false;
var cart = await cartQuery
.GetFullCartAsync(request.CartId)
.ToObservable()
.SelectMany(c => c.InitCart(_catalogGateway, isPopulatePrice: true));
var item = cart.CartItems.FirstOrDefault(x => x.Product.ProductId == request.ProductId);
// if not exists then it should be a new item
if (item == null)
{
isNewItem = true;
item = new CartItem()
{
Quantity = request.Quantity
};
item.LinkProduct(new Product(request.ProductId));
cart.CartItems.Add(item);
}
else
{
// otherwise is updating the current item in the cart
item.Quantity += request.Quantity;
}
cart = _priceCalculator.Execute(cart);
// Todo: refactor to unit of work later
if (!isNewItem)
{
await cartItemCommander.UpdateAsync(item);
}
else
{
await cartItemCommander.AddAsync(item);
}
await cartCommander.UpdateAsync(cart);
await UnitOfWork.SaveChangesAsync(cancellationToken);
return(new UpdateItemInCartResponse {
Result = cart.ToDto()
});
}
public override async Task <GetCartResponse> Handle(GetCartRequest request, CancellationToken cancellationToken)
{
var cart = await QueryRepositoryFactory
?.QueryEfRepository <Domain.Cart>()
?.GetFullCart(request.CartId)
?.ToObservable()
?.SelectMany(c => c.InitCart(_catalogGateway, isPopulatePrice: true))
?.Select(c => _priceCalculator.Execute(c));
return(new GetCartResponse {
Result = cart.ToCartDto()
});
}
public override async Task <GetCartResponse> Handle(GetCartRequest request, CancellationToken cancellationToken)
{
var cartRepo = QueryRepositoryFactory?.QueryEfRepository <Domain.Cart>();
var cartInfo = await cartRepo.GetFullCart(request.CartId, false);
cartInfo = await cartInfo.InitCart(_catalogGateway, isPopulatePrice : true);
cartInfo = _priceCalculator.Execute(cartInfo);
return(new GetCartResponse {
Result = cartInfo.ToDto()
});
}
public override async Task <CheckoutResponse> Handle(CheckoutRequest request, CancellationToken cancellationToken)
{
var cartRepository = UnitOfWork.Repository <Domain.Cart>();
var cart = await QueryRepositoryFactory
?.QueryEfRepository <Domain.Cart>()
?.GetFullCart(request.CartId);
cart.IsCheckout = true;
var checkoutCart = await cartRepository.UpdateAsync(cart);
return(new CheckoutResponse
{
IsSucceed = checkoutCart != null
});
}
public override async Task <GetTasksResponse> Handle(GetTasksRequest request, CancellationToken cancellationToken)
{
var queryRepository = QueryRepositoryFactory.QueryEfRepository <Project>();
var result = await queryRepository.GetByIdAsync(request.ProjectId, q => q.Include(x => x.Tasks));
if (result == null)
{
throw new Exception($"Couldn't find project#{request.ProjectId}.");
}
return(new GetTasksResponse
{
Result = result.ToDto()
});
}
public override async Task <RemoveReviewResponse> TxHandle(RemoveReviewRequest request,
CancellationToken cancellationToken)
{
var reviewQueryRepo = QueryRepositoryFactory.QueryEfRepository <Domain.Review>();
var reviewRepo = UnitOfWork.Repository <Domain.Review>();
var review = await reviewQueryRepo.FindOneAsync(x => x.Id == request.ReviewId);
if (review == null)
{
throw new Exception($"Could not find a review #{request.ReviewId}.");
}
var result = await reviewRepo.DeleteAsync(review);
return(new RemoveReviewResponse {
ReviewId = result.Id
});
}
public override async Task <UpdateTodoResponse> TxHandle(UpdateTodoRequest request,
CancellationToken cancellationToken)
{
var commandRepository = UnitOfWork.Repository <Domain.Todo>();
var queryRepository = QueryRepositoryFactory.QueryEfRepository <Domain.Todo>();
var todo = await queryRepository.GetByIdAsync(request.Id);
if (todo == null)
{
throw new Exception($"Could not find item #{request.Id}.");
}
var updated = await commandRepository.UpdateAsync(todo);
return(new UpdateTodoResponse {
Result = updated.ToDto()
});
}
public override async Task <ClearTodosResponse> TxHandle(ClearTodosRequest request,
CancellationToken cancellationToken)
{
var commandRepository = UnitOfWork.Repository <Domain.Todo>();
var queryRepository = QueryRepositoryFactory.QueryEfRepository <Domain.Todo>();
var todos = await queryRepository.ListAsync();
if (todos == null || todos.Count <= 0)
{
return(new ClearTodosResponse());
}
//TODO: need to have a ClearAll method in CommandRepository
foreach (var todo in todos)
{
await commandRepository.DeleteAsync(todo);
}
return(new ClearTodosResponse());
}
public override async Task <UpdateReviewResponse> Handle(UpdateReviewRequest request,
CancellationToken cancellationToken)
{
var reviewQueryRepo = QueryRepositoryFactory.QueryEfRepository <Domain.Review>();
var reviewRepo = UnitOfWork.Repository <Domain.Review>();
var review = await reviewQueryRepo.FindOneAsync(x => x.Id == request.ReviewId);
if (review == null)
{
throw new Exception($"Could not find a review #{request.ReviewId}.");
}
review.Content = request.Content;
var result = await reviewRepo.UpdateAsync(review);
await UnitOfWork.SaveChangesAsync(cancellationToken);
return(new UpdateReviewResponse {
Result = result.ToDto()
});
}