AdminModule\UpdatePresenter

Complexity

Total Complexity

48

Size/Duplication

Total Lines	359
Duplicated Lines	7.24 %

Coupling/Cohesion

Components	2
Dependencies	8

Test Coverage

Coverage

33.77%

Importance

Changes	4
Bugs	2	Features	0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	beforeRender()	0	4	1
A	startup()	0	4	1
A	actionAddModule()	0	3	1
A	renderAddModule()	0	4	1
A	renderFunctions()	0	4	1
A	renderCreateModule()	0	4	1
A	renderDefault()	0	16	3
B	handleUpdateSystem()	0	28	4
A	getMessageFromFile()	0	10	2
A	actionClearCache()	0	7	1
A	handleBackupDatabase()	0	16	2
B	actionRegister()	0	29	3
A	copyTemplates()	0	7	2
A	actionUnregister()	0	13	1
A	isRegistered()	12	12	3
C	handleCheckUpdates()	0	52	9
A	handleDeleteModule()	0	21	2
A	createComponentAddModuleForm()	0	12	1
A	getModulesToInstall()	0	16	3
A	createComponentCreateModuleForm()	14	14	1
A	createModuleFormSubmitted()	0	15	1
A	renderLog()	0	9	1
A	getLog()	0	8	2
A	addModuleFormSubmitted()	0	17	1

<?php

namespace AdminModule;

/**
 * Description of UpdatePresenter
 *
 * @author Tomáš Voslař <tomas.voslar at webcook.cz>
 */
class UpdatePresenter extends \AdminModule\BasePresenter
{
    protected function beforeRender()
    {
        parent::beforeRender();
    }

    protected function startup()
    {
        parent::startup();
    }

    public function renderDefault()
    {
        $this->reloadContent();

        $packages = \WebCMS\Helpers\SystemHelper::getPackages();

        foreach ($packages as &$package) {
            if ($package['module']) {
                $module = $this->createObject($package['package']);

                $package['registered'] = $this->isRegistered($module->getName());
            }
        }

        $this->template->packages = $packages;

The property $template is declared private in Nette\Application\UI\Control. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

Accessing packages on the interface Nette\Templating\ITemplate suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    public function handleUpdateSystem()
    {
        $installLog = './log/install.log';
        $installErrorLog = './log/install-error.log';

        putenv("COMPOSER_HOME=/usr/bin/.composer");

        exec("cd ../;git pull;composer update -n > $installLog 2> $installErrorLog");

        $successMessage = $this->getMessageFromFile('.'.$installLog);

        if (strpos($successMessage, 'System has been updated.') !== FALSE) {
            $this->flashMessage('System has been udpated.', 'success');
        }

        $errorMessage = $this->getMessageFromFile('.'.$installErrorLog);
        if (!empty($errorMessage)) {
            $this->flashMessage('Error while updating system. Please contact administrator.', 'danger');
        }

        $this->handleCheckUpdates();

        if (!$this->isAjax()) {
            $this->forward('Update:');
        } else {
            $this->invalidateControl('footer');
        }
    }

    /**
     * @param string $file
     */
    private function getMessageFromFile($file)
    {
        if (file_exists($file)) {
            $message = file_get_contents($file);
        } else {
            $message = 'error';
        }

        return $message;
    }

    public function actionClearCache()
    {
        $this->context->cacheStorage->clean(array(\Nette\Caching\Cache::ALL => TRUE));

The property $context is declared private in Nette\Application\UI\Presenter. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

        $this->flashMessage('Cache has been cleared.', 'success');
        $this->redirect("Update:functions");
    }

    public function handleBackupDatabase()
    {
        $par = $this->context->getParameters();

The property $context is declared private in Nette\Application\UI\Presenter. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

        if (!file_exists('./upload/backups')) {
            mkdir('./upload/backups');
        }

        $user = $par['database']['user'];
        $password = $par['database']['password'];
        $database = $par['database']['dbname'];

        exec("mysqldump -u $user -p$password $database > ./upload/backups/db-backup-".time().".sql");

        $this->flashMessage('Backup has been create. You can download this backup in filesystem - backup directory.', 'success');
    }

    // REFACTOR
    public function actionRegister($name)
    {
        $module = $this->createObject($name);

        if (!$this->isRegistered($name)) {
            $exists = $this->em->getRepository('WebCMS\Entity\Module')->findOneBy(array(
            'name' => $module->getName(),
            ));

            if (is_object($exists)) {
                $exists->setActive(true);
            } else {
                $mod = new \WebCMS\Entity\Module();
                $mod->setName($module->getName());
                $mod->setPresenters($module->getPresenters());
                $mod->setActive(true);

                $this->em->persist($mod);
            }

            $this->em->flush();
            $this->copyTemplates($name);
            $this->flashMessage('Module has been registered.', 'success');
        } else {
            $this->flashMessage('Module is already registered.', 'danger');
        }

        $this->forward('default');
    }

    private function copyTemplates($name)
    {
        if (!file_exists('../app/templates/'.$name)) {
            mkdir('../app/templates/'.$name);
        }
        exec('cp -r ../libs/webcms2/'.$name.'/Frontend/templatesDefault/* ../app/templates/'.$name);
    }

    public function actionUnregister($name)
    {
        $module = $this->createObject($name);
        $module = $this->em->getRepository('WebCMS\Entity\Module')->findOneBy(array(
            'name' => $module->getName(),
        ));

        $module->setActive(false);
        $this->em->flush();

        $this->flashMessage('Module has been unregistered from system.', 'success');
        $this->forward('default');
    }

    private function isRegistered($name)

This method seems to be duplicated in your project.

    {
        $exists = $this->em->getRepository('WebCMS\Entity\Module')->findOneBy(array(
            'name' => $name,
        ));

        if (is_object($exists) && $exists->getActive()) {
            return TRUE;
        } else {
            return FALSE;
        }
    }

    public function handleCheckUpdates()
    {
        $client = new \Packagist\Api\Client();

        $packages = \WebCMS\Helpers\SystemHelper::getPackages();

        $needUpdateCount = 0;
        foreach ($packages as &$package) {
            if ($package['vendor'] === 'webcms2') {
                $apiResult = $client->get($package['vendor'].'/'.$package['package']);
                $versions = $apiResult->getVersions();

                $devVersion = $versions[$package['version']];
                if (count($versions) > 1) {
                    $newestVersion = next($versions);
                    $newestVersion = $newestVersion->getVersion();
                    while (strpos($newestVersion, 'dev') !== false) {
                        $newestVersion = next($versions);
                        $newestVersion = $newestVersion->getVersion();
                    }
                } else {
                    $newestVersion = null;
                }

            // development or production version?
            if (strpos($package['version'], 'dev') !== false) {
                if ($package['versionHash'] !== mb_substr($devVersion->getSource()->getReference(), 0, 7)) {
                    $needUpdateCount++;
                }
            } else {
                if ($package['version'] !== $newestVersion) {
                    $needUpdateCount++;
                }
            }
            }
        }

        $nuc = $this->settings->get('needUpdateCount', 'system', 'text');

        $setting = $this->em->find('WebCMS\Entity\Setting', $nuc->getId());
        $setting->setValue($needUpdateCount);

        if ($needUpdateCount > 0) {
            $this->flashMessage('Available new updates.', 'success');
        } else {
            $this->flashMessage('Your system is up to date.', 'success');
        }

        $this->em->flush();

        $this->invalidateControl('header');
    }

    public function handleDeleteModule($name)
    {
        $config = json_decode(file_get_contents('../composer.json'));

        if (!empty($config->require->$name)) {
            unset($config->require->$name);
        }

        file_put_contents('../composer.json', json_encode($config, JSON_PRETTY_PRINT));

        $installLog = './log/install.log';
        $installErrorLog = './log/install-error.log';

        putenv("COMPOSER_HOME=/usr/bin/.composer");
        exec("rm -rf ../app/proxies/*");
        exec("cd ../;composer update $name -n > $installLog 2> $installErrorLog");
        exec("cd ../;composer dumpautoload");
        exec("./libs/webcms2/webcms2/install/install.sh 3");

        $this->forward('default');
    }

    public function actionAddModule()
    {
    }

    public function renderAddModule()
    {
        $this->reloadModalContent();
    }

    public function createComponentAddModuleForm()
    {
        $form = $this->createForm();

        $form->addSelect('module', 'Module', $this->getModulesToInstall())->setAttribute('class', 'form-control');

'form-control' is of type string, but the function expects a boolean.

        $form->addText('version', 'Module version')->setDefaultValue('0.*')->setAttribute('class', 'form-control');

'form-control' is of type string, but the function expects a boolean.

        $form->addSubmit('install', 'Install module');
        $form->onSuccess[] = callback($this, 'addModuleFormSubmitted');

        return $form;
    }

    public function addModuleFormSubmitted($form)
    {
        $values = $form->getValues();

        putenv("COMPOSER_HOME=/usr/bin/.composer");

        $installLog = './log/install.log';
        $installErrorLog = './log/install-error.log';

        $module = $values->module;
        $version = $values->version;
        exec("cd ../;composer require $module $version --no-update > $installLog 2> $installErrorLog");
        exec("cd ../;composer update > $installLog 2> $installErrorLog");
        exec("../libs/webcms2/webcms2/install/install.sh 3; >");

        $this->forward('default');
    }

    private function getModulesToInstall()
    {
        $packages = \WebCMS\Helpers\SystemHelper::getPackages();

        $client = new \Packagist\Api\Client();
        $apiResult = $client->search('webcms2/*');

        $notInstalled = array();
        foreach ($apiResult as $package) {
            if (!array_key_exists($package->getName(), $packages)) {
                $notInstalled[$package->getName()] = $package->getName();
            }
        }

        return $notInstalled;
    }

    public function renderFunctions()
    {
        $this->reloadContent();
    }

    public function renderCreateModule()
    {
        $this->reloadModalContent();
    }

    public function createComponentCreateModuleForm()

This method seems to be duplicated in your project.

    {
        $form = $this->createForm();

        $form->addText('name', 'Name')->setAttribute('class', 'form-control');

'form-control' is of type string, but the function expects a boolean.

        $form->addText('author', 'Author')->setAttribute('class', 'form-control');

'form-control' is of type string, but the function expects a boolean.

        $form->addText('email', 'Author\'s email')->setAttribute('class', 'form-control');

'form-control' is of type string, but the function expects a boolean.

        $form->addTextArea('description', 'Description')->setAttribute('class', 'form-control');

'form-control' is of type string, but the function expects a boolean.

        $form->addSubmit('install', 'Create new module')->setAttribute('class', 'btn btn-primary');

'btn btn-primary' is of type string, but the function expects a boolean.

        $form->onSuccess[] = callback($this, 'createModuleFormSubmitted');

        return $form;
    }

    public function createModuleFormSubmitted($form)
    {
        $values = $form->getValues();

        $name = strtolower(trim($values->name));
        $nameBig = ucfirst($name);
        $author = trim($values->author);
        $email = trim($values->email);
        $description = trim($values->description);

        exec("cd ../libs/webcms2/webcms2/install;./module.sh create $name $nameBig '$author' '$email' '$description' > ../../../../log/install.log 2> ../../../../log/install-error.log");

        $this->flashMessage('Module has been created.', 'success');
        $this->forward('default');
    }

    // render log tab
    public function renderLog()
    {
        $this->reloadContent();

        $this->template->installLog = $this->getLog('../log/install.log');

The property $template is declared private in Nette\Application\UI\Control. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

Accessing installLog on the interface Nette\Templating\ITemplate suggest that you code against a concrete implementation. How about adding an instanceof check?

        $this->template->installErrorLog = $this->getLog('../log/install-error.log');

The property $template is declared private in Nette\Application\UI\Control. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

Accessing installErrorLog on the interface Nette\Templating\ITemplate suggest that you code against a concrete implementation. How about adding an instanceof check?

        $this->template->updateLog = $this->getLog('../log/auto-update.log');

The property $template is declared private in Nette\Application\UI\Control. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

Accessing updateLog on the interface Nette\Templating\ITemplate suggest that you code against a concrete implementation. How about adding an instanceof check?

        $this->template->errorLog = $this->getLog('../log/error.log');

The property $template is declared private in Nette\Application\UI\Control. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

Accessing errorLog on the interface Nette\Templating\ITemplate suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    /**
     * @param string $path
     */
    private function getLog($path)
    {
        if (file_exists($path)) {
            return nl2br(file_get_contents($path));
        }

        return '';
    }
}