ExtensionInstallerController::installAction() - Code Metrics - Inspection of "add logging to cacheclearer and extensionhelper fo..." - zikula/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#4264)

by Craig
created 2020-05-16 11:56 UTC
ExtensionInstallerController::installAction() B

↳ Parent: ExtensionInstallerController
Complexity

Conditions	11
Paths	7
Size

Total Lines	62
Code Lines	37
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	11
eloc	37
c	1
b	0
f	0
nc	7
nop	5
dl	0
loc	62
rs	7.3166
How to fix Long Method Complexity

<?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\ExtensionsModule\Controller;

use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
use Symfony\Contracts\Translation\TranslatorInterface;
use Zikula\Bundle\CoreBundle\Composer\MetaData;
use Zikula\Bundle\CoreBundle\Controller\AbstractController;
use Zikula\Bundle\CoreBundle\HttpKernel\ZikulaHttpKernelInterface;
use Zikula\ExtensionsModule\AbstractExtension;
use Zikula\ExtensionsModule\Api\ApiInterface\VariableApiInterface;
use Zikula\ExtensionsModule\Collector\InstallerCollector;
use Zikula\ExtensionsModule\Constant;
use Zikula\ExtensionsModule\Entity\ExtensionEntity;
use Zikula\ExtensionsModule\Entity\RepositoryInterface\ExtensionRepositoryInterface;
use Zikula\ExtensionsModule\Event\ExtensionPostCacheRebuildEvent;
use Zikula\ExtensionsModule\Form\Type\ExtensionInstallType;
use Zikula\ExtensionsModule\Helper\ExtensionDependencyHelper;
use Zikula\ExtensionsModule\Helper\ExtensionHelper;
use Zikula\ExtensionsModule\Helper\ExtensionStateHelper;
use Zikula\PermissionsModule\Annotation\PermissionCheck;
use Zikula\PermissionsModule\Api\ApiInterface\PermissionApiInterface;
use Zikula\ThemeModule\Engine\Annotation\Theme;

/**
 * @Route("")
 */
class ExtensionInstallerController extends AbstractController
{
    /**
     * @var ExtensionStateHelper
     */
    private $extensionStateHelper;

    /**
     * @var ExtensionRepositoryInterface
     */
    private $extensionRepository;

    /**
     * @var ExtensionDependencyHelper
     */
    private $dependencyHelper;

    public function __construct(
        AbstractExtension $extension,
        PermissionApiInterface $permissionApi,
        VariableApiInterface $variableApi,
        TranslatorInterface $translator,
        ExtensionStateHelper $extensionStateHelper,
        ExtensionRepositoryInterface $extensionRepository,
        ExtensionDependencyHelper $dependencyHelper
    )
    {
        parent::__construct($extension, $permissionApi, $variableApi, $translator);
        $this->extensionStateHelper = $extensionStateHelper;
        $this->extensionRepository = $extensionRepository;
        $this->dependencyHelper = $dependencyHelper;
    }

    /**
     * @Route("/preinstall/{id}", requirements={"id" = "^[1-9]\d*$"})
     * @PermissionCheck("admin")
     * @Theme("admin")
     * @Template("@ZikulaExtensionsModule/Extension/preinstall.html.twig")
     */
    public function preInstallAction(ExtensionEntity $extension) {
        if (Constant::STATE_TRANSITIONAL !== $extension->getState()) {
            $this->extensionStateHelper->updateState($extension->getId(), Constant::STATE_TRANSITIONAL);

            return $this->redirectToRoute('zikulaextensionsmodule_extension_list');
        }
        $unsatisfiedDependencies = $this->dependencyHelper->getUnsatisfiedExtensionDependencies($extension);
        $form = $this->createForm(ExtensionInstallType::class, [
            'dependencies' => $this->formatDependencyCheckboxArray($unsatisfiedDependencies)
        ], [
            'action' => $this->generateUrl('zikulaextensionsmodule_extensioninstaller_install', ['id' => $extension->getId()])
        ]);

        return [
            'dependencies' => $unsatisfiedDependencies,
            'extension' => $extension,
            'form' => $form->createView()
        ];
    }

    /**
     * @Route("/install/{id}", requirements={"id" = "^[1-9]\d*$"})
     * @PermissionCheck("admin")
     * @Theme("admin")
     *
     * Install and initialise an extension.
     *
     * @return RedirectResponse
     */
    public function installAction(
        Request $request,
        ExtensionEntity $extension,
        ZikulaHttpKernelInterface $kernel,
        InstallerCollector $installerCollector,
        ExtensionHelper $extensionHelper
    ) {
        $id = $extension->getId();

        $state = $extension->getState();

        $isBundle = $kernel->isBundle($extension->getName());

        $extensionBundle = $kernel->getBundle($extension->getName());
        $className = $extensionBundle->getInstallerClass();
        $className = $extensionBundle->getInstallerClass();
        $hasInstaller = $installerCollector->has($className);

        $installer = $installerCollector->get($className);


        $unsatisfiedDependencies = $this->dependencyHelper->getUnsatisfiedExtensionDependencies($extension);
        $form = $this->createForm(ExtensionInstallType::class, [
            'dependencies' => $this->formatDependencyCheckboxArray($unsatisfiedDependencies)
        ]);

        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            if ($form->get('install')->isClicked()) {
            if ($form->get('install')->/** @scrutinizer ignore-call */ isClicked()) {
                $extensionsInstalled = [];
                $data = $form->getData();

                // Install extension dependencies
                foreach ($data['dependencies'] as $dependencyId => $installSelected) {
                    if (!$installSelected && MetaData::DEPENDENCY_REQUIRED !== $unsatisfiedDependencies[$dependencyId]->getStatus()) {
                        continue;
                    }
                    $dependencyExtensionEntity = $this->extensionRepository->get($unsatisfiedDependencies[$dependencyId]->getModname());
                    if (isset($dependencyExtensionEntity)) {
                        if (!$extensionHelper->install($dependencyExtensionEntity)) {
                            $this->addFlash('error', $this->trans('Failed to install dependency "%name%"!', ['%name%' => $dependencyExtensionEntity->getName()]));

                            return $this->redirectToRoute('zikulaextensionsmodule_extension_list');
                        }
                        $extensionsInstalled[] = $dependencyExtensionEntity->getId();
                        $this->addFlash('status', $this->trans('Installed dependency "%name%".', ['%name%' => $dependencyExtensionEntity->getName()]));
                    } else {
                        $this->addFlash('warning', $this->trans('Warning: could not install selected dependency "%name%".', ['%name%' => $unsatisfiedDependencies[$dependencyId]->getModname()]));
                    }
                }

                if ($extensionHelper->install($extension)) {
                    $this->addFlash('status', $this->trans('Done! Installed "%name%".', ['%name%' => $extension->getName()]));
                    $extensionsInstalled[] = $id;

                    return $this->redirectToRoute('zikulaextensionsmodule_extensioninstaller_postinstall', ['extensions' => json_encode($extensionsInstalled)]);
                }
                $this->extensionStateHelper->updateState($id, Constant::STATE_UNINITIALISED);
                $this->addFlash('error', $this->trans('Initialization of "%name%" failed!', ['%name%' => $extension->getName()]));
            }
            if ($form->get('cancel')->isClicked()) {
                $this->extensionStateHelper->updateState($id, Constant::STATE_UNINITIALISED);
                $this->addFlash('status', 'Operation cancelled.');
            }
        }

        return $this->redirectToRoute('zikulaextensionsmodule_extension_list');
    }

    /**
     * Post-installation action to trigger the MODULE_POSTINSTALL event.
     * The additional Action is required because this event must occur AFTER the rebuild of the cache which occurs on Request.
     *
     * @Route("/postinstall/{extensions}", methods = {"GET"})
     */
    public function postInstallAction(
        ZikulaHttpKernelInterface $kernel,
        EventDispatcherInterface $eventDispatcher,
        string $extensions = null
    ): RedirectResponse {
        if (!empty($extensions)) {
            $extensions = json_decode($extensions);
            foreach ($extensions as $extensionId) {
                /** @var ExtensionEntity $extensionEntity */
                $extensionEntity = $this->extensionRepository->find($extensionId);
                if (null === $this->extensionRepository) {
                    continue;
                }
                /** @var AbstractExtension $extensionBundle */
                $extensionBundle = $kernel->getBundle($extensionEntity->getName());
                $eventDispatcher->dispatch(new ExtensionPostCacheRebuildEvent($extensionBundle, $extensionEntity));
            }
        }

        return $this->redirectToRoute('zikulaextensionsmodule_extension_list', ['justinstalled' => json_encode($extensions)]);
    }

    /**
     * Create array suitable for checkbox FormType [[ID => bool][ID => bool]].
     */
    private function formatDependencyCheckboxArray(array $dependencies): array
    {
        $return = [];
        foreach ($dependencies as $dependency) {
            /** @var ExtensionEntity $dependencyExtension */
            $dependencyExtension = $this->extensionRepository->get($dependency->getModname());
            $return[$dependency->getId()] = null !== $dependencyExtension;
        }

        return $return;
    }
}

zikula / core

Pull Request — master (#4264)

ExtensionInstallerController::installAction() B

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
