9.5/_stages_service_8php_source.html

<?php

namespace ‪TYPO3\CMS\Workspaces\Service;


/*

 * 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\Database\Connection;

use ‪TYPO3\CMS\Core\Database\ConnectionPool;

use ‪TYPO3\CMS\Core\SingletonInterface;

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

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

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

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


class ‪StagesService implements ‪SingletonInterface

{

    const ‪TABLE_STAGE = 'sys_workspace_stage';

    // if a record is in the "ready to publish" stage STAGE_PUBLISH_ID the nextStage is STAGE_PUBLISH_EXECUTE_ID, this id wont be saved at any time in db

    const ‪STAGE_PUBLISH_EXECUTE_ID = -20;

    // ready to publish stage

    const ‪STAGE_PUBLISH_ID = -10;

    const ‪STAGE_EDIT_ID = 0;

    const ‪MODE_NOTIFY_SOMEONE = 0;

    const ‪MODE_NOTIFY_ALL = 1;

    const ‪MODE_NOTIFY_ALL_STRICT = 2;


    private ‪$pathToLocallang = 'LLL:EXT:workspaces/Resources/Private/Language/locallang.xlf';


    protected ‪$recordService;


    protected ‪$workspaceStageCache = [];


    protected ‪$workspaceStageAllowedCache = [];


    protected ‪$fetchGroupsCache = [];


    protected ‪$userGroups = [];


    public function ‪getWorkspaceId()

    {

        return $this->‪getBackendUser()->workspace;

    }


    public function ‪getPreviousStageForElementCollection(

        $workspaceItems,

        array $byTableName = ['tt_content', 'pages']

    ) {

        $currentStage = [];

        $previousStage = [];

        $usedStages = [];

        $found = false;

        $availableStagesForWS = array_reverse($this->‪getStagesForWS());

        $availableStagesForWSUser = $this->‪getStagesForWSUser();

        $byTableName = array_flip($byTableName);

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

            if (!array_key_exists($tableName, $byTableName)) {

                continue;

            }

            foreach ($items as $item) {

                $usedStages[$item['t3ver_stage']] = true;

            }

        }

        foreach ($availableStagesForWS as $stage) {

            if (isset($usedStages[$stage['uid']])) {

                $currentStage = $stage;

                $previousStage = $this->‪getPrevStage($stage['uid']);

                break;

            }

        }

        foreach ($availableStagesForWSUser as $userWS) {

            if ($previousStage['uid'] == $userWS['uid']) {

                $found = true;

                break;

            }

        }

        if ($found === false || !$this->‪isStageAllowedForUser($currentStage['uid'])) {

            $previousStage = [];

        }

        return [

            $currentStage,

            $previousStage

        ];

    }


    public function ‪getNextStageForElementCollection(

        $workspaceItems,

        array $byTableName = ['tt_content', 'pages']

    ) {

        $currentStage = [];

        $usedStages = [];

        $nextStage = [];

        $availableStagesForWS = $this->‪getStagesForWS();

        $availableStagesForWSUser = $this->‪getStagesForWSUser();

        $byTableName = array_flip($byTableName);

        $found = false;

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

            if (!array_key_exists($tableName, $byTableName)) {

                continue;

            }

            foreach ($items as $item) {

                $usedStages[$item['t3ver_stage']] = true;

            }

        }

        foreach ($availableStagesForWS as $stage) {

            if (isset($usedStages[$stage['uid']])) {

                $currentStage = $stage;

                $nextStage = $this->‪getNextStage($stage['uid']);

                break;

            }

        }

        foreach ($availableStagesForWSUser as $userWS) {

            if ($nextStage['uid'] == $userWS['uid']) {

                $found = true;

                break;

            }

        }

        if ($found === false || !$this->‪isStageAllowedForUser($currentStage['uid'])) {

            $nextStage = [];

        }

        return [

            $currentStage,

            $nextStage

        ];

    }


    public function ‪getStagesForWS()

    {

        if (isset($this->workspaceStageCache[$this->‪getWorkspaceId()])) {

            $stages = $this->workspaceStageCache[$this->‪getWorkspaceId()];

        } elseif ($this->‪getWorkspaceId() === 0) {

            $stages = [];

        } else {

            $stages = $this->‪prepareStagesArray($this->‪getWorkspaceRecord()->getStages());

            $this->workspaceStageCache[$this->‪getWorkspaceId()] = $stages;

        }

        return $stages;

    }


    public function ‪getStagesForWSUser()

    {

        if ($this->‪getBackendUser()->isAdmin()) {

            return $this->‪getStagesForWS();

        }


        $allowedStages = [];

        $stageRecords = $this->‪getWorkspaceRecord()->‪getStages();


        // Only use stages that are allowed for current backend user

        foreach ($stageRecords as $stageRecord) {

            if ($stageRecord->isAllowed()) {

                $allowedStages[$stageRecord->getUid()] = $stageRecord;

            }

        }


        // Add previous and next stages (even if they are not allowed!)

        foreach ($allowedStages as $allowedStage) {

            $previousStage = $allowedStage->‪getPrevious();

            $nextStage = $allowedStage->‪getNext();

            if ($previousStage !== null && !isset($allowedStages[$previousStage->getUid()])) {

                $allowedStages[$previousStage->getUid()] = $previousStage;

            }

            if ($nextStage !== null && !isset($allowedStages[$nextStage->getUid()])) {

                $allowedStages[$nextStage->getUid()] = $nextStage;

            }

        }


        uasort($allowedStages, function (‪StageRecord $first, ‪StageRecord $second) {

            return $first->‪determineOrder($second);

        });

        return $this->‪prepareStagesArray($allowedStages);

    }


    protected function ‪prepareStagesArray(array $stageRecords)

    {

        $stagesArray = [];

        foreach ($stageRecords as $stageRecord) {

            $stage = [

                'uid' => $stageRecord->getUid(),

                'label' => $stageRecord->getTitle(),

            ];

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

                $stage['title'] = ‪$GLOBALS['LANG']->sL($this->pathToLocallang . ':actionSendToStage') . ' "' . $stageRecord->getTitle() . '"';

            } else {

                $stage['title'] = ‪$GLOBALS['LANG']->sL($this->pathToLocallang . ':publish_execute_action_option');

            }

            $stagesArray[] = $stage;

        }

        return $stagesArray;

    }


    public function ‪getStageTitle($ver_stage)

    {

        switch ($ver_stage) {

            case ‪self::STAGE_PUBLISH_EXECUTE_ID:

                $stageTitle = ‪$GLOBALS['LANG']->sL('LLL:EXT:workspaces/Resources/Private/Language/locallang_mod_user_ws.xlf:stage_publish');

                break;

            case ‪self::STAGE_PUBLISH_ID:

                $stageTitle = ‪$GLOBALS['LANG']->sL('LLL:EXT:workspaces/Resources/Private/Language/locallang_mod.xlf:stage_ready_to_publish');

                break;

            case ‪self::STAGE_EDIT_ID:

                $stageTitle = ‪$GLOBALS['LANG']->sL('LLL:EXT:workspaces/Resources/Private/Language/locallang_mod_user_ws.xlf:stage_editing');

                break;

            default:

                $stageTitle = $this->‪getPropertyOfCurrentWorkspaceStage($ver_stage, 'title');

                if ($stageTitle == null) {

                    $stageTitle = ‪$GLOBALS['LANG']->sL('LLL:EXT:workspaces/Resources/Private/Language/locallang.xlf:error.getStageTitle.stageNotFound');

                }

        }

        return $stageTitle;

    }


    public function ‪getStageRecord($stageid)

    {

        return ‪BackendUtility::getRecord('sys_workspace_stage', $stageid);

    }


    public function ‪getNextStage($stageId)

    {

        if (!‪MathUtility::canBeInterpretedAsInteger($stageId)) {

            throw new \InvalidArgumentException(

                ‪$GLOBALS['LANG']->sL('LLL:EXT:workspaces/Resources/Private/Language/locallang.xlf:error.stageId.integer'),

                1291109987

            );

        }

        $nextStage = false;

        $workspaceStageRecs = $this->‪getStagesForWS();

        if (is_array($workspaceStageRecs) && !empty($workspaceStageRecs)) {

            reset($workspaceStageRecs);

            while (key($workspaceStageRecs) !== null) {

                $workspaceStageRec = current($workspaceStageRecs);

                if ($workspaceStageRec['uid'] == $stageId) {

                    $nextStage = next($workspaceStageRecs);

                    break;

                }

                next($workspaceStageRecs);

            }

        }

        if ($nextStage === false) {

            $nextStage[] = [

                'uid' => ‪self::STAGE_EDIT_ID,

                'title' => ‪$GLOBALS['LANG']->sL($this->pathToLocallang . ':actionSendToStage') . ' "'

                    . ‪$GLOBALS['LANG']->sL('LLL:EXT:workspaces/Resources/Private/Language/locallang_mod_user_ws.xlf:stage_editing') . '"'

            ];

        }

        return $nextStage;

    }


    public function ‪getNextStages(array &$nextStageArray, $stageId)

    {

        // Current stage is "Ready to publish" - there is no next stage

        if ($stageId == self::STAGE_PUBLISH_ID) {

            return $nextStageArray;

        }

        $nextStageRecord = $this->‪getNextStage($stageId);

        if (empty($nextStageRecord) || !is_array($nextStageRecord)) {

            // There is no next stage

            return $nextStageArray;

        }

        // Check if the user has the permission to for the current stage

        // If this next stage record is the first next stage after the current the user

        // has always the needed permission

        if ($this->‪isStageAllowedForUser($stageId)) {

            $nextStageArray[] = $nextStageRecord;

            return $this->‪getNextStages($nextStageArray, $nextStageRecord['uid']);

        }

        // He hasn't - return given next stage array

        return $nextStageArray;

    }


    public function ‪getPrevStage($stageId)

    {

        if (!‪MathUtility::canBeInterpretedAsInteger($stageId)) {

            throw new \InvalidArgumentException(

                ‪$GLOBALS['LANG']->sL('LLL:EXT:workspaces/Resources/Private/Language/locallang.xlf:error.stageId.integer'),

                1476048351

            );

        }

        $prevStage = false;

        $workspaceStageRecs = $this->‪getStagesForWS();

        if (is_array($workspaceStageRecs) && !empty($workspaceStageRecs)) {

            end($workspaceStageRecs);

            while (key($workspaceStageRecs) !== null) {

                $workspaceStageRec = current($workspaceStageRecs);

                if ($workspaceStageRec['uid'] == $stageId) {

                    $prevStage = prev($workspaceStageRecs);

                    break;

                }

                prev($workspaceStageRecs);

            }

        }


        return $prevStage;

    }


    public function ‪getPrevStages(array &$prevStageArray, $stageId)

    {

        // Current stage is "Editing" - there is no prev stage

        if ($stageId != self::STAGE_EDIT_ID) {

            $prevStageRecord = $this->‪getPrevStage($stageId);

            if (!empty($prevStageRecord) && is_array($prevStageRecord)) {

                // Check if the user has the permission to switch to that stage

                // If this prev stage record is the first previous stage before the current

                // the user has always the needed permission

                if ($this->‪isStageAllowedForUser($stageId)) {

                    $prevStageArray[] = $prevStageRecord;

                    $prevStageArray = $this->‪getPrevStages($prevStageArray, $prevStageRecord['uid']);

                }

            }

        }

        return $prevStageArray;

    }


    public function ‪getResponsibleBeUser($stageRecord, $selectDefaultUserField = false)

    {

        if (!$stageRecord instanceof StageRecord) {

            $stageRecord = $this->‪getWorkspaceRecord()->‪getStage($stageRecord);

        }


        $recipientArray = [];


        if (!$selectDefaultUserField) {

            $backendUserIds = $stageRecord->‪getAllRecipients();

        } else {

            $backendUserIds = $stageRecord->getDefaultRecipients();

        }


        $userList = implode(',', $backendUserIds);

        $userRecords = $this->‪getBackendUsers($userList);

        foreach ($userRecords as $userUid => $userRecord) {

            $recipientArray[$userUid] = $userRecord;

        }

        return $recipientArray;

    }


    public function ‪getResponsibleUser($stageRespValue)

    {

        return implode(',', $this->‪resolveBackendUserIds($stageRespValue));

    }


    public function ‪resolveBackendUserIds($backendUserGroupList)

    {

        $elements = GeneralUtility::trimExplode(',', $backendUserGroupList, true);

        $backendUserIds = [];

        $backendGroupIds = [];


        foreach ($elements as $element) {

            if (strpos($element, 'be_users_') === 0) {

                // Current value is a uid of a be_user record

                $backendUserIds[] = str_replace('be_users_', '', $element);

            } elseif (strpos($element, 'be_groups_') === 0) {

                $backendGroupIds[] = str_replace('be_groups_', '', $element);

            } elseif ((int)$element) {

                $backendUserIds[] = (int)$element;

            }

        }


        if (!empty($backendGroupIds)) {

            $allBeUserArray = ‪BackendUtility::getUserNames();

            $backendGroupList = implode(',', $backendGroupIds);

            $this->userGroups = [];

            $backendGroups = $this->‪fetchGroups($backendGroupList);

            foreach ($backendGroups as $backendGroup) {

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

                    if (GeneralUtility::inList($backendUser['usergroup_cached_list'], $backendGroup['uid'])) {

                        $backendUserIds[] = $backendUserId;

                    }

                }

            }

        }


        return array_unique($backendUserIds);

    }


    public function ‪getBackendUsers($backendUserList)

    {

        if (empty($backendUserList)) {

            return [];

        }


        $backendUserList = implode(',', GeneralUtility::intExplode(',', $backendUserList));

        $backendUsers = ‪BackendUtility::getUserNames(

            'username, uid, email, realName, lang, uc',

            'AND uid IN (' . $backendUserList . ')' . ‪BackendUtility::BEenableFields('be_users')

        );


        if (empty($backendUsers)) {

            $backendUsers = [];

        }

        return $backendUsers;

    }


    public function ‪getPreselectedRecipients(‪StageRecord $stageRecord)

    {

        if ($stageRecord->‪areEditorsPreselected()) {

            return array_merge(

                $stageRecord->‪getPreselectedRecipients(),

                $this->getRecordService()->getCreateUserIds()

            );

        }

        return $stageRecord->‪getPreselectedRecipients();

    }


    protected function ‪getWorkspaceRecord()

    {

        return ‪WorkspaceRecord::get($this->‪getWorkspaceId());

    }


    private function ‪fetchGroups($grList, $idList = '')

    {

        $cacheKey = md5($grList . $idList);

        if (isset($this->fetchGroupsCache[$cacheKey])) {

            return $this->fetchGroupsCache[$cacheKey];

        }

        if ($idList === '') {

            // we're at the beginning of the recursion and therefore we need to reset the userGroups member

            $this->userGroups = [];

        }

        $groupList = $this->‪fetchGroupsRecursive($grList);

        $this->fetchGroupsCache[$cacheKey] = $groupList;

        return $groupList;

    }


    private function ‪fetchGroupsFromDB(array $groups)

    {

        // The userGroups array is filled

        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('be_groups');


        $result = $queryBuilder

            ->select('*')

            ->from('be_groups')

            ->where(

                $queryBuilder->expr()->in(

                    'uid',

                    $queryBuilder->createNamedParameter($groups, Connection::PARAM_INT_ARRAY)

                )

            )

            ->execute();


        while ($row = $result->fetch()) {

            $this->userGroups[$row['uid']] = $row;

        }

    }


    private function ‪fetchGroupsRecursive($grList, $idList = '')

    {

        $requiredGroups = GeneralUtility::intExplode(',', $grList, true);

        $existingGroups = array_keys($this->userGroups);

        $missingGroups = array_diff($requiredGroups, $existingGroups);

        if (!empty($missingGroups)) {

            $this->‪fetchGroupsFromDB($missingGroups);

        }

        // Traversing records in the correct order

        foreach ($requiredGroups as $uid) {

            // traversing list

            // Get row:

            $row = $this->userGroups[$uid];

            if (is_array($row) && !GeneralUtility::inList($idList, $uid)) {

                // Must be an array and $uid should not be in the idList, because then it is somewhere previously in the grouplist

                // If the localconf.php option isset the user of the sub- sub- groups will also be used

                if (‪$GLOBALS['TYPO3_CONF_VARS']['BE']['customStageShowRecipientRecursive'] == 1) {

                    // Include sub groups

                    if (trim($row['subgroup'])) {

                        // Make integer list

                        $theList = implode(',', GeneralUtility::intExplode(',', $row['subgroup']));

                        // Get the subgroups

                        $subGroups = $this->‪fetchGroups($theList, $idList . ',' . $uid);

                        // Merge the subgroups to the already existing userGroups array

                        $subUid = key($subGroups);

                        $this->userGroups[$subUid] = $subGroups[$subUid];

                    }

                }

            }

        }

        return ‪$this->userGroups;

    }


    public function ‪getPropertyOfCurrentWorkspaceStage($stageId, $property)

    {

        $result = null;

        if (!‪MathUtility::canBeInterpretedAsInteger($stageId)) {

            throw new \InvalidArgumentException(

                ‪$GLOBALS['LANG']->sL('LLL:EXT:workspaces/Resources/Private/Language/locallang.xlf:error.stageId.integer'),

                1476048371

            );

        }

        $workspaceStage = ‪BackendUtility::getRecord(self::TABLE_STAGE, $stageId);

        if (is_array($workspaceStage) && isset($workspaceStage[$property])) {

            $result = $workspaceStage[$property];

        }

        return $result;

    }


    public function ‪getPositionOfCurrentStage($stageId)

    {

        $stagesOfWS = $this->‪getStagesForWS();

        $countOfStages = count($stagesOfWS);

        switch ($stageId) {

            case ‪self::STAGE_PUBLISH_ID:

                $position = $countOfStages;

                break;

            case ‪self::STAGE_EDIT_ID:

                $position = 1;

                break;

            default:

                $position = 1;

                foreach ($stagesOfWS as $key => $stageInfoArray) {

                    $position++;

                    if ($stageId == $stageInfoArray['uid']) {

                        break;

                    }

                }

        }

        return ['position' => $position, 'count' => $countOfStages];

    }


    public function ‪isPrevStageAllowedForUser($stageId)

    {

        $isAllowed = false;

        try {

            $prevStage = $this->‪getPrevStage($stageId);

            // if there's no prev-stage the stageIds match,

            // otherwise we've to check if the user is permitted to use the stage

            if (!empty($prevStage) && $prevStage['uid'] != $stageId) {

                // if the current stage is allowed for the user, the user is also allowed to send to prev

                $isAllowed = $this->‪isStageAllowedForUser($stageId);

            }

        } catch (\Exception $e) {

        }

        return $isAllowed;

    }


    public function ‪isNextStageAllowedForUser($stageId)

    {

        $isAllowed = false;

        try {

            $nextStage = $this->‪getNextStage($stageId);

            // if there's no next-stage the stageIds match,

            // otherwise we've to check if the user is permitted to use the stage

            if (!empty($nextStage) && $nextStage['uid'] != $stageId) {

                // if the current stage is allowed for the user, the user is also allowed to send to next

                $isAllowed = $this->‪isStageAllowedForUser($stageId);

            }

        } catch (\Exception $e) {

        }

        return $isAllowed;

    }


    protected function ‪isStageAllowedForUser($stageId)

    {

        $cacheKey = $this->‪getWorkspaceId() . '_' . $stageId;

        if (isset($this->workspaceStageAllowedCache[$cacheKey])) {

            return $this->workspaceStageAllowedCache[$cacheKey];

        }

        $isAllowed = $this->‪getBackendUser()->‪workspaceCheckStageForCurrent($stageId);

        $this->workspaceStageAllowedCache[$cacheKey] = $isAllowed;

        return $isAllowed;

    }


    public function ‪isValid($stageId)

    {

        $isValid = false;

        $stages = $this->‪getStagesForWS();

        foreach ($stages as $stage) {

            if ($stage['uid'] == $stageId) {

                $isValid = true;

                break;

            }

        }

        return $isValid;

    }


    public function ‪getRecordService()

    {

        if (!isset($this->recordService)) {

            $this->recordService = GeneralUtility::makeInstance(RecordService::class);

        }

        return ‪$this->recordService;

    }


    protected function ‪getBackendUser()

    {

        return ‪$GLOBALS['BE_USER'];

    }

}