public static async ValueTask <SuccessOrError <Unit> > VerifyCanSendToChatChannel(ServiceInvokerContext context,
ChatChannel channel)
{
var selector = context.Context.Resolve <IChatChannelSelector>();
var canSend = await selector.CanParticipantSendMessageToChannel(context.Participant, channel);
if (!canSend)
{
return(ChatError.InvalidChannel);
}
if (channel is PrivateChatChannel)
{
var mediator = context.Context.Resolve <IMediator>();
var conference = await mediator.Send(new FindConferenceByIdRequest(context.Participant.ConferenceId));
var options = conference.Configuration.Chat;
if (!options.IsPrivateChatEnabled)
{
return(ChatError.PrivateMessagesDisabled);
}
}
return(SuccessOrError <Unit> .Succeeded(Unit.Value));
}
public static async ValueTask <SuccessOrError <Unit> > ValidateConferenceIsOpen(ServiceInvokerContext context)
{
var openConferenceRepo = context.Context.Resolve <IOpenConferenceRepository>();
if (!await openConferenceRepo.IsOpen(context.Participant.ConferenceId))
{
return(ConferenceError.ConferenceNotOpen);
}
return(SuccessOrError <Unit> .Succeeded(Unit.Value));
}
public async Task <SuccessOrError <Unit> > TalkingStickTake()
{
var participant = GetContextParticipant();
var roomId = await GetParticipantRoomId(participant);
if (roomId == null)
{
return(SuccessOrError <Unit> .Failed(SceneError.RoomNotFound));
}
return(await GetInvoker().Create(new TalkingStickPassRequest(participant, roomId, false))
.RequirePermissions(DefinedPermissions.Scenes.CanTakeTalkingStick).Send());
}
public async Task <SuccessOrError <Unit> > SetOverwrittenScene(IScene?scene)
{
var participant = GetContextParticipant();
var roomId = await GetParticipantRoomId(participant);
if (roomId == null)
{
return(SuccessOrError <Unit> .Failed(SceneError.RoomNotFound));
}
return(await GetInvoker()
.Create(new SetOverwrittenContentSceneRequest(participant.ConferenceId, roomId, scene))
.RequirePermissions(DefinedPermissions.Scenes.CanOverwriteContentScene).Send());
}
public async Task <SuccessOrError <Unit> > UpdateStatus(Dictionary <ProducerSource, UseMediaStateInfo> dto)
{
try
{
var(participant, _) = GetContextParticipantWithToken();
await _mediator.Send(new UpdateStatusRequest(participant, Context.ConnectionId, dto));
return(SuccessOrError <Unit> .Succeeded(Unit.Value));
}
catch (Exception e)
{
LogException(e, dto);
return(e.ToError());
}
}
public async Task <SuccessOrError> RevokeToken(string token)
{
var oldRefreshToken = await _context.RefreshTokens
.Include(x => x.User)
.SingleOrDefaultAsync(x => x.Token == token);
if (oldRefreshToken == null)
{
return(IdentityErrors.InvalidRefreshToken);
}
_context.Remove(oldRefreshToken);
await _context.SaveChangesAsync();
return(SuccessOrError.FromSuccess());
}
public static async ValueTask <SuccessOrError <Unit> > ValidateObject <T>(ServiceInvokerContext context, T obj)
{
if (!context.Context.TryResolve <IValidator <T> >(out var validator))
{
return(SuccessOrError <Unit> .Succeeded(Unit.Value));
}
var result = validator.Validate(obj);
if (result.IsValid)
{
return(SuccessOrError <Unit> .Succeeded(Unit.Value));
}
return(result.ToError());
}
public async Task <SuccessOrError <Unit> > ErrorOccurred(Error dto)
{
try
{
var(participant, _) = GetContextParticipantWithToken();
await _mediator.Publish(new EquipmentErrorNotification(participant, Context.ConnectionId, dto));
return(SuccessOrError <Unit> .Succeeded(Unit.Value));
}
catch (Exception e)
{
LogException(e, dto);
return(e.ToError());
}
}
public async Task <SuccessOrError <Unit> > Initialize(InitializeEquipmentDto dto)
{
try
{
var(participant, _) = GetContextParticipantWithToken();
await _mediator.Send(new InitializeEquipmentRequest(participant, Context.ConnectionId, dto.Name,
dto.Devices));
return(SuccessOrError <Unit> .Succeeded(Unit.Value));
}
catch (Exception e)
{
LogException(e, dto);
return(e.ToError());
}
}
public async Task <SuccessOrError <Unit> > SetScene(IScene?scene)
{
if (scene == null)
{
return(SuccessOrError <Unit> .Failed(new FieldValidationError("scene", "Scene must not be null")));
}
var participant = GetContextParticipant();
var roomId = await GetParticipantRoomId(participant);
if (roomId == null)
{
return(SuccessOrError <Unit> .Failed(SceneError.RoomNotFound));
}
return(await GetInvoker().Create(new SetSceneRequest(participant.ConferenceId, roomId, scene))
.RequirePermissions(DefinedPermissions.Scenes.CanSetScene).Send());
}
public async Task <SuccessOrError> Register(string emailAddress, string password, string userName)
{
var emailAddressTaken = await _context.Users
.AnyAsync(x =>
x.EmailAddress.ToLower() == emailAddress.ToLower() ||
x.UserName.ToLower() == userName.ToLower());
if (emailAddressTaken)
{
return(IdentityErrors.EmailTaken);
}
var hashedPassword = new SimpleHash().Compute(password);
var newUser = User.Create(emailAddress, hashedPassword, userName);
await _context.Users.AddAsync(newUser);
await _context.SaveChangesAsync();
return(SuccessOrError.FromSuccess());
}
public async Task <SuccessOrError <Unit> > TalkingStickPass(string?participantId)
{
if (participantId == null)
{
return(SuccessOrError <Unit> .Failed(new FieldValidationError(nameof(participantId),
"Participant id not be null")));
}
var participant = GetContextParticipant();
var roomId = await GetParticipantRoomId(participant);
if (roomId == null)
{
return(SuccessOrError <Unit> .Failed(SceneError.RoomNotFound));
}
return(await GetInvoker()
.Create(new TalkingStickPassRequest(new Participant(participant.ConferenceId, participantId), roomId,
false)).RequirePermissions(DefinedPermissions.Scenes.CanPassTalkingStick).Send());
}
public async Task <SuccessOrError> Handle(Guid userId)
{
var user = await _context.Users.SingleOrDefaultAsync(x => x.Id == userId);
if (user == null)
{
return(CommonErrors.UserNotExist);
}
if (user.WasSetup)
{
return(SuccessOrError.FromSuccess());
}
await InitializeDefaultExpenseTypes(user.Id);
user.Setup();
await _context.SaveChangesAsync();
return(SuccessOrError.FromSuccess());
}
public async Task <SuccessOrError <Unit> > Handle(ChangeBreakoutRoomsRequest request,
CancellationToken cancellationToken)
{
var(conferenceId, patch) = request;
await using (var @lock = await _repository.LockBreakoutRooms(conferenceId))
{
var current = await _repository.Get(conferenceId);
if (current == null)
{
return(BreakoutRoomError.NotOpen);
}
var newState = current.Config with {
}; // clone
patch.ApplyTo(newState);
await _mediator.Send(new ApplyBreakoutRoomRequest(conferenceId, newState, @lock));
}
return(SuccessOrError <Unit> .Succeeded(Unit.Value));
}
public static async ValueTask <SuccessOrError <Unit> > CheckPermissions(ServiceInvokerContext context,
params PermissionDescriptor <bool>[] requiredPermissions)
{
if (requiredPermissions.Length == 0)
{
return(SuccessOrError <Unit> .Succeeded(Unit.Value));
}
var participantPermissions = context.Context.Resolve <IParticipantPermissions>();
var permissions =
await participantPermissions.FetchForParticipant(context.Participant);
foreach (var permission in requiredPermissions)
{
var permissionValue = await permissions.GetPermissionValue(permission);
if (!permissionValue)
{
return(CommonError.PermissionDenied(permission));
}
}
return(SuccessOrError <Unit> .Succeeded(Unit.Value));
}
protected override async Task <SuccessOrError <TResponse> > CreateRequest(CancellationToken token)
{
var request = _lazyRequest.Value;
return(SuccessOrError <TResponse> .Succeeded(await _mediator.Send(request, token)));
}
protected void AssertSuccess <T>(SuccessOrError <T> successOrError)
{
Assert.True(successOrError.Success, $"Failed with error: {successOrError.Error?.Code}");
}
protected void AssertFailed <T>(SuccessOrError <T> successOrError)
{
Assert.False(successOrError.Success, "The call succeeded unexpectedly");
}
