ModuleUpdater.class.php

<?php
 
if (!defined('XOOPS_ROOT_PATH')) {
    exit();
}
 
require_once XOOPS_LEGACY_PATH . '/admin/class/ModuleInstallUtils.class.php';

class Legacy_ModulePhasedUpgrader
{
    public $_mMilestone = [];

    public $mLog = null;

    public $_mCurrentXoopsModule;

    public $_mCurrentVersion;

    public $_mTargetXoopsModule;

    public $_mTargetVersion;

    public $_mForceMode = false;
 
    public function Legacy_ModulePhasedUpgrader() {
        self::__construct();
    }
 
    public function __construct()
    {
        $this->mLog =new Legacy_ModuleInstallLog();
    }

    public function setForceMode($isForceMode)
    {
        $this->_mForceMode = $isForceMode;
    }

    public function setCurrentXoopsModule(&$xoopsModule)
    {
        $handler =& xoops_gethandler('module');
        $cloneModule =& $handler->create();
 
        $cloneModule->unsetNew();
        $cloneModule->set('mid', $xoopsModule->get('mid'));
        $cloneModule->set('name', $xoopsModule->get('name'));
        $cloneModule->set('version', $xoopsModule->get('version'));
        $cloneModule->set('last_update', $xoopsModule->get('last_update'));
        $cloneModule->set('weight', $xoopsModule->get('weight'));
        $cloneModule->set('isactive', $xoopsModule->get('isactive'));
        $cloneModule->set('dirname', $xoopsModule->get('dirname'));
        $cloneModule->set('hasmain', $xoopsModule->get('hasmain'));
        $cloneModule->set('hasadmin', $xoopsModule->get('hasadmin'));
        $cloneModule->set('hassearch', $xoopsModule->get('hassearch'));
        $cloneModule->set('hasconfig', $xoopsModule->get('hasconfig'));
        $cloneModule->set('hascomments', $xoopsModule->get('hascomments'));
        $cloneModule->set('hasnotification', $xoopsModule->get('hasnotification'));
 
        $this->_mCurrentXoopsModule =& $cloneModule;
        $this->_mCurrentVersion = $cloneModule->get('version');
    }

    public function setTargetXoopsModule(&$xoopsModule)
    {
        $this->_mTargetXoopsModule =& $xoopsModule;
        $this->_mTargetVersion = $this->getTargetPhase();
    }

    public function executeUpgrade()
    {
        if ($this->hasUpgradeMethod()) {
            return $this->_callUpgradeMethod();
        } else {
            return $this->executeAutomaticUpgrade();
        }
    }

    public function getCurrentVersion()
    {
        return $this->_mCurrentVersion;
    }

    public function getTargetPhase()
    {
        ksort($this->_mMilestone);
 
        foreach ($this->_mMilestone as $t_version => $t_value) {
            if ($t_version > $this->getCurrentVersion()) {
                return $t_version;
            }
        }
 
        return $this->_mTargetXoopsModule->get('version');
    }

    public function hasUpgradeMethod()
    {
        ksort($this->_mMilestone);
 
        foreach ($this->_mMilestone as $t_version => $t_value) {
            if ($t_version > $this->getCurrentVersion()) {
                if (is_callable([$this, $t_value])) {
                    return true;
                }
            }
        }
 
        return false;
    }

    public function _callUpgradeMethod()
    {
        ksort($this->_mMilestone);
 
        foreach ($this->_mMilestone as $t_version => $t_value) {
            if ($t_version > $this->getCurrentVersion()) {
                if (is_callable([$this, $t_value])) {
                    return $this->$t_value();
                }
            }
        }
 
        return false;
    }

    public function isLatestUpgrade()
    {
        return ($this->_mTargetXoopsModule->get('version') == $this->getTargetPhase());
    }

    public function saveXoopsModule(&$module)
    {
        $handler =& xoops_gethandler('module');
        if ($handler->insert($module)) {
            $this->mLog->addReport('XCL Module is updated.');
        } else {
            $this->mLog->addError('Could not update module information.');
        }
    }
 
    public function _processScript()
    {
        $installScript = trim($this->_mTargetXoopsModule->getInfo('onUpdate'));
        if (false != $installScript) {
            require_once XOOPS_MODULE_PATH . '/' . $this->_mTargetXoopsModule->get('dirname') . '/' . $installScript;
            $funcName = 'xoops_module_update_' . $this->_mTargetXoopsModule->get('dirname');
            if (function_exists($funcName)) {
                // Because X2 can use reference parameter, Legacy doesn't use the following code;'
                //if (!call_user_func($funcName, $this->_mTargetXoopsModule, $this->getCurrentVersion(), new XCube_Ref($this->mLog))) {
 
                $result = $funcName($this->_mTargetXoopsModule, $this->getCurrentVersion(), new XCube_Ref($this->mLog));
                if (!$result) {
                    $this->mLog->addError('Failed to execute ' . $funcName);
                }
            }
        }
    }
 
    public function _processReport()
    {
        if (!$this->mLog->hasError()) {
            $this->mLog->add(XCube_Utils::formatString(_AD_LEGACY_MESSAGE_UPDATING_MODULE_SUCCESSFUL, $this->_mCurrentXoopsModule->get('name')));
        } else {
            $this->mLog->addError(XCube_Utils::formatString(_AD_LEGACY_ERROR_UPDATING_MODULE_FAILURE, $this->_mCurrentXoopsModule->get('name')));
        }
    }

    public function _updateModuleTemplates()
    {
        Legacy_ModuleInstallUtils::clearAllOfModuleTemplatesForUpdate($this->_mTargetXoopsModule, $this->mLog);
        Legacy_ModuleInstallUtils::installAllOfModuleTemplates($this->_mTargetXoopsModule, $this->mLog);
    }

    public function _updateBlocks()
    {
        Legacy_ModuleInstallUtils::smartUpdateAllOfBlocks($this->_mTargetXoopsModule, $this->mLog);
    }

    public function _updatePreferences()
    {
        Legacy_ModuleInstallUtils::smartUpdateAllOfPreferences($this->_mTargetXoopsModule, $this->mLog);
    }

    public function executeAutomaticUpgrade()
    {
        $this->mLog->addReport(_AD_LEGACY_MESSAGE_UPDATE_STARTED);
 
        //
        // Updates all of module templates
        //
        $this->_updateModuleTemplates();
        if (!$this->_mForceMode && $this->mLog->hasError()) {
            $this->_processReport();
            return false;
        }
 
        //
        // Update blocks.
        //
        $this->_updateBlocks();
        if (!$this->_mForceMode && $this->mLog->hasError()) {
            $this->_processReport();
            return false;
        }
 
        //
        // Update preferences & notifications.
        //
        $this->_updatePreferences();
        if (!$this->_mForceMode && $this->mLog->hasError()) {
            $this->_processReport();
            return false;
        }
 
        //
        // Update module object.
        //
        $this->saveXoopsModule($this->_mTargetXoopsModule);
        if (!$this->_mForceMode && $this->mLog->hasError()) {
            $this->_processReport();
            return false;
        }
 
        //
        // call back 'onUpdate'
        //
        $this->_processScript();
        if (!$this->_mForceMode && $this->mLog->hasError()) {
            $this->_processReport();
            return false;
        }
 
        $this->_processReport();
 
        return true;
    }
}