public async Task SendPrivateChatMessage_ParticipantConnected_ReceiveNotificationAndAddToSubscriptions()
{
const string message = "Hello";
// arrange
var(connection, conference) = await ConnectToOpenedConference();
var olaf = CreateUser();
var olafConnection = await ConnectUserToConference(olaf, conference);
var channel = ChannelSerializer
.Encode(new PrivateChatChannel(new HashSet <string> {
olaf.Sub, Moderator.Sub
})).ToString();
var chatMessageNotification = new TaskCompletionSource <ChatMessageDto>();
olafConnection.Hub.On(CoreHubMessages.ChatMessage,
(ChatMessageDto dto) => chatMessageNotification.SetResult(dto));
// act
await connection.Hub.InvokeAsync(nameof(CoreHub.SendChatMessage),
new SendChatMessageDto(message, channel, new ChatMessageOptions()));
// assert
await chatMessageNotification.Task.WithDefaultTimeout();
var syncSubscriptionsId = SynchronizedSubscriptions.SyncObjId(connection.User.Sub);
await connection.SyncObjects.AssertSyncObject <SynchronizedSubscriptions>(syncSubscriptionsId,
value => Assert.Contains(value.Subscriptions.Keys, x => x == channel));
}
public async Task <SuccessOrError <Unit> > Handle(SendChatMessageRequest request,
CancellationToken cancellationToken)
{
var(participant, _, channel, _) = request;
var conferenceId = participant.ConferenceId;
var message = await BuildChatMessage(request);
var channelId = ChannelSerializer.Encode(channel);
var messagesCount =
await _chatRepository.AddChatMessageAndGetMessageCount(conferenceId, channelId.ToString(), message);
var subscribedParticipants =
await _mediator.Send(new FetchSubscribedParticipantsRequest(conferenceId, channelId));
if (channel is PrivateChatChannel privateChatChannel)
{
subscribedParticipants = await UpdateParticipantsSubscriptionsIfNecessary(subscribedParticipants,
privateChatChannel, participant.ConferenceId);
}
await _mediator.Publish(new ChatMessageReceivedNotification(conferenceId, subscribedParticipants, message,
channel, messagesCount));
await _mediator.Send(new SetParticipantTypingRequest(participant, channel, false));
return(Unit.Value);
}
private async Task <SynchronizedObjectId> WaitForGlobalChat(UserConnection connection)
{
var chatChannels = await WaitForChatChannels(connection);
var globalChannelId = ChannelSerializer.Encode(GlobalChatChannel.Instance).ToString();
return(chatChannels.Single(x => x.ToString() == globalChannelId));
}
public async Task <EntityPage <ChatMessage> > Handle(FetchMessagesRequest request,
CancellationToken cancellationToken)
{
var(conferenceId, chatChannel, start, end) = request;
var channelId = ChannelSerializer.Encode(chatChannel).ToString();
return(await _chatRepository.FetchMessages(conferenceId, channelId, start, end));
}
public async Task Handle(RoomsRemovedNotification notification, CancellationToken cancellationToken)
{
foreach (var removedRoomId in notification.RemovedRoomIds)
{
var channel = new RoomChatChannel(removedRoomId);
var channelId = ChannelSerializer.Encode(channel);
await _chatRepository.DeleteChannel(notification.ConferenceId, channelId.ToString());
}
}
public override void RunImpl()
{
Channel channel = ChannelSerializer.Load();
Rank rank = RankSerializer.Load();
Client.SendPacket(new PROTOCOL_BASE_GET_SYSTEM_INFO_ACK(rank, channel));
Client.SendPacket(new PROTOCOL_BASE_NOTICE_ACK());
Client.SendPacket(new PROTOCOL_BASE_URL_LIST_ACK());
Client.SendPacket(new PROTOCOL_BASE_MAP_RULELIST_ACK());
Client.SendPacket(new PROTOCOL_BASE_MAP_MATCHINGLIST_PART_1_ACK());
Client.SendPacket(new PROTOCOL_BASE_MAP_MATCHINGLIST_PART_2_ACK());
Client.SendPacket(new PROTOCOL_BASE_MAP_MATCHINGLIST_PART_3_ACK());
}
public static bool TryParseChatChannel(string s, [NotNullWhen(true)] out ChatChannel?channel)
{
try
{
channel = ChannelSerializer.Decode(SynchronizedObjectId.Parse(s));
return(true);
}
catch (Exception)
{
channel = null;
return(false);
}
}
public async Task Handle(ChatMessageReceivedNotification notification, CancellationToken cancellationToken)
{
var(_, participants, message, channel, messagesCount) = notification;
ChatMessageSender?sender = null;
if (!message.Options.IsAnonymous)
{
sender = message.Sender;
}
var channelId = ChannelSerializer.Encode(channel).ToString();
var messageDto = new ChatMessageDto(messagesCount - 1, channelId, sender, message.Message,
message.Timestamp, message.Options);
var participantGroups = participants.Select(CoreHubGroups.OfParticipant);
await _hubContext.Clients.Groups(participantGroups).ChatMessage(messageDto, cancellationToken);
}
public override void RunImpl()
{
Channel channel = ChannelSerializer.Load();
Client.SendPacket(new PROTOCOL_BASE_GET_CHANNELLIST_ACK(channel));
}
private SynchronizedObjectId GetChannelId(ChatChannel channel)
{
return(ChannelSerializer.Encode(channel));
}
