public IActionResult AddMessage(MessageModel messageModel)
{
try
{
if (messageModel == null)
{
return(BadRequest("Data is null."));
}
if (!ModelState.IsValid)
{
Errors errors = ErrorsHelper.GetErrors(ModelState);
return(BadRequest(errors));
}
string id = User.Identity.Name;
messageModel.userID = id;
MessageModel message = messagesRepository.AddMessage(messageModel);
return(StatusCode(StatusCodes.Status201Created, message));
}
catch (Exception ex)
{
Errors errors = ErrorsHelper.GetErrors(ex);
return(StatusCode(StatusCodes.Status500InternalServerError, errors));
}
}
public async Task SendTo(string recieverId, string message, string localDate)
{
var posixTime = DateTime.SpecifyKind(new DateTime(1970, 1, 1), DateTimeKind.Utc);
var localDateParsed = posixTime.AddMilliseconds(Convert.ToInt64(localDate));
var senderUser = await _userManager.GetUserAsync(Context.User);
var senderId = senderUser.Id;
var senderEmail = await _userManager.GetEmailAsync(senderUser);
var recieverEmail = _userManager.Users.Where(u => u.Id == recieverId).FirstOrDefault().Email;
DateTime localTime = DateTime.Now;
var reciever = new User {
Id = recieverId,
Email = recieverEmail
};
var sender = new User {
Id = senderId,
Email = senderEmail
};
var receiverConId = await GetConnectionId(recieverId);
var isUnread = receiverConId == null;
_messagesRepository.AddMessage(sender, reciever, message, localDateParsed, isUnread);
}
public async Task <ActionResult <MessageDto> > CreateMessage(CreateMessageDto createMessageDto)
{
var currentUsername = User.GetUsername();
if (currentUsername == createMessageDto.RecipientUsername)
{
return(BadRequest("You cannot send messages to yourself"));
}
var sender = await _userRepository.GetUserByUsernameAsync(currentUsername);
var recipient = await _userRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername);
var message = new Message
{
Sender = sender,
Recipient = recipient,
SenderUsername = sender.UserName,
RecipientUsername = recipient.UserName,
Content = createMessageDto.Content,
};
_messagesRepository.AddMessage(message);
if (await _messagesRepository.SaveAllAsync())
{
return(Ok(_mapper.Map <MessageDto>(message)));
}
return(BadRequest("Failed to send message"));
}
public async Task SendMessage(CreateMessageDto createMessageDto)
{
var username = Context.User.GetUsername();
if (username == createMessageDto.RecipientUsername)
{
throw new HubException("You cannot send message to yourself");
}
var sender = await userRepository.GetUserByUsernameAsync(username);
var recipient = await userRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername);
if (recipient == null)
{
throw new HubException("Not found user");
}
var message = new Message
{
Content = createMessageDto.Content,
Sender = sender,
Recipient = recipient,
SenderUsername = sender.UserName,
RecipientUsername = recipient.UserName
};
var groupName = GetGroupName(sender.UserName, recipient.UserName);
var group = await messageRepository.GetMessageGroup(groupName);
if (group.Connections.Any(x => x.Username == recipient.UserName))
{
message.DateRead = DateTime.UtcNow;
}
else
{
var connections = await presenceTracker.GetConnectionsForUser(recipient.UserName);
if (connections != null)
{
await presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived",
new { username = sender.UserName, KnownAs = sender.KnownAs });
}
}
messageRepository.AddMessage(message);
if (await messageRepository.SaveAllAsync())
{
await Clients.Group(groupName).SendAsync("NewMessage", mapper.Map <MessageDto>(message));
}
}
public IActionResult Post(string recipient, Message message)
{
try
{
var result = _repository.AddMessage(recipient, message);
return(Ok(result));
}
catch (Exception ex)
{
_logger.LogError($"Exception in MessagesController.Post(). message: [{message}]", ex);
return(StatusCode(500));
}
}
public async Task <ActionResult> CreateMessage([FromBody] MessageRequestDTO requestDTO)
{
var senderUsername = User.GetUsername();
if (senderUsername == requestDTO.RecipientUsername)
{
return(BadRequest("You can't message yourself"));
}
var sender = await _userRepository.GetUserByUsernameAsync(senderUsername);
var recipient = await _userRepository.GetUserByUsernameAsync(requestDTO.RecipientUsername);
if (recipient == null)
{
return(NotFound("Recipient not found"));
}
var message = new Message
{
Content = requestDTO.Content,
Sender = sender,
SenderUsername = sender.UserName,
Recipient = recipient,
RecipientUsername = recipient.UserName,
};
_messageRepository.AddMessage(message);
if (await _messageRepository.SaveAllAsync())
{
return(Ok(new MessageDTO
{
Id = message.Id,
Content = requestDTO.Content,
SenderId = sender.Id,
SenderUsername = sender.UserName,
SenderPhotoUrl = sender.Photos.FirstOrDefault(x => x.IsMain).Url,
RecipientId = recipient.Id,
RecipientUsername = recipient.UserName,
RecipientPhotoUrl = recipient.Photos.FirstOrDefault(x => x.IsMain).Url,
DateSent = message.DateSent
}));
}
return(BadRequest("Unable to send message to user"));
}
public IActionResult CreateMessage([FromBody] Message message)
{
if (message == null)
{
return(BadRequest());
}
message.Date = DateTime.Now;
_messagesRepository.AddMessage(message);
if (!_messagesRepository.Save())
{
throw new Exception("Failed to save changes");
}
return(CreatedAtRoute("GetMessage", new { id = message.Id }, message));
}
public HttpResponseMessage AddMessage(MessageModel messageModel)
{
try
{
HttpResponseMessage hrm = new HttpResponseMessage(HttpStatusCode.Created)
{
Content = new StringContent(JsonConvert.SerializeObject(messagesRepository.AddMessage(messageModel)))
};
return(hrm);
}
catch (Exception ex)
{
Errors errors = ErrorsHelper.GetErrors(ex);
HttpResponseMessage hr = new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(errors.ToString())
};
return(hr);
}
}
public HttpResponseMessage AddMessage(MessageModel messageModel)
{
try
{
if (messageModel == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Data is null."));
}
if (!ModelState.IsValid)
{
Errors errors = ErrorsHelper.GetErrors(ModelState);
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
MessageModel message = messagesRepository.AddMessage(messageModel);
return(Request.CreateResponse(HttpStatusCode.Created, message));
}
catch (Exception ex)
{
Errors errors = ErrorsHelper.GetErrors(ex);
return(Request.CreateResponse(HttpStatusCode.InternalServerError, errors));
}
}
public async Task <ActionResult <MessageDto> > CreateMessage(CreateMessageDto createMessageDto)
{
var username = User.GetUserName();
if (username == createMessageDto.RecipientUsername.ToLower())
{
return(BadRequest("You cannot send messages to yourself"));
}
var sender = await _userRepository.GetUserByUsernameAsync(username);
var recipient = await _userRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername);
if (recipient is null)
{
return(NotFound());
}
var message = new Message
{
Sender = sender,
SenderId = sender.Id,
SenderUsername = username,
Recipient = recipient,
RecipientId = recipient.Id,
RecipientUsername = recipient.UserName,
Content = createMessageDto.Content
};
_messagesRepository.AddMessage(message);
if (await _messagesRepository.SaveAllAsync())
{
return(Ok(_mapper.Map <MessageDto>(message)));
}
return(BadRequest("Unable to save message"));
}
public async Task <ActionResult <MessageDto> > AddMessage(CreateMessageDto createMessageDto)
{
var username = User.GetUsername();
if (username == createMessageDto.RecipientUsername)
{
BadRequest("You cannot send message to yourself");
}
var sender = await userRepository.GetUserByUsernameAsync(username);
var recipient = await userRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername);
if (recipient == null)
{
return(NotFound());
}
var message = new Message
{
Content = createMessageDto.Content,
Sender = sender,
Recipient = recipient,
SenderUsername = sender.UserName,
RecipientUsername = recipient.UserName
};
messageRepository.AddMessage(message);
if (await messageRepository.SaveAllAsync())
{
return(Ok(mapper.Map <MessageDto>(message)));
}
return(BadRequest("Failed to add message"));
}
public async Task <ActionResult <AppUserMessagesResponse> > CreateMessage([FromBody] AppUserMessagesRequest request)
{
var userName = User.GetUserName();
if (userName == request.RecipientUserName.ToLowerInvariant())
{
return(BadRequest("You cannot send messages to yourself"));
}
var sender = await GetUser(userName).ConfigureAwait(false);
var recipient = await GetUser(request.RecipientUserName).ConfigureAwait(false);
if (recipient == null)
{
return(NotFound());
}
var message = new Message
{
Sender = sender,
Recipient = recipient,
SenderUserName = sender.UserName,
RecipientUserName = recipient.UserName,
Content = request.Content
};
_messagesRepository.AddMessage(message);
if (await _messagesRepository.SaveAllAsync())
{
return(Ok(_mapper.Map <AppUserMessagesResponse>(message)));
}
return(BadRequest("Failed to send message"));
}
/// <summary>
/// Post api/messages отправка сообщения
/// </summary>
/// <param name="value">Сообщение</param>
/// <returns>Успешность выполнения</returns>
public IHttpActionResult Post([FromBody] Message value)
{
_messagesRepository.AddMessage(value);
return(Ok());
}
