Source for file history.php

Documentation is available at history.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Administrator
  4.  * @subpackage  com_contenthistory
  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. /**
  13.  * Methods supporting a list of contenthistory records.
  14.  *
  15.  * @package     Joomla.Administrator
  16.  * @subpackage  com_contenthistory
  17.  * @since       3.2
  18.  */
  19. class ContenthistoryModelHistory extends JModelList
  20. {
  21.     /**
  22.      * Constructor.
  23.      *
  24.      * @param   array  $config  An optional associative array of configuration settings.
  25.      *
  26.      * @see     JControllerLegacy
  27.      * @since   3.2
  28.      */
  29.     public function __construct($config = array())
  30.     {
  31.         if (empty($config['filter_fields']))
  32.         {
  33.             $config['filter_fields'] = array(
  34.                     'version_id', 'h.version_id',
  35.                     'version_note', 'h.version_note',
  36.                     'save_date', 'h.save_date',
  37.                     'editor_user_id', 'h.editor_user_id',
  38.             );
  39.         }
  40.  
  41.         parent::__construct($config);
  42.     }
  43.  
  44.     /**
  45.      * Method to test whether a history record can be deleted. Note that we check whether we have edit permissions
  46.      * for the content item row.
  47.      *
  48.      * @param   object  $record  A JTable object.
  49.      *
  50.      * @return  boolean  True if allowed to delete the record. Defaults to the permission set in the component.
  51.      *
  52.      * @since   3.2
  53.      */
  54.     protected function canEdit($record)
  55.     {
  56.         if (!empty($record->ucm_type_id))
  57.         {
  58.             $result = false;
  59.  
  60.             // Check that the type id matches the type alias
  61.             $typeAlias = JFactory::getApplication()->input->get('type_alias');
  62.             $contentTypeTable = JTable::getInstance('Contenttype', 'JTable');
  63.  
  64.             if ($contentTypeTable->getTypeId($typeAlias) == $record->ucm_type_id)
  65.             {
  66.                 /**
  67.                  * Make sure user has edit privileges for this content item. Note that we use edit permissions
  68.                  * for the content item, not delete permissions for the content history row.
  69.                  */
  70.                 $user = JFactory::getUser();
  71.                 $result = $user->authorise('core.edit', $typeAlias . (int) $record->version_id);
  72.             }
  73.         }
  74.  
  75.         return $result;
  76.     }
  77.  
  78.     /**
  79.      * Method to delete one or more records from content history table.
  80.      *
  81.      * @param   array  &$pks  An array of record primary keys.
  82.      *
  83.      * @return  boolean  True if successful, false if an error occurs.
  84.      *
  85.      * @since   3.2
  86.      */
  87.     public function delete(&$pks)
  88.     {
  89.         $pks = (array) $pks;
  90.         $table = $this->getTable();
  91.  
  92.         // Iterate the items to delete each one.
  93.         foreach ($pks as $i => $pk)
  94.         {
  95.             if ($table->load($pk))
  96.             {
  97.                 if ($this->canEdit($table))
  98.                 {
  99.                     if (!$table->delete($pk))
  100.                     {
  101.                         $this->setError($table->getError());
  102.  
  103.                         return false;
  104.                     }
  105.                 }
  106.                 else
  107.                 {
  108.                     // Prune items that you can't change.
  109.                     unset($pks[$i]);
  110.                     $error = $this->getError();
  111.  
  112.                     if ($error)
  113.                     {
  114.                         JLog::add($error, JLog::WARNING, 'jerror');
  115.  
  116.                         return false;
  117.                     }
  118.                     else
  119.                     {
  120.                         JLog::add(JText::_('JLIB_APPLICATION_ERROR_DELETE_NOT_PERMITTED'), JLog::WARNING, 'jerror');
  121.  
  122.                         return false;
  123.                     }
  124.                 }
  125.             }
  126.             else
  127.             {
  128.                 $this->setError($table->getError());
  129.  
  130.                 return false;
  131.             }
  132.         }
  133.  
  134.         // Clear the component's cache
  135.         $this->cleanCache();
  136.  
  137.         return true;
  138.     }
  139.  
  140.     /**
  141.      * Method to get a table object, load it if necessary.
  142.      *
  143.      * @param   string  $type    The table name. Optional.
  144.      * @param   string  $prefix  The class prefix. Optional.
  145.      * @param   array   $config  Configuration array for model. Optional.
  146.      *
  147.      * @return  JTable  A JTable object
  148.      *
  149.      * @since   3.2
  150.      */
  151.     public function getTable($type = 'Contenthistory', $prefix = 'JTable', $config = array())
  152.     {
  153.         return JTable::getInstance($type, $prefix, $config);
  154.     }
  155.  
  156.     /**
  157.      * Method to toggle on and off the keep forever value for one or more records from content history table.
  158.      *
  159.      * @param   array  &$pks  An array of record primary keys.
  160.      *
  161.      * @return  boolean  True if successful, false if an error occurs.
  162.      *
  163.      * @since   3.2
  164.      */
  165.     public function keep(&$pks)
  166.     {
  167.         $pks = (array) $pks;
  168.         $table = $this->getTable();
  169.  
  170.         // Iterate the items to delete each one.
  171.         foreach ($pks as $i => $pk)
  172.         {
  173.             if ($table->load($pk))
  174.             {
  175.                 if ($this->canEdit($table))
  176.                 {
  177.                     $table->keep_forever = $table->keep_forever ? 0 : 1;
  178.  
  179.                     if (!$table->store())
  180.                     {
  181.                         $this->setError($table->getError());
  182.  
  183.                         return false;
  184.                     }
  185.                 }
  186.                 else
  187.                 {
  188.                     // Prune items that you can't change.
  189.                     unset($pks[$i]);
  190.                     $error = $this->getError();
  191.  
  192.                     if ($error)
  193.                     {
  194.                         JLog::add($error, JLog::WARNING, 'jerror');
  195.  
  196.                         return false;
  197.                     }
  198.                     else
  199.                     {
  200.                         JLog::add(JText::_('COM_CONTENTHISTORY_ERROR_KEEP_NOT_PERMITTED'), JLog::WARNING, 'jerror');
  201.  
  202.                         return false;
  203.                     }
  204.                 }
  205.             }
  206.             else
  207.             {
  208.                 $this->setError($table->getError());
  209.  
  210.                 return false;
  211.             }
  212.         }
  213.  
  214.         // Clear the component's cache
  215.         $this->cleanCache();
  216.  
  217.         return true;
  218.     }
  219.  
  220.     /**
  221.      * Method to auto-populate the model state.
  222.      *
  223.      * Note. Calling getState in this method will result in recursion.
  224.      *
  225.      * @param   string  $ordering   An optional ordering field.
  226.      * @param   string  $direction  An optional direction (asc|desc).
  227.      *
  228.      * @return  void 
  229.      *
  230.      * @since   3.2
  231.      */
  232.     protected function populateState($ordering = null, $direction = null)
  233.     {
  234.         $input = JFactory::getApplication()->input;
  235.         $itemId = $input->get('item_id', 0, 'integer');
  236.         $typeId = $input->get('type_id', 0, 'integer');
  237.         $typeAlias = $input->get('type_alias', '', 'string');
  238.  
  239.         $this->setState('item_id', $itemId);
  240.         $this->setState('type_id', $typeId);
  241.         $this->setState('type_alias', $typeAlias);
  242.         $this->setState('sha1_hash', $this->getSha1Hash());
  243.  
  244.         // Load the parameters.
  245.         $params = JComponentHelper::getParams('com_contenthistory');
  246.         $this->setState('params', $params);
  247.  
  248.         // List state information.
  249.         parent::populateState('h.save_date', 'DESC');
  250.     }
  251.  
  252.     /**
  253.      * Build an SQL query to load the list data.
  254.      *
  255.      * @return  JDatabaseQuery 
  256.      *
  257.      * @since   3.2
  258.      */
  259.     protected function getListQuery()
  260.     {
  261.         // Create a new query object.
  262.         $db = $this->getDbo();
  263.         $query = $db->getQuery(true);
  264.  
  265.         // Select the required fields from the table.
  266.         $query->select(
  267.             $this->getState(
  268.                 'list.select',
  269.                 'h.version_id, h.ucm_item_id, h.ucm_type_id, h.version_note, h.save_date, h.editor_user_id,' .
  270.                 'h.character_count, h.sha1_hash, h.version_data, h.keep_forever'
  271.             )
  272.         )
  273.         ->from($db->quoteName('#__ucm_history') . ' AS h')
  274.         ->where($db->quoteName('h.ucm_item_id') . ' = ' . $this->getState('item_id'))
  275.         ->where($db->quoteName('h.ucm_type_id') . ' = ' . $this->getState('type_id'))
  276.  
  277.         // Join over the users for the editor
  278.         ->select('uc.name AS editor')
  279.         ->join('LEFT', '#__users AS uc ON uc.id = h.editor_user_id');
  280.  
  281.         // Add the list ordering clause.
  282.         $orderCol = $this->state->get('list.ordering');
  283.         $orderDirn = $this->state->get('list.direction');
  284.         $query->order($db->quoteName($orderCol) . $orderDirn);
  285.  
  286.         return $query;
  287.     }
  288.  
  289.     /**
  290.      * Get the sha1 hash value for the current item being edited.
  291.      *
  292.      * @return  string  sha1 hash of row data
  293.      *
  294.      * @since   3.2
  295.      */
  296.     protected function getSha1Hash()
  297.     {
  298.         $result = false;
  299.         $typeTable = JTable::getInstance('Contenttype', 'JTable');
  300.         $typeId = JFactory::getApplication()->input->getInteger('type_id', 0);
  301.         $typeTable->load($typeId);
  302.         $typeAliasArray = explode('.', $typeTable->type_alias);
  303.         JTable::addIncludePath(JPATH_ROOT . '/administrator/components/' . $typeAliasArray[0] . '/tables');
  304.         $contentTable = $typeTable->getContentTable();
  305.         $keyValue = JFactory::getApplication()->input->getInteger('item_id', 0);
  306.  
  307.         if ($contentTable && $contentTable->load($keyValue))
  308.         {
  309.             $helper = new JHelper;
  310.  
  311.             $dataObject = $helper->getDataObject($contentTable);
  312.             $result = $this->getTable('Contenthistory', 'JTable')->getSha1(json_encode($dataObject), $typeTable);
  313.         }
  314.  
  315.         return $result;
  316.     }
  317. }

Documentation generated on Tue, 19 Nov 2013 15:04:43 +0100 by phpDocumentor 1.4.3