RegisterkeyController.php

<?php
namespace T3o\TerFe2\Controller;

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

use ApacheSolrForTypo3\Solr\GarbageCollector;
use ApacheSolrForTypo3\Solr\IndexQueue\Queue;
use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Persistence\Generic\QuerySettingsInterface;

/**
 * Controller for the extension key registration
 */
class RegisterkeyController extends \T3o\TerFe2\Controller\AbstractTerBasedController
{

    /**
     * @var \T3o\TerFe2\Domain\Repository\ExtensionRepository
     */
    protected $extensionRepository;

    /**
     * @var \T3o\TerFe2\Domain\Repository\VersionRepository
     */
    protected $versionRepository;

    /**
     * @var \TYPO3\CMS\Extbase\Domain\Repository\FrontendUserRepository
     */
    protected $userRepository;

    /**
     * inject extensionRepository
     *
     * @param \T3o\TerFe2\Domain\Repository\ExtensionRepository $extensionRepository
     * @return void
     */
    public function injectExtensionRepository(\T3o\TerFe2\Domain\Repository\ExtensionRepository $extensionRepository)
    {
        $this->extensionRepository = $extensionRepository;
    }

    /**
     * inject versionRepository
     *
     * @param \T3o\TerFe2\Domain\Repository\VersionRepository $versionRepository
     * @return void
     */
    public function injectVersionRepository(\T3o\TerFe2\Domain\Repository\VersionRepository $versionRepository)
    {
        $this->versionRepository = $versionRepository;
    }

    /**
     * inject userRepository
     *
     * @param \TYPO3\CMS\Extbase\Domain\Repository\FrontendUserRepository $userRepository
     * @return void
     */
    public function injectUserRepository(\TYPO3\CMS\Extbase\Domain\Repository\FrontendUserRepository $userRepository)
    {
        $this->userRepository = $userRepository;
    }

    /**
     * Initialize all actions
     *
     * @param boolean $uploaded TRUE if an extension version was successfully uploaded
     * @return void
     */
    public function indexAction($uploaded = false)
    {
        // get extensions by user if a user is logged in
        if ($GLOBALS['TSFE']->fe_user->user['uid']) {
            $this->frontendUser = $this->userRepository->findByUid($GLOBALS['TSFE']->fe_user->user['uid']);
            $extensions = $this->extensionRepository->findByFrontendUser($this->frontendUser->getUsername());
            $expiringExtensions = $this->extensionRepository->findByFrontendUserAndExpiring($this->frontendUser->getUsername());
            $this->view->assign('extensions', $extensions);
            $this->view->assign('expiringExtensions', $expiringExtensions);
            $this->view->assign('uploaded', $uploaded);
        }
    }

    /**
     * Register a new extension
     *
     * @param string $extensionKey Extension key
     * @return void
     */
    public function createAction($extensionKey)
    {

        // Remove spaces from extensionKey if there are some
        $extensionKey = trim($extensionKey);

        // Check if the extension exists in the ter
        if ($this->terConnection->checkExtensionKey($extensionKey, $error)) {
            $extensionData = array(
                'extensionKey' => $extensionKey,
                'title' => $extensionKey,
                'description' => '',
            );

            // Register the extension key at ter server, if successfull, add it to the extension table
            if ($this->terConnection->registerExtension($extensionData)) {
                // Create extension model
                $extension = $this->objectManager->get(\T3o\TerFe2\Domain\Model\Extension::class);
                $extension->setExtKey($extensionKey);
                $extension->setFrontendUser($this->frontendUser['username']);

                $this->extensionRepository->add($extension);
                $this->addFlashMessage(
                    '',
                    $this->translate('registerkey.key_registered'),
                    \TYPO3\CMS\Core\Messaging\FlashMessage::OK
                );
                $this->redirect('index', 'Registerkey');
            } else {
                $this->addFlashMessage(
                    $this->resolveWSErrorMessage('not_register.message'),
                    $this->resolveWSErrorMessage('not_register.title'),
                    \TYPO3\CMS\Core\Messaging\FlashMessage::ERROR
                );
            }
        } else {
            /** @var \T3o\TerFe2\Domain\Model\Extension $extension */
            $extension = $this->extensionRepository->findOneByExtKey($extensionKey);
            $message = '';
            if ($error === 'key_invalid') {
                $message = $this->resolveWSErrorMessage($error . '.message');
            }
            if ($extension instanceof \T3o\TerFe2\Domain\Model\Extension && $extension->getFrontendUser()) {
                /** @var \TYPO3\CMS\Extbase\Domain\Model\FrontendUser $frontendUser */
                $frontendUser = $this->userRepository->findOneByUsername($extension->getFrontendUser());
                if ($frontendUser instanceof \TYPO3\CMS\Extbase\Domain\Model\FrontendUser) {
                    $message = $this->resolveWSErrorMessage(
                        $error . '.message',
                        [
                            '<a href="mailto:' . htmlspecialchars($frontendUser->getEmail()) . '">' . htmlspecialchars($frontendUser->getName()) . '</a>'
                        ]
                    );
                }
            }
            $this->addFlashMessage(
                $message,
                $this->resolveWSErrorMessage($error . '.title'),
                \TYPO3\CMS\Core\Messaging\FlashMessage::ERROR
            );
        }

        $this->redirect('index', 'Registerkey', null, array());
    }

    /**
     * Transfer an extension key to another user
     *
     * @param string $newUser Username of the assignee
     * @param \T3o\TerFe2\Domain\Model\Extension $extension Extension to transfer
     * @return void
     */
    public function transferAction($newUser, \T3o\TerFe2\Domain\Model\Extension $extension)
    {

        $newUser = trim($newUser);
        if ($newUser == '') {
            $this->addFlashMessage(
                '',
                $this->translate('registerkey.newuserempty'),
                \TYPO3\CMS\Core\Messaging\FlashMessage::ERROR
            );
        } elseif ((strtolower($extension->getFrontendUser()) == strtolower($GLOBALS['TSFE']->fe_user->user['username'])) || $this->securityRole->isAdmin()) {
            // check if the extension belongs to the current user

            $error = '';

            // Is it possible to assign the key to a new user
            if ($this->terConnection->assignExtensionKey($extension->getExtKey(), $newUser, $error)) {
                $extension->setFrontendUser($newUser);
                $this->extensionRepository->update($extension);
                $this->addFlashMessage($this->translate('registerkey.keyTransfered', array($extension->getExtKey(), $newUser)), '', \TYPO3\CMS\Core\Messaging\FlashMessage::OK);
            } else {
                $this->addFlashMessage(
                    $this->resolveWSErrorMessage($error),
                    $this->translate('registerkey.transferError.title', array($extension->getExtKey())),
                    \TYPO3\CMS\Core\Messaging\FlashMessage::ERROR
                );
            }
        } else {
            $this->addFlashMessage(
                '',
                $this->translate('registerkey.notyourextension'),
                \TYPO3\CMS\Core\Messaging\FlashMessage::ERROR
            );
        }

        $this->redirect('index', 'Registerkey');
    }

    /**
     * Delete an extension key from ter server
     *
     * @param \T3o\TerFe2\Domain\Model\Extension $extension Extension to delete
     * @return void
     */
    public function deleteAction(\T3o\TerFe2\Domain\Model\Extension $extension)
    {

        if ($extension->getVersionCount() > 0) {
            $this->addFlashMessage(
                $this->translate('registerkey.deleting_prohibited', array($extension->getExtKey())),
                '',
                \TYPO3\CMS\Core\Messaging\FlashMessage::ERROR
            );
        } elseif ((strtolower($extension->getFrontendUser()) == strtolower($GLOBALS['TSFE']->fe_user->user['username'])) || $this->securityRole->isAdmin()) {
            // Deleted in ter, then delete the key in the ter_fe2 extension table
            if ($this->terConnection->deleteExtensionKey($extension->getExtKey())) {
                $extensionUid = $extension->getUid();
                $this->extensionRepository->remove($extension);

                // ext:solr garbage collector
                if (ExtensionManagementUtility::isLoaded('solr')) {
                    $garbageCollector = GeneralUtility::makeInstance(GarbageCollector::class);
                    $garbageCollector->collectGarbage('tx_terfe2_domain_model_extension', $extensionUid);
                }
                $this->addFlashMessage(
                    '',
                    $this->translate('registerkey.deleted', array($extension->getExtKey())),
                    \TYPO3\CMS\Core\Messaging\FlashMessage::OK
                );
            } else {
                $this->addFlashMessage(
                    $this->resolveWSErrorMessage('cannotbedeleted.message', array($extension->getExtKey())),
                    $this->resolveWSErrorMessage('cannotbedeleted.title', array($extension->getExtKey())),
                    \TYPO3\CMS\Core\Messaging\FlashMessage::ERROR
                );
            }
        } else {
            $this->addFlashMessage($this->translate('registerkey.notyourextension'), '', \TYPO3\CMS\Core\Messaging\FlashMessage::ERROR);
        }

        $this->redirect('index', 'Registerkey');
    }

    /**
     * Sets the expire back to zero and touches the extension
     * The process for getting expiring extensions will be back in 1 year
     *
     * @param \T3o\TerFe2\Domain\Model\Extension $extension
     * @ignorevalidation $extension
     * @return void
     * @throws \TYPO3\CMS\Extbase\Mvc\Exception\UnsupportedRequestTypeException
     */
    public function keepAction(\T3o\TerFe2\Domain\Model\Extension $extension)
    {
        $extension->setExpire(null);
        $this->extensionRepository->update($extension);
        $this->redirect('index', 'Registerkey');
    }

    /**
     * Delete an extension version from ter server
     *
     * @param \T3o\TerFe2\Domain\Model\Version $version Extension to delete
     * @ignorevalidation $version
     * @return void
     */
    public function deleteExtensionVersionAction(\T3o\TerFe2\Domain\Model\Version $version)
    {
        if (!$this->securityRole->isAdmin()) {
            $this->addFlashMessage(
                $this->resolveWSErrorMessage('not_admin.message'),
                $this->resolveWSErrorMessage('not_admin.title'),
                \TYPO3\CMS\Core\Messaging\FlashMessage::ERROR
            );
            $this->redirect('index');
        }

        $redirectToIndexAction = false;

        // Deleted in ter, then delete the version (and probably the extension) in the ter_fe2 extension table
        if ($this->terConnection->deleteExtensionVersion($version->getExtension()->getExtKey(), $version->getVersionString())) {
            $version->getExtension()->removeVersion($version);
            $this->versionRepository->remove($version);
            if (empty($version->getExtension()->getVersions())) {
                $redirectToIndexAction = true;
                // remove from index queue
                if (ExtensionManagementUtility::isLoaded('solr')) {
                    $indexQueue = GeneralUtility::makeInstance(Queue::class);
                    $indexQueue->deleteItem('tx_terfe2_domain_model_extension', $version->getExtension()->getUid());
                }
            }
            $this->addFlashMessage(
                '',
                $this->translate('registerkey.version_deleted', array($version->getVersionString(), $version->getExtension()->getExtKey())),
                \TYPO3\CMS\Core\Messaging\FlashMessage::OK
            );
        } else {
            $this->addFlashMessage(
                $this->resolveWSErrorMessage('extensioncannotbedeleted.message', array($version->getExtension()->getExtKey())),
                $this->resolveWSErrorMessage('extensioncannotbedeleted.title', array($version->getExtension()->getExtKey())),
                \TYPO3\CMS\Core\Messaging\FlashMessage::ERROR
            );
        }
        if ($redirectToIndexAction) {
            $this->redirect('index', 'Registerkey', null);
        } else {
            $this->redirect('admin', 'Registerkey', null, array('extensionKey' => $version->getExtension()->getExtKey()));
        }
    }

    /**
     * Show all extensions for ter admins
     *
     * @param string $extensionKey
     */
    public function adminAction($extensionKey = '')
    {
        if (!$this->securityRole->isAdmin()) {
            $this->addFlashMessage(
                $this->resolveWSErrorMessage('no_admin.message'),
                $this->resolveWSErrorMessage('no_admin.title'),
                \TYPO3\CMS\Core\Messaging\FlashMessage::ERROR
            );
            $this->redirect('index');
        }

        $this->extensionRepository->setDefaultOrderings(
            array('extKey' => \TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_ASCENDING)
        );
        if (!$extensionKey) {
            $this->view->assign('adminExtensions', $this->extensionRepository->findAllAdmin());
        } else {
            $this->view->assign('adminExtensions', $this->extensionRepository->findByExtKey($extensionKey));
        }
    }

    /**
     * @param \T3o\TerFe2\Domain\Model\Extension $extension
     * @param \T3o\TerFe2\Domain\Model\Version $version
     * @return void
     */
    public function setAsLastVersionAction(\T3o\TerFe2\Domain\Model\Extension $extension, \T3o\TerFe2\Domain\Model\Version $version)
    {
        $extension->setLastVersion($version);
        $this->extensionRepository->update($extension);
        $this->redirectWithMessage(
            'Version ' . $version->getVersionString() . ' set as latest version!',
            'admin',
            'New last version',
            \TYPO3\CMS\Core\Messaging\FlashMessage::OK,
            null,
            null,
            ['extensionKey' => $extension->getExtKey()]
        );
    }

    /**
     * resolve the error key and get the corresponding translation
     *
     * @param string $error
     * @param array $arguments
     * @return string $message already translated
     */
    protected function resolveWSErrorMessage($error, $arguments = array())
    {
        return $this->translate('registerkey.error.' . $error, $arguments);
    }
}