Removes all configuration data by associated module

@param string $module
@return boolean
327485
public function removeAllByModule($module)
    {
        $this->initializeOnDemand();

        if ($this->arrayConfig->hasModule($module) && $this->configMapper->deleteAllByModule($module)) {
            $this->arrayConfig->removeAllByModule($module);
            return true;
        } else {
            return false;
        }
    }
845410
public static function setAll($module,$data){
        $data=json_encode($data);
        $config=self::get("config");
        $table=$config&&key_exists('db_table',$config)?$config['db_table']:"config";
        $module_key=$config&&key_exists('module_field',$config)?$config['module_field']:"module";
        $content=$config&&key_exists('content_field',$config)?$config['content_field']:"content";
        Update::table($table)->set($content,$data)
            ->where($module_key,$module)
            ->excuse();
        Cache::remove(md5("config_".$module));
    }
1296786
public function reset($module)
    {
        if (is_string($module)) {
            $module = $this->laravel['modules']->findOrFail($module);
        }

        $migrator = new Migrator($module);

        $migrated = $migrator->reset();

        if (count($migrated)) {
            foreach ($migrated as $migration) {
                $this->line("Rollback: <info>{$migration}</info>");
            }

            return;
        }

        $this->comment('Nothing to rollback.');
    }
469475
public function disable($moduleName)
    {
        $module = $this->findOrFalse('module_name', $moduleName);
        if ($module)
        {
            if ($module->module_status)
            {
                $module->module_status = 0;
                $module->save();
                $this->app['events']->fire('modules.disable.'.$moduleName, null);
                return true;
            }
            return false;
        }
        return false;
    }
172592
public function uninstall($module_id)
    {
        try {
            $result = $this->canUninstall($module_id);
        } catch (Exception $ex) {
            $result = $ex->getMessage();
        }

        $this->hook->attach("module.uninstall.before|$module_id", $result, $this);

        if ($result !== true) {
            return $result;
        }

        $this->module->delete($module_id);
        $this->setOverrideConfig();

        $this->hook->attach("module.uninstall.after|$module_id", $result, $this);
        return $result;
    }
1051437
private function checkActivation($module)
    {
        try {
            $moduleValidator = new ModuleValidator($module->getAbsoluteBaseDir());
            $moduleValidator->validate(false);
        } catch (\Exception $ex) {
            throw $ex;
        }

        return true;
    }
30997
private static function getModuleFromDB($module){
        $data=Cache::get(md5("config_".$module));
        if(!$data){
            $config=self::get("config");
            $table=$config&&key_exists('db_table',$config)?$config['db_table']:"config";
            $module_key=$config&&key_exists('module_field',$config)?$config['module_field']:"module";
            $content=$config&&key_exists('content_field',$config)?$config['content_field']:"content";
            $data= Select::table($table)
                ->where($module_key,$module)
                ->value($content);
            Cache::set(md5("config_".$module),$data);
        }
        if($data){
            $data=json_decode($data,true);
        }
        return $data;
    }
1143174
public function removeModule($module)
    {
        if ($module instanceof ModuleInterface) {
            if (!in_array($module, $this->modules)) {
                throw new \InvalidArgumentException(
                    'This occurrence of '.get_class($module).' is not registered.'
                );
            }

            $this->modules = array_filter($this->modules, function ($instance) use ($module) {
                return $instance !== $module;
            });

            return $this;
        }

        /** @var string $className */
        $className = $module;

        if (!$this->hasModule($className)) {
            throw new \InvalidArgumentException(
                'The container doesn\'t contain a '.$className.' module'
            );
        }

        $this->modules[$className]->detachEvents();
        unset($this->modules[$className]);

        return $this;
    }
388875
public function has($module, $name, &$position = false)
    {
        foreach ($this->data as $index => $row) {
            if ($row[ConstProviderInterface::CONFIG_PARAM_MODULE] == $module && $row[ConstProviderInterface::CONFIG_PARAM_NAME] == $name) {
                if ($position !== false) {
                    $position = $index;
                }

                return true;
            }
        }

        return false;
    }
700180
protected function permissionAccess(string $module, string $function): bool
    {
        if (!$this->permissionResolver->hasAccess($module, $function)) {
            return false;
        }

        return true;
    }
481461
public function removeFromCacheDir($module)
    {
        // Create a path
        $path = $this->appConfig->getModuleCacheDir($module);
        return $this->performRemoval($path);
    }
1138638
public function getAllByModule($module)
    {
        if (!$this->hasModule($module)) {
            return false;
        } else {
            $result = array();

            foreach ($this->data as $index => $row) {
                if (isset($row[ConstProviderInterface::CONFIG_PARAM_MODULE]) && $row[ConstProviderInterface::CONFIG_PARAM_MODULE] == $module) {
                    $name = $row[ConstProviderInterface::CONFIG_PARAM_NAME];
                    $value = $row[ConstProviderInterface::CONFIG_PARAM_VALUE];

                    $result[$name] = $value;
                }
            }

            return $result;
        }
    }
1076479
protected function unregisterModule($moduleName, $hook)
    {
        if (!in_array($hook, array_keys($this->modules))) {
            return false;
        }
        if (array_key_exists($moduleName, $this->modules[$hook])) {
            unset($this->modules[$hook][$moduleName]);
            return true;
        }
        return false;
    }
396085
public function deactivate(\OxidEsales\Eshop\Core\Module\Module $module)
    {
        $result = false;
        if ($moduleId = $module->getId()) {
            $this->_callEvent('onDeactivate', $moduleId);

            $this->_addToDisabledList($moduleId);

            //removing recoverable options
            $this->_deleteBlock($moduleId);
            $this->_deleteTemplateFiles($moduleId);
            $this->_deleteModuleFiles($moduleId);
            $this->_deleteModuleEvents($moduleId);
            $this->_deleteModuleVersions($moduleId);
            $this->deleteModuleControllers($moduleId);
            $this->deleteModuleSmartyPluginDirectories($moduleId);

            $this->deactivateShopAwareServices($module);

            $this->resetCache();

            $result = true;
        }

        return $result;
    }
728472
public function cleanup()
    {
        $aDeletedModules = $this->getDeletedExtensions();

        //collecting deleted extension IDs
        $aDeletedModuleIds = array_keys($aDeletedModules);

        // removing from aModules config array
        $this->_removeExtensions($aDeletedModuleIds);

        // removing from aDisabledModules array
        $this->_removeFromDisabledModulesArray($aDeletedModuleIds);

        // removing from aModulePaths array
        $this->removeFromModulesArray(static::MODULE_KEY_PATHS, $aDeletedModuleIds);

        // removing from aModuleEvents array
        $this->removeFromModulesArray(static::MODULE_KEY_EVENTS, $aDeletedModuleIds);

        // removing from aModuleVersions array
        $this->removeFromModulesArray(static::MODULE_KEY_VERSIONS, $aDeletedModuleIds);

        // removing from aModuleExtensions array
        $this->removeFromModulesArray(static::MODULE_KEY_EXTENSIONS, $aDeletedModuleIds);

        // removing from aModuleFiles array
        $this->removeFromModulesArray(static::MODULE_KEY_FILES, $aDeletedModuleIds);

        // removing from aModuleTemplates array
        $this->removeFromModulesArray(static::MODULE_KEY_TEMPLATES, $aDeletedModuleIds);

        // removing from aModuleControllers array
        $this->removeFromModulesArray(static::MODULE_KEY_CONTROLLERS, $aDeletedModuleIds);

        //removing from config tables and templates blocks table
        $this->_removeFromDatabase($aDeletedModuleIds);

        //Remove from caches.
        \OxidEsales\Eshop\Core\Module\ModuleVariablesLocator::resetModuleVariables();
    }
739625
public function uninstall()
    {
        // 1. remove tables
        $migrator = new MysqlDbMigrator($this->sModuleAlias);
        $migrator->migrateTo(-1);

        // 2. remove row from the modules table
        Core::app()->deleteModuleById($this->sModuleAlias);

        // 3. Delete config
        $file = RX_PATH.'/ruxon/config/modules/'.$this->sModuleAlias.'.inc.php';
        if (file_exists($file)) {
            unlink($file);
        }

        return true;
    }
926718
protected static function _deactivateOldModule()
    {
        $sModule = self::OLD_MODULE_ID;

        /**
         * @var oxModule $oModule
         */
        $oModule = self::_getModule();

        if ($oModule->load($sModule) === false) {
            self::_getUtilsView()->addErrorToDisplay(new oxException('EXCEPTION_MODULE_NOT_LOADED'));
            return false;
        }

        try {
            $oModuleCache = self::_getModuleCache($oModule);
            $oModuleInstaller = self::_getModuleInstaller($oModuleCache);
            return $oModuleInstaller->deactivate($oModule);
        } catch (oxException $oEx) {
            self::_getUtilsView()->addErrorToDisplay($oEx);

            if (method_exists($oEx, 'debugOut')) {
                $oEx->debugOut();
            }
        }

        return false;
    }