public void Map_CreateMessageDto_To_Message() { var dto = new CreateMessageDto { Body = "body", Created = DateTime.MaxValue, Creator = "creator", Id = "12345" }; IEnumerable<CreateMessageDto> dtos = new List<CreateMessageDto>() { dto }; var handler = new AutoMapMappingHandler(); var result = handler.Map<Message>( dto ); Assert.AreEqual( dto.Body, result.Body ); Assert.AreEqual( dto.Created, result.Created ); Assert.AreEqual( dto.Id, result.Id ); var resultCollection = handler.Map<IEnumerable<Message>>( dtos ); Assert.IsTrue( resultCollection.Any( a => a.Body == result.Body && a.Created == result.Created && a.Creator == result.Creator && a.Id == result.Id ) ); }
public async Task <ActionResult <MessageDto> > CreateMessage([FromForm] CreateMessageDto createMessageDto) { var senderId = User.GetUserId(); if (senderId != createMessageDto.SenderId) { return(BadRequest()); } if (senderId.ToString().ToLower() == createMessageDto.RecipientId.ToString().ToLower()) { return(BadRequest("You cannot sent messages to yourself")); } var classifiedAdId = _classifiedAdsRepository.GetClassifiedAdDetail(createMessageDto.ClassifiedAdsId); if (classifiedAdId != null) { return(BadRequest("ClassifiedAd not exist")); } var sender = await _userManager.FindByIdAsync(senderId.ToLower()); var recipent = await _userManager.FindByIdAsync(createMessageDto.RecipientId.ToLower()); if (recipent == null) { return(NotFound()); } var message = new Message { Sender = sender, Recipient = recipent, SenderUsername = sender.UserName, RecipientUsername = recipent.UserName, SenderId = sender.Id, RecipientId = recipent.Id, Deleted = false, SenderDeleted = false, RecipientDeleted = false, Content = createMessageDto.Content, ClassifiedAdsId = createMessageDto.ClassifiedAdsId }; _messageRepository.AddMessage(message); if (await _messageRepository.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.ToLower()) { throw new HubException("You cannot send messages to yourself"); } var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(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 { var connections = await _tracker.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 <IActionResult> Post([FromBody] CreateMessageDto messageDto) { #region validation var result = await _unitOfWork.UserService.GetByEmail(messageDto.Email); var user = result.Data; if (!result.Success || user == null) { return(NotFound(new ApiMessage { Message = ResponseMessage.UserNotFound })); } if (user.Id == User.GetUserId()) { return(NotFound(new ApiMessage { Message = ResponseMessage.SenderAndReceiverAreTheSame })); } if (messageDto.ParentId.HasValue) { if (!await _unitOfWork.MessageService.IsMessageExist(messageDto.ParentId.Value)) { return(NotFound(new ApiMessage { Message = ResponseMessage.ParentMessageNotFound })); } } #endregion var message = _mapper.Map <Message>(messageDto); await _unitOfWork.MessageService.AddAsync(message); var userMessage = new UserMessage { SenderUserId = User.GetUserId(), ReceiverUserId = user.Id, SendDate = DateTime.Now, MessageId = message.Id, }; await _unitOfWork.UserMessageService.AddAsync(userMessage); await _unitOfWork.SaveChangesAsync(); return(Created(Url.Link("GetMessage", new { message.Id }), _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"); } // Get hold of both our users in the sender and the recipient // As we need to populate the messages when we create it // And going the other way, we need to return a dto from this as well var sender = await this.unitOfWork.UserRepository.GetUserByUsernameAsync(username); var recipient = await this.unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername); if (recipient == null) { throw new HubException("User Not Found!"); } 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 { var connections = await tracker.GetConnectionsForUser(recipient.UserName); if (connections != null) // user is online but not in the same group { await presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived", new { username = sender.UserName, knownAs = sender.KnownAs } ); } } this.unitOfWork.MessageRepository.AddMessage(message); if (await this.unitOfWork.Complete()) { await Clients.Group(groupName).SendAsync("NewMessage", mapper.Map <MessageDto>(message)); } }
public async Task <IActionResult> SendMessage([FromBody] CreateMessageDto dto) { var username = User.GetUsername(); var result = await _messageLogic.AddMessage(dto, username); if (result != null) { return(Ok(result)); } return(BadRequest("The message was not sent. Please try again.")); }
public async void SendMessage(CreateMessageDto createMessageDto) { var userId = Context.User.GetUserId(); if (userId == createMessageDto.RecipientId) { throw new HubException("You cannot send messages to yourself"); } var sender = await _unitOfWork.MemberRepository.GetUserByIdAsync(userId); var recipient = await _unitOfWork.MemberRepository.GetUserByIdAsync(createMessageDto.RecipientId); if (recipient == null) { throw new HubException("Not found user"); } var message = new MemberMessage { Sender = sender, Recipient = recipient, SenderId = sender.Id, RecipientId = recipient.Id, Content = createMessageDto.Content }; var groupName = GetGroupName(sender.Id, recipient.Id); var group = await _unitOfWork.MemberMessageRepository.GetMessageGroupAsync(groupName); if (group.Connections.Any(x => x.RecipientId == recipient.Id)) { message.DateRead = DateTime.UtcNow; } else { var connections = await _tracker.GetConnectionsForUser(recipient.Id); if (connections != null) { await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived", new { memberId = sender.Id, firstName = sender.FirstName }); } } _unitOfWork.MemberMessageRepository.AddMessage(message); if (await _unitOfWork.CompleteAsync()) { await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MemberMessageDto>(message)); } }
public async Task SendMessage(CreateMessageDto createMessageDto) { var userName = Context.User.GetUsername(); if (userName == createMessageDto.RecipientUsername) { throw new HubException("You cannot send messages to yourself"); } var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(userName); var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(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); // nếu cả 2 user đang ở trong box chat thì hiển thị đã đọc if (group.Connections.Any(x => x.Username == recipient.UserName)) { message.DateRead = DateTime.Now; } else { // user nhận online nhưng đang không trong group chat var connection = await _presenceTracker.GetConnectionsForUser(recipient.UserName); if (connection != null) { await _presenceHub.Clients.Clients(connection).SendAsync("NewMessageReceived", new { username = sender.UserName, knowAs = sender.KnownAs }); } } _unitOfWork.MessageRepository.AddMessage(message); if (await _unitOfWork.Complete()) { await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDto>(message)); } }
// sending message via hub public async Task SendMessage(CreateMessageDto createMessageDto) { var username = Context.User.GetUsername(); if (username == createMessageDto.RecipientUsername.ToLower()) { throw new HubException("You cannot send message to yourself"); } var sender = await _unitOfWork.UserRepository.GetUserByUserName(username); var recipient = await _unitOfWork.UserRepository.GetUserByUserName(createMessageDto.RecipientUsername); if (recipient == null) { throw new HubException("Not found user"); } var message = new Message { Sender = sender, Recipent = recipient, SenderUsername = sender.UserName, RecipentUsername = recipient.UserName, Content = createMessageDto.Content }; var groupName = GetGroupName(sender.UserName, recipient.UserName); var group = await _unitOfWork.MessageRepository.GetMessageGroup(groupName); // to update the date read to now if the user is connected to this specific hub so it wont be marked as "Unread" if (group.Connections.Any(x => x.Username == recipient.UserName)) { message.DateRead = DateTime.UtcNow; } else { var connections = await _presenceTracker.GetConnectionsForUser(recipient.UserName); // if there are any connections, we know the recipient is online but not in the same message group 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) // this code block copied over from MessagesController.cs { var username = Context.User.GetUsername(); if (username == createMessageDto.RecipientUsername.ToLower()) { throw new HubException("You cannot send messages to yourself"); } var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); // sender // next we get hold of users in sender and recipient // we need to populate the message when we create it and go the other way when we return a DTO from this var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername); if (recipient == null) { throw new HubException("Not Found User"); } var message = new Message // at this stage we know we are redy to create a 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 { var connections = await _tracker.GetConnectionsForUser(recipient.UserName); if (connections != null) { // if the user is online and not connected to the same group ¬ await _presenceHub.Clients.Clients(connections).SendAsync("NewMessageReceived", new { username = sender.UserName, knownAs = sender.KnownAs }); // { } represents an anonymous object } } _unitOfWork.MessageRepository.AddMessage(message); // method that adds our message if (await _unitOfWork.Complete()) { // var group = GetGroupName(sender.UserName, recipient.UserName); await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <MessageDto>(message)); // maps from the message we have created // we receive a message from our client // we need to update our message hub thread variable to update when a message is received // return BadRequest("Failed to send message"); // not required as we are not returning from this } }
public async Task SendMessage(CreateMessageDto createMessageDto) { var username = Context.User.GetUserName(); if (username == createMessageDto.RecipientName.ToLower()) { throw new HubException("you can not message ypurself"); } var sender = await _userRepository.GetUserByUserNameAsync(username); var receipent = await _userRepository.GetUserByUserNameAsync(createMessageDto.RecipientName); if (receipent == null) { throw new HubException("Not found user"); } var message = new Message { Sender = sender, Recipient = receipent, SenderName = sender.UserName, RecipientName = receipent.UserName, Content = createMessageDto.Content }; var groupName = GetGroupName(sender.UserName, receipent.UserName); var group = await _messageRepository.GetMessageGroup(groupName); if (group.Connections.Any(x => x.Username == receipent.UserName)) { message.DateRead = DateTime.UtcNow; } else { var connections = _presenceTracker.GetConnectionForUser(receipent.UserName); IReadOnlyList <string> connectionsReadOnly = connections.AsReadOnly(); if (connections != null) { await _presenceHub.Clients.Clients(connectionsReadOnly).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)); } throw new HubException("Failed to send message"); }
public async Task <IActionResult> SendMessage(int userId, CreateMessageDto messageForCreationDto) { var source = await _szkolniakRepo.GetUser(userId); messageForCreationDto.SenderId = userId; var message = _map.Map <Message>(messageForCreationDto); _szkolniakRepo.AddToRepo(message); await _szkolniakRepo.SaveAll(); var messageToReturn = _map.Map <MessageToReturnDto>(message); return(CreatedAtRoute("GetMessage", new { userId, id = message.Id }, messageToReturn)); }
public async Task <IActionResult> Create(CreateMessageDto input) { var token = GetToken(); var userId = LoginHelper.GetClaim(token, "UserId"); if (input.SenderId != Guid.Parse(userId)) { return(Unauthorized()); } var result = await _messageAppService.Create(input); return(Ok(result)); }
public List <Message> CreateNotifications(CreateMessageDto dto, List <string> tokens) { return(tokens.Select(token => new Message() { Token = token, Data = new Dictionary <string, string>() { { "Title", dto.Title }, { "Body", dto.Body }, { "Action", dto.Action }, { "ActionId", dto.ActionId.ToString() }, }, }) .ToList()); }
public async Task <ActionResult <MessageDto> > CreateMessage(CreateMessageDto createMessageDto) { var email = User.GetEmail(); if (email == createMessageDto.RecipientEmail) { return(BadRequest("You cannot send messages to yourself")); } var sender = await _unitOfWork.UserRepository.GetUserByEmailAsync(email); var recipient = await _unitOfWork.UserRepository.GetUserByEmailAsync(createMessageDto.RecipientEmail); if (recipient == null) { return(NotFound()); } if (await _unitOfWork.MessageRepository.GetChat(sender.Id, recipient.Id) == null) { var chat = new Chat { SenderId = sender.Id, RecipientId = recipient.Id, UserId = sender.Id }; _unitOfWork.MessageRepository.AddChat(chat); } var message = new Message { Sender = sender, Recipient = recipient, SenderFullName = sender.FullName, RecipientFullName = recipient.FullName, COntent = createMessageDto.Content }; _unitOfWork.MessageRepository.AddMessage(message); if (await _unitOfWork.Complete()) { return(Ok(_mapper.Map <MessageDto>(message))); } return(BadRequest("Failed to save message")); }
public async Task <ActionResult <string> > CreateMessage(CreateMessageDto request) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var result = await _repository.CreateMessage(request.Key, request.Content, request.ExpiresAt); if (result == null) { return(BadRequest()); } return(result.Id); }
public void Post_DispatchesMessage() { var id = "12345"; var dto = new CreateMessageDto { Creator = id }; var messageHandler = new Mock<IMessageHandler>(); var controller = this.GetController( messageHandler: messageHandler ); controller.Post( dto ); messageHandler.Verify( a => a.DispatchMessage( It.IsAny<Message>(), It.IsAny<int>() ) ); }
public async Task <ActionResult <MessageDto> > CreateMessage( CreateMessageDto createMessageDto) { ActionResult <MessageDto> res; var username = User.GetUsername(); if (username == createMessageDto.RecipientUsername.ToLower()) { res = BadRequest("You cannot send messages to yourself"); } else { var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); var recipient = await _unitOfWork.UserRepository .GetUserByUsernameAsync(createMessageDto.RecipientUsername); if (recipient == null) { res = NotFound(); } else { var message = new Message { Sender = sender, Recipient = recipient, SenderUsername = sender.UserName, RecipientUsername = recipient.UserName, Content = createMessageDto.Content, }; _unitOfWork.MessageRepository.AddMessage(message); if (await _unitOfWork.Complete()) { res = Ok(_mapper.Map <MessageDto>(message)); } else { res = BadRequest("Failed to send message"); } } } return(res); }
public async Task SendMessage(CreateMessageDto createMessageDto) { int sourceId = this.Context.User.GetUserId(); if (sourceId == createMessageDto.TargetUserId) { throw new HubException("You cannot send messages to yourself."); } var sourceUser = await this.unitOfWork.UserRepository.FindById(sourceId); var targetUser = await this.unitOfWork.UserRepository.FindById(createMessageDto.TargetUserId); if (sourceUser == null || targetUser == null) { throw new HubException("Source or target user not found."); } var message = this.messageFactory.CreateWithUsers(sourceUser, targetUser, createMessageDto.Content); var groupName = this.MakeGroupName(sourceUser.UserName, targetUser.UserName); var group = await this.unitOfWork.GroupRepository.GetMessageGroup(groupName); if (group.Connections.Any(x => x.Username == targetUser.UserName)) { message.SeenAt = DateTime.UtcNow; } else { var connectionIds = this.presenceTracker.GetUserConnections(targetUser.Id); if (connectionIds.Any()) { await this.presenceHub.Clients.Clients(connectionIds).SendAsync(NewMessageReceived, new { username = sourceUser.UserName, knownAs = sourceUser.KnownAs }); } } this.unitOfWork.MessageRepository.AddNew(message); if (await this.unitOfWork.SaveChangesAsync()) { await Clients.Group(groupName).SendAsync(NewMessage, this.mapper.Map <MessageDto>(message)); } }
public async Task <ActionResult <MessageDto> > CreateMessage(CreateMessageDto createMessageDto) { // Get Username & Id var username = User.GetUsername(); // check if recipient is name of sender if (username == createMessageDto.RecipientUsername.ToLower()) { return(BadRequest("The cannot send messages to yourself.")); } var sender = await _userRepository.GetUserByUserNameAsync(username); var recipient = await _userRepository.GetUserByUserNameAsync(createMessageDto.RecipientUsername); // check if recipient exists if (recipient == null) { return(NotFound()); } // Create new message var message = new Message { Sender = sender, SenderUsername = sender.UserName, Recipient = recipient, RecipientUsername = recipient.UserName, Content = createMessageDto.Content }; // Send message to DB _messageRepository.AddMessage(message); // Save changes if (await _messageRepository.SaveAllAsync()) { return(Ok(_Mapper.Map <MessageDto>(message))); } // If all else fails return(BadRequest("Failed to send message.")); }
public async Task <ActionResult <MessageDTO> > CreateMessage([FromBody] CreateMessageDto createMessageDto) { var senderUsername = User.FindFirst(ClaimTypes.Name)?.Value; if (senderUsername == createMessageDto.RecipientUsername.ToLower()) { return(BadRequest("You cannot send messages to yourself!")); } var senderUser = await unitOfWork.userRepository.GetUserByUsernameAsync(senderUsername); var recipientUser = await unitOfWork.userRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername); if (recipientUser == null) { return(NotFound()); } var message = new Message { Sender = senderUser, SenderDeleted = false, SenderId = senderUser.Id, SenderUsername = senderUser.UserName, Recipient = recipientUser, RecipientDeleted = false, RecipientId = recipientUser.Id, RecipientUsername = recipientUser.UserName, Content = createMessageDto.Content, //DateRead optional //DateSent je Now //id je autoincrement }; unitOfWork.messageRepository.AddMessage(message); if (await unitOfWork.Complete()) { return(Ok(mapper.Map <MessageDTO>(message))); } return(BadRequest("Failed to send a message")); }
public async Task <ActionResult <MessageDto> > CreateMessage(CreateMessageDto messageDto) { if (String.IsNullOrEmpty(messageDto.Content)) { return(BadRequest("Message cannot be empty")); } //var senderId = User.GetUserId(); var senderUserName = User.GetUserName(); if (senderUserName == messageDto.RecipientUsername) { return(BadRequest("You cannot send messages to yourself")); } var sender = await _unitOfWork.UserRepository.GetUserByUserNameAsync(senderUserName); var recipient = await _unitOfWork.UserRepository.GetUserByUserNameAsync(messageDto.RecipientUsername); if (recipient == null) { return(NotFound("Recipient not found")); } var message = new Message() { Content = messageDto.Content, Sender = sender, SenderUsername = senderUserName, Recipient = recipient, RecipientUsername = recipient.UserName }; _unitOfWork.MessageRepository.AddMessage(message); if (await _unitOfWork.CompleteAsync()) { return(Ok(_mapper.Map <MessageDto>(message))); } return(BadRequest("Failed to send message")); }
public async Task <ActionResult <MessageDto> > CreateMessage(CreateMessageDto createMessageDto) { var currentUsername = User.GetUsername(); if (currentUsername == createMessageDto.RecipientUsername.ToLower()) { return(BadRequest("You cannot send message to yourself!")); } // 1. transfer CreateMessageDto to Message var currentUser = await _unitOfWork.UserRepository.GetUserByUsernameAsync(currentUsername); var recipientUser = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername.ToLower()); if (recipientUser == null) { return(NotFound()); } var message = new Message { SenderUsername = currentUsername, Sender = currentUser, RecipientUsername = recipientUser.UserName, Recipient = recipientUser, Content = createMessageDto.Content, }; // 2. Save transferred Message to MessageRepo _unitOfWork.MessageRepository.AddMessage(message); // 3. Return created MessageDto if (await _unitOfWork.Complete()) { return(Ok(_mapper.Map <MessageDto>(message))); } return(BadRequest("Failed to send message.")); }
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); var sender = await _unitOfWork.UserRepository.GetUserByUsernameAsync(username); var recipient = await _unitOfWork.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)); _unitOfWork.MessageRepository.AddMessage(message); if (await _unitOfWork.Complete()) { return(Ok(_mapper.Map <MessageDto>(message))); } return(BadRequest("Failed to send message.")); }
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 _unitOfWork.UserRepository.GetUserByUsernameAsync(username); var recipient = await _unitOfWork.UserRepository.GetUserByUsernameAsync(createMessageDto.RecipientUsername); var work = await _unitOfWork.WorkRepository.GetWorkByIdAsync(createMessageDto.WorkId); if (recipient == null || work == null) { return(NotFound()); } var message = new Message { Sender = sender, Recipient = recipient, SenderUsername = sender.UserName, RecipientUsername = recipient.UserName, Content = createMessageDto.Content, WorkId = createMessageDto.WorkId }; _unitOfWork.MessageRepository.AddMessage(message); if (await _unitOfWork.SaveAll()) { return(CreatedAtRoute("messages", new { messageId = message.Id }, _mapper.Map <MessageDto>(message))); } return(BadRequest("Failed to save message")); }
public async Task <ActionResult <MessageDto> > CreateMessage(CreateMessageDto createMessageDto) { var userId = User.GetUserId(); var userName = _userRepository.GetUserByIdAsync(userId).Result.UserName; if (userName == createMessageDto.RecipientUserName.ToLower()) { return(BadRequest("You can noit send messages to yourself!")); } var sender = await _userRepository.GetUserByUserNameAsync(userName); var recipient = await _userRepository.GetUserByUserNameAsync(createMessageDto.RecipientUserName.ToLower()); if (recipient == null) { return(NotFound()); } var message = new Message() { MessageId = Guid.NewGuid().ToString(), 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("Failed to send message")); }
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")); } // Get hold of both our users in the sender and the recipient // As we need to populate the messages when we create it // And going the other way, we need to return a dto from this as well var sender = await this.unitOfWork.UserRepository.GetUserByUsernameAsync(username); var recipient = await this.unitOfWork.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 }; this.unitOfWork.MessageRepository.AddMessage(message); if (await this.unitOfWork.Complete()) { return(Ok(mapper.Map <MessageDto>(message))); } return(BadRequest("Failed To Save Message")); }
public async Task <IActionResult> CreateMessage(int userId, CreateMessageDto createMessageDto) { var sender = await _repository.GetUser(userId); if (sender.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } createMessageDto.SenderId = userId; var recipient = await _repository.GetUser(createMessageDto.RecipientId); if (recipient == null) { return(BadRequest("Could not find the user!!")); } var message = _mapper.Map <Message>(createMessageDto); _repository.Add(message); // if (await _repository.SaveAll()) // return CreatedAtRoute("GetMessage", new { id = message.Id }, message); // at this stage, the CreatedAtRoute will return everything related to Sender and Recipient // including PasswordHash and PasswordSalt. In order to avoid that, // we will reverseMap the message into createMessageDto. // var messageToCreate = _mapper.Map<CreateMessageDto>(message); if (await _repository.SaveAll()) { var messageToCreate = _mapper.Map <MessageToReturnDto>(message); return(CreatedAtRoute("GetMessage", new { id = message.Id }, messageToCreate)); } throw new Exception("Creating the message failed on save!!"); }
public async Task <ActionResult <MessageDto> > CreateMessage(CreateMessageDto createMessageDto) { //here you get username of loggedIn user by using Authorization token claims. var username = User.GetUsername(); if (username == createMessageDto.RecipientUsername.ToLower()) { return(BadRequest("You can't send message to yourself.")); } //gets loggedIn user info var sender = await unitOfWork.UserRepository.GetUserByUsernameAsync(username); //gets recipient's info var recipient = await unitOfWork.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 }; unitOfWork.MessageRepository.AddMessage(message); if (await unitOfWork.Complete()) { return(Ok(mapper.Map <MessageDto>(message))); } return(BadRequest("Fails to send message")); }
public async Task <ActionResult <MessageDto> > CreateMessage(CreateMessageDto createMessageDto) { var username = User.GetUsername(); if (username == createMessageDto.RecipientUsername.ToLower()) { return(BadRequest("you cant send to you")); } 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.Value.UserName, RecipientUsername = recipient.Value.UserName, Content = createMessageDto.Content, }; _messageRepository.AddMessage(message); if (await _messageRepository.SaveAllAsync()) { return(Ok(_mapper.Map <MessageDto>(message))); } return(BadRequest("sending is failed")); }
public async Task <ActionResult <MessageDto> > CreateMessage(CreateMessageDto createMessageDto) { var userName = User.GetUserName(); if (userName == createMessageDto.RecipientUserName.ToLower()) { return(BadRequest("You cannot message yoursefl")); } var sender = await _userRepository.GetUserByUserNameAsync(userName); var recipient = await _userRepository.GetUserByUserNameAsync(createMessageDto.RecipientUserName); if (recipient == null) { return(NotFound()); } var message = new Message { SenderId = sender.Id, SenderUserName = sender.UserName, Sender = sender, RecipinetId = recipient.Id, RecipientUserName = recipient.UserName, Recipient = recipient, Content = createMessageDto.Content }; _messageRepository.AddMessage(message); if (await _messageRepository.SaveAllAsync()) { return(Ok(_mapper.Map <MessageDto>(message))); } return(BadRequest("Failed to send message")); }
public async void SendMessage(CreateMessageDto createMessageDto) { var userId = Context.User.GetUserId(); if (userId == createMessageDto.RecipientId) { throw new HubException("You cannot send messages to yourself"); } var sender = await _unitOfWork.MemberRepository.GetUserByIdAsync(userId); var @event = await _unitOfWork.EventRepository.GetEventByIdAsync(createMessageDto.RecipientId); if (@event == null) { throw new HubException("Not found event"); } var message = new EventMessage { Sender = sender, Event = @event, SenderId = sender.Id, EventId = @event.Id, Content = createMessageDto.Content }; var groupName = @event.Id; var group = await _unitOfWork.EventMessageRepository.GetMessageGroupAsync(groupName); _context.EventMessages.Add(message); if (await _context.SaveChangesAsync() > 0) { await Clients.Group(groupName).SendAsync("NewMessage", _mapper.Map <EventMessageDto>(message)); } }