public void Create(UserRegisteredEvent @event) { this.Id = @event.AggregateId; this.Name = @event.Fullname; this.Email = @event.Email; this.RegistrationDate = @event.Date; }
private void Apply(UserRegisteredEvent @event) { _firstName = @event.FirstName; _lastName = @event.LastName; _email = @event.Email; _userHasActivatedAccount = false; }
public async Task UserVerification_DuplicateEmail_NotProcessed() { var testGuid = Guid.NewGuid(); const int semaphoreTimeout = 1000; var testEmail = _faker.Internet.Email(); var userRegisteredEvent = new UserRegisteredEvent() { Email = testEmail, Name = _faker.Random.String2(5), Surname = _faker.Random.String2(5) }; var streamProvider = _cluster.Cluster.Client.GetStreamProvider(Constants.StreamProviderName); var userRegistrationStream = streamProvider.GetStream <UserRegisteredEvent>(testGuid, nameof(UserRegisteredEvent)); var userVerifiedStream = streamProvider.GetStream <UserVerificationEvent>(testGuid, nameof(UserVerificationEvent)); await userVerifiedStream.SubscribeAsync(this); await userRegistrationStream.OnNextAsync(userRegisteredEvent); await _semaphore.WaitAsync(semaphoreTimeout); Assert.Equal(testEmail, _userVerificationEvent.Email); Assert.Equal(UserVerificationStatusEnum.Verified, _userVerificationEvent.Status); _userVerificationEvent = null; await userRegistrationStream.OnNextAsync(userRegisteredEvent); await _semaphore.WaitAsync(semaphoreTimeout); Assert.NotNull(_userVerificationEvent); Assert.Equal(testEmail, _userVerificationEvent.Email); Assert.Equal(UserVerificationStatusEnum.Duplicate, _userVerificationEvent.Status); }
public Task PublishUserRegisteredEvent(User user) { var newEvent = new UserRegisteredEvent { UserId = user.Id.ToString(), UserName = user.UserName, Email = user.Email.Value }; var msg = JsonSerializer.Serialize(newEvent, Common.DTOs.JsonSerializationOptions.options); var body = Encoding.UTF8.GetBytes(msg); var factory = new ConnectionFactory() { HostName = rabbimqSettings.Host, UserName = rabbimqSettings.Username, Password = rabbimqSettings.Password }; using (var connection = factory.CreateConnection()) using (var channel = connection.CreateModel()) { var props = channel.CreateBasicProperties(); props.ContentType = "application/json"; props.ContentEncoding = "UTF-8"; props.DeliveryMode = 2; channel.QueueDeclare(queue: rabbimqSettings.MailQueue, durable: true, exclusive: false, autoDelete: false, arguments: null); channel.BasicPublish(exchange: rabbimqSettings.Exchange, routingKey: rabbimqSettings.RoutingKey, basicProperties: props, body: body); } return(Task.CompletedTask); }
void Unregistered(object message) { message.Match() .With <RegisterUserCommand>(register => { var userRegistered = new UserRegisteredEvent(register.Id, register.Login, register.UserName); Persist(userRegistered, UpdateState); }); }
public async Task GivenUserRegisteredEventHandler_WhenCorrectLogDataIsReceived_ThenShouldCallLoggingRepository() { const string userId = "12340-223d234d"; var mockAuthenticationLogRepository = Substitute.For <IAuthenticationLogRepository>(); var authenticationLogEvent = new UserRegisteredEvent(userId); var userRegisteredEventHandler = new AuthenticationLogEventHandler(mockAuthenticationLogRepository); await userRegisteredEventHandler.Handle(authenticationLogEvent); await mockAuthenticationLogRepository.Received().SaveAuthenticationLog(Arg.Any <AuthenticationLog>()); }
public static AuthenticationEvent New(EventAction eventOccurred, string emailAddresss, Guid userId) { switch (eventOccurred) { case EventAction.UserRegistered: var authenticationEvent = new UserRegisteredEvent() { EventAction = eventOccurred.ToString(), UserId = userId, UserInfo = new EventUserInfo() { Email = emailAddresss, UserId = userId, EmailIsVerified = false } }; return(authenticationEvent); case EventAction.EmailUniqueValidationFailed: var validationFailedEvent = new EmailUniqueValidationFailedEvent() { EventAction = eventOccurred.ToString(), UserId = userId, Email = emailAddresss }; return(validationFailedEvent); case EventAction.EmailVerified: return(new EmailVerifiedEvent() { EventAction = eventOccurred.ToString(), UserId = userId, UserInfo = new EventUserInfo() { Email = emailAddresss, UserId = userId, EmailIsVerified = true } }); case EventAction.EmailChangeRequested: return(new EmailChangeRequestedEvent() { EventAction = eventOccurred.ToString(), UserId = userId, NewEmailAddress = emailAddresss }); default: return(null); } }
public static async Task SendUserRegisteredEventAsync(ApplicationUser user, IMessageSession messageSession, ILogger logger) { var @event = new UserRegisteredEvent { UserId = user.Id, UserName = user.UserName, PhoneNumber = user.PhoneNumber, Code = user.Code, InvitingUserCode = user.InvitingUserCode }; await messageSession.Publish(@event); logger.LogInformation("----- Published UserRegisteredEvent: {IntegrationEventId} from {AppName} - ({@IntegrationEvent})", @event.Id, Program.AppName, @event); }
private void Consume(IRegisterUserCommand command) { // Store order registration and get id int id = 12; Console.WriteLine($"Order with id {id} registered"); Console.WriteLine("Publishing order registered event"); //notify subscribers that a order is registered var orderRegisteredEvent = new UserRegisteredEvent(command, id); //publish event _rabbitMqManager.SendUserRegisteredEvent(orderRegisteredEvent); }
public async Task Consume(ConsumeContext <IRegisterUserCommand> context) { var command = context.Message; var id = 12; await Console.Out.WriteLineAsync($"User with id {id} registered"); //notify subscribers that user is registered. var userRegisteredEvent = new UserRegisteredEvent(command, id); await context.Publish <IUserRegisteredEvent>(userRegisteredEvent); }
public void UserRegisteredEventMailHandlerCallsSendMethod() { var @event = new UserRegisteredEvent { Email = "*****@*****.**", FirstName = "Luka", LastName = "Lukic", DateRegistered = DateTime.Now, Username = "******" }; var handler = new UserRegisteredEventMailHandler(@event); var mock = new Mock <IEmailSender>(); handler.Handle(mock.Object); mock.Verify(m => m.Send(), Times.Once()); }
public async Task <string> RegisterUserWithExternalId([FromBody] ExternalRegisterModel Model) { string result = "Success"; SparkUser su = new SparkUser { Name = Model.Name, }; Guid userGuid = await _userRepository.RegisterUserWithExternalId(su, Model.ExternalName, Model.ExternalId); UserRegisteredEvent newUser = new UserRegisteredEvent { UserId = userGuid, ExternalId = Model.ExternalId, Provider = Model.ExternalName }; await _client.PublishAsync(newUser); return(await Task.FromResult(result)); }
async Task <IActionResult> RegisterUser(SignupData data, string role, string idWorkshop = null) { var authData = await _repository.GetAuthDataByEmail(data.Email.ToLower()); if (authData != null) { _log.Error("User with the provided email already exists"); return(Conflict()); } var userId = Guid.NewGuid().ToString(); var token = GenerateToken(data.Email.ToLower(), role, userId); await _repository.NewAuthData(new AuthData { UserId = userId, Email = data.Email.ToLower(), Password = data.Password, Token = token }); // Notify the kafka message broker that a new user has been registered var userRegisteredEvent = new UserRegisteredEvent { User = new User { Id = userId, Name = data.Name, Surname = data.Surname, Email = data.Email.ToLower(), Phone = data.Phone, IsWorker = role == UserRole.Worker, IdWorkshop = idWorkshop } }; await _mbProducer.Send(userRegisteredEvent, "UserRegistration"); return(Ok()); }
public async Task Consume(ConsumeContext <IRegisterUserCommand> context) { var command = context.Message; var userService = new UserService(); //Store order registration and get Id var id = userService.AddUser(new Domain.Entities.Users { Email = command.Email, Name = command.Name, Password = command.Password, Username = command.Username }); await Console.Out.WriteLineAsync("Usuário " + command.Name + " registrado com sucesso!"); //notify subscribers that a order is registered var orderRegisteredEvent = new UserRegisteredEvent(command, id); //publish event await context.Publish <IRegisteredUserEvent>(orderRegisteredEvent); }
public async Task <RegisterUserCommandResult> Handle(RegisterUserCommand request, CancellationToken cancellationToken) { if (!string.IsNullOrWhiteSpace(request.Token)) { var validationResult = await _tokenValidator.ValidateAccessTokenAsync(request.Token); if (validationResult.IsError) { throw new DomainException(validationResult.Error); } if (!validationResult.Client?.RedirectUris.Any(url => url.Equals(request.ReturnUrl, StringComparison.OrdinalIgnoreCase)) ?? true) { throw new DomainException($"Invalid return url: {request.ReturnUrl}"); } } else if (!string.IsNullOrWhiteSpace(request.ReturnUrl)) { var context = await _interactionService.GetAuthorizationContextAsync(request.ReturnUrl); if (context == null) { throw new DomainException("Invalid context"); } } var user = await _userService.GetByUsername(request.Email, cancellationToken); if (user != null) { return new RegisterUserCommandResult { IsSuccess = false, Errors = new List <string> { $"Email {request.Email} already exists." } } } ; user = new ApplicationUser { Id = Guid.NewGuid().ToString(), Email = request.Email, UserName = request.Email, EmailConfirmed = !_options.RequireConfirmedEmail }; var password = !string.IsNullOrWhiteSpace(request.PlainTextPassword) ? request.PlainTextPassword : Guid.NewGuid().ToString().ToSha256(); var result = await _userManager.CreateAsync(user, password); var token = await _userManager.GenerateEmailConfirmationTokenAsync(user); var encodedToken = Base64UrlEncoder.Encode(token); var response = new RegisterUserCommandResult { Id = result.Succeeded ? user.Id : string.Empty, IsSuccess = result.Succeeded, Errors = result.Errors.Select(e => e.Description) }; if (!result.Succeeded) { return(response); } _urlBuilder .Create(_interactionOptions.UserInteractionEndpoints.BaseUrl) .Path(_interactionOptions.UserInteractionEndpoints.ConfirmUser) .AddQuery("userId", user.Id) .AddQuery("token", encodedToken) .AddQuery("returnUrl", request.ReturnUrl); var userRegisteredEvent = new UserRegisteredEvent { UserId = user.Id, Url = _urlBuilder.ToString() }; await _eventPublisher.PublishAsync(userRegisteredEvent); return(response); } }
protected User(UserRegisteredEvent userRegisteredEvent) : this() => ApplyChange <User>(userRegisteredEvent);
public async Task <IActionResult> SendAsync(UserRegisteredEvent accountCreatedEvent) { await _messageSubscriber.HandleAsync(accountCreatedEvent); return(Ok()); }
public Task OnNextAsync(UserRegisteredEvent item, StreamSequenceToken token = null) { RaiseEvent(item); return(Task.CompletedTask); }
private async Task ServerValuesAsync(UserRegisteredEvent message) { await _userRepository.AddUser(message.UserId, message.ExternalId, message.Provider); }
public async Task HandleAsync(UserRegisteredEvent args) { await SendNotificationAsync <Guid?, User, UserDto>(args, args.User, args.User.FullName); }
public async Task <IActionResult> RegisterAsync([FromBody] RegisterUserDTO registerUserDTO) { if (registerUserDTO == null) { return(new BadRequestObjectResult(new ErrorDTO { ErrorMessage = "Register data is null" })); } if (string.IsNullOrWhiteSpace(registerUserDTO.Email) || string.IsNullOrWhiteSpace(registerUserDTO.Password) || string.IsNullOrWhiteSpace(registerUserDTO.Password2)) { return(new BadRequestObjectResult(new ErrorDTO { ErrorMessage = "Email or password is empty" })); } if (registerUserDTO.Password.Length < 7) { return(new BadRequestObjectResult(new ErrorDTO { ErrorMessage = "Password is too short" })); } if (registerUserDTO.Password != registerUserDTO.Password2) { return(new BadRequestObjectResult(new ErrorDTO { ErrorMessage = "Passwords are not equal" })); } var user = await userRepository.GetByEmailAsync(registerUserDTO.Email); if (user != null) { return(new BadRequestObjectResult(new ErrorDTO { ErrorMessage = "User does exist" })); } var passwordHash = passwordHasher.Hash(registerUserDTO.Email, registerUserDTO.Password); user = new User { Email = registerUserDTO.Email, PasswordHash = passwordHash }; using (var transaction = dbContext.Database.BeginTransaction()) { await userRepository.CreateAsync(user); await dbContext.SaveChangesAsync(); var userRegisteredEvent = new UserRegisteredEvent(user.Id, user.Email); await integrationEventLogService.SaveEventAsync(userRegisteredEvent); await dbContext.SaveChangesAsync(); transaction.Commit(); } return(NoContent()); }
// 学习被注册成功后的事件处理方法 public Task Handle(UserRegisteredEvent message, CancellationToken cancellationToken) { // 恭喜您,注册成功,欢迎加入我们。 return(Task.CompletedTask); }
public void Apply(UserRegisteredEvent @event) { Name = @event.Name; Surname = @event.Surname; Email = @event.Email; }