TYPO3_6-2/_module_loader_8php_source.html

 <?php
 namespace TYPO3\CMS\Backend\Module;

 use TYPO3\CMS\Backend\Utility\BackendUtility;
 use TYPO3\CMS\Core\Utility\GeneralUtility;

 class ModuleLoader {

     // After the init() function this array will contain the structure of available modules for the backend user.
     public $modules = array();

     // Array with paths pointing to the location of modules from extensions
     public $absPathArray = array();

     // This array will hold the elements that should go into the select-list of modules for groups...
     public $modListGroup = array();

     // This array will hold the elements that should go into the select-list of modules for users...
     public $modListUser = array();

     public $BE_USER;

     // If set TRUE, workspace "permissions" will be observed so non-allowed modules will not be included in the array of modules.
     public $observeWorkspaces = FALSE;

     protected $navigationComponents = array();

     public function load($modulesArray, $BE_USER = '') {
         // Setting the backend user for use internally
         if (is_object($BE_USER)) {
             $this->BE_USER = $BE_USER;
         } else {
             $this->BE_USER = $GLOBALS['BE_USER'];
         }
         /*$modulesArray might look like this when entering this function.
         Notice the two modules added by extensions - they have a path attachedArray
         (
         [web] => list,info,perm,func
         [file] => list
         [user] =>
         [tools] => em,install,txphpmyadmin
         [help] => about
         [_PATHS] => Array
         (
         [system_install] => /www/htdocs/typo3/32/coreinstall/typo3/ext/install/mod/
         [tools_txphpmyadmin] => /www/htdocs/typo3/32/coreinstall/typo3/ext/phpmyadmin/modsub/
         ))
          */
         $this->absPathArray = $modulesArray['_PATHS'];
         unset($modulesArray['_PATHS']);
         // Unset the array for calling external backend module dispatchers in typo3/mod.php
         unset($modulesArray['_dispatcher']);
         // Unset the array for calling backend modules based on external backend module dispatchers in typo3/mod.php
         unset($modulesArray['_configuration']);
         $this->navigationComponents = $modulesArray['_navigationComponents'];
         unset($modulesArray['_navigationComponents']);
         $theMods = $this->parseModulesArray($modulesArray);
         // Originally modules were found in typo3/mod/
         // User defined modules were found in ../typo3conf/
         // Today almost all modules reside in extensions and they are found by the _PATHS array of the incoming $TBE_MODULES array
         // Setting paths for 1) core modules (old concept from mod/) and 2) user-defined modules (from ../typo3conf)
         $paths = array();
         // Path of static modules
         $paths['defMods'] = PATH_typo3 . 'mod/';
         // Local modules (maybe frontend specific)
         $paths['userMods'] = PATH_typo3 . '../typo3conf/';
         // Traverses the module setup and creates the internal array $this->modules
         foreach ($theMods as $mods => $subMod) {
             $path = NULL;
             $extModRelPath = $this->checkExtensionModule($mods);
             // EXTENSION module:
             if ($extModRelPath) {
                 $theMainMod = $this->checkMod($mods, PATH_site . $extModRelPath);
                 if (is_array($theMainMod) || $theMainMod != 'notFound') {
                     // ... just so it goes on... submodules cannot be within this path!
                     $path = 1;
                 }
             } else {
                 // 'CLASSIC' module
                 // Checking for typo3/mod/ module existence...
                 $theMainMod = $this->checkMod($mods, $paths['defMods'] . $mods);
                 if (is_array($theMainMod) || $theMainMod != 'notFound') {
                     $path = $paths['defMods'];
                 } else {
                     // If not typo3/mod/ then it could be user-defined in typo3conf/ ...?
                     $theMainMod = $this->checkMod($mods, $paths['userMods'] . $mods);
                     if (is_array($theMainMod) || $theMainMod != 'notFound') {
                         $path = $paths['userMods'];
                     }
                 }
             }
             // If $theMainMod is not set (FALSE) there is no access to the module !(?)
             if ($theMainMod && !is_null($path)) {
                 $this->modules[$mods] = $theMainMod;
                 // SUBMODULES - if any - are loaded
                 if (is_array($subMod)) {
                     foreach ($subMod as $valsub) {
                         $extModRelPath = $this->checkExtensionModule($mods . '_' . $valsub);
                         if ($extModRelPath) {
                             // EXTENSION submodule:
                             $theTempSubMod = $this->checkMod($mods . '_' . $valsub, PATH_site . $extModRelPath);
                             // Default sub-module in either main-module-path, be it the default or the userdefined.
                             if (is_array($theTempSubMod)) {
                                 $this->modules[$mods]['sub'][$valsub] = $theTempSubMod;
                             }
                         } else {
                             // 'CLASSIC' submodule
                             // Checking for typo3/mod/xxx/ module existence...
                             // FIXME what about $path = 1; from above and using $path as string here?
                             $theTempSubMod = $this->checkMod($mods . '_' . $valsub, $path . $mods . '/' . $valsub);
                             // Default sub-module in either main-module-path, be it the default or the userdefined.
                             if (is_array($theTempSubMod)) {
                                 $this->modules[$mods]['sub'][$valsub] = $theTempSubMod;
                             } elseif ($path == $paths['defMods']) {
                                 // If the submodule did not exist in the default module path, then check if there is a submodule in the submodule path!
                                 $theTempSubMod = $this->checkMod($mods . '_' . $valsub, $paths['userMods'] . $mods . '/' . $valsub);
                                 if (is_array($theTempSubMod)) {
                                     $this->modules[$mods]['sub'][$valsub] = $theTempSubMod;
                                 }
                             }
                         }
                     }
                 }
             } else {
                 // This must be done in order to fill out the select-lists for modules correctly!!
                 if (is_array($subMod)) {
                     foreach ($subMod as $valsub) {
                         // FIXME path can only be NULL here, or not?
                         $this->checkMod($mods . '_' . $valsub, $path . $mods . '/' . $valsub);
                     }
                 }
             }
         }
     }

     public function checkExtensionModule($name) {
         if (isset($this->absPathArray[$name])) {
             return rtrim(\TYPO3\CMS\Core\Utility\PathUtility::stripPathSitePrefix($this->absPathArray[$name]), '/');
         }
     }

     public function checkMod($name, $fullpath) {
         if ($name == 'user_ws' && !\TYPO3\CMS\Core\Utility\ExtensionManagementUtility::isLoaded('version')) {
             return FALSE;
         }
         // Check for own way of configuring module
         if (is_array($GLOBALS['TBE_MODULES']['_configuration'][$name]['configureModuleFunction'])) {
             $obj = $GLOBALS['TBE_MODULES']['_configuration'][$name]['configureModuleFunction'];
             if (is_callable($obj)) {
                 $MCONF = call_user_func($obj, $name, $fullpath);
                 if ($this->checkModAccess($name, $MCONF) !== TRUE) {
                     return FALSE;
                 }
                 return $MCONF;
             }
         }
         // Check if this is a submodule
         if (strpos($name, '_') !== FALSE) {
             list($mainModule, ) = explode('_', $name, 2);
         }

         $finalModuleConfiguration = array();

         // merges $MCONF and $MLANG from conf.php and the additional configuration of the module
         $setupInformation = $this->getModuleSetupInformation($name, $fullpath);

         // Because 'path/../path' does not work
         // clean up the configuration part
         if (count($setupInformation['configuration']) > 0) {
             if (!$setupInformation['configuration']['shy'] && $this->checkModAccess($name, $setupInformation['configuration']) && $this->checkModWorkspace($name, $setupInformation['configuration'])) {
                 $finalModuleConfiguration = $setupInformation['configuration'];
                 $finalModuleConfiguration['name'] = $name;
                 // Language processing. This will add module labels and image reference to the internal ->moduleLabels array of the LANG object.
                 if (is_object($GLOBALS['LANG'])) {
                     // $setupInformation['labels']['default']['tabs_images']['tab'] is for modules the reference
                     // to the module icon.
                     $defaultLabels = $setupInformation['labels']['default'];
                     // Here the path is transformed to an absolute reference.
                     if ($defaultLabels['tabs_images']['tab']) {
                         // Initializing search for alternative icon:
                         // Alternative icon key (might have an alternative set in $TBE_STYLES['skinImg']
                         $altIconKey = 'MOD:' . $name . '/' . $defaultLabels['tabs_images']['tab'];
                         $altIconAbsPath = is_array($GLOBALS['TBE_STYLES']['skinImg'][$altIconKey]) ? GeneralUtility::resolveBackPath(PATH_typo3 . $GLOBALS['TBE_STYLES']['skinImg'][$altIconKey][0]) : '';
                         // Setting icon, either default or alternative:
                         if ($altIconAbsPath && @is_file($altIconAbsPath)) {
                             $defaultLabels['tabs_images']['tab'] = $altIconAbsPath;
                         } else {
                             // Setting default icon:
                             if (substr($defaultLabels['tabs_images']['tab'], 0, 4) === 'EXT:') {
                                 list($extensionKey, $relativePath) = explode('/', substr($defaultLabels['tabs_images']['tab'], 4), 2);
                                 $defaultLabels['tabs_images']['tab'] = \TYPO3\CMS\Core\Utility\ExtensionManagementUtility::extPath($extensionKey) . $relativePath;
                             } else {
                                 $defaultLabels['tabs_images']['tab'] = $fullpath . '/' . $defaultLabels['tabs_images']['tab'];
                             }
                         }

                         $defaultLabels['tabs_images']['tab'] = $this->getRelativePath(PATH_typo3, $defaultLabels['tabs_images']['tab']);

                         // Finally, setting the icon with correct path:
                         if (substr($defaultLabels['tabs_images']['tab'], 0, 3) == '../') {
                             $defaultLabels['tabs_images']['tab'] = PATH_site . substr($defaultLabels['tabs_images']['tab'], 3);
                         } else {
                             $defaultLabels['tabs_images']['tab'] = PATH_typo3 . $defaultLabels['tabs_images']['tab'];
                         }
                     }

                     // If LOCAL_LANG references are used for labels of the module:
                     if ($defaultLabels['ll_ref']) {
                         // Now the 'default' key is loaded with the CURRENT language - not the english translation...
                         $defaultLabels['labels']['tablabel'] = $GLOBALS['LANG']->sL($defaultLabels['ll_ref'] . ':mlang_labels_tablabel');
                         $defaultLabels['labels']['tabdescr'] = $GLOBALS['LANG']->sL($defaultLabels['ll_ref'] . ':mlang_labels_tabdescr');
                         $defaultLabels['tabs']['tab'] = $GLOBALS['LANG']->sL($defaultLabels['ll_ref'] . ':mlang_tabs_tab');
                         $GLOBALS['LANG']->addModuleLabels($defaultLabels, $name . '_');
                     } else {
                         // ... otherwise use the old way:
                         $GLOBALS['LANG']->addModuleLabels($defaultLabels, $name . '_');
                         $GLOBALS['LANG']->addModuleLabels($setupInformation['labels'][$GLOBALS['LANG']->lang], $name . '_');
                     }
                 }

                 // Default script setup
                 if ($setupInformation['configuration']['script'] === '_DISPATCH') {
                     if ($setupInformation['configuration']['extbase']) {
                         $finalModuleConfiguration['script'] = BackendUtility::getModuleUrl('Tx_' . $name);
                     } else {
                         $finalModuleConfiguration['script'] = BackendUtility::getModuleUrl($name);
                     }
                 } elseif ($setupInformation['configuration']['script'] && file_exists($setupInformation['path'] . '/' . $setupInformation['configuration']['script'])) {
                     $finalModuleConfiguration['script'] = $this->getRelativePath(PATH_typo3, $fullpath . '/' . $setupInformation['configuration']['script']);
                 } else {
                     $finalModuleConfiguration['script'] = 'dummy.php';
                 }

                 // Default tab setting
                 if ($setupInformation['configuration']['defaultMod']) {
                     $finalModuleConfiguration['defaultMod'] = $setupInformation['configuration']['defaultMod'];
                 }

                 // Navigation Frame Script (GET params could be added)
                 if ($setupInformation['configuration']['navFrameScript']) {
                     $navFrameScript = explode('?', $setupInformation['configuration']['navFrameScript']);
                     $navFrameScript = $navFrameScript[0];
                     if (file_exists($setupInformation['path'] . '/' . $navFrameScript)) {
                         $finalModuleConfiguration['navFrameScript'] = $this->getRelativePath(PATH_typo3, $fullpath . '/' . $setupInformation['configuration']['navFrameScript']);
                     }
                 }

                 // additional params for Navigation Frame Script: "&anyParam=value&moreParam=1"
                 if ($setupInformation['configuration']['navFrameScriptParam']) {
                     $finalModuleConfiguration['navFrameScriptParam'] = $setupInformation['configuration']['navFrameScriptParam'];
                 }

                 // check if there is a navigation component (like the pagetree)
                 if (is_array($this->navigationComponents[$name])) {
                     $finalModuleConfiguration['navigationComponentId'] = $this->navigationComponents[$name]['componentId'];
                 // navigation component can be overriden by the main module component
                 } elseif ($mainModule && is_array($this->navigationComponents[$mainModule]) && $setupInformation['configuration']['inheritNavigationComponentFromMainModule'] !== FALSE) {
                     $finalModuleConfiguration['navigationComponentId'] = $this->navigationComponents[$mainModule]['componentId'];
                 }
             } else {
                 return FALSE;
             }
         } else {
             $finalModuleConfiguration = 'notFound';
         }

         return $finalModuleConfiguration;
     }

     protected function getModuleSetupInformation($moduleName, $pathToModuleDirectory) {

         // Because 'path/../path' does not work
         $path = preg_replace('/\\/[^\\/.]+\\/\\.\\.\\//', '/', $pathToModuleDirectory);

         $moduleSetupInformation = array(
             'configuration' => array(),
             'labels' => array(),
             'path' => $path
         );

         if (@is_dir($path) && file_exists($path . '/conf.php')) {
             $MCONF = array();
             $MLANG = array();

             // The conf-file is included. This must be valid PHP.
             include $path . '/conf.php';

             // move the global variables defined in conf.php into the local method
             if (is_array($MCONF)) {
                 $moduleSetupInformation['configuration'] = $MCONF;
             } else {
                 $moduleSetupInformation['configuration'] = array();
             }
             $moduleSetupInformation['labels'] = $MLANG;
         }

         // overlay them with additional setup information and configuration
         if (is_array($GLOBALS['TBE_MODULES']['_configuration'][$moduleName])) {
             $moduleSetupInformation['configuration'] = array_merge_recursive($moduleSetupInformation['configuration'], $GLOBALS['TBE_MODULES']['_configuration'][$moduleName]);
         }

         // add some default configuration
         if (!isset($moduleSetupInformation['configuration']['inheritNavigationComponentFromMainModule'])) {
             $moduleSetupInformation['configuration']['inheritNavigationComponentFromMainModule'] = TRUE;
         }

         return $moduleSetupInformation;
     }

     public function checkModAccess($name, $MCONF) {
         if ($MCONF['access']) {
             $access = strtolower($MCONF['access']);
             // Checking if admin-access is required
             // If admin-permissions is required then return TRUE if user is admin
             if (strstr($access, 'admin')) {
                 if ($this->BE_USER->isAdmin()) {
                     return TRUE;
                 }
             }
             // This will add modules to the select-lists of user and groups
             if (strstr($access, 'user')) {
                 $this->modListUser[] = $name;
             }
             if (strstr($access, 'group')) {
                 $this->modListGroup[] = $name;
             }
             // This checks if a user is permitted to access the module
             if ($this->BE_USER->isAdmin() || $this->BE_USER->check('modules', $name)) {
                 return TRUE;
             }
         } else {
             return TRUE;
         }
     }

     public function checkModWorkspace($name, $MCONF) {
         if ($this->observeWorkspaces) {
             $status = TRUE;
             if ($MCONF['workspaces']) {
                 $status = FALSE;
                 if ($this->BE_USER->workspace === 0 && GeneralUtility::inList($MCONF['workspaces'], 'online') || $this->BE_USER->workspace === -1 && GeneralUtility::inList($MCONF['workspaces'], 'offline') || $this->BE_USER->workspace > 0 && GeneralUtility::inList($MCONF['workspaces'], 'custom')) {
                     $status = TRUE;
                 }
             } elseif ($this->BE_USER->workspace === -99) {
                 $status = FALSE;
             }
             return $status;
         } else {
             return TRUE;
         }
     }

     public function parseModulesArray($arr) {
         $theMods = array();
         if (is_array($arr)) {
             foreach ($arr as $mod => $subs) {
                 // Clean module name to alphanum
                 $mod = $this->cleanName($mod);
                 if ($mod) {
                     if ($subs) {
                         $subsArr = GeneralUtility::trimExplode(',', $subs);
                         foreach ($subsArr as $subMod) {
                             $subMod = $this->cleanName($subMod);
                             if ($subMod) {
                                 $theMods[$mod][] = $subMod;
                             }
                         }
                     } else {
                         $theMods[$mod] = 1;
                     }
                 }
             }
         }
         return $theMods;
     }

     public function cleanName($str) {
         return preg_replace('/[^a-z0-9]/i', '', $str);
     }

     public function getRelativePath($baseDir, $destDir) {
         // A special case , the dirs are equals
         if ($baseDir == $destDir) {
             return './';
         }
         // Remove beginning
         $baseDir = ltrim($baseDir, '/');
         $destDir = ltrim($destDir, '/');
         $found = TRUE;
         $slash_pos = 0;
         do {
             $slash_pos = strpos($destDir, '/');
             if (substr($destDir, 0, $slash_pos) == substr($baseDir, 0, $slash_pos)) {
                 $baseDir = substr($baseDir, $slash_pos + 1);
                 $destDir = substr($destDir, $slash_pos + 1);
             } else {
                 $found = FALSE;
             }
         } while ($found == TRUE);
         $slashes = strlen($baseDir) - strlen(str_replace('/', '', $baseDir));
         for ($i = 0; $i < $slashes; $i++) {
             $destDir = '../' . $destDir;
         }
         return GeneralUtility::resolveBackPath($destDir);
     }

 }
TYPO3

GeneralUtility

$MCONF
$MCONF['navFrameScript']
Definition: conf.php:4

$moduleName
$moduleName
Definition: mod.php:22

TYPO3\CMS\Backend\Module\ModuleLoader\checkModWorkspace
checkModWorkspace($name, $MCONF)
Definition: ModuleLoader.php:441

TYPO3\CMS\Backend\Module\ModuleLoader
Definition: ModuleLoader.php:32

TYPO3\CMS\Backend\Module\ModuleLoader\checkExtensionModule
checkExtensionModule($name)
Definition: ModuleLoader.php:204

TYPO3\CMS\Backend\Module\ModuleLoader\checkModAccess
checkModAccess($name, $MCONF)
Definition: ModuleLoader.php:406

TYPO3\CMS\Core\Utility\ExtensionManagementUtility\extPath
static extPath($key, $script='')
Definition: ExtensionManagementUtility.php:120

BackendUtility

$MLANG
$MLANG['default']['tabs_images']['tab']
Definition: conf.php:2

TYPO3\CMS\Core\Utility\GeneralUtility\trimExplode
static trimExplode($delim, $string, $removeEmptyValues=FALSE, $limit=0)
Definition: GeneralUtility.php:1536

TYPO3\CMS\Backend\Module\ModuleLoader\cleanName
cleanName($str)
Definition: ModuleLoader.php:497

TYPO3\CMS\Backend\Utility\BackendUtility\getModuleUrl
static getModuleUrl($moduleName, $urlParameters=array(), $backPathOverride=FALSE, $returnAbsoluteUrl=FALSE)
Definition: BackendUtility.php:3143

TYPO3\CMS\Backend\Module\ModuleLoader\$modListUser
$modListUser
Definition: ModuleLoader.php:56

TYPO3\CMS\Backend\Module\ModuleLoader\$BE_USER
$BE_USER
Definition: ModuleLoader.php:64

TYPO3\CMS\Backend\Module\ModuleLoader\$navigationComponents
$navigationComponents
Definition: ModuleLoader.php:77

TYPO3\CMS\Backend\Module\ModuleLoader\checkMod
checkMod($name, $fullpath)
Definition: ModuleLoader.php:222

TYPO3\CMS\Backend\Module\ModuleLoader\$modListGroup
$modListGroup
Definition: ModuleLoader.php:50

TYPO3\CMS\Backend\Module\ModuleLoader\$modules
$modules
Definition: ModuleLoader.php:38

TYPO3\CMS\Backend\Module\ModuleLoader\getRelativePath
getRelativePath($baseDir, $destDir)
Definition: ModuleLoader.php:509

TYPO3\CMS\Backend\Module\ModuleLoader\$absPathArray
$absPathArray
Definition: ModuleLoader.php:44

TYPO3\CMS\Backend\Module\ModuleLoader\getModuleSetupInformation
getModuleSetupInformation($moduleName, $pathToModuleDirectory)
Definition: ModuleLoader.php:358

$GLOBALS
if(!defined('TYPO3_MODE')) $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_userauth.php']['logoff_pre_processing'][]
Definition: ext_localconf.php:5

TYPO3\CMS\Core\Utility\GeneralUtility\inList
static inList($list, $item)
Definition: GeneralUtility.php:719

TYPO3\CMS\Backend\Module\ModuleLoader\load
load($modulesArray, $BE_USER='')
Definition: ModuleLoader.php:89

TYPO3\CMS\Backend\Module\ModuleLoader\$observeWorkspaces
$observeWorkspaces
Definition: ModuleLoader.php:70

TYPO3\CMS\Backend\Module\ModuleLoader\parseModulesArray
parseModulesArray($arr)
Definition: ModuleLoader.php:466

TYPO3\CMS\Core\Utility\GeneralUtility\resolveBackPath
static resolveBackPath($pathStr)
Definition: GeneralUtility.php:3136

TYPO3\CMS\Backend\Module
Definition: AbstractFunctionModule.php:2