public async Task <ActionResult <MessageDTO> > CreateMessage(CreateMessageDTO createMessg) { var userName = User.FindFirst(ClaimTypes.NameIdentifier)?.Value; if (userName == createMessg.recipientUsername.ToLower()) { return(BadRequest("Can not send message to yourself")); } var sender = await userRepository.GetUserByNameAsync(userName); var recipient = await userRepository.GetUserByNameAsync(createMessg.recipientUsername); if (recipient == null) { return(NotFound("Could not find the user")); } var messg = new Message { sender = sender, recipient = recipient, content = createMessg.content }; messageRepository.AddMessage(messg); if (await messageRepository.SaveAllAsync()) { return(Ok(this.mapper.Map <MessageDTO>(messg))); } return(BadRequest("Could not send the message")); }
public async Task <ActionResult <MessageDTO> > AddMessage(CreateMessageDTO message) { var sendUserName = User.GetUserName(); if (sendUserName == message.RecipientUserName) { return(BadRequest("Not allowed to send message to yourself")); } var sender = await _mainRespositories.AppUserRespository.GetUserByUserNameAsync(sendUserName); var recipient = await _mainRespositories.AppUserRespository.GetUserByUserNameAsync(message.RecipientUserName); if (recipient == null) { return(NotFound()); } var newMsg = new Message { SenderId = sender.Id, SenderUserName = sender.UserName, RecipientId = recipient.Id, RecipientUserName = recipient.UserName, Content = message.Content }; await _mainRespositories.MessageRepository.AddMessage(newMsg); if (await _mainRespositories.Complete()) { return(Ok(_mapper.Map <MessageDTO>(newMsg))); } return(BadRequest("Fail to send message")); }
public async Task <ActionResult <MessageDTO> > AddMessage(CreateMessageDTO createMessageDTO) { var senderUsername = User.GetUsername(); var sender = await _userRepository.GetUserByUsernameAsync(senderUsername); var recipient = await _userRepository.GetUserByUsernameAsync(createMessageDTO.RecipientUsername); if (senderUsername == createMessageDTO.RecipientUsername) { return(BadRequest("You can't send a message to yourself")); } if (recipient == null) { return(NotFound()); } var message = new Message() { Sender = sender, SenderUsername = sender.UserName, Recipient = recipient, RecipientUsername = recipient.UserName, Content = createMessageDTO.Content }; _messageRepository.AddMessage(message); if (await _messageRepository.SaveAllAsync()) { return(Ok(_mapper.Map <MessageDTO>(message))); } return(BadRequest("An error occurred sending the message")); }
public async Task <ActionResult <MessageDTO> > CreateMessage(CreateMessageDTO createMessageDTO) { var username = User.GetUsername(); if (username == createMessageDTO.ReceiverUsername.ToLower()) { return(BadRequest("Not able to send message to itself.")); } var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); var receiver = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDTO.ReceiverUsername); if (receiver == null) { return(NotFound("Recipient not found")); } var message = new Message { Sender = sender, SenderUsername = sender.UserName, Receiver = receiver, ReceiverUsername = receiver.UserName, Content = createMessageDTO.Content }; _unitOfWork.MessageRepository.AddMessage(message); if (await _unitOfWork.Complete()) { return(Ok(_mapper.Map <MessageDTO>(message))); // Return mapped MessageDTO from message } return(BadRequest("Failed to create the message!")); }
public async Task <ActionResult <MessageDTO> > CreateMessage(CreateMessageDTO createMessageDTO) { var username = User.GetUserName(); if (username == createMessageDTO.RecipientUserName.ToLower()) { return(BadRequest("You can not 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 { Sender = sender, Recipient = recipient, SenderUserName = sender.UserName, RecipientUserName = recipient.UserName, Content = createMessageDTO.Content }; _messageRepository.AddMessage(message); if (await _messageRepository.SaveAllAsync()) { return(Ok(_mapper.Map <MessageDTO>(message))); } return(BadRequest("Failed to send message")); }
public async Task <ActionResult <MessageDTO> > Create(Guid channelId, [FromBody] CreateMessageDTO model) { //1)Channel laden via de channelrepository op basis van de channelId var channel = channelRepository.GetById(channelId); //2)Valideren currentUser rechten heeft om messages te posten (Utility helper function) //3)Indien true, message.FromCreateMessageDTO(channel,model); var message = uMessageAPI.Models.Message.FromCreateMessageDTO(channel, model, await GetCurrentUserAsync()); //message.ChannelId = channelId; // Check whether the current channel was resolved. //if ( message.ChannelId == channelId) { // Create message and assign a name. await hubContext.Clients.All.BroadcastMessage(message.Text); messageRepository.Add(message); messageRepository.SaveChanges(); //} // Check whether the channel was successfully created. if (message != null) { // Generate the channel response for given channel. return(Ok(MessageDTO.FromMessage(message))); } return(NotFound()); }
public async Task SendMessage(CreateMessageDTO createMessageDTO) { var username = Context.User.GetUsername(); if (username == createMessageDTO.RecipientUsername.ToLower()) { throw new HubException("You cannot message yourself"); } var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDTO.RecipientUsername.ToLower()); if (recipient == null) { throw new HubException("User not found"); } var message = new Message { SenderId = sender.Id, SenderUsername = sender.UserName, RecipientId = recipient.Id, RecipientUsername = recipient.UserName, Content = createMessageDTO.Content }; var groupName = GetGroupName(sender.UserName, recipient.UserName); var group = await _unitOfWork.MessagesRepository.GetMessageGroup(groupName); if (group.Connections.Any(connection => connection.Username == recipient.UserName)) { message.DateRead = DateTime.UtcNow; } else { var connections = await _presenceTracker.GetConnectionsForUser(recipient.UserName); if (connections != null) { await _presenceHubContext.Clients.Clients(connections).SendAsync("NewMessageReceived", new { username = sender.UserName, knownAs = sender.KnownAs }); } } _unitOfWork.MessagesRepository.AddMessage(message); if (await _unitOfWork.Complete()) { await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDTO>(message)); } else { throw new HubException("Failed to save message"); } }
public async Task <MessageDTO> Create(CreateMessageDTO dto, CancellationToken cancel) { var message = await _repository.Create(dto.ToEntity(), cancel); await _hubContext.Clients.Group(dto.RoomId.ToString()).SendAsync("MessageSent", message); return(message.ToDTO()); }
public static Message FromCreateMessageDTO(Channel channel, CreateMessageDTO model, User user) { var currentTime = DateTime.Now; // Create a channel object based on the model and current time. return(new Message { Channel = channel, Text = model.Text, Created = currentTime, Modified = currentTime, User = user }); }
public IHttpActionResult CreateMessage(CreateMessageDTO createMessageDTO) { try { service.CreateMessage(createMessageDTO); return(Ok()); } catch (Exception) { return(InternalServerError()); } }
public async Task SendMessage(CreateMessageDTO createMessageDTO) { var username = Context.User.GetUserName(); if (username == createMessageDTO.RecipientUserName.ToLower()) { throw new HubException("You cannot send messages to yourself"); } var sender = await _unitOfWork.UserRepository.GetUsersByUserNameAsync(username); var recipient = await _unitOfWork.UserRepository.GetUsersByUserNameAsync(createMessageDTO.RecipientUserName); if (recipient == null) { throw new HubException("Not found User"); } var message = new Message { Sender = sender, Recipient = recipient, SenderUserName = sender.UserName, RecipientUserName = recipient.UserName, Content = createMessageDTO.Content }; var groupName = GetGroupName(sender.UserName, recipient.UserName); var group = await _unitOfWork.MessageRepository.GetMessageGroup(groupName); if (group.Connections.Any(x => x.Username == recipient.UserName)) { message.DateRead = DateTime.UtcNow; } else { //When user is online but not on message screen. it pops new message arrived var connections = await _presenceTracker.GetConnectionsForUser(recipient.UserName); if (connections != null) { await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived", new { username = sender.UserName, knownAs = sender.KnownAs }); } } _unitOfWork.MessageRepository.AddMessage(message); if (await _unitOfWork.Complete()) { await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDTO>(message)); } }
public async Task SendMessage(CreateMessageDTO createMessageDTO) { var username = Context.User.GetUsername(); if (username == createMessageDTO.RecipientUserName.ToLower()) { throw new HubException("You cannot send messages to yourself"); } var sender = await _userRepository.GetUserByUsernameAsync(username); var recipient = await _userRepository.GetUserByUsernameAsync(createMessageDTO.RecipientUserName); if (recipient == null) { throw new Exception("Not Found User"); } var message = new Message { Sender = sender, Recipient = recipient, Content = createMessageDTO.Content, SenderUserName = 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 _tracker.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()) { //var group = GetGroupName(sender.UserName, recipient.UserName); await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDTO>(message)); } }
public async Task AddMessage(CreateMessageDTO message) { var sendUserName = Context.User.GetUserName(); if (sendUserName == message.RecipientUserName) { throw new HubException("Not allowed to send message to yourself"); } var sender = await _mainRespositores.AppUserRespository.GetUserByUserNameAsync(sendUserName); var recipient = await _mainRespositores.AppUserRespository.GetUserByUserNameAsync(message.RecipientUserName); if (recipient == null) { new HubException("Receipient is not found"); } var groupname = this.GetGroupName(sender.UserName, recipient.UserName); var msgGroup = await _mainRespositores.MessageRepository.GetMessageGroup(groupname); var newMsg = new Message { SenderId = sender.Id, SenderUserName = sender.UserName, RecipientId = recipient.Id, RecipientUserName = recipient.UserName, Content = message.Content }; if (msgGroup.Connections.Any(x => x.Username == message.RecipientUserName)) { newMsg.DateRead = DateTime.UtcNow; } else { await NotifyNewMsg(recipient.UserName, sender); } await _mainRespositores.MessageRepository.AddMessage(newMsg); if (await _mainRespositores.Complete()) { await Clients.Group(groupname).SendAsync("NewMessage", _mapper.Map <MessageDTO>(newMsg)); } else { throw new HubException("Fail to send message"); } }
public async Task CreateAsync(CreateMessageDTO message) { var messageEntity = new Message { Topic = message.Topic, Content = message.Content, AutopartId = message.AutopartId, ReceiverId = message.ReceiverId, SenderId = message.SenderId, }; await this.messagesRepository.AddAsync(messageEntity); await this.messagesRepository.SaveChangesAsync(); }
public static Message ToEntity(this CreateMessageDTO dto) { if (dto == null) { return(null); } return(new Message { Id = Guid.NewGuid(), Content = dto.Content, Date = DateTime.Now, RoomId = dto.RoomId, UserId = dto.UserId, RepliedMessageContent = dto.RepliedMessageContent }); }
public async Task MessageCreate_HappyPath() { var dto = new CreateMessageDTO { Content = "Hello", RoomId = StaticData.PublicRoomId, UserId = StaticData.TestUserId }; var message = await _handler.Create(dto, CancellationToken.None); Assert.IsNotNull(message); var dataFromDb = await Context.Messages.SingleAsync(x => x.Id == message.Id); Assert.AreEqual(dataFromDb.Content, dto.Content); await DeleteDatabase(); }
private ICreateMessageDTO GetPublishMessageBody(IPublishMessageParameters parameters) { var createMessageDTO = new CreateMessageDTO { MessageEvent = new MessageEventDTO { Type = EventType.MessageCreate, CreatedAt = new DateTimeOffset(2000, 11, 22, 0, 0, 0, TimeSpan.Zero), MessageCreate = new MessageCreateDTO { Target = new MessageCreateTargetDTO { RecipientId = parameters.RecipientId }, MessageData = new MessageDataDTO { Text = parameters.Text } }, } }; // If there is media attached, include it if (parameters.MediaId != null) { createMessageDTO.MessageEvent.MessageCreate.MessageData.Attachment = new AttachmentDTO { Type = AttachmentType.Media, Media = new MediaEntity { Id = parameters.MediaId } }; } // If there are quick reply options, include them if (parameters.QuickReplyOptions != null && parameters.QuickReplyOptions.Length > 0) { createMessageDTO.MessageEvent.MessageCreate.MessageData.QuickReply = new QuickReplyDTO { Type = QuickReplyType.Options, Options = parameters.QuickReplyOptions, }; } return(createMessageDTO); }
public void CreateMessage(CreateMessageDTO createMessageDTO) { var updatedDialog = db.Dialogs.FirstOrDefault(d => d.DialogId == createMessageDTO.DialogId); updatedDialog.LastMessageText = createMessageDTO.Text; updatedDialog.LastMessageCreatedAt = createMessageDTO.CreatedAt; var messageToBeAdded = new Message { CreatedAt = createMessageDTO.CreatedAt, AuthorId = createMessageDTO.AuthorId, DialogId = createMessageDTO.DialogId, Text = createMessageDTO.Text }; Db.Messages.Add(messageToBeAdded); Db.SaveChanges(); }
public async Task MessageDelete_HappyPath() { var dto = new CreateMessageDTO { Content = "Hello", RoomId = StaticData.PublicRoomId, UserId = StaticData.TestUserId }; var message = await _handler.Create(dto, CancellationToken.None); await _handler.Delete(new Guid[] { message.Id }, false, CancellationToken.None); var dataFromDb = await Context.Messages.ToListAsync(); Assert.AreEqual(dataFromDb.Count, 0); await DeleteDatabase(); }
public async Task NewMessage(CreateMessageDTO request) { if (!usersConnectedToChat.TryGetValue(Context.ConnectionId, out int connectedUserId)) { Context.Abort(); } if (!string.IsNullOrWhiteSpace(request.Message) || !string.IsNullOrWhiteSpace(request.MediaUrl)) { using (var scope = _serviceProvider.CreateScope()) { var handler = scope.ServiceProvider.GetService <IHandlerHub <CreateMessageDTO, ObjectResult> >(); var objectResult = await handler.Handle(request, connectedUserId); MessageDTO messageAdded = (MessageDTO)objectResult.Value; await Clients.Group(messageAdded.DiscussionId.ToString()).SendAsync("messageReceived", messageAdded); } } }
public async Task MessageGet() { var dto = new CreateMessageDTO { Content = "Hello", RoomId = StaticData.PublicRoomId, UserId = StaticData.TestUserId }; var message = await _handler.Create(dto, CancellationToken.None); var messages = await _handler.GetAllByRoom(message.RoomId, CancellationToken.None); Assert.AreEqual(1, messages.Count); messages = await _handler.Get(message.RoomId, DateTime.Now, 20, CancellationToken.None); Assert.AreEqual(1, messages.Count); await DeleteDatabase(); }
public async Task <IActionResult> Add(CreateMessageInputModel input) { if (!this.ModelState.IsValid) { return(this.View(input)); } var currentUserId = this.User.FindFirst(ClaimTypes.NameIdentifier).Value; var receiver = this.usersService.GetByUsername <UsersListItemViewModel>(input.ReceiverUsername); var message = new CreateMessageDTO { Topic = input.Topic, Content = input.Content, AutopartId = input.AutopartId, SenderId = currentUserId, ReceiverId = receiver.Id, }; await this.messagesService.CreateAsync(message); return(this.Redirect("/")); }
public async Task <ActionResult <MessageDTO> > CreateMessage(CreateMessageDTO createMessageDTO) { var username = User.GetUsername(); if (username == createMessageDTO.RecipientUsername.ToLower()) { return(BadRequest("You cannot message yourself")); } var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDTO.RecipientUsername.ToLower()); if (recipient == null) { return(NotFound()); } var message = new Message { SenderId = sender.Id, SenderUsername = sender.UserName, RecipientId = recipient.Id, RecipientUsername = recipient.UserName, Content = createMessageDTO.Content }; _unitOfWork.MessagesRepository.AddMessage(message); if (await _unitOfWork.Complete()) { return(Ok(_mapper.Map <MessageDTO>(message))); } return(BadRequest("Failed to save message")); }
public bool CreateMessage(CreateMessageDTO createMessageDTO) { var message = _mapper.Map <CreateMessageDTO, Message>(createMessageDTO); return(Database.MessageRepository.CreateMessage(message)); }
public async Task <IActionResult> Create([FromBody] CreateMessageDTO dto) { var message = await _handler.Create(dto, HttpContext.RequestAborted); return(Ok(message)); }
public void CreateMessage(CreateMessageDTO createMessageDTO) { MessagesLogic.CreateMessage(createMessageDTO); }