/// <summary>
/// It doesn't cache user profiles
/// </summary>
/// <param name="uow"></param>
/// <param name="userDto"></param>
protected void CacheUserDto(IdentityUow uow, UserDto userDto)
{
if (userDto == null)
{
return;
}
uow.Cache.SetCachedItemAsync(CacheKeyHelper.GetCacheKey <UserDto>(userDto.Key), userDto);
uow.Cache.SetCachedItemAsync(CacheKeyHelper.GetCacheKey <UserDto>(userDto.Username), userDto);
uow.Cache.SetCachedItemAsync(CacheKeyHelper.GetCacheKey <UserDto>(userDto.Email), userDto);
uow.Cache.SetCachedItemAsync(
CacheKeyHelper.GetCacheKey <UserDto>(userDto.Mobile.LocalNumberWithAreaCode), userDto);
uow.Cache.SetCachedItemAsync(
CacheKeyHelper.GetCacheKey <UserDto>(userDto.Mobile.LocalNumberWithAreaCodeInDigits), userDto);
var userUpdatedEvent = new UserUpdatedEvent {
UpdatedUser = userDto
};
var userProfile = GetUserProfile(userDto.Key, _userProfileConfig.UserProfileOriginator);
if (!string.IsNullOrWhiteSpace(userProfile?.Body))
{
var basicMemberInfo = Serializer.Deserialize <BasicMemberInfo>(userProfile.Body);
userUpdatedEvent.Roles = basicMemberInfo.Roles;
}
DispatchEvent(userUpdatedEvent);
}
public void Process(UserUpdatedEvent @event)
{
var user = _users.GetById(@event.Id);
if (user == null)
{
user = new User()
{
Id = @event.Id,
Name = @event.Name,
PhoneNumber = @event.PhoneNumber,
Email = @event.Email,
Geo = @event.Geo,
RecipientType = @event.UserType
};
}
else
{
user.Id = @event.Id;
user.Name = @event.Name;
user.PhoneNumber = @event.PhoneNumber;
user.Email = @event.Email;
user.Geo = @event.Geo;
user.RecipientType = @event.UserType;
}
_users.Save(user);
}
public void Handle(UserUpdatedEvent @event)
{
var account = AccountInfos.FirstOrDefault(x => x.Id == @event.UserId);
if (account != null)
{
}
}
private void Apply(UserUpdatedEvent @event)
{
FirstName = @event.FirstName;
LastName = @event.LastName;
Email = @event.Email;
Position = @event.Position;
Department = @event.Department;
IsAdmin = @event.IsAdmin;
}
public async Task HandleAsync(UserUpdatedEvent domainEvent)
{
var user = await _userRepository.GetByIdAsync(domainEvent.AggregateId);
user.EmailAddress = domainEvent.EmailAddress;
user.Status = domainEvent.UserStatus.ToString();
await _userRepository.UpdateAsync(user);
}
private void HandleUserUpdatedEvent(UserUpdatedEvent e)
{
UserState cs = e.ResultUserState;
UserListItem newUserListItem = UserListItem.GenerateUserListItemFromUserState(cs);
UserListUpdateCommand newCLUC = new UserListUpdateCommand(newUserListItem, e.User, e.ConnectionId);
_logger.Info($"Updating User list Id:{cs.Id} UserName:{cs.UserName}.");
Persist <UserListUpdateCommand>(newCLUC, postUserListItemUpdateHandler);
}
private async Task SendUserUpdatedEventAsync(Guid userId, string nickName, string avatar, UserType?userType)
{
UserUpdatedEvent @event = new UserUpdatedEvent {
UserId = userId, NickName = nickName, Avatar = avatar, UserType = (int?)userType
};
_messageSession = (IMessageSession)_serviceProvider.GetService(typeof(IMessageSession));
await _messageSession.Publish(@event);
_logger.LogInformation("----- Published UserUpdatedEvent: {IntegrationEventId} from {AppName} - ({@IntegrationEvent})", @event.Id, Program.AppName, @event);
}
public IExecutionResult Create(UpdateUserCommand command)
{
var @event = new UserUpdatedEvent(
command.Id,
command.FirstName
);
Emit(@event);
return(ExecutionResult.Success());
}
private string Descriptify <T>(UserUpdatedEvent e) where T : UserUpdatedEvent
{
return(JsonConvert.SerializeObject(new
{
e.FirstName,
e.LastName,
e.Email,
e.Department,
e.Position,
e.IsAdmin,
}));
}
public async Task UserUpdatedEventHandler_Consume_Updates_Name()
{
AuthenticationContext.OpenInMemoryConnection();
try
{
var userUpdatedEvent = new UserUpdatedEvent
{
UserKey = Guid.NewGuid(),
FirstName = "Ellen",
LastName = "Doe",
EmailAddress = "*****@*****.**"
};
var user = new User
{
UserKey = userUpdatedEvent.UserKey,
Name = "John Doe"
};
var credential = new Credential
{
CredentialType = CredentialType.Email,
User = user,
Identifier = "*****@*****.**"
};
using (var context = AuthenticationContext.GetInMemoryContext())
{
context.Users.Add(user);
context.Credentials.Add(credential);
context.SaveChanges();
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
var handler = new UserUpdatedEventHandler(context);
await handler.ConsumeAsync(userUpdatedEvent);
}
using (var context = AuthenticationContext.GetInMemoryContext())
{
Assert.AreEqual("Ellen Doe", context.Users.Single().Name);
Assert.AreEqual("*****@*****.**", context.Credentials.Single().Identifier);
}
}
finally
{
AuthenticationContext.CloseInMemoryConnection();
}
}
public async Task UserUpdatedEventHandler_Consume_Updates_Name()
{
CharityActionContext.OpenInMemoryConnection();
try
{
var userUpdatedEvent = new UserUpdatedEvent
{
UserKey = Guid.NewGuid(),
FirstName = "Ellen",
LastName = "Doe",
EmailAddress = "*****@*****.**",
ProfileImage = "new image"
};
var charity = new Charity
{
CharityKey = Guid.NewGuid()
};
var charityAction = new CharityAction
{
OrganiserUserKey = userUpdatedEvent.UserKey,
OrganiserUserName = "******",
OrganiserImage = "old image",
Charity = charity
};
using (var context = CharityActionContext.GetInMemoryContext())
{
context.CharityActions.Add(charityAction);
context.SaveChanges();
}
using (var context = CharityActionContext.GetInMemoryContext())
{
var handler = new UserUpdatedEventHandler(context);
await handler.ConsumeAsync(userUpdatedEvent);
}
using (var context = CharityActionContext.GetInMemoryContext())
{
Assert.AreEqual("Ellen Doe", context.CharityActions.Single().OrganiserUserName);
Assert.AreEqual("new image", context.CharityActions.Single().OrganiserImage);
}
}
finally
{
CharityActionContext.CloseInMemoryConnection();
}
}
public async Task UserUpdatedEventHandler_Handle_Returns_Success()
{
DonationsContext.OpenInMemoryConnection();
try
{
var user = new User {
UserKey = Guid.NewGuid(),
ProfileImage = "PrettyImage",
UserName = "******"
};
var Event = new UserUpdatedEvent()
{
UserKey = user.UserKey,
AddressLine1 = "AddressLine1",
AddressLine2 = "AddressLine2",
ProfileImage = "UglyImage",
BirthDate = DateTime.UtcNow,
City = "TestCity",
Country = "TestCountry",
EmailAddress = "*****@*****.**",
FirstName = "FirstTest",
LastName = "LastTest",
PhoneNumber = "0600000000"
};
using (var context = DonationsContext.GetInMemoryContext())
{
context.Users.Add(user);
await context.SaveChangesAsync();
var handler = new UserUpdatedEventHandler(context);
await handler.ConsumeAsync(Event);
}
using (var context = DonationsContext.GetInMemoryContext())
{
Assert.AreEqual(1, context.Users.Count());
Assert.AreEqual(Event.FirstName + " " + Event.LastName, context.Users.Single().UserName);
Assert.AreEqual(Event.ProfileImage, context.Users.Single().ProfileImage);
Assert.AreEqual(Event.UserKey, context.Users.Single().UserKey);
}
}
finally
{
DonationsContext.CloseInMemoryConnection();
}
}
public async Task <ApplicationUser> EditUserAsync(EditUserRequest request, [CurrentUserGlobalState] CurrentUser currentUser)
{
ApplicationUser user = await _context.Users.SingleAsync(applicationUser => applicationUser.Id == currentUser.UserId.ToString());
user.Name = request.Name;
user.PhoneNumber = request.PhoneNumber;
_context.Update(user);
var evt = new UserUpdatedEvent(user.Id, user.Name, user.PhoneNumber);
await _eventService.SaveEventAndDbContextChangesAsync(evt);
await _eventService.PublishEventAsync(evt);
return(user);
}
public Task ExecuteAsync(HookType type, IDomainEntityContext <User> context, CancellationToken cancellationToken)
{
switch (context.EditMode)
{
case EditMode.Create:
context.AddEventAsync(UserCreatedEvent.Create(_correlationIdProvider.Id, context.Entity.Id, _currentUser.Id), cancellationToken);
break;
case EditMode.Update:
context.AddEventAsync(UserUpdatedEvent.Create(_correlationIdProvider.Id, context.Entity.Id, _currentUser.Id), cancellationToken);
break;
case EditMode.Delete:
context.AddEventAsync(UserDeletedEvent.Create(_correlationIdProvider.Id, context.Entity.Id, _currentUser.Id), cancellationToken);
break;
}
return(Task.CompletedTask);
}
public async Task UserUpdatedEventHandler_Consume_Event_Has_No_UserKey()
{
StoryContext.OpenInMemoryConnection();
try
{
var userUpdatedEvent = new UserUpdatedEvent
{
UserKey = Guid.Empty,
FirstName = "Ellen",
LastName = "Doe",
ProfileImage = "new image"
};
var charityAction = new User
{
UserKey = Guid.NewGuid(),
Name = "John Doe",
ProfileImage = "old image"
};
using (var context = StoryContext.GetInMemoryContext())
{
context.Users.Add(charityAction);
context.SaveChanges();
}
using (var context = StoryContext.GetInMemoryContext())
{
var handler = new UserUpdatedEventHandler(context);
await handler.ConsumeAsync(userUpdatedEvent);
}
using (var context = StoryContext.GetInMemoryContext())
{
Assert.AreEqual("John Doe", context.Users.Single().Name);
Assert.AreEqual("old image", context.Users.Single().ProfileImage);
}
}
finally
{
StoryContext.CloseInMemoryConnection();
}
}
public async Task UserUpdatedEventHandler_Consume_Event_Has_No_UserKey()
{
CharityContext.OpenInMemoryConnection();
try
{
var userUpdatedEvent = new UserUpdatedEvent
{
UserKey = Guid.Empty,
FirstName = "Ellen",
LastName = "Doe"
};
var charity = new Charity
{
OwnerUserKey = Guid.NewGuid(),
OwnerUserName = "******"
};
using (var context = CharityContext.GetInMemoryContext())
{
context.Charities.Add(charity);
context.SaveChanges();
}
using (var context = CharityContext.GetInMemoryContext())
{
var handler = new UserUpdatedEventHandler(context);
await handler.ConsumeAsync(userUpdatedEvent);
}
using (var context = CharityContext.GetInMemoryContext())
{
Assert.AreEqual("John Doe", context.Charities.Single().OwnerUserName);
}
}
finally
{
CharityContext.CloseInMemoryConnection();
}
}
public bool TranslateAkkaUpdateEventToExternalMessage(CommandEventMessage internalCommandEvent)
{
UserUpdatedEvent e = internalCommandEvent as UserUpdatedEvent;
HTTPExternalInterface.HandleEDStateMessage(
new HTTPDestinedCommandStateEvent(
MicroServices.ProcessingStatus.Processed,
e.Message,
new HTTPSourcedCommand(
e.CommandType.ToString(),
e.Area.ToString(),
null,
e.ResultUserState,
e.User,
e.ConnectionId,
e.Id
)
),
false //User only?
);
return(true);
}
public Task Handle(UserUpdatedEvent message, CancellationToken cancellationToken)
{
// Send some greetings e-mail
return(Task.CompletedTask);
}
public void Apply(UserUpdatedEvent domainEvent)
{
this.FirstName = domainEvent.FirstName;
}
public Task Handle(UserUpdatedEvent notification, CancellationToken cancellationToken)
{
return(Task.CompletedTask);
}
private void UpdateFrom(UserUpdatedEvent @event)
{
Id = @event.UserId;
_name = @event.Name;
_email = @event.Email;
}
public void Handle(UserUpdatedEvent message)
{
}
public Task Handle(UserUpdatedEvent message, CancellationToken cancellationToken)
{
// Faça o pós adição, atualizar cache ou algo parecido??
return(Task.CompletedTask);
}
public async Task HandleAsync(UserUpdatedEvent args)
{
await SendNotificationAsync <Guid?, User, UserDto>(args, args.User, args.User.FullName);
}
