public async Task <IActionResult> ActivateAsync([FromQuery, Required] string email) { var command = new ActivateUserCommand(email); await _commandProcessor.SendAsync(command); return(Ok(SuccessCodes.UserActivated)); }
public async Task <IActionResult> ActivateUser(Guid id, ActivateUserCommand input) { input.Id = id; await _mediator.Publish(input); return(Ok()); }
public async Task ThenResultContainsInvalidCodeMessageIfTheAccessCodeDoesntMatchTheAnyOnTheUser() { //Act var command = new ActivateUserCommand { AccessCode = "AccessCode", UserId = Guid.NewGuid().ToString(), User = new User { SecurityCodes = new[] { new SecurityCode { Code = "Edocssecca", CodeType = SecurityCodeType.AccessCode, ExpiryTime = DateTime.MaxValue } } } }; var result = await _activateUserCommandValidator.ValidateAsync(command); Assert.IsTrue( result .ValidationDictionary.Values.Any(message => message.Equals(InvalidCodeMessage, StringComparison.Ordinal)) ); }
public async Task ThenFalseIsReturnedIfTheAccessCodeMatchAnyOnTheUserButItHasExpired() { //Act var command = new ActivateUserCommand { AccessCode = "AccessCode", UserId = Guid.NewGuid().ToString(), User = new User { SecurityCodes = new[] { new SecurityCode { Code = "AccessCode", CodeType = SecurityCodeType.AccessCode, ExpiryTime = DateTime.MinValue } } } }; var actual = await _activateUserCommandValidator.ValidateAsync(command); //Assert Assert.IsFalse(actual.IsValid()); }
public async Task ThenTrueIsReturnedIfAllFieldsAreProvidedAndTheAccessCodeMatchesCaseInsensitive() { //Act var command = new ActivateUserCommand { AccessCode = "AccessCode", UserId = Guid.NewGuid().ToString(), User = new User { SecurityCodes = new[] { new SecurityCode { Code = "ACCESSCODE", CodeType = SecurityCodeType.AccessCode, ExpiryTime = DateTime.MaxValue } } } }; var actual = await _activateUserCommandValidator.ValidateAsync(command); //Assert Assert.IsTrue(actual.IsValid()); }
public async Task ThenThenUserIsUpdatedWithTheCorrectDetails() { //Arrange var userId = Guid.NewGuid().ToString(); var accessCode = "123ADF&^%"; var user = new User { Email = "*****@*****.**", LastName = "Tester", FirstName = "Test", Password = "******", IsActive = false, Id = userId }; var activateUserCommand = new ActivateUserCommand { UserId = userId, AccessCode = accessCode }; _userRepository.Setup(x => x.GetById(userId)).ReturnsAsync(user); _activateUserCommandValidator.Setup(x => x.ValidateAsync(It.Is <ActivateUserCommand>(p => p.AccessCode == accessCode && p.UserId == userId))).ReturnsAsync(new ValidationResult { ValidationDictionary = new Dictionary <string, string>() }); //Act await _handler.Handle(activateUserCommand); //Assert _userRepository.Verify(x => x.Update(It.Is <User>(p => p.IsActive && p.Id == userId)), Times.Once); }
private void AccountActiveStateChanged() { OnPropertyChanged("IsAccountActivated"); OnPropertyChanged("IsAccountDectivated"); ActivateUserCommand.UpdateCanExecuteState(); DeactivateUserCommand.UpdateCanExecuteState(); }
public void Handle(ActivateUserCommand command) { User user = repo.GetById <User>(new Guid(command.Key)); user.Activate(); repo.Save(user, Guid.NewGuid()); }
private static void SeedAdminUser(this IApplicationBuilder app) { var createUserCommand = new RegisterUserCommand( "admin", "admin", "admin", "*****@*****.**", Gender.Other, DateTime.Now, "zaq1@WSX", "zaq1@WSX"); var activateUserCommand = new ActivateUserCommand(createUserCommand.Id); try { var commandDispatcher = app.ApplicationServices.GetService <ICommandDispatcher>(); commandDispatcher.DispatchAsync(createUserCommand).GetAwaiter().GetResult(); commandDispatcher.DispatchAsync(activateUserCommand).GetAwaiter().GetResult(); } catch (Exception ex) { if (!(ex is BusinessLogicException)) { throw; } } }
public CommandResult ActivateFirstAccess(ActivateUserCommand command, string userIdentity) { var user = _repository.GetById(command.Id); if (user == null) { return(new CommandResult(false, "Usuário não encontrado. ", command)); } user.ActivateFirstAccess(command.Role); _repository.UpdateRoleActive(user); var log = new AccessLog( "PrimeiroAcesso", DateTime.Now, userIdentity, "UserAuth", $"acesso liberado: {command.Id}"); _log.Register(log); user.HidePassword(); return(new CommandResult(true, "Usuário Ativo. ", user)); }
public async Task <IActionResult> Activate([FromBody] ActivateUserViewModel viewModel) { var command = new ActivateUserCommand(new AggregateId(viewModel.Id)); await _commandQueryDispatcherDecorator.DispatchAsync(command); return(Ok()); }
public async Task Handle(ActivateUserCommand message, CancellationToken token = default) { var user = await _session.Get <User>(message.Id); await user.ActivateAccount(); await _session.Commit(token); }
public async Task <IActionResult> CreateUser([FromBody] ActivateUserCommand command) { command.UserId = UserId; var result = await Mediator.Send(command); return(Ok(result)); }
public async Task <CommandResult <bool> > Handle(ActivateUserCommand request, CancellationToken cancellationToken) { var res = await _repo.ActivateUser(request.UserId).ConfigureAwait(false); return(new CommandResult <bool>() { Message = res ? "User Activated Successfully." : "Error occurred. Please try again", ResponseObj = true, Status = true }); }
public async Task <DomainUser?> ActivateNewUser(ActivateUserCommand cmd) { //TODO: collect Ldap user info if (cmd.Email == null) { throw new NotImplementedException("Automatically fetching emails is currently nor supported"); } return(_mapper.Map <User, DomainUser>(await _users.CreateNewUser(cmd.Uid, UserDefaultRole, cmd.Email))); }
public async Task <IActionResult> Activate(int id) { var command = new ActivateUserCommand(id); var result = await _mediator.Send(command); if (result == null) { return(NotFound()); } return(Ok()); }
public async Task Then_The_Command_Is_Handled_And_Endpoint_Called( ActivateUserCommand command, [Frozen] Mock <IApimDeveloperApiClient <ApimDeveloperApiConfiguration> > apimDeveloperApiClient, ActivateUserCommandHandler handler) { await handler.Handle(command, CancellationToken.None); apimDeveloperApiClient.Verify(x => x.Put(It.Is <PutUpdateUserRequest>(c => c.PutUrl.Contains(command.Id.ToString()) && ((UserRequestData)c.Data).State.Equals(1) )), Times.Once); }
public void UserAuthHandler_Activate_Valid() { var repository = new FakeUserAuthRepository(); var logRepository = new FakeAccessLogRepository(); var handler = new UserAuthHandler(repository, logRepository); var command = new ActivateUserCommand(); command.Id = repository.GetInactivesFirstAccess().FirstOrDefault().Id; command.Role = "user"; var result = handler.ActivateFirstAccess(command, "userIdentity"); Assert.IsTrue(result.Success); }
public async Task <IResult> Execute(ActivateUserCommand request) { var user = await _userService.Get(request.Id); if (user.IsActive()) { return(await Result.FailAsync("User already actived!")); } user.Activate(); await _userService.Update(user); return(await _unitOfWork.Commit() ? Result.Success() : Result.Fail("Internal error, please try again.")); }
public async Task <Unit> Handle(ActivateUserCommand request, CancellationToken cancellationToken) { var email = new Email(request.UserId); var userToActivate = await _repository.GetByEmail(email); if (userToActivate == null) { throw new UserNotFoundForDeleteException(); } userToActivate.UpdateIsActive(request.Active); await _repository.Update(userToActivate); return(new Unit()); }
public async Task ThenTrueIsReturnedIfOnlyTheEmailHasBeenSuppliedAndTheUserIdIsNull() { //Act var command = new ActivateUserCommand { UserId = null, Email = "User@Email", User = new User { Email = "user@email" } }; var actual = await _activateUserCommandValidator.ValidateAsync(command); //Assert Assert.IsTrue(actual.IsValid()); }
public void ActivateUserCommandHandler_Succeeds() { var handler = new ActivateUserCommandHandler(_repository); var command = new ActivateUserCommand("*****@*****.**", "999999"); var user = Substitute.For <User>(); user.Email.Returns("*****@*****.**"); user.ActivationCode.Returns(999999); user.Status.Returns(UserStatus.New); _context.Users.Add(user); var result = handler.Execute(command); result.Errors.Should().BeEmpty(); user.Received().Activate(); user.DidNotReceive().ActivationFailed(); }
public async Task ThenTheUserIsNotUpdatedIfTheUserIsAlreadyActive() { //Arrange var userId = Guid.NewGuid().ToString(); var accessCode = "123ADF&^%"; var user = new User { Email = "*****@*****.**", LastName = "Tester", FirstName = "Test", Password = "******", IsActive = true, Id = userId, SecurityCodes = new[] { new SecurityCode { Code = accessCode, CodeType = SecurityCodeType.AccessCode, ExpiryTime = DateTime.MaxValue } } }; var activateUserCommand = new ActivateUserCommand { UserId = userId, AccessCode = accessCode }; _userRepository.Setup(x => x.GetById(userId)).ReturnsAsync(user); _activateUserCommandValidator.Setup(x => x.ValidateAsync(It.Is <ActivateUserCommand>(p => p.AccessCode == accessCode && p.UserId == userId && p.User.SecurityCodes.Any(sc => sc.Code == accessCode && sc.CodeType == SecurityCodeType.AccessCode)))) .ReturnsAsync(new ValidationResult { ValidationDictionary = new Dictionary <string, string>() }); //Act await _handler.Handle(activateUserCommand); //Assert _userRepository.Verify(x => x.Update(It.Is <User>(p => p.IsActive && p.Id == userId)), Times.Never); }
public async Task <IActionResult> Activate(Guid id) { if (id == Guid.Empty) { return(BadRequest("Please provide userid")); } var userModel = await _queryProcessor.Query(new GetUser(id)); if (userModel == null) { return(NotFound()); } var activateUserCommand = new ActivateUserCommand(id); await _commandSender.Send(activateUserCommand); return(NoContent()); }
public void ActivateUserCommandHandler_Fails_For_Inactive_User() { var handler = new ActivateUserCommandHandler(_repository); var command = new ActivateUserCommand("*****@*****.**", "999999"); var user = Substitute.For <User>(); user.Email.Returns("*****@*****.**"); user.ActivationCode.Returns(999999); user.Status.Returns(UserStatus.Inactive); _context.Users.Add(user); var result = handler.Execute(command); result.Errors.Should().HaveCount(1); result.Errors[0].Expression.ToString().Should().Be("p => p.ActivationCode"); result.Errors[0].Message.Should().Be("This activation code is invalid"); user.DidNotReceive().Activate(); user.Received().ActivationFailed(); }
public async Task <IActionResult> ActivateUser(int id) { if (!ModelState.IsValid) { LogEndOfRequest("Failed Bad request", 400); return(BadRequest(ModelState)); } try { var command = new ActivateUserCommand(id); await userService.ActivateUserCommand.HandleAsync(command); LogEndOfRequest("Success", 200); return(Ok()); } catch (KeyNotFoundException) { LogEndOfRequest($"Failed User with id {id} not found", 404); return(NotFound()); } }
public void Arrange() { _activateUserCommandValidator = new Mock <IValidator <ActivateUserCommand> >(); _activateUserCommandValidator.Setup(x => x.ValidateAsync(It.IsAny <ActivateUserCommand>())) .ReturnsAsync(new ValidationResult { ValidationDictionary = new Dictionary <string, string>() }); _user = new User { SecurityCodes = new[] { new SecurityCode { Code = AccessCode, CodeType = SecurityCodeType.AccessCode, ReturnUrl = ReturnUrl } } }; _userRepository = new Mock <IUserRepository>(); _userRepository.Setup(x => x.GetById(It.IsAny <string>())).ReturnsAsync(_user); _userRepository.Setup(x => x.GetByEmailAddress(It.IsAny <string>())).ReturnsAsync(_user); _auditService = new Mock <IAuditService>(); _logger = new Mock <ILogger>(); _handler = new ActivateUserCommandHandler(_activateUserCommandValidator.Object, _userRepository.Object, _auditService.Object, _logger.Object); _command = new ActivateUserCommand { AccessCode = AccessCode, UserId = UserId }; }
public CommandResult ActivateFirstAccess(ActivateUserCommand command) { CommandResult result = _handler.ActivateFirstAccess(command, User.Identity.Name); return(result); }
public JsonResult Activate(ActivateUserCommand command) { var result = _commandBus.Send(command); return(Json(result.Message)); }
public async Task Activate(ActivateUserCommand activateUserCommand) { await _mediator.Send(activateUserCommand); }