public void TestMessages_AddMessages_String()
{
MessageService.AddMessage("Unit Test 2 - Text");
Assert.AreEqual(1, MessageService.Messages.Count());
Assert.IsTrue(MessageService.Messages.Any(m => m.MessageText == "Unit Test 2 - Text"));
}
public async Task SendMessage(
//[FromServices]MessageService message,
//[FromServices]SessionService session,
//[FromServices]IMemoryCache cache,
long sessionId,
string content,
int contentType
)
{
await _message.AddMessage(Context.UserIdentifier, sessionId, content, MessageTypeEnum.User,
(MessageContentTypeEnum)contentType);
var sessionInfo = await _session.GetSessionById(sessionId);
if (sessionInfo.Type == SessionTypeEnum.OneToOne)
{
var s = await _session.GetSessionUserIds(sessionId);
var friendUserId = s.FirstOrDefault(x => x != Context.UserIdentifier);
if (_cache.TryGetValue(friendUserId, out _))
{
await Clients.User(friendUserId).SendAsync("ReceivedMessage", content);
}
}
else if (sessionInfo.Type == SessionTypeEnum.Group)
{
await Clients.Group(sessionInfo.SessionId.ToStringEx()).SendAsync("SendMessage", content);
}
}
public async Task <ActionResult <MessageViewModel> > CreateMessage(MessageInputViewModel viewModel)
{
var createdMessage = await MessageService.AddMessage(Mapper.Map <Message>(viewModel));
return(CreatedAtAction(nameof(GetMessage),
new { id = createdMessage.Id },
Mapper.Map <MessageViewModel>(createdMessage)));
}
public ActionResult <List <Message> > AddMessage([FromBody] Message message)
{
_logger.LogInformation("ChatController AddMessage");
message.Sent = DateTime.Now;
_service.AddMessage(message);
_hub.Clients.All.SendAsync("message", _service.Messages);
return(Ok(_service.Messages));
}
public void AddMessage_StringText_Bool_Test()
{
string hello = "Hello,world!!!";
bool status = true;
JsonFileSave jsonFile = new JsonFileSave();
MessageService message = new MessageService(jsonFile);
bool act = message.AddMessage(hello);
Assert.AreEqual(status, act);
}
public void AddMessage()
{
var mock = new Mock <IMessageData>(MockBehavior.Strict);
mock.Setup(x => x.AddMessage(1, 2, 3, "message", new DateTime()));
var messageService = new MessageService(mock.Object);
messageService.AddMessage(1, 2, 3, "message", new string[0], new DateTime());
mock.Verify(x => x.AddMessage(1, 2, 3, "message", new DateTime()), Times.Exactly(1));
}
public IActionResult Contacts(MessageBindingModel model, HttpResponse response)
{
if (string.IsNullOrEmpty(model.Email) || string.IsNullOrEmpty(model.Subject))
{
Redirect(response, "/home/contacts");
}
MessageService service = new MessageService(Data.Data.Context);
service.AddMessage(model);
Redirect(response, "home/index");
return(null);
}
public void TestAddMessage()
{
DateTime time = DateTime.Now;
List <Message> messages = createMessages();
foreach (var item in messages)
{
MessageService.AddMessage(item);
}
Assert.AreSame(MessageService.GetMessages("aaa", time), messages);
}
private void testMessageInsert()
{
MessageService service = new MessageService();
UserMessage result = new UserMessage
{
EntryDate = 20160828,
EntryTime = 235800,
UserName = "******",
Message = "Fourth Message.Its over service"
};
service.AddMessage(result);
}
static void Main(string[] args)
{
var service = new MessageService();
for (int i = 0; i < 10; i++)
{
var message = $"Created message {i + 1}";
service.AddMessage(message);
Console.WriteLine(message);
}
Console.Write("Press any key to exit...");
Console.ReadKey(true);
}
public async Task UnblockedUser_ReturnTrue(string messageLine, string senderUsername, string receiverUsername)
{
//arrange
mockMessageQueueRepository.Setup(x => x.GetMessageQueue(It.IsAny <string>(), It.IsAny <string>()))
.Returns((string senderUserName, string receiverUsername) =>
{
var messageQueue = new MessageQueue(Constants.MessageQueueKey, senderUserName, receiverUsername, Constants.MessageLines);
return(Task.FromResult(messageQueue));
});
mockMessageQueueRepository.Setup(x => x.UpdateMessageQueue(It.IsAny <MessageQueue>())).ReturnsAsync(true);
var messageHistory = new MessageHistroy(Constants.MessageHistoryKey, new List <string>()
{
senderUsername, receiverUsername
}, Constants.MessageEntities);
mockMessageHistoryRepository.Setup(x => x.GetMessageHistory(It.IsAny <string>(), It.IsAny <string>()))
.Returns((string senderUserName, string receiverUsername) =>
{
return(Task.FromResult(messageHistory));
});
mockUserProvider.Setup(x => x.IsUserRegistered(It.IsAny <string>())).ReturnsAsync(true);
mockUserProvider.Setup(x => x.IsBlockedByUser(It.IsAny <string>())).ReturnsAsync(false);
var messageService = new MessageService(
mockMessageQueueRepository.Object,
mockMessageHistoryRepository.Object,
mockUserProvider.Object,
logger.Object);
//act
var result = await messageService.AddMessage(messageLine, senderUsername, receiverUsername);
//assert
Assert.True(result.Success);
Assert.Equal(Messages.MessageSended, result.Message);
mockMessageQueueRepository.Verify(x => x.UpdateMessageQueue(It.IsAny <MessageQueue>()), Times.Once);
mockMessageQueueRepository.Verify(x => x.GetMessageQueue(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
mockUserProvider.Verify(x => x.IsUserRegistered(It.IsAny <string>()), Times.Once);
mockUserProvider.Verify(x => x.IsBlockedByUser(It.IsAny <string>()), Times.Once);
}
public async Task SendMessage(string to, string message)
{
int?uid = Context.GetHttpContext().Session.GetInt32("uid");
if (uid != null)
{
Uzer u = UserService.FindUserByID((int)uid);
int t;
if (Int32.TryParse(to, out t))
{
MessageService.AddMessage((int)uid, t, message, DateTime.Now);
}
string connId = _store.GetConnectionIdByUserId(to);
if (connId != null)
{
await Clients.Client(connId).SendAsync("ReceiveMessage", uid.ToString(), u.FirstName + " " + u.LastName, message);
}
}
}
public async Task UnRegisteredRecieverUser_ReturnFalse(string messageLine, string senderUsername, string receiverUsername)
{
//arrange
mockUserProvider.Setup(x => x.IsUserRegistered(It.IsAny <string>())).ReturnsAsync(false);
mockUserProvider.Setup(x => x.IsBlockedByUser(It.IsAny <string>())).ReturnsAsync(false);
var messageService = new MessageService(
mockMessageQueueRepository.Object,
mockMessageHistoryRepository.Object,
mockUserProvider.Object,
logger.Object);
//act
var result = await messageService.AddMessage(messageLine, senderUsername, receiverUsername);
//assert
Assert.False(result.Success);
Assert.Equal(Messages.UserNotFound, result.Message);
mockMessageQueueRepository.Verify(x => x.UpdateMessageQueue(It.IsAny <MessageQueue>()), Times.Never);
mockUserProvider.Verify(x => x.IsUserRegistered(It.IsAny <string>()), Times.Once);
mockUserProvider.Setup(x => x.IsBlockedByUser(It.IsAny <string>())).ReturnsAsync(false);
}
public ActionResult AddMessage(string StrContent)
{
MessageModel models = new MessageModel();
var MemberId = Guid.Empty;
if (Session["User"] != null)
{
string UserModel = Session["User"].ToString();
MemberId = new Guid(UserModel.Split('|')[1]);
models.UserId = MemberId;
models.UserName = UserModel.Split('|')[0];
}
models.StrContent = StrContent;
if (MSer.AddMessage(models) == true)
{
return(Content("1"));
}
else
{
return(Content("0"));
}
}
private static void SendMessage(Message m, DateTime dateTime)
{
Chat chat = GetChatById(m.ChatId);
if (chat == null)
{
// TODO: 是否需要抛出异常
Trace.WriteLine("Error: Send message failed,ChatId " + m.ChatId + " not exsit");
}
else if (chat.Status == ChatStatus.Closed)
{
// TODO: 是否需要抛出异常
Trace.WriteLine("Error: Send message failed,ChatId " + m.ChatId + " status is closed");
}
else
{
if (NewMessage != null)
{
NewMessage(null, new ChatMessageEventArgs(m));
}
m.SentDate = dateTime;
MessageService.AddMessage(m);
}
}
public IActionResult ResponseAddMessage([FromServices] MessageService messageService, ShortMessageModel data)
{
messageService.AddMessage(data);
this.TempData["responseAddMessage"] = "Add message success";
return(RedirectToAction("Message"));
}
public async Task BroadcastHelloAsync()
{
msgService.AddMessage("Hallo :D");
}
/// <summary>
/// 添加消息
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public static int AddMessage(Message message)
{
return(MessageService.AddMessage(message));
}
public Message AddMessage([Inject] MessageService service, MessageInput message) => service.AddMessage(new Message
{
Author = message.Author,
Text = message.Text
});
public bool AddMsg(MessageInfo mi)
{
return(_ms.AddMessage(mi));
}
public IActionResult Post([FromBody] CreateMessageCommand cmd)
{
_messageService.AddMessage(cmd.message);
return(NoContent());
}
public async Task SendMessage(string user, string message)
{
messageService.AddMessage(user, message);
await Clients.All.SendAsync("ReceiveMessage", user, message);
}