Config::runMigrations() - Code Metrics - Inspection of "A successful test of sending and using the token u..." - rsanjoseo/alxarafe - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 0f30b5...54eb22 )

by Rafael

created 2024-11-17 18:17 UTC

Config::runMigrations() A

↳ Parent: Config

Complexity

Conditions	3
Paths	3

Size

Total Lines	15
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	10
c	0
b	0
f	0
dl	0
loc	15
rs	9.9332
cc	3
nc	3
nop	0

<?php

/* Copyright (C) 2024       Rafael San José         <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */

namespace Alxarafe\Base;

use Alxarafe\Lib\Routes;
use Alxarafe\Lib\Trans;
use Alxarafe\Tools\Debug;
use CoreModules\Admin\Model\Migration;
use DebugBar\DebugBarException;
use stdClass;

/**
 * Manage the configuration file
 */
abstract class Config
{
    /**
     * Configuration filename.
     */
    private const CONFIG_FILENAME = 'config.json';

    /**
     * Defines the configuration file structure
     */
    public const  CONFIG_STRUCTURE = [
        'main' => [
            'path', // Path to the public folder (usually htdocs)
            'url',
            'data', // Route to the private folder that stores the documents.
            'theme',
            'language',
        ],
        'db' => [
            'type',
            'host',
            'user',
            'pass',
            'name',
            'port',
            'prefix',
            'charset',
            'collation',
            'encryption', // Pending review: If true, some database fields are encrypted.
            'encrypt_type', // Pending review: Encryption type ('0' if none, '1' if DES and '2' if AES)
        ],
        'security' => [
            'debug',
            'unique_id', // Unique identifier of the installation.
            'https', // If true, the use of https is forced (recommended)
            'jwt_secret_key',
        ]
    ];

    /**
     * Contains configuration file information
     *
     * @var stdClass|null
     */
    private static ?stdClass $config = null;

    private static array $messages = [];

    /**
     * Returns an array with the messages accumulated since the last call.
     *
     * @return array
     */
    public static function getMessages()
    {
        $result = self::$messages;
        self::$messages = [];
        return $result;
    }

    /**
     * Gets the information defined in the configuration file.
     * To reload the configuration file, set $reload to true.
     *
     * @param bool $reload
     * @return stdClass|null
     */
    public static function getConfig(bool $reload = false): ?stdClass
    {
        if ($reload || !isset(self::$config)) {
            self::$config = self::loadConfig($reload);
        }

        return self::$config;
    }

    /**
     * Add the configuration parameters received in $data in the configuration file.
     *
     * @param stdClass $data
     * @return bool
     * @throws DebugBarException
     */
    public static function setConfig(stdClass $data): bool
    {
        /**
         * If the configuration file is empty, we add the parameters
         * that we can obtain at runtime (getDefaultMainFileInfo).
         */
        if (empty(self::$config)) {
            self::$config = new stdClass();
            self::$config->main = static::getDefaultMainFileInfo();
        }

        foreach (self::CONFIG_STRUCTURE as $section => $values) {
            foreach ($values as $key) {
                if (!isset($data->$section)) {
                    error_log($section . ' is not defined!');
                    continue;
                }
                if (!isset($data->$section->$key)) {
                    error_log($key . ' is not defined in ' . $section . '!');
                    continue;
                }
                if (!isset(self::$config->$section)) {
                    self::$config->$section = new stdClass();
                }
                self::$config->$section->$key = $data->$section->$key;
            }
        }

        /**
         * Save the configuration in the configuration file.
         */
        Trans::setLang(self::$config->main->language ?? Trans::FALLBACK_LANG);
        $ok = self::saveConfig();
        self::getConfig(true);
        Debug::initialize(true);
        return $ok;
    }

    /**
     * Those configuration parameters that we can obtain at run time,
     * or their default values, are obtained.
     *
     * @return stdClass
     */
    public static function getDefaultMainFileInfo(): stdClass
    {
        $result = new stdClass();
        $result->path = constant('BASE_PATH');
        $result->url = constant('BASE_URL');
        return $result;
    }

    /**
     * Updates the configuration file with the information it has in memory.
     *
     * @return bool
     */
    private static function saveConfig(): bool
    {
        if (empty(self::$config)) {
            return true;
        }
        return file_put_contents(self::getConfigFilename(), json_encode(self::$config, JSON_PRETTY_PRINT)) !== false;
    }

    /**
     * Returns the config.json complete path.
     *
     * @return string
     */
    private static function getConfigFilename(): string
    {
        return realpath(constant('BASE_PATH') . '/..') . DIRECTORY_SEPARATOR . self::CONFIG_FILENAME;
    }

    /**
     * Obtains an associative array with all migrations. The index is the name of the
     * migration and the name of the module separated by an @ sign, which ensures that
     * the migration is registered as executed; and the value is the relative path of
     * the file containing the migration.
     *
     * @return array
     */
    private static function getMigrations(): array
    {
        $result = [];

        $routes = Routes::getAllRoutes();
        if (empty($routes['Migrations'])) {
            return $result;
        }

        $migrations = $routes['Migrations'];

        foreach ($migrations as $module => $data) {
            foreach ($data as $filename => $migration) {
                $route_array = explode('|', $migration);
                $filepath = $route_array[1];

                $result[$filename . '@' . $module] = $filepath;
            }
        }
        ksort($result);

        return $result;
    }

    /**
     * Runs pending migrations in alphabetical order.
     * By default, migration names are preceded by the date in Japanese format,
     * which ensures chronological execution.
     *
     * @return void
     */
    public static function runMigrations(): void
    {
        $result = static::getMigrations();

        $batch = 1 + Migration::getLastBatch();
        foreach ($result as $filename => $filepath) {
            if (Migration::where(['migration' => $filename])->first()) {
                continue;
            }

            $migration = require_once $filepath;
            $migration->up();
            Migration::create([
                'migration' => $filename,
                'batch' => $batch,
            ]);
        }
    }

    public static function runSeeders()
    {
        $routes = Routes::getAllRoutes();
        if (empty($routes['Seeders'])) {
            return;
        }

        $seeders = $routes['Seeders'];

        $result = [];

        foreach ($seeders as $data) {
            foreach ($data as $seeder) {
                $route_array = explode('|', $seeder);
                $classname = $route_array[0];
                new $classname();
            }
        }
    }

    /**
     * Adds a new message that will then be returned by getMessages.
     *
     * @param $message
     * @return void
     */
    private static function addNewMessage($message)

    {
        self::$messages[] = $message;
    }

    /**
     * Returns a stdClass with the program configuration.
     * If the configuration file does not exist, is not accessible, or is not correct, returns null.
     * The configuration is loaded from the file only once and stored in a variable. You can set $reload
     * to true to force a reload of the configuration file.
     *
     * @param bool $reload
     * @return stdClass|null
     */
    private static function loadConfig(bool $reload = false): ?stdClass
    {
        if (!$reload && isset(self::$config)) {
            return self::$config;
        }

        $filename = self::getConfigFilename();
        if (!file_exists($filename)) {
            return null;
        }

        $config = file_get_contents($filename);
        if ($config === false) {
            return self::$config;
        }

        $result = json_decode($config);
        if (json_last_error() === JSON_ERROR_NONE) {
            self::$config = $result;
        }

        return $result;
    }
}


1			<?php
2
3			/* Copyright (C) 2024 Rafael San José <[email protected]>
4			*
5			* This program is free software; you can redistribute it and/or modify
6			* it under the terms of the GNU General Public License as published by
7			* the Free Software Foundation; either version 3 of the License, or
8			* any later version.
9			*
10			* This program is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			* GNU General Public License for more details.
14			*
15			* You should have received a copy of the GNU General Public License
16			* along with this program. If not, see <https://www.gnu.org/licenses/>.
17			*/
18
19			namespace Alxarafe\Base;
20
21			use Alxarafe\Lib\Routes;
22			use Alxarafe\Lib\Trans;
23			use Alxarafe\Tools\Debug;
24			use CoreModules\Admin\Model\Migration;
25			use DebugBar\DebugBarException;
26			use stdClass;
27
28			/**
29			* Manage the configuration file
30			*/
31			abstract class Config
32			{
33			/**
34			* Configuration filename.
35			*/
36			private const CONFIG_FILENAME = 'config.json';
37
38			/**
39			* Defines the configuration file structure
40			*/
41			public const CONFIG_STRUCTURE = [
42			'main' => [
43			'path', // Path to the public folder (usually htdocs)
44			'url',
45			'data', // Route to the private folder that stores the documents.
46			'theme',
47			'language',
48			],
49			'db' => [
50			'type',
51			'host',
52			'user',
53			'pass',
54			'name',
55			'port',
56			'prefix',
57			'charset',
58			'collation',
59			'encryption', // Pending review: If true, some database fields are encrypted.
60			'encrypt_type', // Pending review: Encryption type ('0' if none, '1' if DES and '2' if AES)
61			],
62			'security' => [
63			'debug',
64			'unique_id', // Unique identifier of the installation.
65			'https', // If true, the use of https is forced (recommended)
66			'jwt_secret_key',
67			]
68			];
69
70			/**
71			* Contains configuration file information
72			*
73			* @var stdClass\|null
74			*/
75			private static ?stdClass $config = null;
76
77			private static array $messages = [];
78
79			/**
80			* Returns an array with the messages accumulated since the last call.
81			*
82			* @return array
83			*/
84			public static function getMessages()
85			{
86			$result = self::$messages;
87			self::$messages = [];
88			return $result;
89			}
90
91			/**
92			* Gets the information defined in the configuration file.
93			* To reload the configuration file, set $reload to true.
94			*
95			* @param bool $reload
96			* @return stdClass\|null
97			*/
98			public static function getConfig(bool $reload = false): ?stdClass
99			{
100			if ($reload \|\| !isset(self::$config)) {
101			self::$config = self::loadConfig($reload);
102			}
103
104			return self::$config;
105			}
106
107			/**
108			* Add the configuration parameters received in $data in the configuration file.
109			*
110			* @param stdClass $data
111			* @return bool
112			* @throws DebugBarException
113			*/
114			public static function setConfig(stdClass $data): bool
115			{
116			/**
117			* If the configuration file is empty, we add the parameters
118			* that we can obtain at runtime (getDefaultMainFileInfo).
119			*/
120			if (empty(self::$config)) {
121			self::$config = new stdClass();
122			self::$config->main = static::getDefaultMainFileInfo();
123			}
124
125			foreach (self::CONFIG_STRUCTURE as $section => $values) {
126			foreach ($values as $key) {
127			if (!isset($data->$section)) {
128			error_log($section . ' is not defined!');
129			continue;
130			}
131			if (!isset($data->$section->$key)) {
132			error_log($key . ' is not defined in ' . $section . '!');
133			continue;
134			}
135			if (!isset(self::$config->$section)) {
136			self::$config->$section = new stdClass();
137			}
138			self::$config->$section->$key = $data->$section->$key;
139			}
140			}
141
142			/**
143			* Save the configuration in the configuration file.
144			*/
145			Trans::setLang(self::$config->main->language ?? Trans::FALLBACK_LANG);
146			$ok = self::saveConfig();
147			self::getConfig(true);
148			Debug::initialize(true);
149			return $ok;
150			}
151
152			/**
153			* Those configuration parameters that we can obtain at run time,
154			* or their default values, are obtained.
155			*
156			* @return stdClass
157			*/
158			public static function getDefaultMainFileInfo(): stdClass
159			{
160			$result = new stdClass();
161			$result->path = constant('BASE_PATH');
162			$result->url = constant('BASE_URL');
163			return $result;
164			}
165
166			/**
167			* Updates the configuration file with the information it has in memory.
168			*
169			* @return bool
170			*/
171			private static function saveConfig(): bool
172			{
173			if (empty(self::$config)) {
174			return true;
175			}
176			return file_put_contents(self::getConfigFilename(), json_encode(self::$config, JSON_PRETTY_PRINT)) !== false;
177			}
178
179			/**
180			* Returns the config.json complete path.
181			*
182			* @return string
183			*/
184			private static function getConfigFilename(): string
185			{
186			return realpath(constant('BASE_PATH') . '/..') . DIRECTORY_SEPARATOR . self::CONFIG_FILENAME;
187			}
188
189			/**
190			* Obtains an associative array with all migrations. The index is the name of the
191			* migration and the name of the module separated by an @ sign, which ensures that
192			* the migration is registered as executed; and the value is the relative path of
193			* the file containing the migration.
194			*
195			* @return array
196			*/
197			private static function getMigrations(): array
198			{
199			$result = [];
200
201			$routes = Routes::getAllRoutes();
202			if (empty($routes['Migrations'])) {
203			return $result;
204			}
205
206			$migrations = $routes['Migrations'];
207
208			foreach ($migrations as $module => $data) {
209			foreach ($data as $filename => $migration) {
210			$route_array = explode('\|', $migration);
211			$filepath = $route_array[1];
212
213			$result[$filename . '@' . $module] = $filepath;
214			}
215			}
216			ksort($result);
217
218			return $result;
219			}
220
221			/**
222			* Runs pending migrations in alphabetical order.
223			* By default, migration names are preceded by the date in Japanese format,
224			* which ensures chronological execution.
225			*
226			* @return void
227			*/
228			public static function runMigrations(): void
229			{
230			$result = static::getMigrations();
231
232			$batch = 1 + Migration::getLastBatch();
233			foreach ($result as $filename => $filepath) {
234			if (Migration::where(['migration' => $filename])->first()) {
235			continue;
236			}
237
238			$migration = require_once $filepath;
239			$migration->up();
240			Migration::create([
241			'migration' => $filename,
242			'batch' => $batch,
243			]);
244			}
245			}
246
247			public static function runSeeders()
248			{
249			$routes = Routes::getAllRoutes();
250			if (empty($routes['Seeders'])) {
251			return;
252			}
253
254			$seeders = $routes['Seeders'];
255
256			$result = [];
			0 ignored issues – show Unused Code introduced 2024-11-16 13:01 UTC by Report Bug Copy Issue Report The assignment to `$result` is dead and can be removed. Loading history...
257			foreach ($seeders as $data) {
258			foreach ($data as $seeder) {
259			$route_array = explode('\|', $seeder);
260			$classname = $route_array[0];
261			new $classname();
262			}
263			}
264			}
265
266			/**
267			* Adds a new message that will then be returned by getMessages.
268			*
269			* @param $message
270			* @return void
271			*/
272			private static function addNewMessage($message)
			0 ignored issues – show Unused Code introduced 2024-11-16 13:01 UTC by Report Bug Copy Issue Report The method `addNewMessage()` is not used, and could be removed. This check looks for private methods that have been defined, but are not used inside the class. Loading history...
273			{
274			self::$messages[] = $message;
275			}
276
277			/**
278			* Returns a stdClass with the program configuration.
279			* If the configuration file does not exist, is not accessible, or is not correct, returns null.
280			* The configuration is loaded from the file only once and stored in a variable. You can set $reload
281			* to true to force a reload of the configuration file.
282			*
283			* @param bool $reload
284			* @return stdClass\|null
285			*/
286			private static function loadConfig(bool $reload = false): ?stdClass
287			{
288			if (!$reload && isset(self::$config)) {
289			return self::$config;
290			}
291
292			$filename = self::getConfigFilename();
293			if (!file_exists($filename)) {
294			return null;
295			}
296
297			$config = file_get_contents($filename);
298			if ($config === false) {
299			return self::$config;
300			}
301
302			$result = json_decode($config);
303			if (json_last_error() === JSON_ERROR_NONE) {
304			self::$config = $result;
305			}
306
307			return $result;
308			}
309			}
310

rsanjoseo / alxarafe

Push — main ( 0f30b5...54eb22 )

Config::runMigrations() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like