public async Task SetConsoleActor([FromBody] ConsoleRequest model)
        {
            await Validate(new Entity { Id = model.SessionId });

            var isTeamMember = await ChallengeService.UserIsTeamPlayer(model.SessionId, Actor.Id);

            if (isTeamMember)
            {
                ActorMap.Update(
                    await ChallengeService.SetConsoleActor(model, Actor.Id, Actor.ApprovedName)
                    );
            }
        }
Beispiel #2
0
        internal async Task <ConsoleActor> SetConsoleActor(ConsoleRequest model, string id, string name)
        {
            var entity = await Store.DbSet
                         .Include(c => c.Player)
                         .FirstOrDefaultAsync(c => c.Id == model.SessionId)
            ;

            return(new ConsoleActor
            {
                UserId = id,
                UserName = name,
                PlayerName = entity.Player.Name,
                ChallengeName = entity.Name,
                ChallengeId = model.SessionId,
                GameId = entity.GameId,
                TeamId = entity.TeamId,
                VmName = model.Name,
                Timestamp = DateTimeOffset.UtcNow
            });
        }
Beispiel #3
0
        public async Task <ConsoleSummary> GetConsole(ConsoleRequest model, bool observer)
        {
            var challenge = Mapper.Map <Challenge>(
                await Store.Retrieve(model.SessionId)
                );

            if (!challenge.State.Vms.Any(v => v.Name == model.Name))
            {
                throw new ResourceNotFound();
            }

            switch (model.Action)
            {
            case ConsoleAction.Ticket:

                return(Mapper.Map <ConsoleSummary>(
                           await Mojo.GetVmTicketAsync(model.Id)
                           ));

            case ConsoleAction.Reset:

                var vm = await Mojo.ChangeVmAsync(
                    new VmOperation
                {
                    Id   = model.Id,
                    Type = VmOperationType.Reset
                }
                    );

                return(new ConsoleSummary
                {
                    Id = vm.Id,
                    Name = vm.Name,
                    SessionId = model.SessionId,
                    IsRunning = vm.State == VmPowerState.Running,
                    IsObserver = observer
                });
            }

            throw new InvalidConsoleAction();
        }
        public async Task <ConsoleSummary> GetConsole([FromBody] ConsoleRequest model)
        {
            await Validate(new Entity { Id = model.SessionId });

            var isTeamMember = await ChallengeService.UserIsTeamPlayer(model.SessionId, Actor.Id);

            AuthorizeAny(
                () => Actor.IsDirector,
                () => Actor.IsObserver,
                () => isTeamMember
                );

            var result = await ChallengeService.GetConsole(model, isTeamMember.Equals(false));

            if (isTeamMember)
            {
                ActorMap.Update(
                    await ChallengeService.SetConsoleActor(model, Actor.Id, Actor.ApprovedName)
                    );
            }

            return(result);
        }