Source for file article.php

Documentation is available at article.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Site
  4.  * @subpackage  com_content
  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.  * Content Component Article Model
  14.  *
  15.  * @package     Joomla.Site
  16.  * @subpackage  com_content
  17.  * @since       1.5
  18.  */
  19. class ContentModelArticle extends JModelItem
  20. {
  21.     /**
  22.      * Model context string.
  23.      *
  24.      * @var        string 
  25.      */
  26.     protected $_context = 'com_content.article';
  27.  
  28.     /**
  29.      * Method to auto-populate the model state.
  30.      *
  31.      * Note. Calling getState in this method will result in recursion.
  32.      *
  33.      * @since   1.6
  34.      *
  35.      * @return void 
  36.      */
  37.     protected function populateState()
  38.     {
  39.         $app = JFactory::getApplication('site');
  40.  
  41.         // Load state from the request.
  42.         $pk = $app->input->getInt('id');
  43.         $this->setState('article.id', $pk);
  44.  
  45.         $offset = $app->input->getUInt('limitstart');
  46.         $this->setState('list.offset', $offset);
  47.  
  48.         // Load the parameters.
  49.         $params = $app->getParams();
  50.         $this->setState('params', $params);
  51.  
  52.         // TODO: Tune these values based on other permissions.
  53.         $user = JFactory::getUser();
  54.  
  55.         if ((!$user->authorise('core.edit.state', 'com_content')) && (!$user->authorise('core.edit', 'com_content')))
  56.         {
  57.             $this->setState('filter.published', 1);
  58.             $this->setState('filter.archived', 2);
  59.         }
  60.  
  61.         $this->setState('filter.language', JLanguageMultilang::isEnabled());
  62.     }
  63.  
  64.     /**
  65.      * Method to get article data.
  66.      *
  67.      * @param   integer  $pk  The id of the article.
  68.      *
  69.      * @return  mixed  Menu item data object on success, false on failure.
  70.      */
  71.     public function getItem($pk = null)
  72.     {
  73.         $pk = (!empty($pk)) ? $pk : (int) $this->getState('article.id');
  74.  
  75.         if ($this->_item === null)
  76.         {
  77.             $this->_item = array();
  78.         }
  79.  
  80.         if (!isset($this->_item[$pk]))
  81.         {
  82.             try
  83.             {
  84.                 $db = $this->getDbo();
  85.                 $query = $db->getQuery(true)
  86.                     ->select(
  87.                         $this->getState(
  88.                             'item.select', 'a.id, a.asset_id, a.title, a.alias, a.introtext, a.fulltext, ' .
  89.                             // If badcats is not null, this means that the article is inside an unpublished category
  90.                             // In this case, the state is set to 0 to indicate Unpublished (even if the article state is Published)
  91.                             'CASE WHEN badcats.id is null THEN a.state ELSE 0 END AS state, ' .
  92.                             'a.catid, a.created, a.created_by, a.created_by_alias, ' .
  93.                             // Use created if modified is 0
  94.                             'CASE WHEN a.modified = ' . $db->quote($db->getNullDate()) . ' THEN a.created ELSE a.modified END as modified, ' .
  95.                             'a.modified_by, a.checked_out, a.checked_out_time, a.publish_up, a.publish_down, ' .
  96.                             'a.images, a.urls, a.attribs, a.version, a.ordering, ' .
  97.                             'a.metakey, a.metadesc, a.access, a.hits, a.metadata, a.featured, a.language, a.xreference'
  98.                         )
  99.                     );
  100.                 $query->from('#__content AS a');
  101.  
  102.                 // Join on category table.
  103.                 $query->select('c.title AS category_title, c.alias AS category_alias, c.access AS category_access')
  104.                     ->join('LEFT', '#__categories AS c on c.id = a.catid');
  105.  
  106.                 // Join on user table.
  107.                 $query->select('u.name AS author')
  108.                     ->join('LEFT', '#__users AS u on u.id = a.created_by');
  109.  
  110.                 // Get contact id
  111.                 $subQuery = $db->getQuery(true)
  112.                     ->select('MAX(contact.id) AS id')
  113.                     ->from('#__contact_details AS contact')
  114.                     ->where('contact.published = 1')
  115.                     ->where('contact.user_id = a.created_by');
  116.  
  117.                     // Filter by language
  118.                     if ($this->getState('filter.language'))
  119.                     {
  120.                         $subQuery->where('(contact.language in (' . $db->quote(JFactory::getLanguage()->getTag()) . ',' . $db->quote('*') . ') OR contact.language IS NULL)');
  121.                     }
  122.  
  123.                 $query->select('(' . $subQuery . ') as contactid');
  124.  
  125.                 // Filter by language
  126.                 if ($this->getState('filter.language'))
  127.                 {
  128.                     $query->where('a.language in (' . $db->quote(JFactory::getLanguage()->getTag()) . ',' . $db->quote('*') . ')');
  129.                 }
  130.  
  131.                 // Join over the categories to get parent category titles
  132.                 $query->select('parent.title as parent_title, parent.id as parent_id, parent.path as parent_route, parent.alias as parent_alias')
  133.                     ->join('LEFT', '#__categories as parent ON parent.id = c.parent_id');
  134.  
  135.                 // Join on voting table
  136.                 $query->select('ROUND(v.rating_sum / v.rating_count, 0) AS rating, v.rating_count as rating_count')
  137.                     ->join('LEFT', '#__content_rating AS v ON a.id = v.content_id')
  138.  
  139.                     ->where('a.id = ' . (int) $pk);
  140.  
  141.                 // Filter by start and end dates.
  142.                 $nullDate = $db->quote($db->getNullDate());
  143.                 $date = JFactory::getDate();
  144.  
  145.                 $nowDate = $db->quote($date->toSql());
  146.  
  147.                 $query->where('(a.publish_up = ' . $nullDate . ' OR a.publish_up <= ' . $nowDate . ')')
  148.                     ->where('(a.publish_down = ' . $nullDate . ' OR a.publish_down >= ' . $nowDate . ')');
  149.  
  150.                 // Join to check for category published state in parent categories up the tree
  151.                 // If all categories are published, badcats.id will be null, and we just use the article state
  152.                 $subquery = ' (SELECT cat.id as id FROM #__categories AS cat JOIN #__categories AS parent ';
  153.                 $subquery .= 'ON cat.lft BETWEEN parent.lft AND parent.rgt ';
  154.                 $subquery .= 'WHERE parent.extension = ' . $db->quote('com_content');
  155.                 $subquery .= ' AND parent.published <= 0 GROUP BY cat.id)';
  156.                 $query->join('LEFT OUTER', $subquery . ' AS badcats ON badcats.id = c.id');
  157.  
  158.                 // Filter by published state.
  159.                 $published = $this->getState('filter.published');
  160.                 $archived = $this->getState('filter.archived');
  161.  
  162.                 if (is_numeric($published))
  163.                 {
  164.                     $query->where('(a.state = ' . (int) $published . ' OR a.state =' . (int) $archived . ')');
  165.                 }
  166.  
  167.                 $db->setQuery($query);
  168.  
  169.                 $data = $db->loadObject();
  170.  
  171.                 if (empty($data))
  172.                 {
  173.                     return JError::raiseError(404, JText::_('COM_CONTENT_ERROR_ARTICLE_NOT_FOUND'));
  174.                 }
  175.  
  176.                 // Check for published state if filter set.
  177.                 if (((is_numeric($published)) || (is_numeric($archived))) && (($data->state != $published) && ($data->state != $archived)))
  178.                 {
  179.                     return JError::raiseError(404, JText::_('COM_CONTENT_ERROR_ARTICLE_NOT_FOUND'));
  180.                 }
  181.  
  182.                 // Convert parameter fields to objects.
  183.                 $registry = new JRegistry;
  184.                 $registry->loadString($data->attribs);
  185.  
  186.                 $data->params = clone $this->getState('params');
  187.                 $data->params->merge($registry);
  188.  
  189.                 $registry = new JRegistry;
  190.                 $registry->loadString($data->metadata);
  191.                 $data->metadata = $registry;
  192.  
  193.                 // Compute selected asset permissions.
  194.                 $user = JFactory::getUser();
  195.  
  196.                 // Technically guest could edit an article, but lets not check that to improve performance a little.
  197.                 if (!$user->get('guest'))
  198.                 {
  199.                     $userId = $user->get('id');
  200.                     $asset = 'com_content.article.' . $data->id;
  201.  
  202.                     // Check general edit permission first.
  203.                     if ($user->authorise('core.edit', $asset))
  204.                     {
  205.                         $data->params->set('access-edit', true);
  206.                     }
  207.  
  208.                     // Now check if edit.own is available.
  209.                     elseif (!empty($userId) && $user->authorise('core.edit.own', $asset))
  210.                     {
  211.                         // Check for a valid user and that they are the owner.
  212.                         if ($userId == $data->created_by)
  213.                         {
  214.                             $data->params->set('access-edit', true);
  215.                         }
  216.                     }
  217.                 }
  218.  
  219.                 // Compute view access permissions.
  220.                 if ($access = $this->getState('filter.access'))
  221.                 {
  222.                     // If the access filter has been set, we already know this user can view.
  223.                     $data->params->set('access-view', true);
  224.                 }
  225.                 else
  226.                 {
  227.                     // If no access filter is set, the layout takes some responsibility for display of limited information.
  228.                     $user = JFactory::getUser();
  229.                     $groups = $user->getAuthorisedViewLevels();
  230.  
  231.                     if ($data->catid == 0 || $data->category_access === null)
  232.                     {
  233.                         $data->params->set('access-view', in_array($data->access, $groups));
  234.                     }
  235.                     else
  236.                     {
  237.                         $data->params->set('access-view', in_array($data->access, $groups) && in_array($data->category_access, $groups));
  238.                     }
  239.                 }
  240.  
  241.                 $this->_item[$pk] = $data;
  242.             }
  243.             catch (Exception $e)
  244.             {
  245.                 if ($e->getCode() == 404)
  246.                 {
  247.                     // Need to go thru the error handler to allow Redirect to work.
  248.                     JError::raiseError(404, $e->getMessage());
  249.                 }
  250.                 else
  251.                 {
  252.                     $this->setError($e);
  253.                     $this->_item[$pk] = false;
  254.                 }
  255.             }
  256.         }
  257.  
  258.         return $this->_item[$pk];
  259.     }
  260.  
  261.     /**
  262.      * Increment the hit counter for the article.
  263.      *
  264.      * @param   integer  $pk  Optional primary key of the article to increment.
  265.      *
  266.      * @return  boolean  True if successful; false otherwise and internal error set.
  267.      */
  268.     public function hit($pk = 0)
  269.     {
  270.         $input = JFactory::getApplication()->input;
  271.         $hitcount = $input->getInt('hitcount', 1);
  272.  
  273.         if ($hitcount)
  274.         {
  275.             $pk = (!empty($pk)) ? $pk : (int) $this->getState('article.id');
  276.  
  277.             $table = JTable::getInstance('Content', 'JTable');
  278.             $table->load($pk);
  279.             $table->hit($pk);
  280.         }
  281.  
  282.         return true;
  283.     }
  284.  
  285.     /**
  286.      * Save user vote on article
  287.      *
  288.      * @param   integer  $pk    Joomla Article Id
  289.      * @param   integer  $rate  Voting rate
  290.      *
  291.      * @return  boolean          Return true on success
  292.      */
  293.     public function storeVote($pk = 0, $rate = 0)
  294.     {
  295.         if ($rate >= 1 && $rate <= 5 && $pk > 0)
  296.         {
  297.             $userIP = $_SERVER['REMOTE_ADDR'];
  298.  
  299.             // Initialize variables.
  300.             $db    = JFactory::getDbo();
  301.             $query = $db->getQuery(true);
  302.  
  303.             // Create the base select statement.
  304.             $query->select('*')
  305.                 ->from($db->quoteName('#__content_rating'))
  306.                 ->where($db->quoteName('content_id') . ' = ' . (int) $pk);
  307.  
  308.             // Set the query and load the result.
  309.             $db->setQuery($query);
  310.             $rating = $db->loadObject();
  311.  
  312.             // Check for a database error.
  313.             if ($db->getErrorNum())
  314.             {
  315.                 JError::raiseWarning(500, $db->getErrorMsg());
  316.  
  317.                 return false;
  318.             }
  319.  
  320.             // There are no ratings yet, so lets insert our rating
  321.             if (!$rating)
  322.             {
  323.                 $query = $db->getQuery(true);
  324.  
  325.                 // Create the base insert statement.
  326.                 $query->insert($db->quoteName('#__content_rating'))
  327.                     ->columns(array($db->quoteName('content_id'), $db->quoteName('lastip'), $db->quoteName('rating_sum'), $db->quoteName('rating_count')))
  328.                     ->values((int) $pk . ', ' . $db->quote($userIP) . ',' . (int) $rate . ', 1');
  329.  
  330.                 // Set the query and execute the insert.
  331.                 $db->setQuery($query);
  332.  
  333.                 try
  334.                 {
  335.                     $db->execute();
  336.                 }
  337.                 catch (RuntimeException $e)
  338.                 {
  339.                     JError::raiseWarning(500, $e->getMessage());
  340.  
  341.                     return false;
  342.                 }
  343.             }
  344.             else
  345.             {
  346.                 if ($userIP != ($rating->lastip))
  347.                 {
  348.                     $query = $db->getQuery(true);
  349.  
  350.                     // Create the base update statement.
  351.                     $query->update($db->quoteName('#__content_rating'))
  352.                         ->set($db->quoteName('rating_count') . ' = rating_count + 1')
  353.                         ->set($db->quoteName('rating_sum') . ' = rating_sum + ' . (int) $rate)
  354.                         ->set($db->quoteName('lastip') . ' = ' . $db->quote($userIP))
  355.                         ->where($db->quoteName('content_id') . ' = ' . (int) $pk);
  356.  
  357.                     // Set the query and execute the update.
  358.                     $db->setQuery($query);
  359.  
  360.                     try
  361.                     {
  362.                         $db->execute();
  363.                     }
  364.                     catch (RuntimeException $e)
  365.                     {
  366.                         JError::raiseWarning(500, $e->getMessage());
  367.  
  368.                         return false;
  369.                     }
  370.                 }
  371.                 else
  372.                 {
  373.                     return false;
  374.                 }
  375.             }
  376.  
  377.             return true;
  378.         }
  379.  
  380.         JError::raiseWarning('SOME_ERROR_CODE', JText::sprintf('COM_CONTENT_INVALID_RATING', $rate), "JModelArticle::storeVote($rate)");
  381.  
  382.         return false;
  383.     }
  384. }

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