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)));
        }
Example #2
0
        public static FailureResult GetFailure(int exitCode,
			TimeSpan timeElapsed,
			Exception ex, 
			IEnumerable<string> outputTextLines, 
			IEnumerable<string> warningTextLines,
			IEnumerable<string> errorTextLines)
        {
            if (outputTextLines == null)
                throw new ArgumentNullException("outputTextLines");

            if (warningTextLines == null)
                throw new ArgumentNullException("warningTextLines");

            if (errorTextLines == null)
                throw new ArgumentNullException("errorTextLines");

            var result = new FailureResult();
            result.IsSuccess = false;
            result.ExiteCode = exitCode;
            result.TimeElapsed = timeElapsed;
            result.Exception = ex;
            result.OutputTextLines = new List<string>(outputTextLines);
            result.ErrorTextLines = new List<string>(errorTextLines);
            result.WarningTextLines = new List<string>(warningTextLines);

            return result;
        }
        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 <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()));
        }
Example #6
0
        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 <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));
        }
Example #8
0
        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 void Should_Throw_Exception_When_No_Async_Result()
        {
            var failure             = "failure";
            var failableAsyncResult = FailureResult <string, string> .CreateAsync(failure);

            Assert.ThrowsAsync <Exception>(async() => await failableAsyncResult.GetResultOrThrowExceptionAsync(f => new Exception()));
        }
        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));
        }
Example #11
0
        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 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));
        }
Example #13
0
        protected IResult <IReadOnlyCollection <T> > GetAll(string procedureName, Mapper <DataSet, T> mapper, IDictionary <string, object> values = null)
        {
            IReadOnlyCollection <T>            entities = null;
            IResult <IReadOnlyCollection <T> > result   = new NoneResult <IReadOnlyCollection <T> >();

            try
            {
                using (var dataSet = _context.ExecuteProcedure(procedureName, values))
                {
                    if (this.CheckDataSet(dataSet))
                    {
                        entities = mapper?.MapCollection(dataSet);
                    }
                }
            }
            catch (UserException ex)
            {
                result = new FailureResult <IReadOnlyCollection <T> >(ex, ex.Message);
            }

            if (entities != null)
            {
                result = new SuccessResult <IReadOnlyCollection <T> >(entities);
            }

            return(result);
        }
Example #14
0
        protected IResult <T> Get(string procedureName, Mapper <DataSet, T> mapper, IDictionary <string, object> values = null)
        {
            T           obj    = default(T);
            IResult <T> result = new NoneResult <T>();

            try
            {
                using (var dataSet = _context.ExecuteProcedure(procedureName, values))
                {
                    if (this.CheckDataSet(dataSet) && mapper != null)
                    {
                        obj = mapper.MapItem(dataSet);
                    }
                }
            }
            catch (UserException ex)
            {
                result = new FailureResult <T>(ex, ex.Message);
            }

            if (obj != null)
            {
                result = new SuccessResult <T>(obj);
            }

            return(result);
        }
Example #15
0
        public void Execute_FactoryThrowsException_FailureResultReturned()
        {
            // arrange
            var commandBuilder = new CommandInput.Builder(1, "command");
            var commandInput   = commandBuilder.Build();

            var parser = Substitute.For <IParser>();

            parser.Parse(Arg.Any <string>()).Returns(new[] { commandInput });

            var factory = Substitute.For <ICommandFactory>();

            factory.Create(Arg.Any <CommandInput>()).Returns(x => { throw new Exception(); });

            var binder = Substitute.For <ICommandParameterBinder>();

            var           sut             = new Session(parser, factory, binder);
            FailureResult executionResult = null;

            // act
            sut.Execute("command", result => executionResult = result as FailureResult);

            // assert
            Assert.Equal(1, executionResult.SourceLine);
        }
        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(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 <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 void Should_Throw_Exception_When_No_Result()
        {
            var failure        = "failure";
            var failableResult = FailureResult <string, string> .Create(failure);

            Assert.Throws <Exception>(() => failableResult.GetResultOrThrowException(f => new Exception()));
        }
Example #20
0
        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 <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 void Should_Throw_Exception_When_Handler_Not_Provided()
        {
            var failure       = "failure";
            var failureResult = FailureResult <bool, string> .Create(failure);

            Assert.Throws <ArgumentNullException>(() =>
                                                  failureResult.Handle(r => r, null));
        }
        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 Matches_expected_message()
        {
            const string received = "What's the frequency, Kenneth?";
            const string expected = "What's {0} {1}, Kenneth?";

            var result = new FailureResult(received);

            result.AssertNotSuccess(expected);
        }
        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_Get_New_Failure_Failable_Result_When_On_Failure()
        {
            var failure = FailureResult <int, int>
                          .Create(2)
                          .OnSuccess(s => s * 2)
                          .OnFailure(f => FailureResult <int, int> .Create(f * 3));

            Assert.AreEqual(6, failure.Handle(s => s, f => f));
        }
Example #27
0
        public static async Task <Result <TSuccessResult, FailureResult> > ExecuteAsync <TSuccessResult>(
            Func <Task <TSuccessResult> > action,
            Expression <Func <TSuccessResult, bool> > waitCondition,
            TimeSpan maxWaitTime,
            Func <int, TimeSpan> stepEngine,
            string timeoutMessage,
            IList <Type> notIgnoredExceptionType,
            Action <int, TimeSpan> callbackIfWaitSuccessful,
            bool continueOnCapturedContext = false)
        {
            var              retryAttempt = 0;
            TSuccessResult?  value        = default;
            List <Exception> ex           = new();
            var              wc           = waitCondition.Compile();
            var              stopwatch    = Stopwatch.StartNew();

            do
            {
                try
                {
                    value = await action().ConfigureAwait(continueOnCapturedContext);

                    if (wc(value))
                    {
                        callbackIfWaitSuccessful?.Invoke(retryAttempt, stopwatch.Elapsed);
                        return(value);
                    }
                }
                catch (Exception e) when(notIgnoredExceptionType.Any(x => x == e.GetType()))
                {
                    throw;
                }
                catch (Exception e)
                {
                    ex.Add(e);
                }

                if (retryAttempt < int.MaxValue)
                {
                    retryAttempt++;
                }

                var sleep            = stepEngine.Invoke(retryAttempt);
                var stopwatchElapsed = stopwatch.Elapsed;
                var canRetry         = stopwatch.Elapsed < maxWaitTime;
                if (!canRetry)
                {
                    var baseFailureResult =
                        FailureResult.Create(retryAttempt, maxWaitTime, stopwatchElapsed, timeoutMessage);
                    return(ex.Any()
                        ? baseFailureResult.WhenExceptions(ex)
                        : baseFailureResult.WhenNotExpectedValue(value, waitCondition !));
                }

                await Task.Delay(sleep);
            } while (true);
        }
        public async Task Should_Create_Failure_Async_Result_When_Factory_Method_Used()
        {
            var failure            = "failure";
            var failureAsyncResult = FailureResult <bool, string> .CreateAsync(failure);

            var failureResult = await failureAsyncResult;

            Assert.AreEqual(failure, (failureResult as FailureResult <bool, string>).Failure);
        }
        public void Should_Create_Failure_Result_When_Factory_Method_Used()
        {
            var failure       = "failure";
            var failureResult = FailureResult <bool, string> .Create(failure);

            Assert.AreEqual(
                failure,
                failureResult.Handle(r => string.Empty, f => f));
            Assert.AreEqual(failure, (failureResult as FailureResult <bool, string>).Failure);
        }
        public void TryGetFailureResult_should_return_failure_result_if_api_task_result_is_failure()
        {
            var failureResult = new FailureResult();
            var taskResult    = ApiTaskResult <SuccessResult, FailureResult> .FailureResult(failureResult, Guid.NewGuid(), new Urn("nid", "nss"));

            var success = taskResult.TryGetFailureResult(out var result);

            success.Should().BeTrue();
            result.Should().Be(failureResult);
        }
        public void Should_Not_Get_New_Result_On_Success_When_Is_Failure()
        {
            var failure        = "failure";
            var FailableResult = FailureResult <string, string> .Create(failure);

            var newResult         = 2;
            var newFailableResult = FailableResult.OnSuccess(r => newResult);

            Assert.AreEqual("failure", newFailableResult.Handle(s => string.Empty, f => f));
        }
        public async void Failure(FailureResult result)
        {
            var message = result.ErrorMessage;
            var title = string.Format("MobilePay Error {0}", (int)result.ErrorCode);
#if SILVERLIGHT
            System.Windows.MessageBox.Show(message, title, System.Windows.MessageBoxButton.OK);
#else
            var popup = new Windows.UI.Popups.MessageDialog(message, title);
            await popup.ShowAsync();
#endif
        }
        public ITaskResult<IdentityWithResult[]> Execute(Layer layer, Func<Identity, TaskContext> contextFactory, ITaskInterceptor interceptor)
        {
            ITaskResult<IdentityWithResult[]> failure = null;

            var results = new ConcurrentBag<IdentityWithResult>();
            var layerTasks = layer.Items.Select(item => SystemTask.Factory.StartNew(() =>
            {
                Identity id = item.Id;
                TaskContext taskContext = contextFactory(id);

                if (interceptor != null)
                {
                    interceptor.BeforeTaskExecute(id, item.Task, taskContext);
                }

                ITaskResult<object> result = item.Task.Execute(taskContext);
                if (interceptor != null)
                {
                    interceptor.AfterTaskExecute(id, item.Task, taskContext, result);
                }

                if (result.IsSuccess)
                {
                    results.Add(new IdentityWithResult(id, result.Data));
                }
                else
                {
                    failure = new FailureResult<IdentityWithResult[]>(result.Error);
                }
            })).ToArray();

            SystemTask.WaitAll(layerTasks);

            if (failure != null)
            {
                return failure;
            }

            return new SuccessResult<IdentityWithResult[]>(results.ToArray());
        }