public async Task <IActionResult> PutMessage([FromRoute] int id, [FromBody] Message message)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != message.MessageId)
{
return(BadRequest());
}
_context.Entry(message).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MessageExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <MessageDetailsResponse> Handle(MessageSendCommand request, CancellationToken cancellationToken)
{
var groupIds = request.Recipients.Where(x => x.Type == RecipientDto.RecipientType.Group)
.Select(x => x.Id)
.ToList();
var groupMembersIds = await context.RecipientGroupMembers.Where(x => groupIds.Contains(x.RecipientGroupId))
.Select(x => x.MemberId)
.ToListAsync(cancellationToken);
var message = new Message
{
Subject = request.Subject,
Text = request.Text,
SenderUserId = identityService.GetCurrentUserId(),
SentAt = DateTime.Now,
ReceiverUserMessages = request.Recipients
.Where(x => x.Type == RecipientDto.RecipientType.User)
.Select(x => x.Id)
.Concat(groupMembersIds)
.Distinct()
.Select(x => new UserMessage
{
UserId = x
})
.ToList()
};
context.Messages.Add(message);
await context.SaveChangesAsync(cancellationToken);
return(mapper.Map <MessageDetailsResponse>(message));
}
public async Task <int> Write(string message)
{
_db.Add(new Message()
{
MessageId = Guid.NewGuid(), CreateAt = DateTime.Now, Text = message
});
return(await _db.SaveChangesAsync());
}
public async Task <IActionResult> PostMessage([FromBody] Message message)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
_context.Messages.Add(message);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetMessage", new { id = message.Id }, message));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <bool> CreateMessage(Message message)
{
await _context.Messages.AddAsync(message);
if ((await _context.SaveChangesAsync()) == 1)
{
return(true);
}
else
{
return(false);
}
}
public async Task <Unit> Handle(RecipientGroupMemberRemoveCommand request, CancellationToken cancellationToken)
{
var membership = await context.RecipientGroupMembers.SingleOrDefaultAsync(
x => x.MemberId == request.MemberId && x.RecipientGroupId == request.GroupId, cancellationToken);
if (membership != null)
{
context.RecipientGroupMembers.Remove(membership);
await context.SaveChangesAsync(cancellationToken);
}
return(Unit.Value);
}
public async Task <bool> BlockUser(BlockList blockList)
{
await _context.BlockLists.AddAsync(blockList);
if ((await _context.SaveChangesAsync()) == 1)
{
return(true);
}
else
{
return(false);
}
}
public async Task <Unit> Handle(RecipientGroupMemberAddCommand request, CancellationToken cancellationToken)
{
var membership = new RecipientGroupMember
{
RecipientGroupId = request.GroupId,
MemberId = request.MemberId
};
context.RecipientGroupMembers.Add(membership);
await context.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
public async Task <Unit> Handle(RecipientGroupCreateCommand request, CancellationToken cancellationToken)
{
var currentUserId = identityService.GetCurrentUserId();
var group = new RecipientGroup
{
Name = request.Name,
UserId = currentUserId
};
context.RecipientGroups.Add(group);
await context.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
public async Task <MessageDetailsResponse> Handle(MessageGetQuery request, CancellationToken cancellationToken)
{
var message = await context.Messages.Include(x => x.SenderUser)
.Include(x => x.ReceiverUserMessages)
.ThenInclude(x => x.ClassRegisterUser)
.SingleAsync(x => x.Id == request.Id, cancellationToken);
var currentUserId = identityService.GetCurrentUserId();
var receiverUserMessage = message.ReceiverUserMessages.SingleOrDefault(x => x.UserId == currentUserId);
if (receiverUserMessage != null)
{
receiverUserMessage.IsRead = true;
}
await context.SaveChangesAsync(cancellationToken);
return(mapper.Map <MessageDetailsResponse>(message));
}
public async Task <User> RegisterAsync(User user, string password)
{
byte[] passwordHash, passwordSalt;
CreatePasswordHash(password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _context.Users.AddAsync(user);
if ((await _context.SaveChangesAsync()) == 1)
{
return(user);
}
else
{
return(null);
}
}
