public static IEnumerable <string> GetParticipantIdsSubscribedTo(
IReadOnlyDictionary <string, IReadOnlyList <string>?> subscriptions,
SynchronizedObjectId synchronizedObjectId)
{
var idString = synchronizedObjectId.ToString();
return(subscriptions.Where(x => x.Value?.Contains(idString) == true).Select(x => x.Key));
}
private async ValueTask SendCurrentSynchronizedObjectValue(Participant participant,
SynchronizedObjectId syncObjId)
{
var value = await _mediator.Send(new FetchSynchronizedObjectRequest(participant.ConferenceId, syncObjId));
await _mediator.Publish(new SynchronizedObjectUpdatedNotification(participant.Yield().ToImmutableList(),
syncObjId.ToString(), value, null));
}
public static void SetupSyncObj <T>(this Mock <IMediator> mediator, SynchronizedObjectId syncObjId, T syncObj)
where T : notnull
{
mediator.Setup(x =>
x.Send(
It.Is <FetchSynchronizedObjectRequest>(request =>
request.SyncObjId.ToString().Equals(syncObjId.ToString())), It.IsAny <CancellationToken>()))
.ReturnsAsync(syncObj);
}
private ISynchronizedObjectProvider GetProvider(SynchronizedObjectId synchronizedObjectId)
{
var provider = _providers.FirstOrDefault(x => x.Id == synchronizedObjectId.Id);
if (provider == null)
{
throw new InvalidOperationException($"There was no provider registered for {synchronizedObjectId.Id}.");
}
return(provider);
}
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);
}
}
protected override async ValueTask <SynchronizedChat> InternalFetchValue(string conferenceId,
SynchronizedObjectId synchronizedObjectId)
{
var conference = await _mediator.Send(new FindConferenceByIdRequest(conferenceId));
if (!conference.Configuration.Chat.ShowTyping)
{
return(new SynchronizedChat(ImmutableDictionary <string, bool> .Empty));
}
var participantsTyping =
await _chatRepository.GetAllParticipantsTyping(conferenceId, synchronizedObjectId.ToString());
return(new SynchronizedChat(participantsTyping.ToImmutableDictionary(x => x, _ => true)));
}
protected override async ValueTask <SynchronizedPoll> InternalFetchValue(string conferenceId,
SynchronizedObjectId synchronizedObjectId)
{
var pollId = synchronizedObjectId.Parameters[PROP_POLL_ID];
var poll = await _repository.GetPoll(conferenceId, pollId);
if (poll == null)
{
return(GetDefaultSynchronizedPoll(pollId));
}
var state = await _repository.GetPollState(conferenceId, pollId) ?? PollState.Default;
return(new SynchronizedPoll(pollId, poll.Instruction, poll.Config, state, poll.CreatedOn));
}
public static ChatChannel Decode(SynchronizedObjectId channel)
{
var typeString = channel.Parameters[PROP_TYPE];
var type = StringToChannelType(typeString);
switch (type)
{
case ChatChannelType.Global:
return(GlobalChatChannel.Instance);
case ChatChannelType.Room:
return(new RoomChatChannel(channel.Parameters["roomId"]));
case ChatChannelType.Private:
return(new PrivateChatChannel(new HashSet <string>
{
channel.Parameters["p1"], channel.Parameters["p2"],
}));
default:
throw new ArgumentOutOfRangeException();
}
}
protected override async ValueTask <SynchronizedEquipment> InternalFetchValue(string conferenceId,
SynchronizedObjectId synchronizedObjectId)
{
var participantId = synchronizedObjectId.Parameters[SynchronizedEquipment.PROP_PARTICIPANT_ID];
var joinedParticipant = new Participant(conferenceId, participantId);
var connections = await _repository.GetConnections(joinedParticipant);
return(new SynchronizedEquipment(connections));
}
public static async Task <T> FetchSynchronizedObject <T>(this IMediator mediator, string conferenceId,
SynchronizedObjectId id) where T : class
{
return((T)await mediator.Send(new FetchSynchronizedObjectRequest(conferenceId, id)));
}
protected override async ValueTask <SynchronizedPollAnswers> InternalFetchValue(string conferenceId,
SynchronizedObjectId synchronizedObjectId)
{
var participantId = synchronizedObjectId.Parameters[PROP_PARTICIPANT_ID];
var conferencePolls = await _repository.GetPollsOfConference(conferenceId);
var answers = await _repository.GetPollAnswersOfParticipant(new Participant(conferenceId, participantId),
conferencePolls.Select(x => x.Id));
return(new SynchronizedPollAnswers(answers.ToDictionary(x => x.Key, x => x.Value)));
}
protected override async ValueTask <SynchronizedPollResult> InternalFetchValue(string conferenceId,
SynchronizedObjectId synchronizedObjectId)
{
var pollId = synchronizedObjectId.Parameters[PROP_POLL_ID];
var result = await _mediator.Send(new FetchPollResultsRequest(conferenceId, pollId));
return(new SynchronizedPollResult(pollId, result.Results, result.ParticipantsAnswered,
result.TokenIdToParticipant));
}
