public async Task <Result <bool> > HandleAsync(AddAdminToRestaurantCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <bool> .Unauthorized());
}
if (currentUser.Role < Role.RestaurantAdmin)
{
return(FailureResult <bool> .Forbidden());
}
var restaurant = await restaurantRepository.FindByRestaurantIdAsync(command.RestaurantId, cancellationToken);
if (restaurant == null)
{
return(FailureResult <bool> .Create(FailureResultCode.RestaurantDoesNotExist));
}
if (currentUser.Role == Role.RestaurantAdmin && !restaurant.HasAdministrator(currentUser.Id))
{
return(FailureResult <bool> .Forbidden());
}
restaurant.AddAdministrator(command.UserId);
await restaurantRepository.StoreAsync(restaurant, cancellationToken);
return(SuccessResult <bool> .Create(true));
}
public async Task <Result <bool> > HandleAsync(RemoveRestaurantCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <bool> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <bool> .Forbidden());
}
var dishCategories = await dishCategoryRepository.FindByRestaurantIdAsync(command.RestaurantId, cancellationToken);
if (dishCategories != null && dishCategories.Count > 0)
{
return(FailureResult <bool> .Create(FailureResultCode.RestaurantContainsDishCategories));
}
var dishes = await dishRepository.FindByRestaurantIdAsync(command.RestaurantId, cancellationToken);
if (dishes != null && dishes.Count > 0)
{
return(FailureResult <bool> .Create(FailureResultCode.RestaurantContainsDishes));
}
await restaurantRepository.RemoveAsync(command.RestaurantId, cancellationToken);
return(SuccessResult <bool> .Create(true));
}
public async Task <Result <bool> > HandleAsync(ChangeUserPasswordCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <bool> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <bool> .Forbidden());
}
var user = await userRepository.FindByUserIdAsync(command.UserId, cancellationToken);
if (user == null)
{
return(FailureResult <bool> .Create(FailureResultCode.UserDoesNotExist));
}
user.ChangePassword(command.Password);
await userRepository.StoreAsync(user, cancellationToken);
return(SuccessResult <bool> .Create(true));
}
public async Task <Result <ICollection <RestaurantViewModel> > > HandleAsync(SysAdminSearchForRestaurantsQuery query, User currentUser, CancellationToken cancellationToken = default)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
if (currentUser == null)
{
return(FailureResult <ICollection <RestaurantViewModel> > .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <ICollection <RestaurantViewModel> > .Forbidden());
}
var paymentMethods = (await paymentMethodRepository.FindAllAsync(cancellationToken))
.ToDictionary(en => en.Id.Value, PaymentMethodViewModel.FromPaymentMethod);
var restaurants = await restaurantRepository.SearchAsync(query.SearchPhrase, cancellationToken);
return(SuccessResult <ICollection <RestaurantViewModel> > .Create(restaurants
.Select(en => RestaurantViewModel.FromRestaurant(en, paymentMethods, userRepository)).ToList()));
}
public async Task <Result <PaymentMethodViewModel> > HandleAsync(AddPaymentMethodCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <PaymentMethodViewModel> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <PaymentMethodViewModel> .Forbidden());
}
var paymentMethod = await paymentMethodRepository.FindByNameAsync(command.Name, cancellationToken);
if (paymentMethod != null)
{
return(FailureResult <PaymentMethodViewModel> .Create(FailureResultCode.PaymentMethodAlreadyExists));
}
paymentMethod = paymentMethodFactory.Create(command.Name, command.Description);
await paymentMethodRepository.StoreAsync(paymentMethod, cancellationToken);
return(SuccessResult <PaymentMethodViewModel> .Create(PaymentMethodViewModel.FromPaymentMethod(paymentMethod)));
}
public async Task <Result <UserViewModel> > HandleAsync(AddUserCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <UserViewModel> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <UserViewModel> .Forbidden());
}
var user = await userRepository.FindByNameAsync(command.Name, cancellationToken);
if (user != null)
{
return(FailureResult <UserViewModel> .Create(FailureResultCode.UserAlreadyExists));
}
user = userFactory.Create(command.Name, command.Role, command.Email, command.Password);
await userRepository.StoreAsync(user, cancellationToken);
return(SuccessResult <UserViewModel> .Create(UserViewModel.FromUser(user)));
}
public async Task <Result <CuisineViewModel> > HandleAsync(AddCuisineCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <CuisineViewModel> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <CuisineViewModel> .Forbidden());
}
var cuisine = await cuisineRepository.FindByNameAsync(command.Name, cancellationToken);
if (cuisine != null)
{
return(FailureResult <CuisineViewModel> .Create(FailureResultCode.CuisineAlreadyExists));
}
cuisine = cuisineFactory.Create(command.Name);
await cuisineRepository.StoreAsync(cuisine, cancellationToken);
return(SuccessResult <CuisineViewModel> .Create(CuisineViewModel.FromCuisine(cuisine)));
}
public async Task <Result <bool> > HandleAsync(ChangePaymentMethodCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <bool> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <bool> .Forbidden());
}
var paymentMethod = await paymentMethodRepository.FindByPaymentMethodIdAsync(command.PaymentMethodId, cancellationToken);
if (paymentMethod == null)
{
return(FailureResult <bool> .Create(FailureResultCode.PaymentMethodDoesNotExist));
}
paymentMethod.Change(command.Name, command.Description);
await paymentMethodRepository.StoreAsync(paymentMethod, cancellationToken);
return(SuccessResult <bool> .Create(true));
}
public async Task <Result <bool> > HandleAsync(EnsureAdminUserCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <bool> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <bool> .Forbidden());
}
var systemAdminUsers = await userRepository.FindByRoleAsync(Role.SystemAdmin);
if (systemAdminUsers.Count != 0)
{
return(SuccessResult <bool> .Create(true));
}
var adminUser = new User(new UserId(Guid.Parse("BDD00A34-F631-4BA1-94D9-C6C909475247")), "admin", Role.SystemAdmin, "*****@*****.**", null, null);
adminUser.ChangePassword("admin");
await userRepository.StoreAsync(adminUser, cancellationToken);
return(SuccessResult <bool> .Create(true));
}
public async Task <Result <Guid> > HandleAsync(AddDishCategoryToRestaurantCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <Guid> .Unauthorized());
}
if (currentUser.Role < Role.RestaurantAdmin)
{
return(FailureResult <Guid> .Forbidden());
}
var restaurant = await restaurantRepository.FindByRestaurantIdAsync(command.RestaurantId, cancellationToken);
if (restaurant == null)
{
return(FailureResult <Guid> .Create(FailureResultCode.RestaurantDoesNotExist));
}
if (currentUser.Role == Role.RestaurantAdmin && !restaurant.HasAdministrator(currentUser.Id))
{
return(FailureResult <Guid> .Forbidden());
}
var dishCategory = new DishCategory(new DishCategoryId(Guid.NewGuid()), command.RestaurantId, command.Name);
await dishCategoryRepository.StoreAsync(dishCategory, cancellationToken);
return(SuccessResult <Guid> .Create(dishCategory.Id.Value));
}
public async Task <Result <bool> > HandleAsync(ChangeCuisineCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <bool> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <bool> .Forbidden());
}
var cuisine = await cuisineRepository.FindByCuisineIdAsync(command.CuisineId, cancellationToken);
if (cuisine == null)
{
return(FailureResult <bool> .Create(FailureResultCode.CuisineDoesNotExist));
}
cuisine.Change(command.Name);
await cuisineRepository.StoreAsync(cuisine, cancellationToken);
return(SuccessResult <bool> .Create(true));
}
public async Task <Result <bool> > HandleAsync(RemoveUserCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <bool> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <bool> .Forbidden());
}
if (command.UserId == currentUser.Id)
{
return(FailureResult <bool> .Create(FailureResultCode.CannotRemoveCurrentUser));
}
await userRepository.RemoveAsync(command.UserId, cancellationToken);
return(SuccessResult <bool> .Create(true));
}
public async Task <Result <RestaurantViewModel> > HandleAsync(AddRestaurantCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <RestaurantViewModel> .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <RestaurantViewModel> .Forbidden());
}
var paymentMethods = (await paymentMethodRepository.FindAllAsync(cancellationToken))
.ToDictionary(en => en.Id.Value, PaymentMethodViewModel.FromPaymentMethod);
var restaurant = restaurantFactory.CreateWithName(command.Name);
await restaurantRepository.StoreAsync(restaurant, cancellationToken);
return(SuccessResult <RestaurantViewModel> .Create(RestaurantViewModel.FromRestaurant(restaurant, paymentMethods, userRepository)));
}
public async Task <Result <bool> > HandleAsync(RemoveDishFromRestaurantCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <bool> .Unauthorized());
}
if (currentUser.Role < Role.RestaurantAdmin)
{
return(FailureResult <bool> .Forbidden());
}
var restaurant = await restaurantRepository.FindByRestaurantIdAsync(command.RestaurantId, cancellationToken);
if (restaurant == null)
{
return(FailureResult <bool> .Create(FailureResultCode.RestaurantDoesNotExist));
}
if (currentUser.Role == Role.RestaurantAdmin && !restaurant.HasAdministrator(currentUser.Id))
{
return(FailureResult <bool> .Forbidden());
}
var dishCategories = await dishCategoryRepository.FindByRestaurantIdAsync(command.RestaurantId, cancellationToken);
var dishCategory = dishCategories?.FirstOrDefault(en => en.Id == command.DishCategoryId);
if (dishCategory == null)
{
return(FailureResult <bool> .Create(FailureResultCode.DishCategoryDoesNotBelongToRestaurant));
}
var dishes = await dishRepository.FindByDishCategoryIdAsync(dishCategory.Id, cancellationToken);
var dish = dishes?.FirstOrDefault(en => en.Id == command.DishId);
if (dish == null)
{
return(FailureResult <bool> .Create(FailureResultCode.DishDoesNotBelongToDishCategory));
}
await dishRepository.RemoveAsync(command.DishId, cancellationToken);
return(SuccessResult <bool> .Create(true));
}
public async Task <Result <ICollection <UserViewModel> > > HandleAsync(GetAllUsersQuery query, User currentUser, CancellationToken cancellationToken = default)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
if (currentUser == null)
{
return(FailureResult <ICollection <UserViewModel> > .Unauthorized());
}
if (currentUser.Role < Role.SystemAdmin)
{
return(FailureResult <ICollection <UserViewModel> > .Forbidden());
}
var users = await userRepository.FindAllAsync(cancellationToken);
return(SuccessResult <ICollection <UserViewModel> > .Create(users.Select(UserViewModel.FromUser).ToList()));
}
public async Task <Result <Guid> > HandleAsync(AddOrChangeDishOfRestaurantCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (currentUser == null)
{
return(FailureResult <Guid> .Unauthorized());
}
if (currentUser.Role < Role.RestaurantAdmin)
{
return(FailureResult <Guid> .Forbidden());
}
var restaurant = await restaurantRepository.FindByRestaurantIdAsync(command.RestaurantId, cancellationToken);
if (restaurant == null)
{
return(FailureResult <Guid> .Create(FailureResultCode.RestaurantDoesNotExist));
}
if (currentUser.Role == Role.RestaurantAdmin && !restaurant.HasAdministrator(currentUser.Id))
{
return(FailureResult <Guid> .Forbidden());
}
var dishCategories = await dishCategoryRepository.FindByRestaurantIdAsync(command.RestaurantId, cancellationToken);
var dishCategory = dishCategories?.FirstOrDefault(en => en.Id == command.DishCategoryId);
if (dishCategory == null)
{
return(FailureResult <Guid> .Create(FailureResultCode.DishCategoryDoesNotBelongToRestaurant));
}
Dish dish;
if (command.Dish.Id != Guid.Empty)
{
var dishes = await dishRepository.FindByDishCategoryIdAsync(dishCategory.Id, cancellationToken);
dish = dishes?.FirstOrDefault(en => en.Id.Value == command.Dish.Id);
if (dish == null)
{
return(FailureResult <Guid> .Create(FailureResultCode.DishDoesNotBelongToDishCategory));
}
if (!string.Equals(dish.Name, command.Dish.Name))
{
dish.ChangeName(command.Dish.Name);
}
if (!string.Equals(dish.Description, command.Dish.Description))
{
dish.ChangeDescription(command.Dish.Description);
}
if (!string.Equals(dish.ProductInfo, command.Dish.ProductInfo))
{
dish.ChangeProductInfo(command.Dish.ProductInfo);
}
dish.ReplaceVariants(FromVariantViewModels(command.Dish.Variants));
}
else
{
dish = new Dish(
new DishId(Guid.NewGuid()),
command.RestaurantId,
command.DishCategoryId,
command.Dish.Name,
command.Dish.Description,
command.Dish.ProductInfo,
FromVariantViewModels(command.Dish.Variants)
);
}
await dishRepository.StoreAsync(dish, cancellationToken);
return(SuccessResult <Guid> .Create(dish.Id.Value));
}
