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