MikoPBX\Common\Providers\ModulesDBConnectionsProvider

Complexity

Total Complexity

24

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	recreateModulesDBConnections()	0	4	1
D	register()	0	128	23

<?php
/*
 * MikoPBX - free phone system for small business
 * Copyright (C) 2017-2020 Alexey Portnov and Nikolay Beketov
 *
 * 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
 * (at your option) 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/>.
 */

declare(strict_types=1);

namespace MikoPBX\Common\Providers;


use MikoPBX\Core\System\Processes;
use MikoPBX\Core\System\Util;
use Phalcon\Di;
use Phalcon\Di\DiInterface;
use Phalcon\Di\ServiceProviderInterface;
use Phalcon\Events\Manager;
use phpDocumentor\Reflection\DocBlock\Tags\See;
use ReflectionClass;
use ReflectionException;


/**
 * Class ModulesDBConnectionsProvider
 * Add to DI modules DB as sqlite3 connections
 *
 * @package Modules
 */
class ModulesDBConnectionsProvider extends DatabaseProviderBase implements ServiceProviderInterface
{
    public const SERVICE_NAME = '';
    /**
     * DiServicesInstall constructor
     *
     * @param $di DiInterface link to app dependency injector
     *
     */
    public function register(DiInterface $di): void
    {
        $registeredDBServices = [];
        $config               = $di->getShared('config');
        $modulesDir           = $config->path('core.modulesDir');

        $results = glob($modulesDir . '/*/module.json', GLOB_NOSORT);

        foreach ($results as $moduleJson) {
            $jsonString            = file_get_contents($moduleJson);
            if ($jsonString === false){
                continue;
            }
            $jsonModuleDescription = json_decode($jsonString, true);
            if ( ! is_array($jsonModuleDescription)
                || !array_key_exists('moduleUniqueID', $jsonModuleDescription)) {
                continue;
            }

            $moduleUniqueId = $jsonModuleDescription['moduleUniqueID'];
            if ( ! isset($moduleUniqueId)) {
                continue;
            }

            $modelsFiles = glob("{$modulesDir}/{$moduleUniqueId}/Models/*.php", GLOB_NOSORT);
            foreach ($modelsFiles as $file) {
                $className        = pathinfo($file)['filename'];
                $moduleModelClass = "\\Modules\\{$moduleUniqueId}\\Models\\{$className}";

                // Test whether this class abstract or not
                try {
                    $reflection = new ReflectionClass($moduleModelClass);
                    if ($reflection->isAbstract()) {
                        continue;
                    }
                } catch (ReflectionException $exception) {
                    continue;
                }

                if (
                    ! class_exists($moduleModelClass)
                    || count(get_class_vars($moduleModelClass)) === 0) {
                    continue;
                }

                $model                 = new $moduleModelClass();
                $connectionServiceName = $model->getReadConnectionService();
                if ( ! isset($connectionServiceName)) {
                    continue;
                }
                $registeredDBServices[] = $connectionServiceName;
                if ($di->has($connectionServiceName)) {
                    $di->remove($connectionServiceName);
                }

                // Create and connect database
                $dbDir = "{$config->path('core.modulesDir')}/{$moduleUniqueId}/db";
                if (!file_exists($dbDir)){
                    Util::mwMkdir($dbDir, true);
                }
                $dbFileName = "{$dbDir}/module.db";
                $dbFileExistBeforeAttachToConnection = file_exists($dbFileName);

                // Log
                $logDir = "{$config->path('core.logsDir')}/$moduleUniqueId/db";
                $logFileName = "{$logDir}/queries.log";
                if (!is_dir($logDir)){
                    Util::mwMkdir($logDir, true);
                    $touchPath = Util::which('touch');
                    Processes::mwExec("{$touchPath} {$logFileName}");
                    Util::addRegularWWWRights($logDir);
                }

                $params = [
                    "debugMode"    => $config->path('modulesDatabases.debugMode'),
                    "adapter"      => "Sqlite",
                    "dbfile"       => $dbFileName,
                    "debugLogFile" => $logFileName,
                ];

                $this->registerDBService($connectionServiceName, $di, $params);

                // if database was created, we have to apply rules
                if (!$dbFileExistBeforeAttachToConnection){
                    Util::addRegularWWWRights($dbDir);
                }
            }
        }

        // Register transactions events
        $mainConnection = $di->getShared('db');

        $eventsManager = $mainConnection->getEventsManager();
        if ($eventsManager === null) {
            $eventsManager = new Manager();
        }
        // Attach all created connections to one transaction manager
        $eventsManager->attach(
            'db',
            function ($event) use ($registeredDBServices, $di) {
                switch ($event->getType()) {
                    case 'beginTransaction':
                    {
                        foreach ($registeredDBServices as $service) {
                            $di->get($service)->begin();
                        }
                        break;
                    }
                    case 'commitTransaction':
                    {
                        foreach ($registeredDBServices as $service) {
                            $di->get($service)->commit();
                        }
                        break;
                    }
                    case 'rollbackTransaction':
                    {
                        foreach ($registeredDBServices as $service) {
                            $di->get($service)->rollback();
                        }
                        break;
                    }
                    default:
                }
            }
        );
        // Назначаем EventsManager экземпляру адаптера базы данных
        $mainConnection->setEventsManager($eventsManager);
    }

    /**
     * Recreate DB connections after table structure changes for additional modules
     */
    public static function recreateModulesDBConnections(): void
    {
        $di = Di::getDefault();
        $di->register(new self());
    }
}