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")); }