public async Task <IActionResult> UserPostMessages(
string username,
[FromQuery(Name = "latest")] int?latestMessage,
[FromBody] PostMessageDto postMessageDto
)
{
await UpdateLatest(latestMessage ?? postMessageDto.Latest);
if (!IsRequestFromSimulator())
{
return(NotAuthorizedError());
}
var user = await _userRepository.ReadAsyncByUsername(username);
if (user == null)
{
LogRequestInfo($"Tried to post message for non existing user \"{username}\".");
return(NotFound());
}
if (postMessageDto?.Content == null)
{
LogRequestInfo("Tried to post null message.");
return(BadRequest());
}
LogRequestInfo($"\"{username}\" posted tweet \"{postMessageDto.Content}\".");
await _messageRepository.CreateAsync(postMessageDto.ToMessage(user));
return(StatusCode(204, ""));
}
public async Task <Message> CreateAsync(Message dto, Action <string, string> AddErrorMessage)
{
ApplicationUser user = await _userManager.GetUserAsync(_httpContextAccessor.HttpContext.User);
if (user == null)
{
AddErrorMessage?.Invoke("General", "Only Logged-in user can perform this operation");
return(null);
}
MessageEntity entity = _mappingService.DtoToEntity(dto);
Chatroom chatroom = await _chatroomService.GetAsync(entity.ChatroomID);
if (user.Id != chatroom.OwnerID)
{
AddErrorMessage?.Invoke("General", "Only Owner of a Chatroom can add participants!");
return(null);
}
MessageEntity createdEntity = await _repository.CreateAsync(entity);
if (createdEntity != null)
{
await _context.SaveChangesAsync();
}
createdEntity = await _repository.GetCompleteAsync(createdEntity.ID);
return(_mappingService.EntityToDto(createdEntity));
}
public async Task <MessageDto> AddMessage(string userId, string roomId, string text)
{
if (!(await roomRepo.FindByIdAsync(roomId) is ChatRoomEntity chatRoom))
{
return(null);
}
if (!(await userRepo.FindByIdAsync(userId) is UserEntity user))
{
return(null);
}
var newMessage = new MessageEntity
{
ChatRoomId = chatRoom.Id,
SenderUserId = user.Id,
SendDate = DateTime.Now,
Text = text
};
int id = await messageRepo.CreateAsync(newMessage);
MessageEntity message = await messageRepo.FindByIdAsync(id);
MessageDto model = mapper.Map <MessageEntity, MessageDto>(message);
await this.notificator.Notificate(new MessageNotification(model, model.ChatRoom.Participants.Select(x => x.Id)));
return(model);
}
/// <inheritdoc />
public async Task AddToStarboard(IGuild guild, IUserMessage message, string content, Embed embed)
{
var starChannel = await GetStarboardChannel(guild);
var starEntry = await starChannel.SendMessageAsync(content, false, embed);
using (var transaction = await _messageRepository.BeginMaintainTransactionAsync())
{
if (await _messageRepository.GetMessage(message.Id) == null)
{
var creationData = new MessageCreationData
{
Id = message.Id,
GuildId = guild.Id,
ChannelId = message.Channel.Id,
AuthorId = message.Author.Id,
Timestamp = message.Timestamp,
};
await _messageRepository.CreateAsync(creationData);
}
await _messageRepository.UpdateStarboardColumn(message.Id, starEntry.Id);
transaction.Commit();
}
}
public async Task <IActionResult> Send(MessageComposeDto model, string sendTo)
{
if (string.IsNullOrEmpty(sendTo))
{
ViewBag.Error = "Niste naveli korisničko ime kome je upućena poruka";
return(View("Compose", model));
}
var senderId = User.Claims.FirstOrDefault(c => c.Type == "Id").Value;
var receiverId = (await userRepository.GetByUsernameAsync(sendTo)).Id;
var message = new Message
{
Id = Guid.NewGuid().ToString("N"),
Subject = model.Subject,
Text = model.Text,
SenderId = senderId,
ReceiverId = receiverId
};
try
{
await messageRepository.CreateAsync(message);
return(RedirectToAction("Outbox", "Messages"));
}
catch (Exception e)
{
ViewBag.Error = e.Message;
return(View("Compose", model));
}
}
public async Task <string> Handle(AddMessageCommand request, CancellationToken cancellationToken)
{
var newMessage = _mapper.Map <Message>(request);
newMessage = await _messageRepository.CreateAsync(newMessage);
return(newMessage.Id.ToString());
}
public async Task <ResponseModel <string> > CreateAsync(MessageModel messageModel)
{
var result = await _messageRepository.CreateAsync(MapToMessage.MapToMessageEntity(messageModel));
if (result)
{
return(new GetResponse <string>("").GetSuccessResponse());
}
return(new GetResponse <string>("").GetErrorResponse("Error, when try to create"));
}
public async Task <IActionResult> user_post_message([FromBody] SimulationMessageCreateDTO message, string username)
{
await write_latest();
var id = await MessageRepo.CreateAsync(message.Content, username);
if (id == -1)
{
return(BadRequest("Message could not be recorded"));
}
return(Ok("Message recorded"));
}
public async Task <IActionResult> PostMessageAsync([FromForm] MessageCreateRequestDTO message)
{
await CheckSessionForUser();
var id = await MessageRepo.CreateAsync(message.Text, user.username);
if (id == -1)
{
return(BadRequest());
}
return(Redirect("/"));
}
public async Task Send(NewMessageDto dto)
{
var currentUser = await GetCurrentUserAsync();
var recipients = conversationRepository.GetConversationUsersAsync(currentUser.Id, dto.ConversationId);
if (recipients.Length == 0)
{
return;
}
var message = messageRepository.CreateAsync(dto.ConversationId, currentUser.Id, dto.Text);
Broastcast("message.sent", message.ToDto(), recipients);
}
public async Task <IActionResult> PostMessage(Message message, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
if (!int.TryParse(userId, out var actualId))
{
return(View("Index"));
}
message.AuthorId = actualId;
message.Author = await _userRepository.ReadAsync(actualId);
message.PubDate = DateTime.Now;
await _messageRepository.CreateAsync(message);
return(RedirectToAction(nameof(Index), "Home"));
}
public async Task <SendMailPayload> SendGroupMailAsync(string subject, string body, List <string> addresses, CancellationToken cancellationToken)
{
Mail newMail;
try
{
var message = new Message()
{
Subject = subject, BodyText = body
};
var messageId = await _messageRepository.CreateAsync(message);
newMail = new Mail()
{
Message = message
};
await _mailRepossitory.CreateAsync(newMail);
}
catch (Exception ex)
{
return(new SendMailPayload(null, $"Failed. Mail was not created. Error: {ex.Message}"));
}
try
{
using var client = await GetClientAsync(cancellationToken);
var mail = CreateGroupMail(subject, body, addresses);
await client.SendAsync(mail, cancellationToken : cancellationToken);
await client.DisconnectAsync(true, cancellationToken);
}
catch (Exception ex)
{
var error = await HandleException(ex, newMail);
return(new SendMailPayload(newMail, error.FailMessage));
}
newMail.Status = MailStatus.Successfully;
await _mailRepossitory.UpdateAsync(newMail);
return(new SendMailPayload(newMail, null));
}
public async Task <IActionResult> user_post_message([FromBody] SimulationMessageCreateDTO message, [FromRoute] string username)
{
logger.LogInformation($"SIMULATION: {username} is posting a message");
if (!reqFromSimulator(out var result))
{
return(result);
}
await write_latest();
var id = await MessageRepo.CreateAsync(message.Content, username);
if (id == -1)
{
logger.LogError($"SIMULATION: {username} does not exist");
return(BadRequest("Message could not be recorded"));
}
return(NoContent());
}
public async Task <OperationResultResponse <StatusType> > ExecuteAsync(CreateMessageRequest request)
{
ValidationResult validationResult = await _validator.ValidateAsync(request);
if (!validationResult.IsValid)
{
return(_responseCreator.CreateFailureResponse <StatusType>(
HttpStatusCode.BadRequest,
validationResult.Errors.Select(vf => vf.ErrorMessage).ToList()));
}
OperationResultResponse <StatusType> response = new();
DbMessage message = await _repository.CreateAsync(_mapper.Map(request));
try
{
await _chatHub.Clients.Group(request.ChannelId.ToString()).SendAsync(
"ReceiveMessage",
new MessageInfo()
{
Id = message.Id,
Content = message.Content,
Status = message.Status,
ThreadMessagesCount = message.ThreadMessagesCount,
CreatedBy = await GetUserAsync(response.Errors),
CreatedAtUtc = message.CreatedAtUtc,
FilesIds = null, //to do
Images = null //to do
});
response.Body = StatusType.Sent;
response.Status = OperationResultStatusType.FullSuccess;
_httpContextAccessor.HttpContext.Response.StatusCode = (int)HttpStatusCode.Created;
}
catch (Exception ex)
{
_logger.LogError("Can't send message.", ex);
response = _responseCreator.CreateFailureResponse <StatusType>(HttpStatusCode.InternalServerError);
}
return(response);
}
public async Task <ChatModel> CreateMessageAsync(MessageModel messageModel, HubCallerContext context)
{
ApplicationUser user = await _userManager.FindByNameAsync(context.User.Identity.Name);
Message message = messageModel.MapToEntity();
await _messageRepository.CreateAsync(message);
Chat chat = await _chatRepository.GetByIdAsync(message.ChatId);
chat.MessageId = message.Id;
chat.IsCheckedByAdmin = default(bool);
await _chatRepository.UpdateAsync(chat);
string chatName = await GetChatNameAsync(message.ChatId);
ChatModel chatModel = await GetChatAsync(chatName);
return(chatModel);
}
public async Task HandleNotificationAsync(IMessageCreate notification, CancellationToken ct)
{
var isThreadChannel = await _threadService.IsThreadChannelAsync(notification.ChannelID, ct);
if (!isThreadChannel)
{
return;
}
using var statsScope = _dogStatsd.StartTimer("message_processing_ms");
var message = notification;
var channel = notification.ChannelID;
var guild = notification.GuildID;
using var logScope = MessageLogMessages.BeginMessageNotificationScope(_logger, guild.Value.Value, channel.Value, notification.ID.Value);
MessageLogMessages.MessageReceivedHandling(_logger);
await TryTrackMessageAsync(
guild,
message,
async (guildId) =>
{
MessageLogMessages.MessageRecordCreating(_logger);
await _messageRepository.CreateAsync(new MessageCreationData()
{
Id = message.ID.Value,
GuildId = guildId,
ChannelId = channel.Value,
AuthorId = message.Author.ID.Value,
Timestamp = message.Timestamp
});
MessageLogMessages.MessageRecordCreated(_logger);
});
MessageLogMessages.MessageReceivedHandled(_logger);
}
public async Task <IActionResult> CreateNew([FromBody] Message message, [FromHeader(Name = "Accept")] string mediaType)
{
if (message == null)
{
return(BadRequest());
}
if (ModelState.IsValid)
{
try
{
await _repo.CreateAsync(message);
if (mediaType == CustomMediaType.Hateoas)
{
var dtomessage = _mapper.Map <Message, DTOMessage>(message);
dtomessage.Links.Add(new DTOLink("self", Url.Link("CreateNew", null), "POST"));
dtomessage.Links.Add(new DTOLink("update", Url.Link("PartialUpdate", new { id = message.Id }), "PATCH"));
return(Created($"api/[controller]/{message.Id}", dtomessage));
}
else
{
return(Created($"api/[controller]/{message.Id}", message));
}
}
catch (Exception e)
{
return(UnprocessableEntity(e));
}
}
else
{
return(UnprocessableEntity());
}
}
/// <inheritdoc />
public async Task AddToStarboard(IGuild guild, IUserMessage message, string content, Embed embed)
{
var starChannel = await GetStarboardChannel(guild);
var starEntry = await starChannel.SendMessageAsync(content, false, embed);
var messageEntity = await _messageRepository.GetMessage(message.Id);
if (messageEntity == null)
{
messageEntity = new MessageEntity
{
Id = message.Id,
GuildId = guild.Id,
ChannelId = message.Channel.Id,
AuthorId = message.Author.Id,
Timestamp = message.Timestamp,
};
await _messageRepository.CreateAsync(messageEntity);
}
messageEntity.StarboardEntryId = starEntry.Id;
await _messageRepository.UpdateStarboardColumn(messageEntity);
}
public async Task <MessageDTO> CreateMessageAsync(Message message)
{
await _messageRepository.CreateAsync(message);
return(new MessageDTO(message));
}
public async Task CreateAsync(Message message)
{
await repo.CreateAsync(message);
}
