ServersController - Code Metrics - Inspection of "Merge pull request #105 from et-nik/develop" - et-nik/gameap - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 805c58...4a8ad5 )

by Nikita

created 2024-06-01 15:15 UTC

ServersController C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	579
Duplicated Lines	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
wmc	53
eloc	250
dl	0
loc	579
rs	6.96
c	1
b	1
f	0

23 Methods

Rating	Name	Size	Complexity
A	consoleLog()	7	1
A	abilities()	23	5
A	summary()	20	2
A	save()	13	1
A	search()	4	1
A	restart()	22	4
A	handleException()	12	2
A	allServersAbilities()	31	6
A	update()	20	3
A	__construct()	18	1
A	store()	11	1
A	get()	56	2
A	makeErrorResponse()	6	1
A	destroy()	15	3
A	getList()	29	2
A	install()	20	3
A	start()	22	4
A	getDocMessage()	9	3
A	sendCommand()	9	1
A	reinstall()	14	2
A	query()	7	1
A	getStatus()	6	1
A	stop()	20	3

How to fix Complexity

<?php

namespace Gameap\Http\Controllers\API;

use Exception;
use Gameap\Exceptions\Repositories\GdaemonTaskRepository\EmptyServerStartCommandException;
use Gameap\Exceptions\Repositories\GdaemonTaskRepository\GdaemonTaskRepositoryException;
use Gameap\Exceptions\Repositories\RecordExistExceptions;
use Gameap\Helpers\PermissionHelper;
use Gameap\Helpers\ServerPermissionHelper;
use Gameap\Http\Controllers\AuthController;
.
|-- OtherDir
|   |-- Bar.php
|   `-- Foo.php
`-- SomeDir
    `-- Foo.php
use Gameap\Http\Requests\Admin\ServerDestroyRequest;
use Gameap\Http\Requests\API\SaveServerRequest;
use Gameap\Http\Requests\API\ServerConsoleCommandRequest;
use Gameap\Models\GdaemonTask;
use Gameap\Models\Server;
use Gameap\Models\User;
use Gameap\Repositories\GdaemonTaskRepository;
use Gameap\Repositories\ServerRepository;
use Gameap\Services\ServerControlService;
use Gameap\Services\ServerService;
use Gameap\UseCases\Commands\CreateGameServerCommand;
use Gameap\UseCases\Commands\EditGameServerCommand;
use Gameap\UseCases\CreateGameServer;
use Gameap\UseCases\EditGameServer;
use Illuminate\Contracts\Auth\Factory as AuthFactory;
use Psr\SimpleCache\CacheInterface;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Symfony\Component\Serializer\SerializerInterface;

class ServersController extends AuthController
{
    /**
     * The ServerRepository instance.
     *
     * @var \Gameap\Repositories\ServerRepository
     */
    public $repository;

    /**
     * The GdaemonTaskRepository instance.
     *
     * @var GdaemonTaskRepository
     */
    public $gdaemonTaskRepository;

    /** @var \Gameap\Services\ServerService  */
    public $serverService;

    /** @var \Gameap\Services\ServerControlService */
    public $serverControlService;

    /** @var SerializerInterface */
    protected $serializer;

    /** @var AuthFactory */
    protected $authFactory;

    /** @var CacheInterface */
    protected $cache;

    /**
     * ServersController constructor.
     * @param ServerRepository $repository
     */
    public function __construct(
        ServerRepository $repository,
        GdaemonTaskRepository $gdaemonTaskRepository,
        ServerService $serverService,
        ServerControlService $serverControlService,
        SerializerInterface $serializer,
        AuthFactory $authFactory,
        CacheInterface $cache
    ) {
        parent::__construct();

        $this->repository            = $repository;
        $this->gdaemonTaskRepository = $gdaemonTaskRepository;
        $this->serverService         = $serverService;
        $this->serverControlService  = $serverControlService;
        $this->serializer            = $serializer;
        $this->authFactory           = $authFactory;
        $this->cache                 = $cache;
    }

    /**
     * @param Server $server
     *
     * @return array|\Illuminate\Http\JsonResponse
     *
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function get(Server $server)
    {
        $this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);

        /** @var User $currentUser */
        $currentUser = $this->authFactory->guard()->user();
        $isAdmin = $currentUser->can(PermissionHelper::ADMIN_PERMISSIONS);

        if ($isAdmin) {
            return $server->only([
                'id',
                'uuid',
                'uuid_short',
                'enabled',
                'installed',
                'blocked',
                'name',
                'ds_id',
                'game_id',
                'game_mod_id',
                'server_ip',
                'server_port',
                'query_port',
                'rcon_port',
                'game',
                'last_process_check',
                'online',

                // Admin details
                'rcon',
                'dir',
                'su_user',
                'start_command',
                'aliases',
                'vars',
            ]);
        }

        return $server->only([
            'id',
            'uuid',
            'uuid_short',
            'enabled',
            'installed',
            'blocked',
            'name',
            'ds_id',
            'game_id',
            'game_mod_id',
            'server_ip',
            'server_port',
            'query_port',
            'rcon_port',
            'game',
            'last_process_check',
            'online',
        ]);
    }

    /**
     * @param Server $server
     *
     * @return array|\Illuminate\Http\JsonResponse
     *
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function abilities(Server $server)
    {
        /** @var User $currentUser */
        $currentUser = $this->authFactory->guard()->user();
        $isAdmin = $currentUser->can(PermissionHelper::ADMIN_PERMISSIONS);

        if (!$isAdmin) {
            $servers = $this->repository->getServersForUser($currentUser->id);
            if (!$servers->contains($server)) {
                return response()->json([
                    'message'   => 'Forbidden',
                    'http_code' => Response::HTTP_FORBIDDEN,
                ], Response::HTTP_FORBIDDEN);
            }
        }

        $abilities = [];

        foreach (ServerPermissionHelper::getAllPermissions() as $permission) {
            $abilities[$permission] = $isAdmin || $currentUser->can($permission, $server);
        }

        return $abilities;
    }

    /**
     * @param Server $server
     *
     * @return array|\Illuminate\Http\JsonResponse
     *
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function start(Server $server)
    {
        $this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
        $this->authorize(ServerPermissionHelper::START_ABILITY, $server);

        try {
            $gdaemonTaskId = $this->serverControlService->start($server);
        } catch (GdaemonTaskRepositoryException $exception) {
            return $this->handleException($exception);
        } catch (RecordExistExceptions $exception) {
            $gdaemonTaskId = $this->gdaemonTaskRepository->getOneWorkingTaskId(
                $server->id,
                GdaemonTask::TASK_SERVER_START
            );

            if (!$gdaemonTaskId) {
                return $this->makeErrorResponse($exception->getMessage());
            }
        }

        return [
            'gdaemonTaskId' => $gdaemonTaskId,
        ];
    }

    /**
     * @param Server $server
     *
     * @return array|\Illuminate\Http\JsonResponse
     *
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function stop(Server $server)
    {
        $this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
        $this->authorize(ServerPermissionHelper::STOP_ABILITY, $server);

        try {
            $gdaemonTaskId = $this->serverControlService->stop($server);
        } catch (RecordExistExceptions $exception) {
            $gdaemonTaskId = $this->gdaemonTaskRepository->getOneWorkingTaskId(
                $server->id,
                GdaemonTask::TASK_SERVER_STOP
            );

            if (!$gdaemonTaskId) {
                return $this->makeErrorResponse($exception->getMessage());
            }
        }

        return [
            'gdaemonTaskId' => $gdaemonTaskId,
        ];
    }

    /**
     * @param Server $server
     * @return array|\Illuminate\Http\JsonResponse
     *
     * @throws \Gameap\Exceptions\Repositories\RecordExistExceptions
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function restart(Server $server)
    {
        $this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
        $this->authorize(ServerPermissionHelper::RESTART_ABILITY, $server);

        try {
            $gdaemonTaskId = $this->serverControlService->restart($server);
        } catch (GdaemonTaskRepositoryException $exception) {
            return $this->handleException($exception);
        } catch (RecordExistExceptions $exception) {
            $gdaemonTaskId = $this->gdaemonTaskRepository->getOneWorkingTaskId(
                $server->id,
                GdaemonTask::TASK_SERVER_RESTART
            );

            if (!$gdaemonTaskId) {
                return $this->makeErrorResponse($exception->getMessage());
            }
        }

        return [
            'gdaemonTaskId' => $gdaemonTaskId,
        ];
    }

    /**
     * @param Server $server
     * @return array|\Illuminate\Http\JsonResponse
     *
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function update(Server $server)
    {
        $this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
        $this->authorize(ServerPermissionHelper::UPDATE_ABILITY, $server);

        try {
            $gdaemonTaskId = $this->serverControlService->update($server);
        } catch (RecordExistExceptions $exception) {
            $gdaemonTaskId = $this->gdaemonTaskRepository->getOneWorkingTaskId(
                $server->id,
                GdaemonTask::TASK_SERVER_UPDATE
            );

            if (!$gdaemonTaskId) {
                return $this->makeErrorResponse($exception->getMessage());
            }
        }

        return [
            'gdaemonTaskId' => $gdaemonTaskId,
        ];
    }

    /**
     * @param Server $server
     * @return array|\Illuminate\Http\JsonResponse
     *
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function install(Server $server)
    {
        $this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
        $this->authorize(ServerPermissionHelper::UPDATE_ABILITY, $server);

        try {
            $gdaemonTaskId = $this->serverControlService->install($server);
        } catch (RecordExistExceptions $exception) {
            $gdaemonTaskId = $this->gdaemonTaskRepository->getOneWorkingTaskId(
                $server->id,
                GdaemonTask::TASK_SERVER_INSTALL
            );

            if (!$gdaemonTaskId) {
                return $this->makeErrorResponse($exception->getMessage());
            }
        }

        return [
            'gdaemonTaskId' => $gdaemonTaskId,
        ];
    }

    /**
     * @param Server $server
     * @return array|\Illuminate\Http\JsonResponse
     *
     * @throws \Gameap\Exceptions\Repositories\RecordExistExceptions
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function reinstall(Server $server)
    {
        $this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
        $this->authorize(ServerPermissionHelper::UPDATE_ABILITY, $server);

        try {
            $deleteTaskId  = $this->gdaemonTaskRepository->addServerDelete($server);
            $gdaemonTaskId = $this->gdaemonTaskRepository->addServerInstall($server, $deleteTaskId);
        } catch (RecordExistExceptions $exception) {
            return $this->makeErrorResponse($exception->getMessage());
        }

        return [
            'gdaemonTaskId' => $gdaemonTaskId,
        ];
    }

    /**
     * Get server status
     * @param Server $server
     * @return array
     *
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function getStatus(Server $server)
    {
        $this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);

        return [
            'processActive' => $server->processActive(),
        ];
    }

    /**
     * @param Server $server
     * @return array
     *
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function query(Server $server)
    {
        $this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);

        $query = $this->serverService->query($server);

        return $query;
    }

    /**
     * @param Server $server
     * @return array
     *
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function consoleLog(Server $server)
    {
        $this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
        $this->authorize(ServerPermissionHelper::CONSOLE_VIEW_ABILITY, $server);

        return [
            'console' => $this->serverService->getConsoleLog($server),
        ];
    }

    /**
     * @param ServerConsoleCommandRequest $request
     * @param Server $server
     * @return array
     *
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function sendCommand(ServerConsoleCommandRequest $request, Server $server)
    {
        $this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
        $this->authorize(ServerPermissionHelper::CONSOLE_SEND_ABILITY, $server);

        $command = $request->input('command');
        $this->serverService->sendConsoleCommand($server, $command);

        return ['message' => 'success'];
    }

    public function search(Request $request)
    {
        $query = $request->input('q');
        return $this->repository->search($query);
    }

    public function getList()
    {
        /** @var User $currentUser */
        $currentUser = $this->authFactory->guard()->user();

        if ($currentUser->can(PermissionHelper::ADMIN_PERMISSIONS)) {
            $collection = $this->repository->getAllServers()->collect();
        } else {
            $collection = $this->repository->getServersForUser($currentUser->id);
        }

        return $collection->map(function ($item) {
            return $item->only([
                'id',
                'uuid',
                'uuid_short',
                'enabled',
                'installed',
                'blocked',
                'name',
                'ds_id',
                'game_id',
                'game_mod_id',
                'server_ip',
                'server_port',
                'query_port',
                'rcon_port',
                'game',
                'online'
            ]);
        });
    }

    public function allServersAbilities()
    {
        /** @var User $currentUser */
        $currentUser = $this->authFactory->guard()->user();

        $cacheKey = 'users:' . $currentUser->id . ':servers-abilities';

        if ($this->cache->has($cacheKey)) {
            return $this->cache->get($cacheKey);
        }

        $isAdmin = $currentUser->can(PermissionHelper::ADMIN_PERMISSIONS);

        if ($isAdmin) {
            $servers = $this->repository->getAllServers()->collect();
        } else {
            $servers = $this->repository->getServersForUser($currentUser->id);
        }

        $abilities = [];
        foreach ($servers as $server) {
            $abilities[$server->id] = [];

            foreach (ServerPermissionHelper::getAllPermissions() as $permission) {
                $abilities[$server->id][$permission] = $isAdmin || $currentUser->can($permission, $server);
            }
        }

        $this->cache->set($cacheKey, $abilities, 60);

        return $abilities;
    }

    public function summary()
    {
        /** @var User $currentUser */
        $currentUser = $this->authFactory->guard()->user();

        if ($currentUser->can(PermissionHelper::ADMIN_PERMISSIONS)) {
            $collection = $this->repository->getAllServers()->collect();
        } else {
            $collection = $this->repository->getServersForUser($currentUser->id);
        }

        $total = $collection->count();
        $online = $collection->filter(function ($item) {
            return $item->online;
        })->count();

        return [
            'total' => $total,
            'online' => $online,
            'offline' => $total - $online,
        ];
    }

    public function store(SaveServerRequest $request, CreateGameServer $createGameServer): array
    {
        /** @var CreateGameServerCommand $command */
        $command = $this->serializer->denormalize(
            $request->all(),
            CreateGameServerCommand::class,
        );

        $result = $createGameServer($command);

        return ['message' => 'success', 'result' => $result];
    }

    public function save(int $id, SaveServerRequest $request, EditGameServer $saveGameServer): array
    {
        /** @var EditGameServerCommand $command */
        $command = $this->serializer->denormalize(
            $request->all(),
            EditGameServerCommand::class,
        );

        $command->id = $id;

        $result = $saveGameServer($command);

        return ['message' => 'success', 'result' => $result->id];
    }

    public function destroy(ServerDestroyRequest $request, Server $server)
    {
        if ($request->input('delete_files')) {
            try {
                $this->gdaemonTaskRepository->addServerDelete($server);
            } catch (RecordExistExceptions $e) {
                // Nothing
            }

            $server->delete();
        } else {
            $server->forceDelete();
        }

        return ['message' => 'success'];
    }

    /**
     * @param Exception $exception
     *
     * @return \Illuminate\Http\JsonResponse
     */
    private function handleException(\Throwable $exception)
    {
        /** @var User $currentUser */
        $currentUser = $this->authFactory->guard()->user();

        if ($currentUser->can(PermissionHelper::ADMIN_PERMISSIONS)) {
            $extraMessage = $this->getDocMessage($exception);
        } else {
            $extraMessage = (string)__('main.common_admin_error');
        }

        return $this->makeErrorResponse($exception->getMessage() . $extraMessage);
    }

    /**
     * @param Exception $exception
     * @return string
     */
    private function getDocMessage(\Throwable $exception)
    {
        $msg = '';

        if ($exception instanceof EmptyServerStartCommandException) {
            $msg = __('gdaemon_tasks.empty_server_start_command_doc');
        }

        return is_string($msg) ? $msg : '';
    }

    /**
     * @param $message
     * @param int $code
     * @return \Illuminate\Http\JsonResponse
     */
    private function makeErrorResponse($message, $code = Response::HTTP_UNPROCESSABLE_ENTITY)
    {
        return response()->json([
            'message'   => $message,
            'http_code' => $code,
        ], $code);
    }
}


1			<?php
2
3			namespace Gameap\Http\Controllers\API;
4
5			use Exception;
6			use Gameap\Exceptions\Repositories\GdaemonTaskRepository\EmptyServerStartCommandException;
7			use Gameap\Exceptions\Repositories\GdaemonTaskRepository\GdaemonTaskRepositoryException;
8			use Gameap\Exceptions\Repositories\RecordExistExceptions;
9			use Gameap\Helpers\PermissionHelper;
10			use Gameap\Helpers\ServerPermissionHelper;
11			use Gameap\Http\Controllers\AuthController;
			0 ignored issues – show Bug introduced 2024-05-26 17:51 UTC by Report Bug Copy Issue Report This use statement conflicts with another class in this namespace, `Gameap\Http\Controllers\API\AuthController`. Consider defining an alias. Let?s assume that you have a directory layout like this: . \|-- OtherDir \| \|-- Bar.php \| `-- Foo.php `-- SomeDir `-- Foo.php and let?s assume the following content of `Bar.php`: // Bar.php namespace OtherDir; use SomeDir\Foo; // This now conflicts the class OtherDir\Foo If both files `OtherDir/Foo.php` and `SomeDir/Foo.php` are loaded in the same runtime, you will see a PHP error such as the following: PHP Fatal error: Cannot use SomeDir\Foo as Foo because the name is already in use in OtherDir/Foo.php However, as `OtherDir/Foo.php` does not necessarily have to be loaded and the error is only triggered if it is loaded before `OtherDir/Bar.php`, this problem might go unnoticed for a while. In order to prevent this error from surfacing, you must import the namespace with a different alias: // Bar.php namespace OtherDir; use SomeDir\Foo as SomeDirFoo; // There is no conflict anymore. Loading history...
12			use Gameap\Http\Requests\Admin\ServerDestroyRequest;
13			use Gameap\Http\Requests\API\SaveServerRequest;
14			use Gameap\Http\Requests\API\ServerConsoleCommandRequest;
15			use Gameap\Models\GdaemonTask;
16			use Gameap\Models\Server;
17			use Gameap\Models\User;
18			use Gameap\Repositories\GdaemonTaskRepository;
19			use Gameap\Repositories\ServerRepository;
20			use Gameap\Services\ServerControlService;
21			use Gameap\Services\ServerService;
22			use Gameap\UseCases\Commands\CreateGameServerCommand;
23			use Gameap\UseCases\Commands\EditGameServerCommand;
24			use Gameap\UseCases\CreateGameServer;
25			use Gameap\UseCases\EditGameServer;
26			use Illuminate\Contracts\Auth\Factory as AuthFactory;
27			use Psr\SimpleCache\CacheInterface;
28			use Illuminate\Http\Request;
29			use Illuminate\Http\Response;
30			use Symfony\Component\Serializer\SerializerInterface;
31
32			class ServersController extends AuthController
33			{
34			/**
35			* The ServerRepository instance.
36			*
37			* @var \Gameap\Repositories\ServerRepository
38			*/
39			public $repository;
40
41			/**
42			* The GdaemonTaskRepository instance.
43			*
44			* @var GdaemonTaskRepository
45			*/
46			public $gdaemonTaskRepository;
47
48			/** @var \Gameap\Services\ServerService */
49			public $serverService;
50
51			/** @var \Gameap\Services\ServerControlService */
52			public $serverControlService;
53
54			/** @var SerializerInterface */
55			protected $serializer;
56
57			/** @var AuthFactory */
58			protected $authFactory;
59
60			/** @var CacheInterface */
61			protected $cache;
62
63			/**
64			* ServersController constructor.
65			* @param ServerRepository $repository
66			*/
67			public function __construct(
68			ServerRepository $repository,
69			GdaemonTaskRepository $gdaemonTaskRepository,
70			ServerService $serverService,
71			ServerControlService $serverControlService,
72			SerializerInterface $serializer,
73			AuthFactory $authFactory,
74			CacheInterface $cache
75			) {
76			parent::__construct();
77
78			$this->repository = $repository;
79			$this->gdaemonTaskRepository = $gdaemonTaskRepository;
80			$this->serverService = $serverService;
81			$this->serverControlService = $serverControlService;
82			$this->serializer = $serializer;
83			$this->authFactory = $authFactory;
84			$this->cache = $cache;
85			}
86
87			/**
88			* @param Server $server
89			*
90			* @return array\|\Illuminate\Http\JsonResponse
91			*
92			* @throws \Illuminate\Auth\Access\AuthorizationException
93			*/
94			public function get(Server $server)
95			{
96			$this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
97
98			/** @var User $currentUser */
99			$currentUser = $this->authFactory->guard()->user();
100			$isAdmin = $currentUser->can(PermissionHelper::ADMIN_PERMISSIONS);
101
102			if ($isAdmin) {
103			return $server->only([
104			'id',
105			'uuid',
106			'uuid_short',
107			'enabled',
108			'installed',
109			'blocked',
110			'name',
111			'ds_id',
112			'game_id',
113			'game_mod_id',
114			'server_ip',
115			'server_port',
116			'query_port',
117			'rcon_port',
118			'game',
119			'last_process_check',
120			'online',
121
122			// Admin details
123			'rcon',
124			'dir',
125			'su_user',
126			'start_command',
127			'aliases',
128			'vars',
129			]);
130			}
131
132			return $server->only([
133			'id',
134			'uuid',
135			'uuid_short',
136			'enabled',
137			'installed',
138			'blocked',
139			'name',
140			'ds_id',
141			'game_id',
142			'game_mod_id',
143			'server_ip',
144			'server_port',
145			'query_port',
146			'rcon_port',
147			'game',
148			'last_process_check',
149			'online',
150			]);
151			}
152
153			/**
154			* @param Server $server
155			*
156			* @return array\|\Illuminate\Http\JsonResponse
157			*
158			* @throws \Illuminate\Auth\Access\AuthorizationException
159			*/
160			public function abilities(Server $server)
161			{
162			/** @var User $currentUser */
163			$currentUser = $this->authFactory->guard()->user();
164			$isAdmin = $currentUser->can(PermissionHelper::ADMIN_PERMISSIONS);
165
166			if (!$isAdmin) {
167			$servers = $this->repository->getServersForUser($currentUser->id);
168			if (!$servers->contains($server)) {
169			return response()->json([
170			'message' => 'Forbidden',
171			'http_code' => Response::HTTP_FORBIDDEN,
172			], Response::HTTP_FORBIDDEN);
173			}
174			}
175
176			$abilities = [];
177
178			foreach (ServerPermissionHelper::getAllPermissions() as $permission) {
179			$abilities[$permission] = $isAdmin \|\| $currentUser->can($permission, $server);
180			}
181
182			return $abilities;
183			}
184
185			/**
186			* @param Server $server
187			*
188			* @return array\|\Illuminate\Http\JsonResponse
189			*
190			* @throws \Illuminate\Auth\Access\AuthorizationException
191			*/
192			public function start(Server $server)
193			{
194			$this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
195			$this->authorize(ServerPermissionHelper::START_ABILITY, $server);
196
197			try {
198			$gdaemonTaskId = $this->serverControlService->start($server);
199			} catch (GdaemonTaskRepositoryException $exception) {
200			return $this->handleException($exception);
201			} catch (RecordExistExceptions $exception) {
202			$gdaemonTaskId = $this->gdaemonTaskRepository->getOneWorkingTaskId(
203			$server->id,
204			GdaemonTask::TASK_SERVER_START
205			);
206
207			if (!$gdaemonTaskId) {
208			return $this->makeErrorResponse($exception->getMessage());
209			}
210			}
211
212			return [
213			'gdaemonTaskId' => $gdaemonTaskId,
214			];
215			}
216
217			/**
218			* @param Server $server
219			*
220			* @return array\|\Illuminate\Http\JsonResponse
221			*
222			* @throws \Illuminate\Auth\Access\AuthorizationException
223			*/
224			public function stop(Server $server)
225			{
226			$this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
227			$this->authorize(ServerPermissionHelper::STOP_ABILITY, $server);
228
229			try {
230			$gdaemonTaskId = $this->serverControlService->stop($server);
231			} catch (RecordExistExceptions $exception) {
232			$gdaemonTaskId = $this->gdaemonTaskRepository->getOneWorkingTaskId(
233			$server->id,
234			GdaemonTask::TASK_SERVER_STOP
235			);
236
237			if (!$gdaemonTaskId) {
238			return $this->makeErrorResponse($exception->getMessage());
239			}
240			}
241
242			return [
243			'gdaemonTaskId' => $gdaemonTaskId,
244			];
245			}
246
247			/**
248			* @param Server $server
249			* @return array\|\Illuminate\Http\JsonResponse
250			*
251			* @throws \Gameap\Exceptions\Repositories\RecordExistExceptions
252			* @throws \Illuminate\Auth\Access\AuthorizationException
253			*/
254			public function restart(Server $server)
255			{
256			$this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
257			$this->authorize(ServerPermissionHelper::RESTART_ABILITY, $server);
258
259			try {
260			$gdaemonTaskId = $this->serverControlService->restart($server);
261			} catch (GdaemonTaskRepositoryException $exception) {
262			return $this->handleException($exception);
263			} catch (RecordExistExceptions $exception) {
264			$gdaemonTaskId = $this->gdaemonTaskRepository->getOneWorkingTaskId(
265			$server->id,
266			GdaemonTask::TASK_SERVER_RESTART
267			);
268
269			if (!$gdaemonTaskId) {
270			return $this->makeErrorResponse($exception->getMessage());
271			}
272			}
273
274			return [
275			'gdaemonTaskId' => $gdaemonTaskId,
276			];
277			}
278
279			/**
280			* @param Server $server
281			* @return array\|\Illuminate\Http\JsonResponse
282			*
283			* @throws \Illuminate\Auth\Access\AuthorizationException
284			*/
285			public function update(Server $server)
286			{
287			$this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
288			$this->authorize(ServerPermissionHelper::UPDATE_ABILITY, $server);
289
290			try {
291			$gdaemonTaskId = $this->serverControlService->update($server);
292			} catch (RecordExistExceptions $exception) {
293			$gdaemonTaskId = $this->gdaemonTaskRepository->getOneWorkingTaskId(
294			$server->id,
295			GdaemonTask::TASK_SERVER_UPDATE
296			);
297
298			if (!$gdaemonTaskId) {
299			return $this->makeErrorResponse($exception->getMessage());
300			}
301			}
302
303			return [
304			'gdaemonTaskId' => $gdaemonTaskId,
305			];
306			}
307
308			/**
309			* @param Server $server
310			* @return array\|\Illuminate\Http\JsonResponse
311			*
312			* @throws \Illuminate\Auth\Access\AuthorizationException
313			*/
314			public function install(Server $server)
315			{
316			$this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
317			$this->authorize(ServerPermissionHelper::UPDATE_ABILITY, $server);
318
319			try {
320			$gdaemonTaskId = $this->serverControlService->install($server);
321			} catch (RecordExistExceptions $exception) {
322			$gdaemonTaskId = $this->gdaemonTaskRepository->getOneWorkingTaskId(
323			$server->id,
324			GdaemonTask::TASK_SERVER_INSTALL
325			);
326
327			if (!$gdaemonTaskId) {
328			return $this->makeErrorResponse($exception->getMessage());
329			}
330			}
331
332			return [
333			'gdaemonTaskId' => $gdaemonTaskId,
334			];
335			}
336
337			/**
338			* @param Server $server
339			* @return array\|\Illuminate\Http\JsonResponse
340			*
341			* @throws \Gameap\Exceptions\Repositories\RecordExistExceptions
342			* @throws \Illuminate\Auth\Access\AuthorizationException
343			*/
344			public function reinstall(Server $server)
345			{
346			$this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
347			$this->authorize(ServerPermissionHelper::UPDATE_ABILITY, $server);
348
349			try {
350			$deleteTaskId = $this->gdaemonTaskRepository->addServerDelete($server);
351			$gdaemonTaskId = $this->gdaemonTaskRepository->addServerInstall($server, $deleteTaskId);
352			} catch (RecordExistExceptions $exception) {
353			return $this->makeErrorResponse($exception->getMessage());
354			}
355
356			return [
357			'gdaemonTaskId' => $gdaemonTaskId,
358			];
359			}
360
361			/**
362			* Get server status
363			* @param Server $server
364			* @return array
365			*
366			* @throws \Illuminate\Auth\Access\AuthorizationException
367			*/
368			public function getStatus(Server $server)
369			{
370			$this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
371
372			return [
373			'processActive' => $server->processActive(),
374			];
375			}
376
377			/**
378			* @param Server $server
379			* @return array
380			*
381			* @throws \Illuminate\Auth\Access\AuthorizationException
382			*/
383			public function query(Server $server)
384			{
385			$this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
386
387			$query = $this->serverService->query($server);
388
389			return $query;
390			}
391
392			/**
393			* @param Server $server
394			* @return array
395			*
396			* @throws \Illuminate\Auth\Access\AuthorizationException
397			*/
398			public function consoleLog(Server $server)
399			{
400			$this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
401			$this->authorize(ServerPermissionHelper::CONSOLE_VIEW_ABILITY, $server);
402
403			return [
404			'console' => $this->serverService->getConsoleLog($server),
405			];
406			}
407
408			/**
409			* @param ServerConsoleCommandRequest $request
410			* @param Server $server
411			* @return array
412			*
413			* @throws \Illuminate\Auth\Access\AuthorizationException
414			*/
415			public function sendCommand(ServerConsoleCommandRequest $request, Server $server)
416			{
417			$this->authorize(ServerPermissionHelper::CONTROL_ABILITY, $server);
418			$this->authorize(ServerPermissionHelper::CONSOLE_SEND_ABILITY, $server);
419
420			$command = $request->input('command');
421			$this->serverService->sendConsoleCommand($server, $command);
422
423			return ['message' => 'success'];
424			}
425
426			public function search(Request $request)
427			{
428			$query = $request->input('q');
429			return $this->repository->search($query);
430			}
431
432			public function getList()
433			{
434			/** @var User $currentUser */
435			$currentUser = $this->authFactory->guard()->user();
436
437			if ($currentUser->can(PermissionHelper::ADMIN_PERMISSIONS)) {
438			$collection = $this->repository->getAllServers()->collect();
439			} else {
440			$collection = $this->repository->getServersForUser($currentUser->id);
441			}
442
443			return $collection->map(function ($item) {
444			return $item->only([
445			'id',
446			'uuid',
447			'uuid_short',
448			'enabled',
449			'installed',
450			'blocked',
451			'name',
452			'ds_id',
453			'game_id',
454			'game_mod_id',
455			'server_ip',
456			'server_port',
457			'query_port',
458			'rcon_port',
459			'game',
460			'online'
461			]);
462			});
463			}
464
465			public function allServersAbilities()
466			{
467			/** @var User $currentUser */
468			$currentUser = $this->authFactory->guard()->user();
469
470			$cacheKey = 'users:' . $currentUser->id . ':servers-abilities';
471
472			if ($this->cache->has($cacheKey)) {
473			return $this->cache->get($cacheKey);
474			}
475
476			$isAdmin = $currentUser->can(PermissionHelper::ADMIN_PERMISSIONS);
477
478			if ($isAdmin) {
479			$servers = $this->repository->getAllServers()->collect();
480			} else {
481			$servers = $this->repository->getServersForUser($currentUser->id);
482			}
483
484			$abilities = [];
485			foreach ($servers as $server) {
486			$abilities[$server->id] = [];
487
488			foreach (ServerPermissionHelper::getAllPermissions() as $permission) {
489			$abilities[$server->id][$permission] = $isAdmin \|\| $currentUser->can($permission, $server);
490			}
491			}
492
493			$this->cache->set($cacheKey, $abilities, 60);
494
495			return $abilities;
496			}
497
498			public function summary()
499			{
500			/** @var User $currentUser */
501			$currentUser = $this->authFactory->guard()->user();
502
503			if ($currentUser->can(PermissionHelper::ADMIN_PERMISSIONS)) {
504			$collection = $this->repository->getAllServers()->collect();
505			} else {
506			$collection = $this->repository->getServersForUser($currentUser->id);
507			}
508
509			$total = $collection->count();
510			$online = $collection->filter(function ($item) {
511			return $item->online;
512			})->count();
513
514			return [
515			'total' => $total,
516			'online' => $online,
517			'offline' => $total - $online,
518			];
519			}
520
521			public function store(SaveServerRequest $request, CreateGameServer $createGameServer): array
522			{
523			/** @var CreateGameServerCommand $command */
524			$command = $this->serializer->denormalize(
525			$request->all(),
526			CreateGameServerCommand::class,
527			);
528
529			$result = $createGameServer($command);
530
531			return ['message' => 'success', 'result' => $result];
532			}
533
534			public function save(int $id, SaveServerRequest $request, EditGameServer $saveGameServer): array
535			{
536			/** @var EditGameServerCommand $command */
537			$command = $this->serializer->denormalize(
538			$request->all(),
539			EditGameServerCommand::class,
540			);
541
542			$command->id = $id;
543
544			$result = $saveGameServer($command);
545
546			return ['message' => 'success', 'result' => $result->id];
547			}
548
549			public function destroy(ServerDestroyRequest $request, Server $server)
550			{
551			if ($request->input('delete_files')) {
552			try {
553			$this->gdaemonTaskRepository->addServerDelete($server);
554			} catch (RecordExistExceptions $e) {
555			// Nothing
556			}
557
558			$server->delete();
559			} else {
560			$server->forceDelete();
561			}
562
563			return ['message' => 'success'];
564			}
565
566			/**
567			* @param Exception $exception
568			*
569			* @return \Illuminate\Http\JsonResponse
570			*/
571			private function handleException(\Throwable $exception)
572			{
573			/** @var User $currentUser */
574			$currentUser = $this->authFactory->guard()->user();
575
576			if ($currentUser->can(PermissionHelper::ADMIN_PERMISSIONS)) {
577			$extraMessage = $this->getDocMessage($exception);
578			} else {
579			$extraMessage = (string)__('main.common_admin_error');
580			}
581
582			return $this->makeErrorResponse($exception->getMessage() . $extraMessage);
583			}
584
585			/**
586			* @param Exception $exception
587			* @return string
588			*/
589			private function getDocMessage(\Throwable $exception)
590			{
591			$msg = '';
592
593			if ($exception instanceof EmptyServerStartCommandException) {
594			$msg = __('gdaemon_tasks.empty_server_start_command_doc');
595			}
596
597			return is_string($msg) ? $msg : '';
598			}
599
600			/**
601			* @param $message
602			* @param int $code
603			* @return \Illuminate\Http\JsonResponse
604			*/
605			private function makeErrorResponse($message, $code = Response::HTTP_UNPROCESSABLE_ENTITY)
606			{
607			return response()->json([
608			'message' => $message,
609			'http_code' => $code,
610			], $code);
611			}
612			}
613

et-nik / gameap

Push — master ( 805c58...4a8ad5 )

ServersController C

Complexity

Size/Duplication

Importance

23 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like