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