9.5/_action_handler_8php_source.html

<?php

namespace ‪TYPO3\CMS\Workspaces\Controller\Remote;


/*

 * 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 ‪TYPO3\CMS\Backend\Utility\BackendUtility;

use ‪TYPO3\CMS\Core\Authentication\BackendUserAuthentication;

use ‪TYPO3\CMS\Core\DataHandling\DataHandler;

use ‪TYPO3\CMS\Core\Exception;

use ‪TYPO3\CMS\Core\Localization\LanguageService;

use ‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;

use ‪TYPO3\CMS\Core\Utility\MathUtility;

use ‪TYPO3\CMS\Fluid\View\StandaloneView;

use ‪TYPO3\CMS\Workspaces\Domain\Record\StageRecord;

use ‪TYPO3\CMS\Workspaces\Domain\Record\WorkspaceRecord;

use ‪TYPO3\CMS\Workspaces\Preview\PreviewUriBuilder;

use ‪TYPO3\CMS\Workspaces\Service\StagesService;

use ‪TYPO3\CMS\Workspaces\Service\WorkspaceService;


class ‪ActionHandler

{

    protected ‪$stageService;


    protected ‪$workspaceService;


    public function ‪__construct()

    {

        $this->stageService = GeneralUtility::makeInstance(StagesService::class);

        $this->workspaceService = GeneralUtility::makeInstance(WorkspaceService::class);

    }


    public function ‪generateWorkspacePreviewLink($uid)

    {

        return GeneralUtility::makeInstance(PreviewUriBuilder::class)->buildUriForPage((int)$uid, 0);

    }


    public function ‪generateWorkspacePreviewLinksForAllLanguages($uid)

    {

        return GeneralUtility::makeInstance(PreviewUriBuilder::class)->buildUrisForAllLanguagesOfPage((int)$uid);

    }


    public function ‪swapSingleRecord($table, $t3ver_oid, $orig_uid)

    {

        $versionRecord = ‪BackendUtility::getRecord($table, $orig_uid);

        $currentWorkspace = $this->‪setTemporaryWorkspace($versionRecord['t3ver_wsid']);


        $cmd[$table][$t3ver_oid]['version'] = [

            'action' => 'swap',

            'swapWith' => $orig_uid,

            'swapIntoWS' => 1

        ];

        $this->‪processTcaCmd($cmd);


        $this->‪setTemporaryWorkspace($currentWorkspace);

    }


    public function ‪deleteSingleRecord($table, $uid)

    {

        $versionRecord = ‪BackendUtility::getRecord($table, $uid);

        $currentWorkspace = $this->‪setTemporaryWorkspace($versionRecord['t3ver_wsid']);


        $cmd[$table][$uid]['version'] = [

            'action' => 'clearWSID'

        ];

        $this->‪processTcaCmd($cmd);


        $this->‪setTemporaryWorkspace($currentWorkspace);

    }


    public function ‪viewSingleRecord($table, $uid)

    {

        return GeneralUtility::makeInstance(PreviewUriBuilder::class)->buildUriForElement($table, $uid);

    }


    public function ‪executeSelectionAction($parameter)

    {

        $result = [];


        if (empty($parameter->action) || empty($parameter->selection)) {

            $result['error'] = 'No action or record selection given';

            return $result;

        }


        $commands = [];

        $swapIntoWorkspace = ($parameter->action === 'swap');

        if ($parameter->action === 'publish' || $swapIntoWorkspace) {

            $commands = $this->‪getPublishSwapCommands($parameter->selection, $swapIntoWorkspace);

        } elseif ($parameter->action === 'discard') {

            $commands = $this->‪getFlushCommands($parameter->selection);

        }


        $result = $this->‪processTcaCmd($commands);

        $result['total'] = count($commands);

        return $result;

    }


    protected function ‪getPublishSwapCommands(array $selection, $swapIntoWorkspace)

    {

        $commands = [];

        foreach ($selection as $record) {

            $commands[$record->table][$record->liveId]['version'] = [

                'action' => 'swap',

                'swapWith' => $record->versionId,

                'swapIntoWS' => (bool)$swapIntoWorkspace,

            ];

        }

        return $commands;

    }


    protected function ‪getFlushCommands(array $selection)

    {

        $commands = [];

        foreach ($selection as $record) {

            $commands[$record->table][$record->versionId]['version'] = [

                'action' => 'clearWSID',

            ];

        }

        return $commands;

    }


    public function ‪saveColumnModel($model)

    {

        $data = [];

        foreach ($model as $column) {

            $data[$column->column] = [

                'position' => $column->position,

                'hidden' => $column->hidden

            ];

        }

        $this->‪getBackendUser()->uc['moduleData']['Workspaces'][$this->‪getBackendUser()->workspace]['columns'] = $data;

        $this->‪getBackendUser()->‪writeUC();

    }


    public function ‪loadColumnModel()

    {

        if (is_array($this->‪getBackendUser()->uc['moduleData']['Workspaces'][$this->‪getBackendUser()->workspace]['columns'])) {

            return $this->‪getBackendUser()->uc['moduleData']['Workspaces'][$this->‪getBackendUser()->workspace]['columns'];

        }

        return [];

    }


    public function ‪saveLanguageSelection($language)

    {

        if (‪MathUtility::canBeInterpretedAsInteger($language) === false && $language !== 'all') {

            $language = 'all';

        }

        $this->‪getBackendUser()->uc['moduleData']['Workspaces'][$this->‪getBackendUser()->workspace]['language'] = $language;

        $this->‪getBackendUser()->‪writeUC();

    }


    public function ‪sendToNextStageWindow($uid, $table, $t3ver_oid)

    {

        $elementRecord = ‪BackendUtility::getRecord($table, $uid);

        $currentWorkspace = $this->‪setTemporaryWorkspace($elementRecord['t3ver_wsid']);


        if (is_array($elementRecord)) {

            $workspaceRecord = ‪WorkspaceRecord::get($elementRecord['t3ver_wsid']);

            $nextStageRecord = $workspaceRecord->getNextStage($elementRecord['t3ver_stage']);

            if ($nextStageRecord !== null) {

                $this->stageService->getRecordService()->add($table, $uid);

                $result = $this->‪getSentToStageWindow($nextStageRecord);

                $result['affects'] = [

                    'table' => $table,

                    'nextStage' => $nextStageRecord->getUid(),

                    't3ver_oid' => $t3ver_oid,

                    'uid' => $uid

                ];

            } else {

                $result = $this->‪getErrorResponse('error.stageId.invalid', 1291111644);

            }

        } else {

            $result = $this->‪getErrorResponse('error.sendToNextStage.noRecordFound', 1287264776);

        }


        $this->‪setTemporaryWorkspace($currentWorkspace);

        return $result;

    }


    public function ‪sendToPrevStageWindow($uid, $table)

    {

        $elementRecord = ‪BackendUtility::getRecord($table, $uid);

        $currentWorkspace = $this->‪setTemporaryWorkspace($elementRecord['t3ver_wsid']);


        if (is_array($elementRecord)) {

            $workspaceRecord = ‪WorkspaceRecord::get($elementRecord['t3ver_wsid']);

            $stageRecord = $workspaceRecord->getStage($elementRecord['t3ver_stage']);


            if ($stageRecord !== null) {

                if (!$stageRecord->isEditStage()) {

                    $this->stageService->getRecordService()->add($table, $uid);

                    $previousStageRecord = $stageRecord->getPrevious();

                    $result = $this->‪getSentToStageWindow($previousStageRecord);

                    $result['affects'] = [

                        'table' => $table,

                        'uid' => $uid,

                        'nextStage' => $previousStageRecord->getUid()

                    ];

                } else {

                    // element is already in edit stage, there is no prev stage - return an error message

                    $result = $this->‪getErrorResponse('error.sendToPrevStage.noPreviousStage', 1287264746);

                }

            } else {

                $result = $this->‪getErrorResponse('error.stageId.invalid', 1291111644);

            }

        } else {

            $result = $this->‪getErrorResponse('error.sendToNextStage.noRecordFound', 1287264765);

        }


        $this->‪setTemporaryWorkspace($currentWorkspace);

        return $result;

    }


    public function ‪sendToSpecificStageWindow($nextStageId, array $elements)

    {

        foreach ($elements as $element) {

            $this->stageService->getRecordService()->add(

                $element->table,

                $element->uid

            );

        }


        $result = $this->‪getSentToStageWindow($nextStageId);

        $result['affects'] = [

            'nextStage' => $nextStageId

        ];

        return $result;

    }


    public function ‪getRecipientList(array $uidOfRecipients, $additionalRecipients, $stageId)

    {

        $stageRecord = ‪WorkspaceRecord::get($this->‪getCurrentWorkspace())->‪getStage($stageId);


        if ($stageRecord === null) {

            throw new \InvalidArgumentException(

                $this->‪getLanguageService()->sL('LLL:EXT:workspaces/Resources/Private/Language/locallang.xlf:error.stageId.integer'),

                1476044776

            );

        }


        $recipients = [];

        $finalRecipients = [];

        $backendUserIds = $stageRecord->getAllRecipients();

        foreach ($uidOfRecipients as $userUid) {

            // Ensure that only configured backend users are considered

            if (!in_array($userUid, $backendUserIds)) {

                continue;

            }

            $beUserRecord = ‪BackendUtility::getRecord('be_users', (int)$userUid);

            if (is_array($beUserRecord) && $beUserRecord['email'] !== '') {

                $uc = $beUserRecord['uc'] ? unserialize($beUserRecord['uc'], ['allowed_classes' => false]) : [];

                $recipients[$beUserRecord['email']] = [

                    'email' => $beUserRecord['email'],

                    'lang' => $uc['lang'] ?? $beUserRecord['lang']

                ];

            }

        }


        if ($stageRecord->hasPreselection() && !$stageRecord->isPreselectionChangeable()) {

            $preselectedBackendUsers = $this->stageService->getBackendUsers(

                implode(',', $this->stageService->getPreselectedRecipients($stageRecord))

            );


            foreach ($preselectedBackendUsers as $preselectedBackendUser) {

                if (empty($preselectedBackendUser['email']) || !GeneralUtility::validEmail($preselectedBackendUser['email'])) {

                    continue;

                }

                if (!isset($recipients[$preselectedBackendUser['email']])) {

                    $uc = (!empty($preselectedBackendUser['uc']) ? unserialize($preselectedBackendUser['uc'], ['allowed_classes' => false]) : []);

                    $recipients[$preselectedBackendUser['email']] = [

                        'email' => $preselectedBackendUser['email'],

                        'lang' => $uc['lang'] ?? $preselectedBackendUser['lang']

                    ];

                }

            }

        }


        if ($additionalRecipients !== '') {

            $emails = GeneralUtility::trimExplode(LF, $additionalRecipients, true);

            $additionalRecipients = [];

            foreach ($emails as $email) {

                $additionalRecipients[$email] = ['email' => $email];

            }

        } else {

            $additionalRecipients = [];

        }

        // We merge $recipients on top of $additionalRecipients because $recipients

        // possibly is more complete with a user language. Furthermore, the list of

        // recipients is automatically unique since we indexed $additionalRecipients

        // and $recipients with the email address

        $allRecipients = array_merge($additionalRecipients, $recipients);

        foreach ($allRecipients as $email => $recipientInformation) {

            if (GeneralUtility::validEmail($email)) {

                $finalRecipients[] = $recipientInformation;

            }

        }

        return $finalRecipients;

    }


    public function ‪discardStagesFromPage($pageId)

    {

        $cmdMapArray = [];

        $workspaceItemsArray = $this->workspaceService->selectVersionsInWorkspace(

            $this->stageService->getWorkspaceId(),

            $filter = 1,

            $stage = -99,

            $pageId,

            $recursionLevel = 0,

            $selectionType = 'tables_modify'

        );

        foreach ($workspaceItemsArray as $tableName => $items) {

            foreach ($items as $item) {

                $cmdMapArray[$tableName][$item['uid']]['version']['action'] = 'clearWSID';

            }

        }

        $this->‪processTcaCmd($cmdMapArray);

        return [

            'success' => true

        ];

    }


    public function ‪sentCollectionToStage(\stdClass $parameters)

    {

        $cmdMapArray = [];

        $comment = $parameters->comments;

        $stageId = $parameters->stageId;

        if (‪MathUtility::canBeInterpretedAsInteger($stageId) === false) {

            throw new \InvalidArgumentException('Missing "stageId" in $parameters array.', 1319488194);

        }

        if (!is_object($parameters->affects) || empty($parameters->affects)) {

            throw new \InvalidArgumentException('Missing "affected items" in $parameters array.', 1319488195);

        }

        $recipients = $this->‪getRecipientList((array)$parameters->recipients, $parameters->additional, $stageId);

        foreach ($parameters->affects as $tableName => $items) {

            foreach ($items as $item) {

                // Publishing uses live id in command map

                if ($stageId == ‪StagesService::STAGE_PUBLISH_EXECUTE_ID) {

                    $cmdMapArray[$tableName][$item->t3ver_oid]['version']['action'] = 'swap';

                    $cmdMapArray[$tableName][$item->t3ver_oid]['version']['swapWith'] = $item->uid;

                    $cmdMapArray[$tableName][$item->t3ver_oid]['version']['comment'] = $comment;

                    $cmdMapArray[$tableName][$item->t3ver_oid]['version']['notificationAlternativeRecipients'] = $recipients;

                } else {

                    // Setting stage uses version id in command map

                    $cmdMapArray[$tableName][$item->uid]['version']['action'] = 'setStage';

                    $cmdMapArray[$tableName][$item->uid]['version']['stageId'] = $stageId;

                    $cmdMapArray[$tableName][$item->uid]['version']['comment'] = $comment;

                    $cmdMapArray[$tableName][$item->uid]['version']['notificationAlternativeRecipients'] = $recipients;

                }

            }

        }

        $this->‪processTcaCmd($cmdMapArray);

        return [

            'success' => true,

            // force refresh after publishing changes

            'refreshLivePanel' => $parameters->stageId == -20

        ];

    }


    protected function ‪processTcaCmd(array $cmdMapArray)

    {

        $result = [];


        if (empty($cmdMapArray)) {

            $result['error'] = 'No commands given to be processed';

            return $result;

        }


        $dataHandler = GeneralUtility::makeInstance(DataHandler::class);

        $dataHandler->start([], $cmdMapArray);

        $dataHandler->process_cmdmap();


        if ($dataHandler->errorLog) {

            $result['error'] = implode('<br/>', $dataHandler->errorLog);

        }


        return $result;

    }


    public function ‪sendToNextStageExecute(\stdClass $parameters)

    {

        $cmdArray = [];

        $setStageId = $parameters->affects->nextStage;

        $comments = $parameters->comments;

        $table = $parameters->affects->table;

        $uid = $parameters->affects->uid;

        $t3ver_oid = $parameters->affects->t3ver_oid;


        $elementRecord = ‪BackendUtility::getRecord($table, $uid);

        $currentWorkspace = $this->‪setTemporaryWorkspace($elementRecord['t3ver_wsid']);


        $recipients = $this->‪getRecipientList((array)$parameters->recipients, $parameters->additional, $setStageId);

        if ($setStageId == ‪StagesService::STAGE_PUBLISH_EXECUTE_ID) {

            $cmdArray[$table][$t3ver_oid]['version']['action'] = 'swap';

            $cmdArray[$table][$t3ver_oid]['version']['swapWith'] = $uid;

            $cmdArray[$table][$t3ver_oid]['version']['comment'] = $comments;

            $cmdArray[$table][$t3ver_oid]['version']['notificationAlternativeRecipients'] = $recipients;

        } else {

            $cmdArray[$table][$uid]['version']['action'] = 'setStage';

            $cmdArray[$table][$uid]['version']['stageId'] = $setStageId;

            $cmdArray[$table][$uid]['version']['comment'] = $comments;

            $cmdArray[$table][$uid]['version']['notificationAlternativeRecipients'] = $recipients;

        }

        $this->‪processTcaCmd($cmdArray);

        $result = [

            'success' => true

        ];


        $this->‪setTemporaryWorkspace($currentWorkspace);

        return $result;

    }


    public function ‪sendToPrevStageExecute(\stdClass $parameters)

    {

        $cmdArray = [];

        $setStageId = $parameters->affects->nextStage;

        $comments = $parameters->comments;

        $table = $parameters->affects->table;

        $uid = $parameters->affects->uid;


        $elementRecord = ‪BackendUtility::getRecord($table, $uid);

        $currentWorkspace = $this->‪setTemporaryWorkspace($elementRecord['t3ver_wsid']);


        $recipients = $this->‪getRecipientList((array)$parameters->recipients, $parameters->additional, $setStageId);

        $cmdArray[$table][$uid]['version']['action'] = 'setStage';

        $cmdArray[$table][$uid]['version']['stageId'] = $setStageId;

        $cmdArray[$table][$uid]['version']['comment'] = $comments;

        $cmdArray[$table][$uid]['version']['notificationAlternativeRecipients'] = $recipients;

        $this->‪processTcaCmd($cmdArray);

        $result = [

            'success' => true

        ];


        $this->‪setTemporaryWorkspace($currentWorkspace);

        return $result;

    }


    public function ‪sendToSpecificStageExecute(\stdClass $parameters)

    {

        $cmdArray = [];

        $setStageId = $parameters->affects->nextStage;

        $comments = $parameters->comments;

        $elements = $parameters->affects->elements;

        $recipients = $this->‪getRecipientList((array)$parameters->recipients, $parameters->additional, $setStageId);

        foreach ($elements as $element) {

            // Avoid any action on records that have already been published to live

            $elementRecord = ‪BackendUtility::getRecord($element->table, $element->uid);

            if ((int)$elementRecord['t3ver_wsid'] === 0) {

                continue;

            }


            if ($setStageId == ‪StagesService::STAGE_PUBLISH_EXECUTE_ID) {

                $cmdArray[$element->table][$element->t3ver_oid]['version']['action'] = 'swap';

                $cmdArray[$element->table][$element->t3ver_oid]['version']['swapWith'] = $element->uid;

                $cmdArray[$element->table][$element->t3ver_oid]['version']['comment'] = $comments;

                $cmdArray[$element->table][$element->t3ver_oid]['version']['notificationAlternativeRecipients'] = $recipients;

            } else {

                $cmdArray[$element->table][$element->uid]['version']['action'] = 'setStage';

                $cmdArray[$element->table][$element->uid]['version']['stageId'] = $setStageId;

                $cmdArray[$element->table][$element->uid]['version']['comment'] = $comments;

                $cmdArray[$element->table][$element->uid]['version']['notificationAlternativeRecipients'] = $recipients;

            }

        }

        $this->‪processTcaCmd($cmdArray);

        $result = [

            'success' => true

        ];

        return $result;

    }


    protected function ‪getSentToStageWindow($nextStage)

    {

        if (!$nextStage instanceof StageRecord) {

            $nextStage = ‪WorkspaceRecord::get($this->‪getCurrentWorkspace())->‪getStage($nextStage);

        }


        $result = [];

        if ($nextStage->isDialogEnabled()) {

            $result['sendMailTo'] = $this->‪getRecipientsOfStage($nextStage);

            $result['additional'] = [

                'type' => 'textarea',

                'value' => ''

            ];

        }

        $result['comments'] = [

            'type' => 'textarea',

            'value' => $nextStage->isInternal() ? '' : $nextStage->getDefaultComment()

        ];


        return $result;

    }


    protected function ‪getRecipientsOfStage($stageRecord)

    {

        if (!$stageRecord instanceof StageRecord) {

            $stageRecord = ‪WorkspaceRecord::get($this->‪getCurrentWorkspace())->‪getStage($stageRecord);

        }


        $result = [];

        $allRecipients = $this->stageService->getResponsibleBeUser($stageRecord);

        $preselectedRecipients = $this->stageService->‪getPreselectedRecipients($stageRecord);

        $isPreselectionChangeable = $stageRecord->isPreselectionChangeable();


        foreach ($allRecipients as $backendUserId => $backendUser) {

            if (empty($backendUser['email']) || !GeneralUtility::validEmail($backendUser['email'])) {

                continue;

            }


            $name = (!empty($backendUser['realName']) ? $backendUser['realName'] : $backendUser['username']);

            $checked = in_array($backendUserId, $preselectedRecipients);

            $disabled = ($checked && !$isPreselectionChangeable);


            $result[] = [

                'label' => sprintf('%s (%s)', $name, $backendUser['email']),

                'value' => $backendUserId,

                'name' => 'recipients-' . $backendUserId,

                'checked' => $checked,

                'disabled' => $disabled

            ];

        }


        return $result;

    }


    protected function ‪getDefaultCommentOfStage($stage)

    {

        $result = $this->stageService->getPropertyOfCurrentWorkspaceStage($stage, 'default_mailcomment');

        return $result;

    }


    public function ‪sendPageToPreviousStage($id)

    {

        $workspaceItemsArray = $this->workspaceService->selectVersionsInWorkspace(

            $this->stageService->getWorkspaceId(),

            $filter = 1,

            $stage = -99,

            $id,

            $recursionLevel = 0,

            $selectionType = 'tables_modify'

        );

        list($currentStage, $previousStage) = $this->stageService->getPreviousStageForElementCollection($workspaceItemsArray);

        // get only the relevant items for processing

        $workspaceItemsArray = $this->workspaceService->selectVersionsInWorkspace(

            $this->stageService->getWorkspaceId(),

            $filter = 1,

            $currentStage['uid'],

            $id,

            $recursionLevel = 0,

            $selectionType = 'tables_modify'

        );

        $stageFormFields = $this->‪getSentToStageWindow($previousStage['uid']);

        $result = array_merge($stageFormFields, [

            'title' => 'Status message: Page send to next stage - ID: ' . $id . ' - Next stage title: ' . $previousStage['title'],

            'items' => $this->‪getSentToStageWindow($previousStage['uid']),

            'affects' => $workspaceItemsArray,

            'stageId' => $previousStage['uid']

        ]);

        return $result;

    }


    public function ‪sendPageToNextStage($id)

    {

        $workspaceItemsArray = $this->workspaceService->selectVersionsInWorkspace(

            $this->stageService->getWorkspaceId(),

            $filter = 1,

            $stage = -99,

            $id,

            $recursionLevel = 0,

            $selectionType = 'tables_modify'

        );

        list($currentStage, $nextStage) = $this->stageService->getNextStageForElementCollection($workspaceItemsArray);

        // get only the relevant items for processing

        $workspaceItemsArray = $this->workspaceService->selectVersionsInWorkspace(

            $this->stageService->getWorkspaceId(),

            $filter = 1,

            $currentStage['uid'],

            $id,

            $recursionLevel = 0,

            $selectionType = 'tables_modify'

        );

        $stageFormFields = $this->‪getSentToStageWindow($nextStage['uid']);

        $result = array_merge($stageFormFields, [

            'title' => 'Status message: Page send to next stage - ID: ' . $id . ' - Next stage title: ' . $nextStage['title'],

            'affects' => $workspaceItemsArray,

            'stageId' => $nextStage['uid']

        ]);

        return $result;

    }


    public function ‪updateStageChangeButtons($id)

    {

        // fetch the next and previous stage

        $workspaceItemsArray = $this->workspaceService->selectVersionsInWorkspace(

            $this->stageService->getWorkspaceId(),

            $filter = 1,

            $stage = -99,

            $id,

            $recursionLevel = 0,

            $selectionType = 'tables_modify'

        );

        list(, $nextStage) = $this->stageService->getNextStageForElementCollection($workspaceItemsArray);

        list(, $previousStage) = $this->stageService->getPreviousStageForElementCollection($workspaceItemsArray);


        $view = GeneralUtility::makeInstance(StandaloneView::class);

        $extensionPath = ‪ExtensionManagementUtility::extPath('workspaces');

        $view->setPartialRootPaths(['default' => $extensionPath . 'Resources/Private/Partials']);

        $view->setTemplatePathAndFilename($extensionPath . 'Resources/Private/Templates/Preview/Ajax/StageButtons.html');

        $request = $view->getRequest();

        $request->setControllerExtensionName('workspaces');

        $view->assignMultiple([

            'enablePreviousStageButton' => is_array($previousStage) && !empty($previousStage),

            'enableNextStageButton' => is_array($nextStage) && !empty($nextStage),

            'enableDiscardStageButton' => is_array($nextStage) && !empty($nextStage) || is_array($previousStage) && !empty($previousStage),

            'nextStage' => $nextStage['title'],

            'nextStageId' => $nextStage['uid'],

            'prevStage' => $previousStage['title'],

            'prevStageId' => $previousStage['uid'],

        ]);

        $renderedView = $view->render();

        return $renderedView;

    }


    protected function ‪setTemporaryWorkspace($workspaceId)

    {

        $workspaceId = (int)$workspaceId;

        $currentWorkspace = (int)$this->‪getBackendUser()->workspace;


        if ($currentWorkspace !== $workspaceId) {

            if (!$this->‪getBackendUser()->‪setTemporaryWorkspace($workspaceId)) {

                throw new Exception(

                    'Cannot set temporary workspace to "' . $workspaceId . '"',

                    1371484524

                );

            }

        }


        return $currentWorkspace;

    }


    protected function ‪getBackendUser()

    {

        return ‪$GLOBALS['BE_USER'];

    }


    protected function ‪getLanguageService()

    {

        return ‪$GLOBALS['LANG'];

    }


    protected function ‪getErrorResponse($errorLabel, $errorCode = 0, $successFlagValue = false)

    {

        $localLangFile = 'LLL:EXT:workspaces/Resources/Private/Language/locallang.xlf';

        $response = [

            'error' => [

                'code' => $errorCode,

                'message' => $this->‪getLanguageService()->‪sL($localLangFile . ':' . $errorLabel)

            ],

            'success' => $successFlagValue

        ];

        return $response;

    }


    protected function ‪getCurrentWorkspace()

    {

        return $this->workspaceService->getCurrentWorkspace();

    }

}