public void Should_Get_Result_When_Available()
{
var result = "result";
var failableResult = SuccessResult <string, bool> .Create(result);
Assert.AreEqual(result, failableResult.GetResultOrThrowException(f => new Exception()));
}
public async Task <Result <UserViewModel> > HandleAsync(LoginCommand command, User currentUser, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (string.IsNullOrWhiteSpace(command.Username))
{
throw new InvalidOperationException("username is null or whitespace");
}
if (string.IsNullOrWhiteSpace(command.Password))
{
throw new InvalidOperationException("password is null or whitespace");
}
var user = await userRepository.FindByNameAsync(command.Username, cancellationToken);
if (user == null)
{
return(FailureResult <UserViewModel> .Unauthorized());
}
if (!user.ValidatePassword(command.Password))
{
return(FailureResult <UserViewModel> .Unauthorized());
}
return(SuccessResult <UserViewModel> .Create(UserViewModel.FromUser(user)));
}
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 <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 <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));
}
/// <summary>
/// Adds a track to a conference
/// </summary>
/// <param name="trackId">Unique identity of a track</param>
/// <param name="talkId">Unique identity of a talk</param>
/// <param name="title">Title of Talk</param>
/// <param name="description">Description of talk</param>
/// <param name="duration">Duration/Length of talk</param>
/// <returns>An instance of <c>TrackId</c></returns>
public Result <TalkId> AddTalkToTrack(TrackId trackId, TalkId talkId, Title title, Description description, Duration duration)
{
var track = _tracks.FirstOrDefault(t => t.TrackId == trackId);
if (track == null)
{
return(InvalidResult <TalkId> .Create("Invalid track"));
}
var talkAddedToTrackResult = track.CreateAndAddTalk(talkId, title, description, duration);
if (talkAddedToTrackResult.IsFailure)
{
return(InvalidResult <TalkId> .Create(talkAddedToTrackResult.Error.Value.Message));
}
var addedTalk = talkAddedToTrackResult.Data;
var talkCreated = new TalkCreated(addedTalk.TalkId, addedTalk.Title, addedTalk.Description,
addedTalk.StartTime);
AddEvent(talkCreated);
var trackAddedToTack = new TalkAddedToTrack(track.TrackId, addedTalk.TalkId, addedTalk.Title, addedTalk.StartTime);
AddEvent(trackAddedToTack);
return(SuccessResult <TalkId> .Create(talkId));
}
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 <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(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(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(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 Should_Execute_Task_Continuation()
{
var successResult = SuccessResult <int, int> .Create(1);
var failureResult = FailureResult <int, int> .Create(2);
Assert.AreEqual(
2,
await successResult
.OnSuccessAsync(s => Task.FromResult(s * 2))
.OnFailureAsync(f => Task.FromResult(f * 5))
.GetResultOrThrowExceptionAsync(f => new Exception()));
Assert.AreEqual(
2,
await successResult
.OnSuccessAsync(s => SuccessResult <int, int> .CreateAsync(s * 2))
.OnFailureAsync(f => FailureResult <int, int> .CreateAsync(f * 5))
.GetResultOrThrowExceptionAsync(f => new Exception()));
Assert.AreEqual(
4,
await failureResult
.OnFailureAsync(f => Task.FromResult(f * 2))
.OnSuccessAsync(s => Task.FromResult(s * 5))
.HandleAsync(s => 0, f => f));
Assert.AreEqual(
4,
await failureResult
.OnFailureAsync(f => FailureResult <int, int> .CreateAsync(f * 2))
.OnSuccessAsync(s => SuccessResult <int, int> .CreateAsync(s * 5))
.HandleAsync(s => 0, f => f));
}
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 <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 <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 <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 void Should_Throw_Exception_When_Handler_Not_Provided()
{
var result = "success";
var successResult = SuccessResult <string, bool> .Create(result);
Assert.Throws <ArgumentNullException>(() =>
successResult.Handle(null, f => f));
}
public void Should_Not_Get_New_Result_On_Success_Failable_Result_When_Is_Failure()
{
var result = FailureResult <int, int>
.Create(1)
.OnSuccess(s => SuccessResult <int, int> .Create(s + 5));
Assert.AreEqual(1, result.Handle(s => s, f => f));
}
public void Should_Get_New_Result_When_New_Failable_Result_On_Success()
{
var result = SuccessResult <int, int>
.Create(1)
.OnSuccess(s => SuccessResult <int, int> .Create(s + 5));
Assert.AreEqual(6, result.GetResultOrThrowException(f => new Exception()));
}
public void Should_Not_Get_New_Failure_Failable_Result_On_Failure_When_Is_Success()
{
var success = SuccessResult <int, int>
.Create(2)
.OnSuccess(s => s * 2)
.OnFailure(f => FailureResult <int, int> .Create(f * 3));
Assert.AreEqual(4, success.Handle(s => s, f => f));
}
public void Should_Chain_New_Results_When_On_Success()
{
var result = SuccessResult <int, int>
.Create(1)
.OnSuccess(s => s * 2)
.OnSuccess(s => s + 5);
Assert.AreEqual(7, result.GetResultOrThrowException(f => new Exception()));
}
public void Should_Get_New_Result_When_On_Success()
{
var result = "result";
var failableResult = SuccessResult <string, string> .Create(result);
var newResult = 2;
var newFailableResult = failableResult.OnSuccess(r => newResult);
Assert.AreEqual(newResult, newFailableResult.GetResultOrThrowException(f => new Exception()));
}
public void Should_Create_Success_Result_When_Factory_Method_Used()
{
var result = "success";
var successResult = SuccessResult <string, bool> .Create(result);
Assert.AreEqual(
result,
successResult.Handle(r => r, f => string.Empty));
Assert.AreEqual(result, (successResult as SuccessResult <string, bool>).Result);
}
/// <summary>
/// Creates an instance of <c>Description</c>
/// </summary>
/// <param name="description">Description</param>
/// <returns>An instance of <c>Description</c></returns>
public static Result <Description> Create(string description)
{
if (string.IsNullOrWhiteSpace(description))
{
return(InvalidResult <Description> .Create("Invalid description"));
}
var descriptionObject = new Description(description);
return(SuccessResult <Description> .Create(descriptionObject));
}
/// <summary>
/// Creates an instance of <c>TrackId</c>
/// </summary>
/// <param name="id">Unique identity of Track</param>
/// <returns>An instance of <c>TrackId</c></returns>
public static Result <TrackId> Create(Guid id)
{
if (id == Guid.Empty)
{
return(InvalidResult <TrackId> .Create("Invalid Id"));
}
var trackId = new TrackId(id);
return(SuccessResult <TrackId> .Create(trackId));
}
/// <summary>
/// Creates an instance of <c>ConferenceId</c>
/// </summary>
/// <param name="id">Unique identity of conference</param>
/// <returns>An instance of <c>ConferenceId</c></returns>
public static Result <ConferenceId> Create(Guid id)
{
if (id == Guid.Empty)
{
return(InvalidResult <ConferenceId> .Create("Invalid Id"));
}
var conferenceId = new ConferenceId(id);
return(SuccessResult <ConferenceId> .Create(conferenceId));
}
public async Task <Result <ICollection <CuisineViewModel> > > HandleAsync(GetAllCuisinesQuery query, User currentUser, CancellationToken cancellationToken = default)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var cuisines = await cuisineRepository.FindAllAsync(cancellationToken);
return(SuccessResult <ICollection <CuisineViewModel> > .Create(cuisines.Select(CuisineViewModel.FromCuisine).ToList()));
}
public async Task <Result <ICollection <PaymentMethodViewModel> > > HandleAsync(GetAllPaymentMethodsQuery query, User currentUser, CancellationToken cancellationToken = default)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var paymentMethods = await paymentMethodRepository.FindAllAsync(cancellationToken);
return(SuccessResult <ICollection <PaymentMethodViewModel> > .Create(paymentMethods.Select(PaymentMethodViewModel.FromPaymentMethod).ToList()));
}
/// <summary>
/// Creates an instance of <c>StartTime</c>
/// </summary>
/// <param name="startTime">Start time</param>
/// <returns>An instance of <c>StartTime</c></returns>
public static Result <TalkStartTime> Create(DateTime startTime)
{
// start time must be between 9-12 or 1-4PM
if ((startTime >= MorningSessionStartTime && startTime < MorningSessionEndTime) ||
(startTime >= AfternoonSessionStartTime && startTime < AfternoonSessionEndTime))
{
var startObject = new TalkStartTime(startTime);
return(SuccessResult <TalkStartTime> .Create(startObject));
}
return(InvalidResult <TalkStartTime> .Create("Invalid start time"));
}