urbackup/src/Controller/AssetController.php

<?php

declare(strict_types=1);

/**
 * -------------------------------------------------------------------------
 * UrBackup plugin for GLPI
 * -------------------------------------------------------------------------
 */

namespace GlpiPlugin\Urbackup\Controller;

use GlpiPlugin\Urbackup\Config;
use GlpiPlugin\Urbackup\Profile;
use GlpiPlugin\Urbackup\Server;
use GlpiPlugin\Urbackup\ServerAsset;
use GlpiPlugin\Urbackup\UrbackupApiClient;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\JsonResponse;
use CommonDBTM;
use Html;
use Session;

class AssetController
{
    #[Route('/plugin/urbackup/asset/action', name: 'urbackup_asset_action', methods: ['POST'])]
    public function assetAction(Request $request): void
    {
        Session::checkLoginUser();
        Session::checkCSRF($_POST);

        $itemtype = (string) $request->request->get('itemtype', '');
        $items_id = (int) $request->request->get('items_id', 0);

        if ($itemtype === '' || $items_id <= 0 || !class_exists($itemtype)) {
            Session::addMessageAfterRedirect(
                __('Invalid asset reference.', 'urbackup'),
                true,
                ERROR
            );
            Html::back();
        }

        if (!Config::isItemtypeEnabled($itemtype)) {
            Session::addMessageAfterRedirect(
                __('UrBackup is not enabled for this asset type.', 'urbackup'),
                true,
                ERROR
            );
            Html::back();
        }

        $item = new $itemtype();

        if (!$item instanceof CommonDBTM || !$item->getFromDB($items_id)) {
            Session::addMessageAfterRedirect(
                __('Asset not found.', 'urbackup'),
                true,
                ERROR
            );
            Html::back();
        }

        $action = (string) $request->request->get('urbackup_action', '');

        switch ($action) {
            case 'connect':
                $server_id = (int) $request->request->get('plugin_urbackup_servers_id', 0);
                if (ServerAsset::connectAssetToServer($itemtype, $items_id, $server_id)) {
                    Session::addMessageAfterRedirect(
                        __('Asset connected to UrBackup server.', 'urbackup'),
                        true,
                        INFO
                    );
                }
                break;

            case 'disconnect':
                if (ServerAsset::disconnectAsset($itemtype, $items_id)) {
                    Session::addMessageAfterRedirect(
                        __('Asset disconnected from UrBackup server.', 'urbackup'),
                        true,
                        INFO
                    );
                }
                break;

            case 'set_internet_mode':
                if (Profile::canCurrentUser(UPDATE)) {
                    $enabled = (int) $request->request->get('internet_mode', 0) === 1;
                    $link = ServerAsset::getLinkForAsset($itemtype, $items_id, true);
                    if ($link) {
                        $server = new Server();
                        if ($server->getFromDB((int) $link['plugin_urbackup_servers_id'])) {
                            $api = new UrbackupApiClient($server);
                            $client_name = (string) ($item->fields['name'] ?? '');
                            $api->saveInternetMode($client_name, $enabled);
                        }
                    }
                }
                break;

            case 'create_client':
                if (Profile::canCurrentUser(CREATE)) {
                    $serverAsset = new ServerAsset();
                    $link = ServerAsset::getLinkForAsset($itemtype, $items_id, true);
                    if ($link) {
                        $server = new Server();
                        if ($server->getFromDB((int) $link['plugin_urbackup_servers_id'])) {
                            $api = new UrbackupApiClient($server);
                            $client_name = (string) ($item->fields['name'] ?? '');
                            $api->addClient($client_name);
                        }
                    }
                }
                break;

            case 'incremental_file_backup':
            case 'full_file_backup':
            case 'incremental_image_backup':
            case 'full_image_backup':
                if (Profile::canCurrentUser(UPDATE)) {
                    $serverAsset = new ServerAsset();
                    $link = ServerAsset::getLinkForAsset($itemtype, $items_id, true);
                    if ($link) {
                        $server = new Server();
                        if ($server->getFromDB((int) $link['plugin_urbackup_servers_id'])) {
                            $api = new UrbackupApiClient($server);
                            $client_name = (string) ($item->fields['name'] ?? '');
                            switch ($action) {
                                case 'incremental_file_backup':
                                    $api->startIncrementalFileBackup($client_name);
                                    break;
                                case 'full_file_backup':
                                    $api->startFullFileBackup($client_name);
                                    break;
                                case 'incremental_image_backup':
                                    $api->startIncrementalImageBackup($client_name);
                                    break;
                                case 'full_image_backup':
                                    $api->startFullImageBackup($client_name);
                                    break;
                            }
                        }
                    }
                }
                break;

            case 'delete_client':
                if (Profile::canCurrentUser(PURGE)) {
                    $serverAsset = new ServerAsset();
                    $link = ServerAsset::getLinkForAsset($itemtype, $items_id, true);
                    if ($link) {
                        $server = new Server();
                        if ($server->getFromDB((int) $link['plugin_urbackup_servers_id'])) {
                            $api = new UrbackupApiClient($server);
                            $client_name = (string) ($item->fields['name'] ?? '');
                            $api->removeClient($client_name);
                        }
                    }
                }
                break;
        }

        Html::back();
    }

    #[Route('/plugin/urbackup/api/clients', name: 'urbackup_api_clients', methods: ['GET'])]
    public function getClients(Request $request): JsonResponse
    {
        Session::checkLoginUser();

        $server_id = (int) $request->query->get('server_id', 0);

        if ($server_id <= 0) {
            return new JsonResponse([]);
        }

        $server = new Server();

        if (!$server->getFromDB($server_id)) {
            return new JsonResponse([]);
        }

        $api = new UrbackupApiClient($server);
        $clients = $api->getStatus();

        return new JsonResponse($clients);
    }
}