public static async Task SeedData(UserManager <ApplicationUser> userManager, ICapPublisher capBus, ApplicationDbContext context)
{
if (!userManager.Users.Any())
{
using (var trans = context.Database.BeginTransaction(capBus, autoCommit: true))
{
var identityUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
var result = await userManager.CreateAsync(identityUser, "Password123");
var userEvent = new UserCreatedEvent
{
UserId = identityUser.Id,
Name = "Bob",
City = "Budapest",
Email = "*****@*****.**",
BirthDate = new DateTime(1997, 10, 23),
ProfileImageUrl = "https://images.dog.ceo/breeds/husky/n02110185_6775.jpg"
};
await capBus.SendEventAsync("identityservice.user.created", userEvent);
}
}
}
public async Task ReceiveUserCreated(UserCreatedEvent userEvent)
{
if (!await _messageTracker.HasProcessed(userEvent.EventId))
{
var reviewer = _mapper.Map <Reviewer>(userEvent);
using (var transaction = await _context.Database.BeginTransactionAsync())
{
try
{
_context.Reviewer.Add(reviewer);
await _context.SaveChangesAsync();
await _messageTracker.MarkAsProcessed(userEvent.EventId);
await transaction.CommitAsync();
}
catch (Exception e)
{
await transaction.RollbackAsync();
_logger.LogError(e, $"Unexpected error while processing event of type {nameof(UserCreatedEvent)}" +
$" EventId: {userEvent.EventId} UserId:{userEvent.UserId}");
}
}
}
}
public User(
Guid id,
string firstName,
string lastName,
int age,
string emailAddress,
string mobileNumber,
string city,
string password)
{
Check.NotNull <Guid>(id, nameof(id));
Check.NotNullOrEmpty(firstName, nameof(firstName));
Check.NotNullOrEmpty(lastName, nameof(lastName));
Check.NotNull(age, nameof(age));
Check.NotNullOrEmpty(emailAddress, nameof(emailAddress));
Check.NotNullOrEmpty(mobileNumber, nameof(mobileNumber));
Check.NotNullOrEmpty(city, nameof(city));
Check.NotNullOrEmpty(password, nameof(password));
var @event = new UserCreatedEvent
{
Id = id,
FirstName = firstName,
Age = age,
City = city,
EmailAddress = emailAddress,
LastName = lastName,
MobileNumber = mobileNumber,
Password = password
};
AddDomainEvent(@event);
Apply(@event);
}
public async Task CreateStartingPacksAsync(UserCreatedEvent @event)
{
using (var scope = _serviceScopeFactory.CreateScope())
{
await scope.ServiceProvider.GetRequiredService <IPackService>().CreateStartingPacksAsync(@event.Id);
}
}
public async Task UserCreatedEventHandler_Consume_Creates_User()
{
StoryContext.OpenInMemoryConnection();
try
{
var userCreatedEvent = new UserCreatedEvent
{
UserKey = Guid.NewGuid(),
ProfileImage = "image",
FirstName = "John",
LastName = "Doe"
};
using (var context = StoryContext.GetInMemoryContext())
{
var handler = new UserCreatedEventHandler(context, AutoMapperHelper.BuildMapper(new MappingProfile()));
await handler.ConsumeAsync(userCreatedEvent);
}
using (var context = StoryContext.GetInMemoryContext())
{
Assert.AreEqual(1, context.Users.Count());
Assert.AreEqual(userCreatedEvent.UserKey, context.Users.Single().UserKey);
Assert.AreEqual(userCreatedEvent.ProfileImage, context.Users.Single().ProfileImage);
Assert.AreEqual(Helpers.GetUserName(userCreatedEvent), context.Users.Single().Name);
}
}
finally
{
StoryContext.CloseInMemoryConnection();
}
}
private void On(UserCreatedEvent created)
{
_id = created.UserId;
_firstName = created.FirstName;
_lastName = created.LastName;
_email = created.Email;
}
public async Task Should_WriteAdnRead_Event_ToAndFrom_Store()
{
Given(repository => { });
var userId = UserId.Create();
var @event = new UserCreatedEvent(userId,
Faker.Name.FirstName(),
Faker.Name.LastName(),
$"{Faker.Random.Word()}@example.com",
"secret");
await When(async repository =>
{
await repository.Save(
new[] { @event },
_streamName,
CancellationToken.None);
return(Task.CompletedTask);
});
await Then(async repository =>
{
var result = await repository
.Get(_streamName, CancellationToken.None);
result.Should().NotBeNull();
result.Should().HaveCount(1);
});
}
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new AppUser {
UserName = model.Email, Name = model.Name, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
var @event = new UserCreatedEvent {
Name = model.Name, Email = model.Email, Id = user.Id
};
_eventBusPublisher.Publish(@event);
//claims are not used for the moment
//await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("userName", user.UserName));
//await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.Name));
//await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email));
//await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", Common.Constants.Roles.Consumer));
return(Ok(new RegisterResponseViewModel(user)));
}
public async Task GetOrCreate_WhenUserDoesntExist_ReturnsCreatedUserAndPublishesEvent()
{
// Arrange
var userEmail = "*****@*****.**";
var userId = Guid.NewGuid();
var user = new Models.User
{
Id = userId,
Email = userEmail
};
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository.Setup(x => x.CreateAsync(userEmail)).ReturnsAsync(user);
UserCreatedEvent userCreatedEvent = null;
var mockBus = new Mock <IBus>();
mockBus.Setup(x => x.PublishAsync(It.IsAny <UserCreatedEvent>()))
.Callback <UserCreatedEvent>(r => userCreatedEvent = r);
var service = new UserService(mockUserRepository.Object, mockBus.Object);
// Act
var actualUser = await service.GetOrCreateAsync(userEmail);
// Assert
Assert.Equal(user, actualUser);
mockBus.Verify(x => x.PublishAsync(It.IsAny <UserCreatedEvent>()), Times.Once);
Assert.Equal(userId, userCreatedEvent.Id);
}
public void PossibleToLoadFromEvents()
{
var user = AggregateCreator.CreateAggregateRoot <User>();
var created = new UserCreatedEvent()
{
UserId = "3333",
Email = "*****@*****.**",
FirstName = "John",
LastName = "Melinda"
};
var changed = new UserNameChangedEvent()
{
UserId = "3333",
FirstName = "John Jr.",
LastName = "Melinda III"
};
user.LoadFromEvents(new List <IEvent> {
created, changed
});
Assert.AreEqual(user.Id, created.UserId);
Assert.AreEqual(user.Version, 1);
Assert.AreEqual(GetPrivateValue <String>(user, "_firstName"), changed.FirstName);
Assert.AreEqual(GetPrivateValue <String>(user, "_lastName"), changed.LastName);
Assert.AreEqual(GetPrivateValue <String>(user, "_email"), created.Email);
}
public async Task RedeemMatchRewards_CallsRedeemMatchRewardsOnce()
{
// Arrange
var stubEvent = new UserCreatedEvent()
{
Id = Guid.NewGuid()
};
var mockBus = new Mock <IBus>();
var mockPackService = new Mock <IPackService>();
var mockServiceProvider = new Mock <IServiceProvider>();
mockServiceProvider.Setup(x => x.GetService(typeof(IPackService))).Returns(mockPackService.Object);
var mockServiceScope = new Mock <IServiceScope>();
mockServiceScope.SetupGet(x => x.ServiceProvider).Returns(mockServiceProvider.Object);
var mockServiceScopeFactory = new Mock <IServiceScopeFactory>();
mockServiceScopeFactory.Setup(x => x.CreateScope()).Returns(mockServiceScope.Object);
// Act
var subscriber = new UserCreatedEventSubscriber(mockBus.Object, mockServiceScopeFactory.Object);
await subscriber.CreateStartingPacksAsync(stubEvent);
// Assert
mockPackService.Verify(x => x.CreateStartingPacksAsync(stubEvent.Id), Times.Once);
}
public void Handle(UserCreatedEvent message)
{
Data.UserId = message.UserId;
Data.Email = message.Email;
RequestUtcTimeout <FollowUpTimeout>(DateTime.Now.AddMinutes(1));
Debug.WriteLine("MarketingService: New user " + Data.Email);
}
public async Task UserCreatedAsync(UserCreatedEvent eventBody)
{
ServiceContract.RequireNotNull(eventBody, nameof(eventBody));
await Task.Yield(); //Remove this line
throw new FulcrumNotFoundException("Method POST /User/Created/1 is not yet implemented - Part of tutorial 4");
}
private void HandleUserCreatedEvent(UserCreatedEvent evnt)
{
this.Id = (Guid)evnt.AggregateRootKey;
this.Password = evnt.Password;
this.DisplayName = evnt.DisplayName;
this.Name = evnt.Name;
this.Email = evnt.Email;
}
protected void When(UserCreatedEvent userCreatedEvent)
{
Salt = userCreatedEvent.Salt;
Username = userCreatedEvent.Username;
Email = userCreatedEvent.Email;
Password = userCreatedEvent.Password;
Roles = new HashSet <Role>();
}
public async Task UserCreatedAsync(UserCreatedEvent eventBody)
{
ServiceContract.RequireNotNull(eventBody, nameof(eventBody));
// TODO: implement
await Task.Yield();
}
public void Apply(UserCreatedEvent domainEvent)
{
this.FirstName = domainEvent.FirstName;
this.CountryCode = domainEvent.CountryCode;
this.LastName = domainEvent.LastName;
this.PhoneNumber = domainEvent.PhoneNumber;
this.PasswordHash = domainEvent.PasswordHash;
this.PasswordSalt = domainEvent.PasswordSalt;
}
public static UserStream UserCreatedEventToStream(UserCreatedEvent @event)
{
return(new UserStream(@event.UserId,
@event.Email,
@event.FirstName,
@event.MiddleName,
@event.LastName,
@event.ImagePath));
}
public void Apply(UserCreatedEvent @event)
{
Version++;
UserName = @event.UserName;
_Password = @event.Password;
_Properties["UserName"] = UserName;
}
private void When(UserCreatedEvent @event)
{
_userName = @event.UserName;
_password = @event.Password;
_email = @event.Email;
_name = @event.Name;
_isActive = @event.IsActive;
_roles = new List <string>();
}
public User Map(UserCreatedEvent @event)
{
return(new User
{
Guid = Guid.Parse(@event.Id),
Name = @event.Name,
Email = @event.Email
});
}
public User(string name)
{
var e = new UserCreatedEvent
{
Name = name,
TimeStamp = DateTime.UtcNow
};
ApplyEvent(e);
}
public void Apply(UserCreatedEvent @event)
{
Id = @event.Id;
Email = @event.Email;
FamilyName = @event.FamilyName;
GivenName = @event.GivenName;
PhoneNumber = @event.PhoneNumber;
Gender = @event.Gender;
Role = @event.Role;
}
public void When(UserCreatedEvent @event)
{
Id = @event.AggregateId;
UserName = @event.UserName;
Password = @event.Password;
Email = @event.Email;
Name = @event.Name;
IsActive = true;
CreationTime = DateTimeOffset.UtcNow;
Roles = Array.Empty <string>();
}
private void Apply(UserCreatedEvent @event)
{
FirstName = @event.FirstName;
LastName = @event.LastName;
Age = @event.Age;
Id = @event.Id;
City = @event.City;
EmailAddress = @event.EmailAddress;
MobileNumber = @event.MobileNumber;
Password = @event.Password;
}
private async Task SendUserCreatedEventAsync(Domain.AggregatesModel.UserAggregate.User user)
{
var @event = new UserCreatedEvent {
UserId = user.Id, NickName = user.Nickname, ChatServerUserId = user.ChatServerUserId
};
_messageSession = (IMessageSession)_serviceProvider.GetService(typeof(IMessageSession));
await _messageSession.Publish(@event);
_logger.LogInformation("----- Published UserCreatedEvent: {IntegrationEventId} from {AppName} - ({@IntegrationEvent})", @event.Id, Program.AppName, @event);
}
public void Create(Fullname fullname, Email email, Password password)
{
var @event = new UserCreatedEvent(
Id,
fullname.Firstname,
fullname.Lastname,
email.ToString(),
password.ToString());
Emit(@event);
}
public void Publish_ShouldCallRegisteredEvent()
{
bus = new InternalBus();
bus.ResetRoutes();
bus.RegisterEventHandler<UserCreatedEvent, CreateUserEventHandler>();
var newEvent = new UserCreatedEvent() { UserName = "******" };
CreateUserEventHandler.Called = false;
bus.Publish(newEvent);
Assert.IsTrue(CreateUserEventHandler.Called);
}
public void Handle(UserCreatedEvent message)
{
Data.CorrelationId = message.CorrelationId;
Data.UserId = message.UserId;
Data.Email = message.Email;
Data.FirstName = message.FirstName;
Data.SignUpDate = message.SignUpDate;
waitUntil = waitUntil.AddDays(45).NextWorkTime();
RequestUtcTimeout <UserCreatedFollowUpTimeoutData>(waitUntil);
}
/// <summary>
/// Crea una nueva instancia de <see cref="SuscriptionTest"/>
/// </summary>
public SuscriptionTest()
{
this.userCreatedEvent = new UserCreatedEvent()
{
Id = new Random().Next(1, 1000),
Age = (ushort)new Random().Next(1, 100),
Name = nameof(UserCreatedEvent.Name),
User = nameof(UserCreatedEvent.User),
};
this.userEventHandler = new UserEventHandler();
}
public void CreateUser(string userName, string shortName, string email, Role role)
{
var evt = new UserCreatedEvent()
{
UserName = userName,
ShortName = shortName,
email = email,
Role = role
};
AcceptChange(domainEvent: evt);
}
