returns the modules of an extension from the ontology

@access public
@author Jerome Bogaerts, <jerome.bogaerts@tudor.lu>
@param  string $extensionID
@return array
345835
public static function getModules($extensionId)
    {
        $returnValue = array();
        foreach (ControllerHelper::getControllers($extensionId) as $controllerClassName) {
            $shortName = strpos($controllerClassName, '\\') !== false
                ? substr($controllerClassName, strrpos($controllerClassName, '\\')+1)
                : substr($controllerClassName, strrpos($controllerClassName, '_')+1)
            ;
            $uri = AccessService::singleton()->makeEMAUri($extensionId, $shortName);
            $returnValue[$uri] = new \core_kernel_classes_Resource($uri);
        }
        return (array) $returnValue;
    }
814062
public static function getActions($extension, $categoryId = 0)
	{
		// Log usage of deprecated function
		JLog::add(__METHOD__ . '() is deprecated, use JHelperContent::getActions() with new arguments order instead.', JLog::WARNING, 'deprecated');

		// Get list of actions
		return JHelperContent::getActions($extension, 'category', $categoryId);
	}
178270
public static function extInfo($extensionName)
    {

        $result = self::_getExtension($extensionName);
        if ($result) {
            $extensionName = $result['name'];
        }

        return self::i()->dump($result, '! extension (' . $extensionName . ') !');
    }
985243
public function listExtensions($type)
    {
        $results = [];

        if ($this->items === null) {
            $this->loadExtensions();
        }

        if (isset($this->items[$type]) && is_array($this->items[$type])) {
            $results = $this->items[$type];
        }

        if ($this->transactionItems !== null && isset($this->transactionItems[$type])) {
            $results = array_merge($results, $this->transactionItems[$type]);
        }

        return $results;
    }
1318290
public function index()
    {
        Session::forget('install-module');

        $result = [];
        foreach ($this->extensions as $ext) {
            if (extension_loaded($ext)) {
                $result [$ext] = 'true';
            } else {
                $result [$ext] = false;
            }
        }

        return view('avored-install::install.extension')->with('result', $result);
    }
763241
public static function discoverAll()
    {
        $components = [];

        // Run through all extensions
        foreach (ExtensionManagementUtility::getLoadedExtensionListArray() as $extensionKey) {
            $components = array_merge($components, self::discoverExtensionComponents($extensionKey));
        }

        return $components;
    }
1045370
public function getModuleById($moduleId)
    {
        foreach ($this->getModules() as $module) {
            if ($module->getModuleId() == $moduleId) {
                return $module;
            }
        }

        return null;
    }
717839
public function findExtensions(): Extensions
    {
        $extensions = new Extensions();


        foreach ($this->configRepository->getPaths() as $path) {
            $composerPattern = $this->configRepository->getRootPath() . '/' . $path . '/composer.json';

            $composerFiles = $this->filesystem->glob($composerPattern);



            if ($composerFiles === false) {
                throw new ExtensionException('Error occurs when looking for extensions in the [' . $composerPattern . '] path.');
            }

            foreach ($composerFiles as $composerFile) {
                $package = $this->extensionFactory->getComposerPackage($composerFile);

                if (!in_array($package->getType(), self::$validTypes, true)) {
                    continue;
                }

                $extension = $this->extensionFactory->create($composerFile);

                if (!$this->extensionValidator->isValid($extension)) {
                    throw new ExtensionException('The extension [' . $extension->getPackage()->getName() . '] is not valid.');
                }

                $extensions->push($extension);
            }
        }

        return $extensions;
    }
151512
public function getContentModules()
    {
        return array_filter($this->getModules(), function (ModuleInterface $module) {
            return !($module instanceof AdministrationModuleInterface)
                && !($module instanceof SubmoduleInterface);
        });
    }
223511
public static function extensions($zend = false)
    {
        if (!self::isDebug()) {
            return false;
        }
        return self::i()->dump(get_loaded_extensions($zend), '! extensions ' . ($zend ? '(Zend)' : '') . ' !');
    }
865485
protected function getModuleConfigs($moduleId)
    {
        $db = \OxidEsales\Eshop\Core\DatabaseProvider::getDb(\OxidEsales\Eshop\Core\DatabaseProvider::FETCH_MODE_ASSOC);
        $config = \OxidEsales\Eshop\Core\Registry::getConfig();
        $shopId = $config->getShopId();
        $module = $this->getModuleConfigId($moduleId);

        $decodeValueQuery = $config->getDecodeValueQuery();
        $moduleConfigsQuery = "SELECT oxvarname, oxvartype, {$decodeValueQuery} as oxvardecodedvalue FROM oxconfig WHERE oxmodule = ? AND oxshopid = ?";
        $dbConfigs = $db->getAll($moduleConfigsQuery, [$module, $shopId]);

        $result = [];
        foreach ($dbConfigs as $oneModuleConfig) {
            $result[$oneModuleConfig['oxvarname']] = $config->decodeValue($oneModuleConfig['oxvartype'], $oneModuleConfig['oxvardecodedvalue']);
        }

        return $result;
    }
636786
def getExtensions(self):
        """"""
        extensions = []
        if isinstance(self.supportedExtensions, list):
            for ext in self.supportedExtensions:
                extensionURL = self._url + "/exts/%s" % ext
                if ext == "SchematicsServer":
                    extensions.append(SchematicsService(url=extensionURL,
                                                        securityHandler=self._securityHandler,
                                                        proxy_url=self._proxy_url,
                                                        proxy_port=self._proxy_port))
            return extensions
        else:
            extensionURL = self._url + "/exts/%s" % self.supportedExtensions
            if self.supportedExtensions == "SchematicsServer":
                extensions.append(SchematicsService(url=extensionURL,
                                                    securityHandler=self._securityHandler,
                                                    proxy_url=self._proxy_url,
                                                    proxy_port=self._proxy_port))
            return extensions
1090123
public static function getAllSchemaVersions(SchemaId $schemaId)
    {
        $schemaIds = preg_grep(sprintf('/(%s):([0-9]+)-([0-9]+)-([0-9]+)/', $schemaId->getCurie()), array_keys(self::$schemas));

        if ($schemaIds === false || count($schemaIds) === 0) {
            return false;
        }

        $schemas = [];

        foreach ($schemaIds as $schemaId) {
            $schemas[] = self::$schemas[$schemaId];
        }

        return $schemas;
    }
1167214
public function getExtensions()
    {
        $data = [];
        foreach (\Yii::$app->extensions as $extension) {
            $data[$extension['name']] = $extension['version'];
        }

        return $data;
    }
414796
public function getModuleNameFromId($appId)
    {
        if (null === $this->moduleNames) {
            $translator = $this->translator;
            $this->moduleNames = [
                '0' => $translator->trans('admin::monitor: module inconnu'),
                '1' => $translator->trans('admin::monitor: module production'),
                '2' => $translator->trans('admin::monitor: module client'),
                '3' => $translator->trans('admin::monitor: module admin'),
                '4' => $translator->trans('admin::monitor: module report'),
                '5' => $translator->trans('admin::monitor: module thesaurus'),
                '6' => $translator->trans('admin::monitor: module comparateur'),
                '7' => $translator->trans('admin::monitor: module validation'),
                '8' => $translator->trans('admin::monitor: module upload'),
            ];
        }

        return isset($this->moduleNames[$appId]) ? $this->moduleNames[$appId] : null;
    }
297389
public static function for_extensions($extensions)
    {
        foreach ($extensions as $extension) {
            if ($formatter = self::for_extension($extension)) {
                return $formatter;
            }
        }

        return false;
    }
307530
public function getExtensionsInfoList()
    {
        $data = json_decode(
            $this->getRemoteContents($this->extensionsInfofoUrl)
        );

        $content = $data->encoding === 'base64' ? base64_decode($data->content) : [];
        return json_decode($content, true);// true to array
    }