public async Task <IActionResult> CreateMessage(int userId,
MessageForCreateDto messageForCreateDto)
{
var sender = await _repo.GetUser(userId);
if (sender.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageForCreateDto.SenderId = userId;
var recipient = await _repo.GetUser(messageForCreateDto.RecipientId);
if (recipient == null)
{
return(BadRequest("Could not find user"));
}
var message = _mapper.Map <Message>(messageForCreateDto);
_repo.Add(message);
if (await _repo.SaveAll())
{
var messageToReturn = _mapper.Map <MessageToReturnDto>(message);
return(CreatedAtRoute("GetMessage", new { userId, id = message.Id }, messageToReturn));
}
throw new Exception("Creating of message failed");
}
public async Task <IActionResult> CreateMessage([FromBody] MessageForCreateDto messageForCreateDto)
{
var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var userFromRepo = await _repo.GetUser(currentUserId);
if (userFromRepo == null)
{
return(Unauthorized());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var conversationFromRepo = await _repo.GetConversation((int)messageForCreateDto.ConversationId, currentUserId);
var messageForCreate = _mapper.Map <Message>(messageForCreateDto);
messageForCreate.Conversation = conversationFromRepo;
messageForCreate.User = userFromRepo;
var createdMessage = await _repo.CreateMessage(messageForCreate);
var messageForReturn = _mapper.Map <MessageForDetailedDto>(createdMessage);
return(Ok(messageForReturn));
}
public async Task SendMessage(MessageForCreateDto message)
{
var user = await context
.Users
.FirstOrDefaultAsync(u => u.Id == message.AuthorId);
var channel = await context
.Channels
.FirstOrDefaultAsync(c => c.Id == message.ChannelId);
if (user == null)
{
throw new NotFoundException("User not found!");
}
if (channel == null)
{
throw new NotFoundException("Channel not found!");
}
var messageToCreate = new Message(
channel,
user,
message.Content
);
context.Messages.Add(messageToCreate);
await context.SaveChangesAsync();
}
public async Task <IActionResult> CreateMessage(int userId, [FromBody] MessageForCreateDto msg)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var recipientId = _repo.GetUser(msg.RecipientId);
//var
if (recipientId == null)
{
return(BadRequest("Could not find recipient user."));
}
if (_repo.GetItem(msg.AboutItemId) == null)
{
return(BadRequest("Item doesn't exist."));
}
var message = _mapper.Map <Message>(msg);
message.Sender = _repo.GetUser(userId).Result;
_repo.Add(message);
var messageToReturn = _mapper.Map <MessageToReturnDto>(message);
if (await _repo.SaveAll())
{
return(CreatedAtRoute("GetMessage", new { id = message.Id }, messageToReturn));
}
return(BadRequest("Error while saving."));
}
public async Task <MessageForDetailDto> CreateMessage(MessageForCreateDto messageDto)
{
var messageEntity = _mapper.Map <Message>(messageDto);
messageEntity.DateTimeSent = DateTime.Now;
await _repo.Create(messageEntity);
await _repo.Save();
return(_mapper.Map <MessageForDetailDto>(messageEntity));
}
public IActionResult AddMessage(MessageForCreateDto messageForCreateDto)
{
try
{
var messageToCreate = _mapper.Map <CustMessage>(messageForCreateDto);
var result = _ctx.Messages.Add(messageToCreate);
_ctx.SaveChanges();
return(Ok(result.Entity));
}
catch (Exception ex)
{
return(BadRequest("Δεν έγινε η αποθήκευση του συστήματος"));
}
}
public async Task <ActionResult> PostMessage(MessageForCreateDto messageDto)
{
if (User.HasClaim(x => x.Type == ClaimTypes.NameIdentifier))
{
int tokenUserId = Int32.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
messageDto.SenderId = tokenUserId;
var newMessage = await _service.CreateMessage(messageDto);
return(CreatedAtAction("GetById", new { id = newMessage.MessageId }, newMessage));
}
else
{
return(Unauthorized());
}
}
public async Task <MessageForListDto> InsertMessage(Guid senderId, MessageForCreateDto messageForCreateDto, CancellationToken cancellationToken = default(CancellationToken))
{
var messageToCreate = new Message
{
Text = messageForCreateDto.Text,
SenderId = senderId,
ReceiverId = messageForCreateDto.ReceiverId
};
var messageFromRepo = await _messageRepository.InsertMessage(messageToCreate, cancellationToken);
var messageToReturn = _mapper.Map <MessageForListDto>(messageFromRepo);
return(messageToReturn);
}
public async Task <IActionResult> SendRequest([FromBody] MessageForCreateDto messageForCreateDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(messageForCreateDto));
}
try
{
var messageToReturn = await _messageService.InsertMessage(base.GetUserClaims().Id, messageForCreateDto);
await _hubContext.Clients.All.SendAsync("BroadcastMessage", messageToReturn);
//await _hubContext.Clients.All.BroadcastMessage(messageToReturn);
return(StatusCode(201));
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex.StackTrace);
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
public async Task <ActionResult <Message> > PostMessage(MessageForCreateDto message)
{
await repo.SendMessage(message);
return(Ok("Sent"));
}
public Task SendMessage(MessageForCreateDto messageForCreateDto)
{
return(Clients.Client(this.Context.ConnectionId).SendAsync("BroadcastMessage", messageForCreateDto));
}
