Source for file database.php

Documentation is available at database.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Administrator
  4.  * @subpackage  com_installer
  5.  *
  6.  * @copyright   Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
  7.  * @license     GNU General Public License version 2 or later; see LICENSE.txt
  8.  */
  9.  
  10. defined('_JEXEC') or die;
  11.  
  12. JLoader::register('InstallerModel', __DIR__ . '/extension.php');
  13. JLoader::register('JoomlaInstallerScript', JPATH_ADMINISTRATOR . '/components/com_admin/script.php');
  14.  
  15. /**
  16.  * Installer Manage Model
  17.  *
  18.  * @package     Joomla.Administrator
  19.  * @subpackage  com_installer
  20.  * @since       1.6
  21.  */
  22. class InstallerModelDatabase extends InstallerModel
  23. {
  24.     protected $_context = 'com_installer.discover';
  25.  
  26.     /**
  27.      * Method to auto-populate the model state.
  28.      *
  29.      * Note. Calling getState in this method will result in recursion.
  30.      *
  31.      * @param   string  $ordering   An optional ordering field.
  32.      * @param   string  $direction  An optional direction (asc|desc).
  33.      *
  34.      * @return  void 
  35.      *
  36.      * @since   1.6
  37.      */
  38.     protected function populateState($ordering = null, $direction = null)
  39.     {
  40.         $app = JFactory::getApplication();
  41.         $this->setState('message', $app->getUserState('com_installer.message'));
  42.         $this->setState('extension_message', $app->getUserState('com_installer.extension_message'));
  43.         $app->setUserState('com_installer.message', '');
  44.         $app->setUserState('com_installer.extension_message', '');
  45.         parent::populateState('name', 'asc');
  46.     }
  47.  
  48.     /**
  49.      * Fixes database problems
  50.      *
  51.      * @return  void 
  52.      */
  53.     public function fix()
  54.     {
  55.         if (!$changeSet = $this->getItems())
  56.         {
  57.             return false;
  58.         }
  59.         $changeSet->fix();
  60.         $this->fixSchemaVersion($changeSet);
  61.         $this->fixUpdateVersion();
  62.         $installer = new JoomlaInstallerScript;
  63.         $installer->deleteUnexistingFiles();
  64.         $this->fixDefaultTextFilters();
  65.     }
  66.  
  67.     /**
  68.      * Gets the changeset object
  69.      *
  70.      * @return  JSchemaChangeset 
  71.      */
  72.     public function getItems()
  73.     {
  74.         $folder = JPATH_ADMINISTRATOR . '/components/com_admin/sql/updates/';
  75.  
  76.         try
  77.         {
  78.             $changeSet = JSchemaChangeset::getInstance(JFactory::getDbo(), $folder);
  79.         }
  80.         catch (RuntimeException $e)
  81.         {
  82.             JFactory::getApplication()->enqueueMessage($e->getMessage(), 'warning');
  83.             return false;
  84.         }
  85.         return $changeSet;
  86.     }
  87.  
  88.     /**
  89.      * Method to get a JPagination object for the data set.
  90.      *
  91.      * @return  boolean 
  92.      *
  93.      * @since   12.2
  94.      */
  95.     public function getPagination()
  96.     {
  97.         return true;
  98.     }
  99.  
  100.     /**
  101.      * Get version from #__schemas table
  102.      *
  103.      * @return  mixed  the return value from the query, or null if the query fails
  104.      *
  105.      * @throws Exception
  106.      */
  107.     public function getSchemaVersion()
  108.     {
  109.         $db = JFactory::getDbo();
  110.         $query = $db->getQuery(true)
  111.             ->select('version_id')
  112.             ->from($db->quoteName('#__schemas'))
  113.             ->where('extension_id = 700');
  114.         $db->setQuery($query);
  115.         $result = $db->loadResult();
  116.  
  117.         return $result;
  118.     }
  119.  
  120.     /**
  121.      * Fix schema version if wrong
  122.      *
  123.      * @param   JSchemaChangeSet  $changeSet  Schema change set
  124.      *
  125.      * @return   mixed  string schema version if success, false if fail
  126.      */
  127.     public function fixSchemaVersion($changeSet)
  128.     {
  129.         // Get correct schema version -- last file in array
  130.         $schema = $changeSet->getSchema();
  131.         $db = JFactory::getDbo();
  132.         $result = false;
  133.  
  134.         // Check value. If ok, don't do update
  135.         $version = $this->getSchemaVersion();
  136.         if ($version == $schema)
  137.         {
  138.             $result = $version;
  139.         }
  140.         else
  141.         {
  142.             // Delete old row
  143.             $query = $db->getQuery(true)
  144.                 ->delete($db->quoteName('#__schemas'))
  145.                 ->where($db->quoteName('extension_id') . ' = 700');
  146.             $db->setQuery($query);
  147.             $db->execute();
  148.  
  149.             // Add new row
  150.             $query->clear()
  151.                 ->insert($db->quoteName('#__schemas'))
  152.                 ->set($db->quoteName('extension_id') . '= 700')
  153.                 ->set($db->quoteName('version_id') . '= ' . $db->quote($schema));
  154.             $db->setQuery($query);
  155.             if ($db->execute())
  156.             {
  157.                 $result = $schema;
  158.             }
  159.         }
  160.         return $result;
  161.     }
  162.  
  163.     /**
  164.      * Get current version from #__extensions table
  165.      *
  166.      * @return  mixed   version if successful, false if fail
  167.      */
  168.  
  169.     public function getUpdateVersion()
  170.     {
  171.         $table = JTable::getInstance('Extension');
  172.         $table->load('700');
  173.         $cache = new JRegistry($table->manifest_cache);
  174.         return $cache->get('version');
  175.     }
  176.  
  177.     /**
  178.      * Fix Joomla version in #__extensions table if wrong (doesn't equal JVersion short version)
  179.      *
  180.      * @return   mixed  string update version if success, false if fail
  181.      */
  182.     public function fixUpdateVersion()
  183.     {
  184.         $table = JTable::getInstance('Extension');
  185.         $table->load('700');
  186.         $cache = new JRegistry($table->manifest_cache);
  187.         $updateVersion = $cache->get('version');
  188.         $cmsVersion = new JVersion;
  189.         if ($updateVersion == $cmsVersion->getShortVersion())
  190.         {
  191.             return $updateVersion;
  192.         }
  193.         else
  194.         {
  195.             $cache->set('version', $cmsVersion->getShortVersion());
  196.             $table->manifest_cache = $cache->toString();
  197.             if ($table->store())
  198.             {
  199.                 return $cmsVersion->getShortVersion();
  200.             }
  201.             else
  202.             {
  203.                 return false;
  204.             }
  205.  
  206.         }
  207.     }
  208.  
  209.     /**
  210.      * For version 2.5.x only
  211.      * Check if com_config parameters are blank.
  212.      *
  213.      * @return  string  default text filters (if any)
  214.      */
  215.     public function getDefaultTextFilters()
  216.     {
  217.         $table = JTable::getInstance('Extension');
  218.         $table->load($table->find(array('name' => 'com_config')));
  219.         return $table->params;
  220.     }
  221.     /**
  222.      * For version 2.5.x only
  223.      * Check if com_config parameters are blank. If so, populate with com_content text filters.
  224.      *
  225.      * @return  mixed  boolean true if params are updated, null otherwise
  226.      */
  227.     public function fixDefaultTextFilters()
  228.     {
  229.         $table = JTable::getInstance('Extension');
  230.         $table->load($table->find(array('name' => 'com_config')));
  231.  
  232.         // Check for empty $config and non-empty content filters
  233.         if (!$table->params)
  234.         {
  235.             // Get filters from com_content and store if you find them
  236.             $contentParams = JComponentHelper::getParams('com_content');
  237.             if ($contentParams->get('filters'))
  238.             {
  239.                 $newParams = new JRegistry;
  240.                 $newParams->set('filters', $contentParams->get('filters'));
  241.                 $table->params = (string) $newParams;
  242.                 $table->store();
  243.                 return true;
  244.             }
  245.         }
  246.     }
  247. }

Documentation generated on Tue, 19 Nov 2013 14:57:52 +0100 by phpDocumentor 1.4.3