public async Task <IActionResult> CreateMessage(int userId, MessageCreationDto messageCreationDto)
{
var sender = await _repo.GetUser(userId, false);
if (sender.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageCreationDto.IdSender = userId;
var recipient = await _repo.GetUser(messageCreationDto.RecipientId, false);
if (recipient == null)
{
return(BadRequest("nie znaleziono użytkownika"));
}
var message = _mapper.Map <Message>(messageCreationDto);
_repo.Add(message);
if (await _repo.SaveAll())
{
var messageToReturn = _mapper.Map <MessageDto>(message);
return(CreatedAtRoute("GetMessage", new { id = message.Id }, messageToReturn));
}
throw new Exception("wiadomość nie została zapisana");
}
public MessageDto AddNewMessage(int lobbyId, int userId, MessageCreationDto message)
{
try
{
var existingLobby = _lobbyRepository.GetLobbyWithJoinRequestById(lobbyId);
if (existingLobby == null)
{
Logger.LogWarning(LoggingEvents.CustomServiceEvents.NewMessageAddError, "Lobby with id = {ID} was not found", lobbyId);
return(null);
}
if (userId != existingLobby.HostId && existingLobby.JoinRequests.Where(u => u.UserId == userId).Count() == 0)
{
return(null);
}
var newMessage = Mapper.Map <Message>(message);
newMessage.LobbyId = lobbyId;
newMessage.SenderId = userId;
Repository.Add(newMessage);
Repository.SaveChanges();
return(Mapper.Map <MessageDto>(newMessage));
}
catch (Exception e)
{
Logger.LogError(LoggingEvents.CustomServiceEvents.NewMessageAddError, e,
"Error addind new message on the lobby with id = {LOBBYID}, by user with id = {USERID}", lobbyId, userId);
return(null);
}
}
public IActionResult Post([FromBody] MessageCreationDto request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var recipient = _repo.GetUser(request.RecipientId);
var sender = _repo.GetUser(request.SenderId);
if (recipient == null)
{
return(BadRequest($"Could not find user {request.RecipientId}"));
}
var message = JObject.FromObject(request, new JsonSerializer {
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
}).ToObject <Message>();
message.Id = Guid.NewGuid().ToString();
_repo.Add(message);
_repo.CompleteAsync();
_chatHub.Clients.User(message.RecipientId).SendAsync("MessageReceived", message);
return(Ok());
}
public async Task <IActionResult> CreateMessage(int userId, MessageCreationDto messageDto)
{
var sender = await this.repo.GetUser(userId);
if (sender.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageDto.SenderId = userId;
var recipient = await this.repo.GetUser(messageDto.RecipientId);
if (recipient == null)
{
return(BadRequest("Could not find user"));
}
var message = this.mapper.Map <Message>(messageDto);
this.repo.Add(message);
if (await this.repo.SaveAll())
{
var messageToReturn = this.mapper.Map <MessageToReturnDto>(message);
return(CreatedAtRoute("GetMessage", new { id = message.Id }, messageToReturn));
}
throw new Exception("Creating the message failed on save");
}
public async Task <IActionResult> CreateMessage(Guid userId, MessageCreationDto messageCreationDto)
{
User sender = await _repository.GetUser(userId, false);
if (sender?.Id != Guid.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageCreationDto.SenderId = userId;
User recipient = await _repository.GetUser(messageCreationDto.RecipientId, false);
if (recipient == null)
{
return(BadRequest("Could not find user"));
}
Message message = _mapper.Map <Message>(messageCreationDto);
_repository.Add(message);
if (await _repository.SaveAll())
{
MessageReturnDto messageReturnDto = _mapper.Map <MessageReturnDto>(message);
return(CreatedAtRoute("GetMessage", new { id = message.Id }, messageReturnDto));
}
throw new Exception("Creating the message failed on save");
}
public async Task <IActionResult> PostMessage([FromBody] MessageCreationDto MessageDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(new { message = ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage) }));
}
var createMessage = _mapper.Map <Message>(MessageDto);
try
{
var createdMessage = await _chatService.PostMessage(createMessage);
return(Ok(createdMessage));
}
catch (UserNotFound)
{
return(NotFound(new MessageObj("User not found")));
}
catch (EnvironmentNotSet)
{
throw;
}
catch (Exception e)
{
return(BadRequest(new MessageObj(e.Message)));
}
}
public IActionResult AddNewMessage(int?lobbyId, [FromBody] MessageCreationDto message)
{
if (!lobbyId.HasValue)
{
return(BadRequest());
}
int userId = _authorizationService.GetUserId(User);
var newMessage = _messageService.AddNewMessage(lobbyId.Value, userId, message);
if (newMessage == null)
{
return(Unauthorized());
}
return(CreatedAtRoute("GetMessage", new { lobbyId, id = newMessage.Id }, newMessage));
}
public async Task <IActionResult> CreateMessage(int userId, MessageCreationDto messageForCreation)
{
var sender = await _repo.GetUser(userId, false);
if (sender.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageForCreation.SenderId = userId;
var recipient = await _repo.GetUser(messageForCreation.RecipientId, false);
if (recipient == null)
{
return(BadRequest("User not found"));
}
var message = _mapper.Map <Message>(messageForCreation);
_repo.Add(message);
if (await _repo.SaveAll())
{
var messageToReturn = _mapper.Map <MessageToReturnDto>(message);
try
{
await _messageHub.Clients.User(messageToReturn.SenderId.ToString()).SendAsync("newMessage", messageToReturn);
await _messageHub.Clients.User(messageToReturn.RecipientId.ToString()).SendAsync("newMessage", messageToReturn);
}
catch (Exception e)
{
throw new Exception(e.ToString());
}
return(CreatedAtRoute("GetMessage", new { id = message.Id }, messageToReturn));
}
throw new Exception("Could not save the message");
}
public IActionResult SendRequest([FromBody] MessageCreationDto msg)
{
_hubContext.Clients.All.SendAsync("MessageReceived", msg);
return(Ok());
}
public async Task SendMessage(MessageCreationDto msg)
{
await Clients.User(msg.RecipientId).SendAsync("MessageReceived", msg);
}
