trust_path/modules/sd2nd/admin/class/installer/Sd2ndUpdater.class.php

   1 <?php
   2 /**
   3  * @file
   4  * @package sd2nd
   5  * @version $Id$
   6 **/
   7
   8 if(!defined('XOOPS_ROOT_PATH'))
   9 {
  10     exit;
  11 }
  12
  13 require_once SD2ND_TRUST_PATH . '/admin/class/installer/Sd2ndInstallUtils.class.php';
  14
  15 /**
  16  * Sd2nd_Updater
  17 **/
  18 class Sd2nd_Updater
  19 {
  20     /**
  21      * @brief   Legacy_ModuleInstallLog
  22     **/
  23     public $mLog = null;
  24
  25     /**
  26      * @brief   string[]
  27     **/
  28     private $_mMileStone = array();
  29
  30     /**
  31      * @brief   XoopsModule
  32     **/
  33     private $_mCurrentXoopsModule = null;
  34
  35     /**
  36      * @brief   XoopsModule
  37     **/
  38     private $_mTargetXoopsModule = null;
  39
  40     /**
  41      * @brief   int
  42     **/
  43     private $_mCurrentVersion = 0;
  44
  45     /**
  46      * @brief   int
  47     **/
  48     private $_mTargetVersion = 0;
  49
  50     /**
  51      * @brief   bool
  52     **/
  53     private $_mForceMode = false;
  54
  55     /**
  56      * __construct
  57      *
  58      * @param   void
  59      *
  60      * @return  void
  61     **/
  62     public function __construct()
  63     {
  64         $this->mLog =& new Legacy_ModuleInstallLog();
  65     }
  66
  67     /**
  68      * setForceMode
  69      *
  70      * @param   bool  $isForceMode
  71      *
  72      * @return  void
  73     **/
  74     public function setForceMode(/*** bool ***/ $isForceMode)
  75     {
  76         $this->_mForceMode = $isForceMode;
  77     }
  78
  79     /**
  80      * setCurrentXoopsModule
  81      *
  82      * @param   XoopsModule  &$module
  83      *
  84      * @return  void
  85     **/
  86     public function setCurrentXoopsModule(/*** XoopsModule ***/ &$module)
  87     {
  88         $moduleHandler =& Sd2nd_Utils::getXoopsHandler('module');
  89         $cloneModule =& $moduleHandler->create();
  90
  91         $cloneModule->unsetNew();
  92         $cloneModule->set('mid',$module->get('mid'));
  93         $cloneModule->set('name',$module->get('name'));
  94         $cloneModule->set('version',$module->get('version'));
  95         $cloneModule->set('last_update',$module->get('last_update'));
  96         $cloneModule->set('weight',$module->get('weight'));
  97         $cloneModule->set('isactive',$module->get('isactive'));
  98         $cloneModule->set('dirname',$module->get('dirname'));
  99         //$cloneModule->set('trust_dirname',$module->get('trust_dirname'));
 100         $cloneModule->set('hasmain',$module->get('hasmain'));
 101         $cloneModule->set('hasadmin',$module->get('hasadmin'));
 102         $cloneModule->set('hasconfig',$module->get('hasconfig'));
 103
 104         $this->_mCurrentXoopsModule =& $cloneModule;
 105         $this->_mCurrentVersion = $cloneModule->get('version');
 106     }
 107
 108     /**
 109      * setTargetXoopsModule
 110      *
 111      * @param   XoopsModule  &$module
 112      *
 113      * @return  void
 114     **/
 115     public function setTargetXoopsModule(/*** XoopsModule ***/ &$module)
 116     {
 117         $this->_mTargetXoopsModule =& $module;
 118         $this->_mTargetVersion = $this->getTargetPhase();
 119     }
 120
 121     /**
 122      * getCurrentVersion
 123      *
 124      * @param   void
 125      *
 126      * @return  int
 127     **/
 128     public function getCurrentVersion()
 129     {
 130         return intval($this->_mCurrentVersion);
 131     }
 132
 133     /**
 134      * getTargetPhase
 135      *
 136      * @param   void
 137      *
 138      * @return  int
 139     **/
 140     public function getTargetPhase()
 141     {
 142         ksort($this->_mMileStone);
 143
 144         foreach($this->_mMileStone as $tVer => $tMethod)
 145         {
 146             if($tVer >= $this->getCurrentVersion())
 147             {
 148                 return intval($tVer);
 149             }
 150         }
 151
 152         return $this->_mTargetXoopsModule->get('version');
 153     }
 154
 155     /**
 156      * hasUpgradeMethod
 157      *
 158      * @param   void
 159      *
 160      * @return  bool
 161     **/
 162     public function hasUpgradeMethod()
 163     {
 164         ksort($this->_mMileStone);
 165
 166         foreach($this->_mMileStone as $tVer => $tMethod)
 167         {
 168             if($tVer >= $this->getCurrentVersion() && is_callable(array($this,$tMethod)))
 169             {
 170                 return true;
 171             }
 172         }
 173
 174         return false;
 175     }
 176
 177     /**
 178      * isLatestUpgrade
 179      *
 180      * @param   void
 181      *
 182      * @return  bool
 183     **/
 184     public function isLatestUpgrade()
 185     {
 186         return ($this->_mTargetXoopsModule->get('version') == $this->getTargetPhase());
 187     }
 188
 189     /**
 190      * _updateModuleTemplates
 191      *
 192      * @param   void
 193      *
 194      * @return  void
 195     **/
 196     private function _updateModuleTemplates()
 197     {
 198         Sd2nd_InstallUtils::uninstallAllOfModuleTemplates($this->_mTargetXoopsModule,$this->mLog);
 199         Sd2nd_InstallUtils::installAllOfModuleTemplates($this->_mTargetXoopsModule,$this->mLog);
 200     }
 201
 202     /**
 203      * _updateBlocks
 204      *
 205      * @param   void
 206      *
 207      * @return  void
 208     **/
 209     private function _updateBlocks()
 210     {
 211         Sd2nd_InstallUtils::smartUpdateAllOfBlocks($this->_mTargetXoopsModule,$this->mLog);
 212     }
 213
 214     /**
 215      * _updatePreferences
 216      *
 217      * @param   void
 218      *
 219      * @return  void
 220     **/
 221     private function _updatePreferences()
 222     {
 223         Sd2nd_InstallUtils::smartUpdateAllOfConfigs($this->_mTargetXoopsModule,$this->mLog);
 224     }
 225
 226     /**
 227      * executeUpgrade
 228      *
 229      * @param   void
 230      *
 231      * @return  bool
 232     **/
 233     public function executeUpgrade()
 234     {
 235         return ($this->hasUpgradeMethod() ?
 236             $this->_callUpgradeMethod() :
 237             $this->executeAutomaticUpgrade());
 238     }
 239
 240     /**
 241      * _callUpgradeMethod
 242      *
 243      * @param   void
 244      *
 245      * @return  bool
 246     **/
 247     private function _callUpgradeMethod()
 248     {
 249         ksort($this->_mMileStone);
 250
 251         foreach($this->_mMileStone as $tVer => $tMethod)
 252         {
 253             if($tVer >= $this->getCurrentVersion() && is_callable(array($this,$tMethod)))
 254             {
 255                 return $this->$tMethod();
 256             }
 257         }
 258
 259         return false;
 260     }
 261
 262     /**
 263      * executeAutomaticUpgrade
 264      *
 265      * @param   void
 266      *
 267      * @return  bool
 268     **/
 269     public function executeAutomaticUpgrade()
 270     {
 271         $this->mLog->addReport(_MI_SD2ND_INSTALL_MSG_UPDATE_STARTED);
 272
 273         $this->_updateModuleTemplates();
 274         if(!$this->_mForceMode && $this->mLog->hasError())
 275         {
 276             $this->_processReport();
 277             return false;
 278         }
 279
 280         $this->_updateBlocks();
 281         if(!$this->_mForceMode && $this->mLog->hasError())
 282         {
 283             $this->_processReport();
 284             return false;
 285         }
 286
 287         $this->_updatePreferences();
 288         if(!$this->_mForceMode && $this->mLog->hasError())
 289         {
 290             $this->_processReport();
 291             return false;
 292         }
 293
 294         $this->saveXoopsModule($this->_mTargetXoopsModule);
 295         if(!$this->_mForceMode && $this->mLog->hasError())
 296         {
 297             $this->_processReport();
 298             return false;
 299         }
 300
 301         $this->_processReport();
 302
 303         return true;
 304     }
 305
 306     /**
 307      * saveXoopsModule
 308      *
 309      * @param   XoopsModule  &$module
 310      *
 311      * @return  void
 312     **/
 313     public function saveXoopsModule(/*** XoopsModule ***/ &$module)
 314     {
 315         $moduleHandler =& Sd2nd_Utils::getXoopsHandler('module');
 316
 317         if($moduleHandler->insert($module))
 318         {
 319             $this->mLog->addReport(_MI_SD2ND_INSTALL_MSG_UPDATE_FINISHED);
 320         }
 321         else
 322         {
 323             $this->mLog->addError(_MI_SD2ND_INSTALL_ERROR_UPDATE_FINISHED);
 324         }
 325     }
 326
 327     /**
 328      * _processReport
 329      *
 330      * @param   void
 331      *
 332      * @return  void
 333     **/
 334     private function _processReport()
 335     {
 336         if(!$this->mLog->hasError())
 337         {
 338             $this->mLog->add(
 339                 XCube_Utils::formatString(
 340                     _MI_SD2ND_INSTALL_MSG_MODULE_UPDATED,
 341                     $this->_mCurrentXoopsModule->get('name')
 342                 )
 343             );
 344         }
 345         else
 346         {
 347             $this->mLog->add(
 348                 XCube_Utils::formatString(
 349                     _MI_SD2ND_INSTALL_ERROR_MODULE_UPDATED,
 350                     $this->_mCurrentXoopsModule->get('name')
 351                 )
 352             );
 353         }
 354     }
 355 }
 356
 357 ?>