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"); }