public async Task <bool> SendMessage(SendMessageApiModel createMessageApiModel)
{
var isSenderBlocked = await _userService.IsSenderBlockedByReceiver(createMessageApiModel.SenderUserId, createMessageApiModel.ReceiverUserId);
if (isSenderBlocked)
{
throw new MessagingDomainException("Can't send message, sender is blocked by receiver.");
}
var entity = new Message(createMessageApiModel.SenderUserId, createMessageApiModel.ReceiverUserId, createMessageApiModel.MessageText);
await _repository.AddAsync(entity);
return(await _repository.UnitOfWork.CommitAsync());
}
public async Task <ActionResult> SendMessage([FromBody] SendMessageApiModel createMessageApiModel)
{
if (createMessageApiModel.SenderUserId == Guid.Empty ||
createMessageApiModel.ReceiverUserId == Guid.Empty)
{
NotFound();
}
if (createMessageApiModel.SenderUserId == createMessageApiModel.ReceiverUserId)
{
return(BadRequest("User and Receiver can't be same"));
}
await _messagingService.SendMessage(createMessageApiModel);
return(Ok());
}
public async Task SendMessage_success()
{
//Act
var fakeSenderUserId = Guid.NewGuid();
var fakeRecevierId = Guid.NewGuid();
var fakeMessageText = "hello";
var fakeModel = new SendMessageApiModel(fakeSenderUserId, fakeRecevierId, fakeMessageText);
_messagingServiceMock.Setup(w => w.SendMessage(fakeModel)).Returns(Task.FromResult(true));
//Arrenge
var controller = CreateDefaultController();
var actionResult = await controller.SendMessage(fakeModel) as OkResult;
//Assert
Assert.Equal(actionResult.StatusCode, (int)System.Net.HttpStatusCode.OK);
}
public async Task SendMessage_throws_MessagingDomainException_when_user_blocked()
{
//Act
var fakeSenderUserId = Guid.NewGuid();
var fakeRecevierId = Guid.NewGuid();
var fakeMessageText = "hello";
var fakeModel = new SendMessageApiModel(fakeSenderUserId, fakeRecevierId, fakeMessageText);
_userServiceMock.Setup(w => w.IsSenderBlockedByReceiver(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(Task.FromResult(true));
//Arrenge
var service = CreateService();
async Task act() => await service.SendMessage(fakeModel);
//Assert
await Assert.ThrowsAsync <MessagingDomainException>(act);
}
public async Task <IActionResult> SendMessage(string id, string message)
{
Message msg = new Message();
var userid = User.FindFirst(ClaimTypes.NameIdentifier).Value;
msg.Sender = userid;
msg.Receiver = id;
msg.Body = message;
await _context.Messages.AddAsync(msg);
await _context.SaveChangesAsync();
SendMessageApiModel msgmodel = new SendMessageApiModel();
msgmodel.Sender_Profile_Picture = _context.Profiles.First(a => a.User_Id == userid).profile_Picture_Url;
msgmodel.Sender_First_Name = _context.Profiles.First(a => a.User_Id == userid).First_Name;
msgmodel.Sender_Last_Name = _context.Profiles.First(a => a.User_Id == userid).Last_Name;
msgmodel.Message = message;
return(Json(msgmodel));
}
public async Task SendMessage_success(bool data, bool commitResult)
{
//Act
var fakeSenderUserId = Guid.NewGuid();
var fakeRecevierId = Guid.NewGuid();
var fakeMessageText = "hello";
var generatedMessageId = 1;
var fakeModel = new SendMessageApiModel(fakeSenderUserId, fakeRecevierId, fakeMessageText);
_userServiceMock.Setup(w => w.IsSenderBlockedByReceiver(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(Task.FromResult(false));
_repositoryMock.Setup(w => w.AddAsync(It.IsAny <Message>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(default(Message)));
_repositoryMock.Setup(w => w.UnitOfWork.CommitAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(commitResult));
//Arrenge
var service = CreateService();
var result = await service.SendMessage(fakeModel);
//Assert
Assert.Equal(data, result);
}
public async Task <ActionResult> SendMessage(SendMessageApiModel apiModel)
{
if (string.IsNullOrEmpty(apiModel.UsernameToSend))
{
return(BadRequest("UsernameToSend is null or empty"));
}
if (string.IsNullOrEmpty(apiModel.MessageText))
{
return(BadRequest("MessageText is null or empty"));
}
var userIdtoSend = await _identityService.GetUserIdByUsername(apiModel.UsernameToSend);
if (userIdtoSend == Guid.Empty)
{
return(NotFound("User not found"));
}
var sendMessageModel = new SendMessageInternalApiModel(_identityService.GetCurrentUserId(), userIdtoSend, apiModel.MessageText);
await _messagingService.SendMessage(sendMessageModel);
return(Ok());
}
public async Task <ActionResult> GetMessages(string id)
{
string userid = User.FindFirst(ClaimTypes.NameIdentifier).Value;
SendMessageApiModel msg = new SendMessageApiModel();
try
{
Message message = _context.Messages.First(a => a.Sender == id && a.Receiver == userid && a.seen == false);
msg.Sender_Profile_Picture = _context.Profiles.First(a => a.User_Id == message.Sender).profile_Picture_Url;
msg.Sender_First_Name = _context.Profiles.First(a => a.User_Id == message.Sender).First_Name;
msg.Sender_Last_Name = _context.Profiles.First(a => a.User_Id == message.Sender).Last_Name;
msg.Message = message.Body;
await _context.SaveChangesAsync();
message.seen = true;
_context.Update(message);
await _context.SaveChangesAsync();
}
catch (Exception a)
{
msg = null;
}
return(Json(msg));
}
