Servers, console and power

$user = $request->user();
$transformer = $this->getTransformer(ServerTransformer::class);

$builder = QueryBuilder::for(
    Server::query()->with($this->getIncludesForTransformer($transformer, ['node']))
)->allowedFilters(
    'uuid',
    'name',
    'description',
    'external_id',
    AllowedFilter::custom('*', new MultiFieldServerFilter()),
);

$type = $request->input('type');

if (in_array($type, ['admin', 'admin-all'])) {

    if (!$user->root_admin) {
        $builder->whereRaw('1 = 2');
    } else {
        $builder = $type === 'admin-all'
            ? $builder
            : $builder->whereNotIn('servers.id', $user->accessibleServers()->pluck('id')->all());
    }
} elseif ($type === 'owner') {
    $builder = $builder->where('servers.owner_id', $user->id);
} else {
    $builder = $builder->whereIn('servers.id', $user->accessibleServers()->pluck('id')->all());
}

$servers = $builder->paginate(min($request->query('per_page', 50), 100))->appends($request->query());

return $this->fractal->transformWith($transformer)->collection($servers)->toArray();

return $this->fractal->item($server)
    ->transformWith($this->getTransformer(ServerTransformer::class))
    ->addMeta([
        'is_server_owner' => $request->user()->id === $server->owner_id,
        'user_permissions' => $this->permissionsService->handle($server, $request->user()),
    ])
    ->toArray();

$user = $request->user();
if ($user->cannot(Permission::ACTION_WEBSOCKET_CONNECT, $server)) {
    throw new HttpForbiddenException('You do not have permission to connect to this server\'s websocket.');
}

$permissions = $this->permissionsService->handle($server, $user);

$node = $server->node;
if (!is_null($server->transfer)) {

    if (!in_array('admin.websocket.transfer', $permissions)) {
        throw new HttpForbiddenException('You do not have permission to view server transfer logs.');
    }

    if ($server->transfer->archived) {
        $node = $server->transfer->newNode;
    }
}

$token = $this->jwtService
    ->setExpiresAt(CarbonImmutable::now()->addMinutes(10))
    ->setUser($request->user())
    ->setClaims([
        'server_uuid' => $server->uuid,
        'permissions' => $permissions,
    ])
    ->setScopes(JwtScope::Websocket)
    ->handle($node, $user->id . $server->uuid);

$socket = str_replace(['https://', 'http://'], ['wss://', 'ws://'], $node->getConnectionAddress());

return new JsonResponse([
    'data' => [
        'token' => $token->toString(),
        'socket' => $socket . sprintf('/api/servers/%s/ws', $server->uuid),
    ],
]);

$key = "resources:$server->uuid";
$stats = $this->cache->remember($key, Carbon::now()->addSeconds(20), function () use ($server) {
    return $this->repository->setServer($server)->getDetails();
});

return $this->fractal->item($stats)
    ->transformWith($this->getTransformer(StatsTransformer::class))
    ->toArray();

$target = $settings->target($server);
$result = ['status' => 'unsupported', 'players' => null, 'max_players' => null, 'checked_at' => null, 'game' => null];
if ($target) {
    $key = $settings->key($server, $target);
    $result = Cache::get($key) ?? array_merge($result, ['status' => 'pending', 'game' => $target['type']]);
    $age = $result['checked_at'] ? now()->diffInSeconds($result['checked_at'], true) : PHP_INT_MAX;
    if ($age >= config('game-query.cache_seconds') && Cache::add($key . ':pending', true, 120)) {
        $job = new QueryGameServerJob($server->id, $key);
        if (config('queue.default') === 'sync') {
            dispatch($job)->afterResponse();
        } else {
            dispatch($job);
        }
    }
}

return ['object' => 'game_query', 'attributes' => $result];

$this->authorize(Permission::ACTION_ACTIVITY_READ, $server);

$query = $server->activity()
    ->whereNotIn('activity_logs.event', ActivityLog::DISABLED_EVENTS)
    ->when(config('activity.hide_admin_activity'), function (Builder $builder) use ($server) {

        $subusers = $server->subusers()->pluck('user_id')->merge($server->owner_id);

        $builder->select('activity_logs.*')
            ->leftJoin('users', function (JoinClause $join) {
                $join->on('users.id', 'activity_logs.actor_id')
                    ->where('activity_logs.actor_type', (new User())->getMorphClass());
            })
            ->where(function (Builder $builder) use ($subusers) {
                $builder->whereNull('users.id')
                    ->orWhere('users.root_admin', 0)
                    ->orWhereIn('users.id', $subusers);
            });
    });
$events = $filters->availableEvents($query->getQuery());

$activity = QueryBuilder::for($query)
    ->with('actor')
    ->allowedSorts('timestamp')
    ->defaultSort('-timestamp')
    ->orderBy('activity_logs.id', 'desc')
    ->allowedFilters(...$filters->allowedFilters($request->user()))
    ->paginate(min($request->query('per_page', 25), 100))
    ->appends($request->query());

return $this->fractal->collection($activity)
    ->transformWith($this->getTransformer(ActivityLogTransformer::class))
    ->addMeta(['available_events' => $events])
    ->toArray();

try {
    $this->repository->setServer($server)->send($request->input('command'));
} catch (DaemonConnectionException $exception) {
    $previous = $exception->getPrevious();

    if ($previous instanceof BadResponseException) {
        if ($previous->getResponse()->getStatusCode() === Response::HTTP_BAD_GATEWAY) {
            throw new HttpException(Response::HTTP_BAD_GATEWAY, 'Server must be online in order to send commands.', $exception);
        }
    }

    throw $exception;
}

Activity::event('server:console.command')->property('command', $request->input('command'))->log();

return $this->returnNoContent();

return config('aquadactyl.features.console_log_sharing', false) === true && parent::authorize();

try {
    $url = $debug->upload($redactor->redact($request->validated('content'), $server), 86400);
} catch (\Throwable) {

    return new JsonResponse(['errors' => [['detail' => 'Unable to share console logs. Please try again later.']]], 503);
}

return new JsonResponse(['url' => $url, 'expires_in' => 86400]);

return Task::permissionForAction(Task::ACTION_POWER, $this->input('signal')) ?? '__invalid';

$this->repository->setServer($server)->send(
    $request->input('signal')
);
Cache::forget("resources:$server->uuid");
if ($target = $queries->target($server)) {
    Cache::forget($queries->key($server, $target));
}

Activity::event(strtolower("server:power.{$request->input('signal')}"))->log();

return $this->returnNoContent();