MikoPBX\Common\Providers\ModulesDBConnectionsProvider::register()

Complexity

Conditions	23
Paths	52

Size

Total Lines	128
Code Lines	78

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    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);
    }