public async Task Consume(ConsumeContext <DeleteUser> context)
{
var message = context.Message;
try
{
var user = await _userService.DeleteAsync(message.Username);
var @event = new UserDeleted
{
Id = user.Id,
Username = user.Username
};
await _bus.Publish(@event);
}
catch (Exception ex)
{
var domainException = ex as UserServiceException;
var failedEvent = new DeleteUserFailed
{
Id = domainException?.UserId,
Username = message.Username
};
await _bus.Publish(failedEvent);
throw;
}
}
/// <summary>
/// Deletes the specified <see cref="User"/>.
/// </summary>
/// <param name="name">The name of the User to delete.</param>
/// <returns>A Result containing the result of the operation.</returns>
public IResult DeleteUser(string name)
{
logger.EnterMethod(xLogger.Params(name));
logger.Info($"Deleting User '{name}'...");
IResult retVal = new Result();
IUser foundUser = default(User);
if (State != State.Running)
{
retVal.AddError($"The Manager is not in a state in which it can service requests (Currently {State}).");
}
else
{
foundUser = FindUser(name);
if (foundUser != default(User))
{
Configuration.Users.Remove((User)foundUser);
}
else
{
retVal.AddError($"The User '{name}' does not exist.");
}
}
if (retVal.ResultCode != ResultCode.Failure)
{
Task.Run(() => UserDeleted?.Invoke(this, new UserEventArgs(foundUser)));
}
retVal.LogResult(logger);
logger.ExitMethod();
return(retVal);
}
private void HandleEvent(UserDeleted <TKey> evt)
{
var(normalizedEmail, normalizedUser, logins, claims) = reverseLookup[evt.UserId];
existingEmails.Remove(normalizedEmail);
existingUserNames.Remove(normalizedUser);
foreach (var login in logins)
{
existingLogins.Remove(login);
}
foreach (var claim in claims)
{
if (usersByClaims.TryGetValue(claim.Type, out Dictionary <string, HashSet <TKey> > byType))
{
if (byType.TryGetValue(claim.Value, out HashSet <TKey> hs))
{
hs.Remove(evt.UserId);
if (hs.Count == 0)
{
byType.Remove(claim.Value);
}
}
if (byType.Count == 0)
{
usersByClaims.Remove(claim.Type);
}
}
}
reverseLookup.Remove(evt.UserId);
}
partial void OnHandle(UserDeleted @event)
{
Entities.UserEntity entity = UserRepository.Load(@event.Rsn);;
entity.IsLogicallyDeleted = true;
UserRepository.Update(entity);
}
/// <summary>
/// Deletes the user.
/// </summary>
public void DeleteUser()
{
this.IsNew = false;
this.IsDeleted = true;
var @event = new UserDeleted(this.Id);
this.ApplyChange(@event);
}
public void TestSerializationOfUserDeleted()
{
var evt = new UserDeleted();
var bytes = LZ4MessagePackSerializer.Serialize <IEvent>(evt, AspnetIdentityResolver.Instance);
var eventChk = LZ4MessagePackSerializer.Deserialize <IEvent>(bytes, AspnetIdentityResolver.Instance) as UserDeleted;
Assert.NotNull(eventChk);
}
public void TestSerializationOfUserDeleted1()
{
var userId = Guid.NewGuid();
var evt = new UserDeleted <Guid>(userId);
var bytes = LZ4MessagePackSerializer.Serialize <IEvent>(evt, AspnetIdentityResolver.Instance);
var eventChk = LZ4MessagePackSerializer.Deserialize <IEvent>(bytes, AspnetIdentityResolver.Instance) as UserDeleted <Guid>;
Assert.NotNull(eventChk);
Assert.Equal(evt.UserId, eventChk.UserId);
}
public void RemoveUser(int index)
{
try
{
this.Book.RemoveAt(index);
UserDeleted.Invoke();
}
catch (ArgumentOutOfRangeException)
{
Console.WriteLine("No such index. Can't delete.");
}
}
public async Task PublishUserDeleted(Guid id)
{
var options = new PublishOptions();
var @event = new UserDeleted
{
Id = id
};
options.SetMessageId(id.ToString());
await _endpoint.Publish(@event, options);
}
public void Handle(UserDeleted @event)
{
using (var context = new ProjectionContext(ConnectionString.Get()))
{
var entity = new UserSqlEntity()
{
Id = @event.AggregateId
};
context.Users.Attach(entity);
context.Users.Remove(entity);
context.SaveChanges();
}
}
public async Task <IActionResult> DeleteAsync(int id)
{
var deleteUser = await _userRepository.DeleteAsync(id, UserID);
if (deleteUser <= 0)
{
return(BadRequest());
}
var userDeletedEvent = new UserDeleted(id);
await _mediator.Publish(userDeletedEvent);
return(NoContent());
}
public async Task UserDeletedConsumeLocalMessage()
{
UserDeleted userDeleted = new UserDeleted()
{
Email = "*****@*****.**",
Username = "******",
Id = 1
};
var sub = new UserDeletedPubSubscriber(bus, dataContext);
await sub.Consume(userDeleted, new MessageContext()
{
GlobalRequestId = Guid.NewGuid()
});
}
public async Task UserDeletedConsumeMessage()
{
UserDeleted userDeleted = new UserDeleted()
{
Email = "*****@*****.**",
Username = "******",
Id = 1
};
var sub = new UserDeletedPubSubscriber(bus);
await sub.Consume(userDeleted, new MessageContext()
{
GlobalRequestId = Guid.NewGuid()
});
}
public async Task Consume(UserDeleted message, MessageContext context)
{
this.dataContext = DataUtility.GetDataContext(dataContext);
using (dataContext)
{
User user = dataContext.Users.SingleOrDefault(p => p.Email == message.Email);
if (user == null)
{
Exception ex = new Exception("User Created : not found by Email");
ex.Data.Add("Email", message.Email);
throw ex;
}
dataContext.Users.Remove(user);
await dataContext.SaveChangesAsync();
}
}
public async Task <IActionResult> DeleteMessage(UserDeleted message)
{
if (!message.messageType.Equals("UserDeleted"))
{
return(BadRequest());
}
var data = await _context.Messages.FindAsync(message.data.UserId);
if (data == null)
{
Notifiy(message.data.UserId, "No UserId Found");
return(NotFound());
}
_context.Messages.Remove(data);
await _context.SaveChangesAsync();
Notifiy(message.data.UserId, "Deleted");
return(Ok());
}
public void Apply(UserDeleted e)
{
}
public void Handle(UserDeleted message)
{
}
/// <summary>
/// Called when [user deleted].
/// </summary>
/// <param name="user">The user.</param>
private void OnUserDeleted(User user)
{
UserDeleted?.Invoke(this, new GenericEventArgs <User>(user));
}
/// <summary>
/// Called when [user deleted].
/// </summary>
/// <param name="user">The user.</param>
private void OnUserDeleted(User user)
{
UserDeleted?.Invoke(this, new GenericEventArgs <User> {
Argument = user
});
}
public void When(UserDeleted c)
{
Version = -1;
}
private void Persist(Content content, UserDeleted @event)
{
content.PlayCount--;
}
public void When(UserDeleted c)
{
Version = -1;
}
private async Task Handle(UserDeleted message)
{
await _dispatcher.BeginInvokeOnMainThread(async() => await _messenger.SendAsync(message));
}
public void Handle(UserDeleted evt)
{
_userRepository.Delete(evt.UserId);
}
protected void ProcessUserDeleted(UserDeleted @event)
{
this.Id = @event.UserId;
this.IsDeleted = @event.IsDeleted;
}
static string When(UserDeleted e)
{
return(string.Format("Deleted user {0} from security {1}", e.Id.Id, e.SecurityId.Id));
}
public void When(UserDeleted e)
{
_send.ToSecurity(new RemoveSecurityItem(e.SecurityId, e.Id));
}
static string When(UserDeleted e)
{
return string.Format("Deleted user {0} from security {1}", e.Id.Id, e.SecurityId.Id);
}
protected virtual void OnUserDeleted()
{
CreateNotification(EventActionType.Deleted);
UserDeleted?.Invoke(this, new NewNotificationEventArgs(this));
}
public int Serialize(ref byte[] bytes, int offset, UserDeleted <TKey> value, IFormatterResolver formatterResolver)
{
var formatter = formatterResolver.GetFormatter <TKey>();
return(formatter.Serialize(ref bytes, offset, value.UserId, formatterResolver));
}
public void Process(UserDeleted @event)
{
_users.DeleteUserById(@event.Id);
}
public void Handle(DeleteUser request)
{
var msg = new UserDeleted(request.Id);
Send(msg);
}
public void RemoveUser(User user)
{
this.Book.Remove(user);
UserDeleted.Invoke();
}
