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); }