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