CoreInstallerExtensionHelper::categorize() - Code Metrics - Inspection of "make admin module categorization more efficient on..." - zikula/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#4293)

by Craig

created 2020-05-06 23:58 UTC

CoreInstallerExtensionHelper::categorize() A

↳ Parent: CoreInstallerExtensionHelper

Complexity

Conditions	2
Paths	2

Size

Total Lines	30
Code Lines	24

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	24
c	0
b	0
f	0
nc	2
nop	0
dl	0
loc	30
rs	9.536

<?php

declare(strict_types=1);

/*
 * This file is part of the Zikula package.
 *
 * Copyright Zikula - https://ziku.la/
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Zikula\Bundle\CoreInstallerBundle\Helper;

use Doctrine\Persistence\ManagerRegistry;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Contracts\Translation\TranslatorInterface;
use Zikula\BlocksModule\Entity\BlockEntity;
use Zikula\Bundle\CoreBundle\HttpKernel\ZikulaHttpKernelInterface;
use Zikula\Bundle\CoreBundle\HttpKernel\ZikulaKernel;
use Zikula\Bundle\CoreBundle\YamlDumper;
use Zikula\ExtensionsModule\AbstractExtension;
use Zikula\ExtensionsModule\Api\ApiInterface\VariableApiInterface;
use Zikula\ExtensionsModule\Api\VariableApi;
use Zikula\ExtensionsModule\Collector\InstallerCollector;
use Zikula\ExtensionsModule\Constant;
use Zikula\ExtensionsModule\Entity\ExtensionEntity;
use Zikula\ExtensionsModule\Helper\BundleSyncHelper;
use Zikula\ExtensionsModule\Helper\ExtensionHelper;

class CoreInstallerExtensionHelper
{
    /**
     * @var ZikulaHttpKernelInterface
     */
    private $kernel;

    /**
     * @var ManagerRegistry
     */
    private $managerRegistry;

    /**
     * @var TranslatorInterface
     */
    private $translator;

    /**
     * @var YamlDumper
     */
    private $yamlHelper;

    /**
     * @var BundleSyncHelper
     */
    private $bundleSyncHelper;

    /**
     * @var ExtensionHelper
     */
    private $extensionHelper;

    /**
     * @var InstallerCollector
     */
    private $installerCollector;

    /**
     * @var VariableApiInterface
     */
    private $variableApi;

    /**
     * @var SessionInterface
     */
    private $session;

    private $adminCategoryHelper;

    public function __construct(
        ZikulaHttpKernelInterface $kernel,
        ManagerRegistry $managerRegistry,
        TranslatorInterface $translator,
        ParameterHelper $parameterHelper,
        BundleSyncHelper $bundleSyncHelper,
        ExtensionHelper $extensionHelper,
        InstallerCollector $installerCollector,
        VariableApiInterface $variableApi,
        SessionInterface $session,
        AdminCategoryHelper $adminCategoryHelper
    ) {
        $this->kernel = $kernel;
        $this->managerRegistry = $managerRegistry;
        $this->translator = $translator;
        $this->yamlHelper = $parameterHelper->getYamlHelper();
        $this->bundleSyncHelper = $bundleSyncHelper;
        $this->extensionHelper = $extensionHelper;
        $this->installerCollector = $installerCollector;
        $this->variableApi = $variableApi;
        $this->session = $session;
        $this->adminCategoryHelper = $adminCategoryHelper;
    }

    public function install(string $extensionName): bool
    {
        $extensionBundle = $this->kernel->getModule($extensionName);
        /** @var AbstractExtension $extensionBundle */
        $className = $extensionBundle->getInstallerClass();
        $installer = $this->installerCollector->get($className);

        if ($installer->install()) {
            return true;
        }

        return false;
    }

    /**
     * Scan the filesystem and sync the extensions table. Set all system extensions to active state.
     */
    public function reSyncAndActivate(): bool
    {
        $extensionsInFileSystem = $this->bundleSyncHelper->scanForBundles(true);
        $this->bundleSyncHelper->syncExtensions($extensionsInFileSystem);

        /** @var ExtensionEntity[] $extensions */
        $extensions = $this->managerRegistry->getRepository('ZikulaExtensionsModule:ExtensionEntity')
            ->findBy(['name' => array_keys(ZikulaKernel::$coreExtension)]);
        foreach ($extensions as $extension) {
            $extension->setState(Constant::STATE_ACTIVE);
        }
        $this->managerRegistry->getManager()->flush();

        return true;
    }

    /**
     * Attempt to upgrade ALL the core extensions. Some will need it, some will not.
     * Extensions that do not need upgrading return TRUE as a result of the upgrade anyway.
     */
    public function upgrade(): bool
    {
        $coreModulesInPriorityUpgradeOrder = [
            'ZikulaExtensionsModule',
            'ZikulaUsersModule',
            'ZikulaZAuthModule',
            'ZikulaGroupsModule',
            'ZikulaPermissionsModule',
            'ZikulaAdminModule',
            'ZikulaBlocksModule',
            'ZikulaThemeModule',
            'ZikulaSettingsModule',
            'ZikulaCategoriesModule',
            'ZikulaSecurityCenterModule',
            'ZikulaRoutesModule',
            'ZikulaMailerModule',
            'ZikulaSearchModule',
            'ZikulaMenuModule',
            'ZikulaBootstrapTheme',
            'ZikulaAtomTheme',
            'ZikulaRssTheme',
            'ZikulaPrinterTheme',
        ];
        $result = true;
        foreach ($coreModulesInPriorityUpgradeOrder as $moduleName) {
            $extensionEntity = $this->managerRegistry->getRepository(ExtensionEntity::class)->get($moduleName);
            if (isset($extensionEntity)) {
                $result = $result && $this->extensionHelper->upgrade($extensionEntity);
            }
        }

        return $result;
    }

    public function executeCoreMetaUpgrade($currentCoreVersion): bool
    {
        /**
         * NOTE: There are *intentionally* no `break` statements within each case here so that the process continues
         * through each case until the end.
         */
        switch ($currentCoreVersion) {
            case '1.4.3':
                $this->install('ZikulaMenuModule');
                $this->reSyncAndActivate();
                $this->adminCategoryHelper->setCategory('ZikulaMenuModule', $this->translator->trans('Content'));
            case '1.4.4':
                // nothing
            case '1.4.5':
                // Menu module was introduced in 1.4.4 but not installed on upgrade
                $schemaManager = $this->managerRegistry->getConnection()->getSchemaManager();
                if (!$schemaManager->tablesExist(['menu_items'])) {
                    $this->install('ZikulaMenuModule');
                    $this->reSyncAndActivate();
                    $this->adminCategoryHelper->setCategory('ZikulaMenuModule', $this->translator->trans('Content'));
                }
            case '1.4.6':
                // nothing needed
            case '1.4.7':
                // nothing needed
            case '1.5.0':
                // nothing needed
            case '1.9.99':
                // upgrades required for 2.0.0
                foreach (['objectdata_attributes', 'objectdata_log', 'objectdata_meta', 'workflows'] as $table) {
                    $sql = "DROP TABLE ${table};";
                    /** @var \Doctrine\DBAL\Driver\PDOConnection $connection */
                    $connection = $this->managerRegistry->getConnection();
                    $stmt = $connection->prepare($sql);
                    $stmt->execute();
                    $stmt->closeCursor();
                }
                $this->variableApi->del(VariableApi::CONFIG, 'metakeywords');
                $this->variableApi->del(VariableApi::CONFIG, 'startpage');
                $this->variableApi->del(VariableApi::CONFIG, 'startfunc');
                $this->variableApi->del(VariableApi::CONFIG, 'starttype');
                if ('userdata' === $this->yamlHelper->getParameter('datadir')) {
                    $this->yamlHelper->setParameter('datadir', 'public/uploads');
                    $fs = new Filesystem();
                    $src = $this->kernel->getProjectDir();
                    try {
                        if ($fs->exists($src . '/userdata')) {
                            $fs->mirror($src . '/userdata', $src . '/public/uploads');
                        }
                    } catch (\Exception $exception) {
                        $this->session->getFlashBag()->add(
                            'info',
                            'Attempt to copy files from `userdata` to `public/uploads` failed. You must manually copy the contents.'
                        );
                    }
                }
                // remove legacy blocks
                $blocksToRemove = $this->managerRegistry->getRepository(BlockEntity::class)->findBy(['blocktype' => ['Extmenu', 'Menutree', 'Menu']]);
                foreach ($blocksToRemove as $block) {
                    $this->managerRegistry->getManager()->remove($block);
                }
                $this->managerRegistry->getManager()->flush();
            case '2.0.15':
                // nothing
            case '3.0.0':
                // current version - cannot perform anything yet
        }

        // always do this
        $this->reSyncAndActivate();
        // set default themes to ZikulaBootstrapTheme
        $this->variableApi->set(VariableApi::CONFIG, 'Default_Theme', 'ZikulaBootstrapTheme');
        $this->variableApi->set('ZikulaAdminModule', 'admintheme', '');
        // unset start page information to avoid missing module errors
        $this->variableApi->set(VariableApi::CONFIG, 'startController_en', '');

        return true;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Zikula package.
7			*
8			* Copyright Zikula - https://ziku.la/
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Zikula\Bundle\CoreInstallerBundle\Helper;
15
16			use Doctrine\Persistence\ManagerRegistry;
17			use Symfony\Component\Filesystem\Filesystem;
18			use Symfony\Component\HttpFoundation\Session\SessionInterface;
19			use Symfony\Contracts\Translation\TranslatorInterface;
20			use Zikula\BlocksModule\Entity\BlockEntity;
21			use Zikula\Bundle\CoreBundle\HttpKernel\ZikulaHttpKernelInterface;
22			use Zikula\Bundle\CoreBundle\HttpKernel\ZikulaKernel;
23			use Zikula\Bundle\CoreBundle\YamlDumper;
24			use Zikula\ExtensionsModule\AbstractExtension;
25			use Zikula\ExtensionsModule\Api\ApiInterface\VariableApiInterface;
26			use Zikula\ExtensionsModule\Api\VariableApi;
27			use Zikula\ExtensionsModule\Collector\InstallerCollector;
28			use Zikula\ExtensionsModule\Constant;
29			use Zikula\ExtensionsModule\Entity\ExtensionEntity;
30			use Zikula\ExtensionsModule\Helper\BundleSyncHelper;
31			use Zikula\ExtensionsModule\Helper\ExtensionHelper;
32
33			class CoreInstallerExtensionHelper
34			{
35			/**
36			* @var ZikulaHttpKernelInterface
37			*/
38			private $kernel;
39
40			/**
41			* @var ManagerRegistry
42			*/
43			private $managerRegistry;
44
45			/**
46			* @var TranslatorInterface
47			*/
48			private $translator;
49
50			/**
51			* @var YamlDumper
52			*/
53			private $yamlHelper;
54
55			/**
56			* @var BundleSyncHelper
57			*/
58			private $bundleSyncHelper;
59
60			/**
61			* @var ExtensionHelper
62			*/
63			private $extensionHelper;
64
65			/**
66			* @var InstallerCollector
67			*/
68			private $installerCollector;
69
70			/**
71			* @var VariableApiInterface
72			*/
73			private $variableApi;
74
75			/**
76			* @var SessionInterface
77			*/
78			private $session;
79
80			private $adminCategoryHelper;
81
82			public function __construct(
83			ZikulaHttpKernelInterface $kernel,
84			ManagerRegistry $managerRegistry,
85			TranslatorInterface $translator,
86			ParameterHelper $parameterHelper,
87			BundleSyncHelper $bundleSyncHelper,
88			ExtensionHelper $extensionHelper,
89			InstallerCollector $installerCollector,
90			VariableApiInterface $variableApi,
91			SessionInterface $session,
92			AdminCategoryHelper $adminCategoryHelper
93			) {
94			$this->kernel = $kernel;
95			$this->managerRegistry = $managerRegistry;
96			$this->translator = $translator;
97			$this->yamlHelper = $parameterHelper->getYamlHelper();
98			$this->bundleSyncHelper = $bundleSyncHelper;
99			$this->extensionHelper = $extensionHelper;
100			$this->installerCollector = $installerCollector;
101			$this->variableApi = $variableApi;
102			$this->session = $session;
103			$this->adminCategoryHelper = $adminCategoryHelper;
104			}
105
106			public function install(string $extensionName): bool
107			{
108			$extensionBundle = $this->kernel->getModule($extensionName);
109			/** @var AbstractExtension $extensionBundle */
110			$className = $extensionBundle->getInstallerClass();
111			$installer = $this->installerCollector->get($className);
112
113			if ($installer->install()) {
114			return true;
115			}
116
117			return false;
118			}
119
120			/**
121			* Scan the filesystem and sync the extensions table. Set all system extensions to active state.
122			*/
123			public function reSyncAndActivate(): bool
124			{
125			$extensionsInFileSystem = $this->bundleSyncHelper->scanForBundles(true);
126			$this->bundleSyncHelper->syncExtensions($extensionsInFileSystem);
127
128			/** @var ExtensionEntity[] $extensions */
129			$extensions = $this->managerRegistry->getRepository('ZikulaExtensionsModule:ExtensionEntity')
130			->findBy(['name' => array_keys(ZikulaKernel::$coreExtension)]);
131			foreach ($extensions as $extension) {
132			$extension->setState(Constant::STATE_ACTIVE);
133			}
134			$this->managerRegistry->getManager()->flush();
135
136			return true;
137			}
138
139			/**
140			* Attempt to upgrade ALL the core extensions. Some will need it, some will not.
141			* Extensions that do not need upgrading return TRUE as a result of the upgrade anyway.
142			*/
143			public function upgrade(): bool
144			{
145			$coreModulesInPriorityUpgradeOrder = [
146			'ZikulaExtensionsModule',
147			'ZikulaUsersModule',
148			'ZikulaZAuthModule',
149			'ZikulaGroupsModule',
150			'ZikulaPermissionsModule',
151			'ZikulaAdminModule',
152			'ZikulaBlocksModule',
153			'ZikulaThemeModule',
154			'ZikulaSettingsModule',
155			'ZikulaCategoriesModule',
156			'ZikulaSecurityCenterModule',
157			'ZikulaRoutesModule',
158			'ZikulaMailerModule',
159			'ZikulaSearchModule',
160			'ZikulaMenuModule',
161			'ZikulaBootstrapTheme',
162			'ZikulaAtomTheme',
163			'ZikulaRssTheme',
164			'ZikulaPrinterTheme',
165			];
166			$result = true;
167			foreach ($coreModulesInPriorityUpgradeOrder as $moduleName) {
168			$extensionEntity = $this->managerRegistry->getRepository(ExtensionEntity::class)->get($moduleName);
169			if (isset($extensionEntity)) {
170			$result = $result && $this->extensionHelper->upgrade($extensionEntity);
171			}
172			}
173
174			return $result;
175			}
176
177			public function executeCoreMetaUpgrade($currentCoreVersion): bool
178			{
179			/**
180			* NOTE: There are intentionally no `break` statements within each case here so that the process continues
181			* through each case until the end.
182			*/
183			switch ($currentCoreVersion) {
184			case '1.4.3':
185			$this->install('ZikulaMenuModule');
186			$this->reSyncAndActivate();
187			$this->adminCategoryHelper->setCategory('ZikulaMenuModule', $this->translator->trans('Content'));
188			case '1.4.4':
189			// nothing
190			case '1.4.5':
191			// Menu module was introduced in 1.4.4 but not installed on upgrade
192			$schemaManager = $this->managerRegistry->getConnection()->getSchemaManager();
193			if (!$schemaManager->tablesExist(['menu_items'])) {
194			$this->install('ZikulaMenuModule');
195			$this->reSyncAndActivate();
196			$this->adminCategoryHelper->setCategory('ZikulaMenuModule', $this->translator->trans('Content'));
197			}
198			case '1.4.6':
199			// nothing needed
200			case '1.4.7':
201			// nothing needed
202			case '1.5.0':
203			// nothing needed
204			case '1.9.99':
205			// upgrades required for 2.0.0
206			foreach (['objectdata_attributes', 'objectdata_log', 'objectdata_meta', 'workflows'] as $table) {
207			$sql = "DROP TABLE ${table};";
208			/** @var \Doctrine\DBAL\Driver\PDOConnection $connection */
209			$connection = $this->managerRegistry->getConnection();
210			$stmt = $connection->prepare($sql);
211			$stmt->execute();
212			$stmt->closeCursor();
213			}
214			$this->variableApi->del(VariableApi::CONFIG, 'metakeywords');
215			$this->variableApi->del(VariableApi::CONFIG, 'startpage');
216			$this->variableApi->del(VariableApi::CONFIG, 'startfunc');
217			$this->variableApi->del(VariableApi::CONFIG, 'starttype');
218			if ('userdata' === $this->yamlHelper->getParameter('datadir')) {
219			$this->yamlHelper->setParameter('datadir', 'public/uploads');
220			$fs = new Filesystem();
221			$src = $this->kernel->getProjectDir();
222			try {
223			if ($fs->exists($src . '/userdata')) {
224			$fs->mirror($src . '/userdata', $src . '/public/uploads');
225			}
226			} catch (\Exception $exception) {
227			$this->session->getFlashBag()->add(
228			'info',
229			'Attempt to copy files from `userdata` to `public/uploads` failed. You must manually copy the contents.'
230			);
231			}
232			}
233			// remove legacy blocks
234			$blocksToRemove = $this->managerRegistry->getRepository(BlockEntity::class)->findBy(['blocktype' => ['Extmenu', 'Menutree', 'Menu']]);
235			foreach ($blocksToRemove as $block) {
236			$this->managerRegistry->getManager()->remove($block);
237			}
238			$this->managerRegistry->getManager()->flush();
239			case '2.0.15':
240			// nothing
241			case '3.0.0':
242			// current version - cannot perform anything yet
243			}
244
245			// always do this
246			$this->reSyncAndActivate();
247			// set default themes to ZikulaBootstrapTheme
248			$this->variableApi->set(VariableApi::CONFIG, 'Default_Theme', 'ZikulaBootstrapTheme');
249			$this->variableApi->set('ZikulaAdminModule', 'admintheme', '');
250			// unset start page information to avoid missing module errors
251			$this->variableApi->set(VariableApi::CONFIG, 'startController_en', '');
252
253			return true;
254			}
255			}
256

zikula / core

Pull Request — master (#4293)

CoreInstallerExtensionHelper::categorize() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like