public async Task CheckIfThereAreNewMessageAsync()
{
ApplicationDbContext db = GetDb();
var chatGroupRepository = new EfDeletableEntityRepository <ChatGroup>(db);
var repository = new EfDeletableEntityRepository <ChatMessage>(db);
var userChatGroupsRepository = new EfDeletableEntityRepository <UserChatGroup>(db);
var service = new ChatsService(
repository,
chatGroupRepository,
userChatGroupsRepository);
await service.CreateUsersGroupAsync(this.sender, this.receiver, "chat name");
var groupId = await service.GetGroupIdAsync("chat name");
var firstChatMessage = new ChatMessage()
{
Id = Guid.NewGuid().ToString(),
Receiver = this.receiver,
Sender = this.sender,
ChatGroupId = groupId,
};
await repository.AddAsync(firstChatMessage);
await repository.SaveChangesAsync();
var isMessage = await service.IsNewMessageAsync();
Assert.True(isMessage);
}
public async Task CheckSendingMessageSenderClientAsync()
{
ApplicationDbContext db = GetDb();
var chatGroupRepository = new EfDeletableEntityRepository <ChatGroup>(db);
var repository = new EfDeletableEntityRepository <ChatMessage>(db);
var userChatGroupsRepository = new EfDeletableEntityRepository <UserChatGroup>(db);
var service = new ChatsService(
repository,
chatGroupRepository,
userChatGroupsRepository);
var currentSender = new ApplicationUser()
{
Id = "20",
UserName = "******",
};
var currentReceiver = new ApplicationUser()
{
Id = "21",
UserName = "******",
};
await service.CreateUsersGroupAsync(currentSender, currentReceiver, "chat name");
await service.SendMessageAsync("message content", currentSender, currentReceiver, "chat name");
var message = await repository.All().FirstOrDefaultAsync();
Assert.NotNull(repository);
Assert.True(message.WaitingForAnswerFromAdmin);
}
public async Task CheckGettingTheReceiverAsync()
{
ApplicationDbContext db = GetDb();
var userChatGroupsRepository = new EfDeletableEntityRepository <UserChatGroup>(db);
var chatGroupsRepository = new EfDeletableEntityRepository <ChatGroup>(db);
var service = new ChatsService(
this.chatMessagesRepository.Object,
chatGroupsRepository,
userChatGroupsRepository);
var currentSender = new ApplicationUser()
{
Id = "20",
UserName = "******",
};
var currentReceiver = new ApplicationUser()
{
Id = "21",
UserName = "******",
};
await service.CreateUsersGroupAsync(currentSender, currentReceiver, "chat name");
var groupId = await service.GetGroupIdAsync("chat name");
var firstReceiverId = await service.GetReceiverAsync(groupId, currentSender.UserName);
var secondReceiverId = await service.GetReceiverAsync(groupId, currentReceiver.UserName);
Assert.Equal(currentReceiver.Id, firstReceiverId);
Assert.Equal(currentSender.Id, secondReceiverId);
}
public IQueryable <MessageViewModel> GetMessages()
{
string userId = User.Identity.GetUserId();
string userName = User.Identity.Name;
return(ChatsService.GetUserMessages(userId, userName));
}
public void Init()
{
var participantsService = new ParticipantsService(
new InMemoryGameMapper(),
new InMemoryParticipantMapper());
var chatsService = new ChatsService(
new InMemoryChatMapper(),
new InMemoryUserMapper()
);
target = new MessagesProcessor(participantsService, chatsService);
}
public async Task CheckSendingMessageSenderAdminAsync()
{
ApplicationDbContext db = GetDb();
var chatGroupRepository = new EfDeletableEntityRepository <ChatGroup>(db);
var repository = new EfDeletableEntityRepository <ChatMessage>(db);
var userChatGroupsRepository = new EfDeletableEntityRepository <UserChatGroup>(db);
var service = new ChatsService(
repository,
chatGroupRepository,
userChatGroupsRepository);
var currentSender = new ApplicationUser()
{
Id = "20",
UserName = "******",
};
var currentReceiver = new ApplicationUser()
{
Id = "21",
UserName = "******",
};
await service.CreateUsersGroupAsync(this.sender, this.receiver, "chat name");
var groupId = await service.GetGroupIdAsync("chat name");
var chatMessage = new ChatMessage()
{
Id = Guid.NewGuid().ToString(),
Receiver = currentReceiver,
Sender = currentSender,
ChatGroupId = groupId,
};
await repository.AddAsync(chatMessage);
await repository.SaveChangesAsync();
await service.CreateUsersGroupAsync(currentSender, currentReceiver, "chat name");
await service.SendMessageAsync("message content", currentReceiver, currentSender, "chat name");
var message = await repository.All().FirstOrDefaultAsync();
Assert.NotNull(repository);
Assert.True(!message.WaitingForAnswerFromAdmin);
}
public object GetInstance(InstanceContext instanceContext, Message message)
{
if (message == null)
{
throw new ApplicationException("Empty message");
}
var s = message.Headers.GetHeader <string>(ChatRoom.ChatRoomNameHeader, Namespaces.HeaderNamespace);
ChatsService <T> service = ((ServiceHostWithChats <T>)instanceContext.Host).ChatsService;
service.PerfCounters.Count(PerfCounters.ChatCommands2ServerPerSecond);
ClaimsPolicy.ServerCheck();
return(service.Rooms[service.FindRoomWithCheck(s)]);
}
public async Task CheckGettingWaitingForAnswerMessagesAsync()
{
ApplicationDbContext db = GetDb();
var chatGroupRepository = new EfDeletableEntityRepository <ChatGroup>(db);
var repository = new EfDeletableEntityRepository <ChatMessage>(db);
var userChatGroupsRepository = new EfDeletableEntityRepository <UserChatGroup>(db);
var service = new ChatsService(
repository,
chatGroupRepository,
userChatGroupsRepository);
await service.CreateUsersGroupAsync(this.sender, this.receiver, "chat name");
var groupId = await service.GetGroupIdAsync("chat name");
var firstChatMessage = new ChatMessage()
{
Id = Guid.NewGuid().ToString(),
Receiver = this.receiver,
Sender = this.sender,
ChatGroupId = groupId,
WaitingForAnswerFromAdmin = false,
};
var secondChatMessage = new ChatMessage()
{
Id = Guid.NewGuid().ToString(),
Receiver = this.receiver,
Sender = this.sender,
ChatGroupId = groupId,
};
await repository.AddAsync(firstChatMessage);
await repository.AddAsync(secondChatMessage);
await repository.SaveChangesAsync();
var messages = await service.GetWaitingForAnswerClientNamesAsync <TestChatModel>();
Assert.Single(messages);
}
public async Task CheckGettingGroupsOldMessagesAsync()
{
ApplicationDbContext db = GetDb();
var chatGroupRepository = new EfDeletableEntityRepository <ChatGroup>(db);
var repository = new EfDeletableEntityRepository <ChatMessage>(db);
var userChatGroupsRepository = new EfDeletableEntityRepository <UserChatGroup>(db);
var service = new ChatsService(
repository,
chatGroupRepository,
userChatGroupsRepository);
await service.CreateUsersGroupAsync(this.sender, this.receiver, "chat name");
var groupId = await service.GetGroupIdAsync("chat name");
var firstChatMessage = new ChatMessage()
{
Id = Guid.NewGuid().ToString(),
Receiver = this.receiver,
Sender = this.sender,
ChatGroupId = groupId,
};
var secondChatMessage = new ChatMessage()
{
Id = Guid.NewGuid().ToString(),
Receiver = this.receiver,
Sender = this.sender,
ChatGroupId = groupId,
};
await repository.AddAsync(firstChatMessage);
await repository.AddAsync(secondChatMessage);
await repository.SaveChangesAsync();
var messages = await service.GetOldMessagesAsync <TestChatModel>(groupId);
Assert.Equal(2, messages.Count());
}
public async Task CheckGettingGroupIdAsync()
{
ApplicationDbContext db = GetDb();
var chatGroupRepository = new EfDeletableEntityRepository <ChatGroup>(db);
var service = new ChatsService(
this.chatMessagesRepository.Object,
chatGroupRepository,
this.userChatGroupsRepository.Object);
var firstGroupId = await service.GetGroupIdAsync("chat name");
await service.CreateUsersGroupAsync(this.sender, this.receiver, "chat name");
var secondGroupId = await service.GetGroupIdAsync("chat name");
Assert.Null(firstGroupId);
Assert.NotNull(secondGroupId);
}
// POST api/chat/5
public IHttpActionResult Post(int id, [FromBody] MessageBindingModel model)
{
string userId = User.Identity.GetUserId();
Message message;
try
{
message = ChatsService.AddUserMessage(userId, id, model);
}
catch (NullReferenceException ex)
{
return(BadRequest());
}
catch (UnauthorizedAccessException ex)
{
return(Unauthorized());
}
return(Ok(message));
}
// GET api/chat/5
public IHttpActionResult GetChat(int id)
{
string userId = User.Identity.GetUserId();
List <MessageViewModel> messages;
try
{
messages = ChatsService.GetUserChatMessages(userId, id);
}
catch (NullReferenceException ex)
{
return(BadRequest());
}
catch (UnauthorizedAccessException ex)
{
return(Unauthorized());
}
return(Ok(messages));
}
public async Task CheckCreatingUsersGroupAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <ChatMessage>(db);
var chatGroupRepository = new EfDeletableEntityRepository <ChatGroup>(db);
var userChatGroupsRepository = new EfDeletableEntityRepository <UserChatGroup>(db);
var service = new ChatsService(
repository,
chatGroupRepository,
userChatGroupsRepository);
var firstChatGroupId = await service.CreateUsersGroupAsync(this.sender, this.receiver, "chat name");
var secondChatGroupId = await service.CreateUsersGroupAsync(this.sender, this.receiver, "chat name");
Assert.NotNull(firstChatGroupId);
Assert.NotNull(secondChatGroupId);
Assert.EndsWith(firstChatGroupId, secondChatGroupId);
}
public ChatsController(ChatsService chatsService)
{
this.chatsService = chatsService;
}
public ServiceHostWithChats(ChatsService <T> chatsService,
Type type, Uri uri) : base(type, uri)
{
ChatsService = chatsService;
}
public ValuesController(ChatHub chatHub, ChatsService chatsService)
{
this.chatHub = chatHub;
this.chatsService = chatsService;
}
