Lagdo\DbAdmin\Service\DbAdmin\QueryLogger

Complexity

Total Complexity

19

Size/Duplication

Total Lines	139
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	categoryDisabled()	0	4	4
A	enduserDisabled()	0	4	4
A	saveRunnedCommand()	0	31	4
A	saveCommand()	0	7	2
A	setCategoryToHistory()	0	3	1
A	user()	0	3	1
A	__construct()	0	13	3

<?php

namespace Lagdo\DbAdmin\Service\DbAdmin;

use Lagdo\DbAdmin\Config\AuthInterface;
use Lagdo\DbAdmin\Driver\Db\ConnectionInterface;
use Lagdo\DbAdmin\Driver\DriverInterface;
use Lagdo\DbAdmin\Service\Options;
use Lagdo\Facades\Logger;

use function json_encode;

/**
 * SQL queries logging and storage.
 */
class QueryLogger
{
    use ConnectionTrait;

    /**
     * @var bool
     */
    private bool $enduserEnabled;

    /**
     * @var bool
     */
    private bool $historyEnabled;

    /**
     * @var array
     */
    private array $userDatabase;

    /**
     * @var int
     */
    private int $category;

    /**
     * @var ConnectionInterface
     */
    private ConnectionInterface $connection;

    /**
     * The constructor
     *
     * @param AuthInterface $auth
     * @param DriverInterface $driver
     * @param array $database
     * @param array $options
     */
    public function __construct(private AuthInterface $auth,
        private DriverInterface $driver, array $database, array $options)
    {
        $this->enduserEnabled = (bool)($options['enduser']['enabled'] ?? false);
        $this->historyEnabled = (bool)($options['history']['enabled'] ?? false);
        $this->category = Options::CAT_BUILDER;
        $this->userDatabase = $options['database'];
        if (!$this->enduserEnabled && !$this->historyEnabled) {
            return;
        }

        // Connect to the logging database.
        $this->connect($driver, $database);
    }

    /**
     * @var string
     */
    protected function user(): string
    {
        return $this->auth->user();
    }

    /**
     * @return void
     */
    public function setCategoryToHistory(): void
    {
        $this->category = Options::CAT_EDITOR;
    }

    /**
     * @return bool
     */
    private function enduserDisabled(): bool
    {
        return (!$this->enduserEnabled && !$this->historyEnabled) ||
            !$this->auth->user() || !$this->getOwnerId(true);
    }

    /**
     * @param int $category
     *
     * @return bool
     */
    private function categoryDisabled(int $category): bool
    {
        return (!$this->enduserEnabled && $category === Options::CAT_BUILDER) ||
            ($category < Options::CAT_BUILDER || $category > Options::CAT_EDITOR);
    }

    /**
     * @param string $query
     * @param int $category
     *
     * @return bool
     */
    private function saveRunnedCommand(string $query, int $category): bool
    {
        if ($this->categoryDisabled($category)) {
            return false;
        }

        if (isset($this->userDatabase['password'])) {
            // Hide the password.
            $this->userDatabase['password'] = '';
        }
        $values = [
            'query' => $query,
            'driver' => $this->userDatabase['driver'],
            'options' => json_encode($this->userDatabase) ?? '{}',
            'category' => $category,
            'last_update' => $this->currentTime(),
            'owner_id' => $this->getOwnerId(),
        ];
        // Duplicates on query are checked on client side, not here.
        $query = "insert into dbadmin_runned_commands" .
            "(query,driver,options,category,last_update,owner_id) values" .
            "(:query,:driver,:options,:category,:last_update,:owner_id)";
        $statement = $this->executeQuery($query, $values);
        if ($statement !== false) {
            return true;
        }

        Logger::warning('Unable to save command in the query logging database.', [
            'error' => $this->connection->error(),
        ]);
        return false;
    }

    /**
     * @param string $query
     *
     * @return bool
     */
    public function saveCommand(string $query): bool
    {
        $category = $this->category;
        // Reset to the default category.
        $this->category = Options::CAT_BUILDER;
        return $this->enduserDisabled() ? false :
            $this->saveRunnedCommand($query, $category);
    }
}