Source for file articles.php

Documentation is available at articles.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.  * This models supports retrieving lists of articles.
  14.  *
  15.  * @package     Joomla.Site
  16.  * @subpackage  com_content
  17.  * @since       1.6
  18.  */
  19. class ContentModelArticles extends JModelList
  20. {
  21.     /**
  22.      * Constructor.
  23.      *
  24.      * @param   array  $config  An optional associative array of configuration settings.
  25.      *
  26.      * @see     JController
  27.      * @since   1.6
  28.      */
  29.     public function __construct($config = array())
  30.     {
  31.         if (empty($config['filter_fields']))
  32.         {
  33.             $config['filter_fields'] = array(
  34.                 'id', 'a.id',
  35.                 'title', 'a.title',
  36.                 'alias', 'a.alias',
  37.                 'checked_out', 'a.checked_out',
  38.                 'checked_out_time', 'a.checked_out_time',
  39.                 'catid', 'a.catid', 'category_title',
  40.                 'state', 'a.state',
  41.                 'access', 'a.access', 'access_level',
  42.                 'created', 'a.created',
  43.                 'created_by', 'a.created_by',
  44.                 'ordering', 'a.ordering',
  45.                 'featured', 'a.featured',
  46.                 'language', 'a.language',
  47.                 'hits', 'a.hits',
  48.                 'publish_up', 'a.publish_up',
  49.                 'publish_down', 'a.publish_down',
  50.                 'images', 'a.images',
  51.                 'urls', 'a.urls',
  52.             );
  53.         }
  54.  
  55.         parent::__construct($config);
  56.     }
  57.  
  58.     /**
  59.      * Method to auto-populate the model state.
  60.      *
  61.      * This method should only be called once per instantiation and is designed
  62.      * to be called on the first call to the getState() method unless the model
  63.      * configuration flag to ignore the request is set.
  64.      *
  65.      * Note. Calling getState in this method will result in recursion.
  66.      *
  67.      * @param   string  $ordering   An optional ordering field.
  68.      * @param   string  $direction  An optional direction (asc|desc).
  69.      *
  70.      * @return  void 
  71.      *
  72.      * @since   12.2
  73.      */
  74.     protected function populateState($ordering = 'ordering', $direction = 'ASC')
  75.     {
  76.         $app = JFactory::getApplication();
  77.  
  78.         // List state information
  79.         $value = $app->input->get('limit', $app->getCfg('list_limit', 0), 'uint');
  80.         $this->setState('list.limit', $value);
  81.  
  82.         $value = $app->input->get('limitstart', 0, 'uint');
  83.         $this->setState('list.start', $value);
  84.  
  85.         $orderCol = $app->input->get('filter_order', 'a.ordering');
  86.  
  87.         if (!in_array($orderCol, $this->filter_fields))
  88.         {
  89.             $orderCol = 'a.ordering';
  90.         }
  91.  
  92.         $this->setState('list.ordering', $orderCol);
  93.  
  94.         $listOrder = $app->input->get('filter_order_Dir', 'ASC');
  95.  
  96.         if (!in_array(strtoupper($listOrder), array('ASC', 'DESC', '')))
  97.         {
  98.             $listOrder = 'ASC';
  99.         }
  100.  
  101.         $this->setState('list.direction', $listOrder);
  102.  
  103.         $params = $app->getParams();
  104.         $this->setState('params', $params);
  105.         $user = JFactory::getUser();
  106.  
  107.         if ((!$user->authorise('core.edit.state', 'com_content')) && (!$user->authorise('core.edit', 'com_content')))
  108.         {
  109.             // Filter on published for those who do not have edit or edit.state rights.
  110.             $this->setState('filter.published', 1);
  111.         }
  112.  
  113.         $this->setState('filter.language', JLanguageMultilang::isEnabled());
  114.  
  115.         // Process show_noauth parameter
  116.         if (!$params->get('show_noauth'))
  117.         {
  118.             $this->setState('filter.access', true);
  119.         }
  120.         else
  121.         {
  122.             $this->setState('filter.access', false);
  123.         }
  124.  
  125.         $this->setState('layout', $app->input->get('layout'));
  126.     }
  127.  
  128.     /**
  129.      * Method to get a store id based on model configuration state.
  130.      *
  131.      * This is necessary because the model is used by the component and
  132.      * different modules that might need different sets of data or different
  133.      * ordering requirements.
  134.      *
  135.      * @param   string  $id  A prefix for the store id.
  136.      *
  137.      * @return  string  A store id.
  138.      *
  139.      * @since   1.6
  140.      */
  141.     protected function getStoreId($id = '')
  142.     {
  143.         // Compile the store id.
  144.         $id .= ':' . serialize($this->getState('filter.published'));
  145.         $id .= ':' . $this->getState('filter.access');
  146.         $id .= ':' . $this->getState('filter.featured');
  147.         $id .= ':' . $this->getState('filter.article_id');
  148.         $id .= ':' . $this->getState('filter.article_id.include');
  149.         $id .= ':' . serialize($this->getState('filter.category_id'));
  150.         $id .= ':' . $this->getState('filter.category_id.include');
  151.         $id .= ':' . serialize($this->getState('filter.author_id'));
  152.         $id .= ':' . $this->getState('filter.author_id.include');
  153.         $id .= ':' . serialize($this->getState('filter.author_alias'));
  154.         $id .= ':' . $this->getState('filter.author_alias.include');
  155.         $id .= ':' . $this->getState('filter.date_filtering');
  156.         $id .= ':' . $this->getState('filter.date_field');
  157.         $id .= ':' . $this->getState('filter.start_date_range');
  158.         $id .= ':' . $this->getState('filter.end_date_range');
  159.         $id .= ':' . $this->getState('filter.relative_date');
  160.  
  161.         return parent::getStoreId($id);
  162.     }
  163.  
  164.     /**
  165.      * Get the master query for retrieving a list of articles subject to the model state.
  166.      *
  167.      * @return  JDatabaseQuery 
  168.      *
  169.      * @since   1.6
  170.      */
  171.     protected function getListQuery()
  172.     {
  173.         // Create a new query object.
  174.         $db = $this->getDbo();
  175.         $query = $db->getQuery(true);
  176.  
  177.         // Select the required fields from the table.
  178.         $query->select(
  179.             $this->getState(
  180.                 'list.select',
  181.                 'a.id, a.title, a.alias, a.introtext, a.fulltext, ' .
  182.                     'a.checked_out, a.checked_out_time, ' .
  183.                     'a.catid, a.created, a.created_by, a.created_by_alias, ' .
  184.                     // Use created if modified is 0
  185.                     'CASE WHEN a.modified = ' . $db->quote($db->getNullDate()) . ' THEN a.created ELSE a.modified END as modified, ' .
  186.                     'a.modified_by, uam.name as modified_by_name,' .
  187.                     // Use created if publish_up is 0
  188.                     'CASE WHEN a.publish_up = ' . $db->quote($db->getNullDate()) . ' THEN a.created ELSE a.publish_up END as publish_up,' .
  189.                     'a.publish_down, a.images, a.urls, a.attribs, a.metadata, a.metakey, a.metadesc, a.access, ' .
  190.                     'a.hits, a.xreference, a.featured,' . ' ' . $query->length('a.fulltext') . ' AS readmore'
  191.             )
  192.         );
  193.  
  194.         // Process an Archived Article layout
  195.         if ($this->getState('filter.published') == 2)
  196.         {
  197.             // If badcats is not null, this means that the article is inside an archived category
  198.             // In this case, the state is set to 2 to indicate Archived (even if the article state is Published)
  199.             $query->select($this->getState('list.select', 'CASE WHEN badcats.id is null THEN a.state ELSE 2 END AS state'));
  200.         }
  201.         else
  202.         {
  203.             /*
  204.             Process non-archived layout
  205.             If badcats is not null, this means that the article is inside an unpublished category
  206.             In this case, the state is set to 0 to indicate Unpublished (even if the article state is Published)
  207.             */
  208.             $query->select($this->getState('list.select', 'CASE WHEN badcats.id is not null THEN 0 ELSE a.state END AS state'));
  209.         }
  210.  
  211.         $query->from('#__content AS a');
  212.  
  213.         // Join over the frontpage articles.
  214.         if ($this->context != 'com_content.featured')
  215.         {
  216.             $query->join('LEFT', '#__content_frontpage AS fp ON fp.content_id = a.id');
  217.         }
  218.  
  219.         // Join over the categories.
  220.         $query->select('c.title AS category_title, c.path AS category_route, c.access AS category_access, c.alias AS category_alias')
  221.             ->join('LEFT', '#__categories AS c ON c.id = a.catid');
  222.  
  223.         // Join over the users for the author and modified_by names.
  224.         $query->select("CASE WHEN a.created_by_alias > ' ' THEN a.created_by_alias ELSE ua.name END AS author")
  225.             ->select("ua.email AS author_email")
  226.  
  227.             ->join('LEFT', '#__users AS ua ON ua.id = a.created_by')
  228.             ->join('LEFT', '#__users AS uam ON uam.id = a.modified_by');
  229.  
  230.         // Get contact id
  231.         $subQuery = $db->getQuery(true)
  232.             ->select('MAX(contact.id) AS id')
  233.             ->from('#__contact_details AS contact')
  234.             ->where('contact.published = 1')
  235.             ->where('contact.user_id = a.created_by');
  236.  
  237.             // Filter by language
  238.             if ($this->getState('filter.language'))
  239.             {
  240.                 $subQuery->where('(contact.language in (' . $db->quote(JFactory::getLanguage()->getTag()) . ',' . $db->quote('*') . ') OR contact.language IS NULL)');
  241.             }
  242.  
  243.         $query->select('(' . $subQuery . ') as contactid');
  244.  
  245.         // Join over the categories to get parent category titles
  246.         $query->select('parent.title as parent_title, parent.id as parent_id, parent.path as parent_route, parent.alias as parent_alias')
  247.             ->join('LEFT', '#__categories as parent ON parent.id = c.parent_id');
  248.  
  249.         // Join on voting table
  250.         $query->select('ROUND(v.rating_sum / v.rating_count, 0) AS rating, v.rating_count as rating_count')
  251.             ->join('LEFT', '#__content_rating AS v ON a.id = v.content_id');
  252.  
  253.         // Join to check for category published state in parent categories up the tree
  254.         $query->select('c.published, CASE WHEN badcats.id is null THEN c.published ELSE 0 END AS parents_published');
  255.         $subquery = 'SELECT cat.id as id FROM #__categories AS cat JOIN #__categories AS parent ';
  256.         $subquery .= 'ON cat.lft BETWEEN parent.lft AND parent.rgt ';
  257.         $subquery .= 'WHERE parent.extension = ' . $db->quote('com_content');
  258.  
  259.         if ($this->getState('filter.published') == 2)
  260.         {
  261.             // Find any up-path categories that are archived
  262.             // If any up-path categories are archived, include all children in archived layout
  263.             $subquery .= ' AND parent.published = 2 GROUP BY cat.id ';
  264.  
  265.             // Set effective state to archived if up-path category is archived
  266.             $publishedWhere = 'CASE WHEN badcats.id is null THEN a.state ELSE 2 END';
  267.         }
  268.         else
  269.         {
  270.             // Find any up-path categories that are not published
  271.             // If all categories are published, badcats.id will be null, and we just use the article state
  272.             $subquery .= ' AND parent.published != 1 GROUP BY cat.id ';
  273.  
  274.             // Select state to unpublished if up-path category is unpublished
  275.             $publishedWhere = 'CASE WHEN badcats.id is null THEN a.state ELSE 0 END';
  276.         }
  277.  
  278.         $query->join('LEFT OUTER', '(' . $subquery . ') AS badcats ON badcats.id = c.id');
  279.  
  280.         // Filter by access level.
  281.         if ($access = $this->getState('filter.access'))
  282.         {
  283.             $user = JFactory::getUser();
  284.             $groups = implode(',', $user->getAuthorisedViewLevels());
  285.             $query->where('a.access IN (' . $groups . ')')
  286.                 ->where('c.access IN (' . $groups . ')');
  287.         }
  288.  
  289.         // Filter by published state
  290.         $published = $this->getState('filter.published');
  291.  
  292.         if (is_numeric($published))
  293.         {
  294.             // Use article state if badcats.id is null, otherwise, force 0 for unpublished
  295.             $query->where($publishedWhere . ' = ' . (int) $published);
  296.         }
  297.         elseif (is_array($published))
  298.         {
  299.             JArrayHelper::toInteger($published);
  300.             $published = implode(',', $published);
  301.  
  302.             // Use article state if badcats.id is null, otherwise, force 0 for unpublished
  303.             $query->where($publishedWhere . ' IN (' . $published . ')');
  304.         }
  305.  
  306.         // Filter by featured state
  307.         $featured = $this->getState('filter.featured');
  308.  
  309.         switch ($featured)
  310.         {
  311.             case 'hide':
  312.                 $query->where('a.featured = 0');
  313.                 break;
  314.  
  315.             case 'only':
  316.                 $query->where('a.featured = 1');
  317.                 break;
  318.  
  319.             case 'show':
  320.             default:
  321.                 // Normally we do not discriminate
  322.                 // between featured/unfeatured items.
  323.                 break;
  324.         }
  325.  
  326.         // Filter by a single or group of articles.
  327.         $articleId = $this->getState('filter.article_id');
  328.  
  329.         if (is_numeric($articleId))
  330.         {
  331.             $type = $this->getState('filter.article_id.include', true) ? '= ' : '<> ';
  332.             $query->where('a.id ' . $type . (int) $articleId);
  333.         }
  334.         elseif (is_array($articleId))
  335.         {
  336.             JArrayHelper::toInteger($articleId);
  337.             $articleId = implode(',', $articleId);
  338.             $type = $this->getState('filter.article_id.include', true) ? 'IN' : 'NOT IN';
  339.             $query->where('a.id ' . $type . ' (' . $articleId . ')');
  340.         }
  341.  
  342.         // Filter by a single or group of categories
  343.         $categoryId = $this->getState('filter.category_id');
  344.  
  345.         if (is_numeric($categoryId))
  346.         {
  347.             $type = $this->getState('filter.category_id.include', true) ? '= ' : '<> ';
  348.  
  349.             // Add subcategory check
  350.             $includeSubcategories = $this->getState('filter.subcategories', false);
  351.             $categoryEquals = 'a.catid ' . $type . (int) $categoryId;
  352.  
  353.             if ($includeSubcategories)
  354.             {
  355.                 $levels = (int) $this->getState('filter.max_category_levels', '1');
  356.  
  357.                 // Create a subquery for the subcategory list
  358.                 $subQuery = $db->getQuery(true)
  359.                     ->select('sub.id')
  360.                     ->from('#__categories as sub')
  361.                     ->join('INNER', '#__categories as this ON sub.lft > this.lft AND sub.rgt < this.rgt')
  362.                     ->where('this.id = ' . (int) $categoryId);
  363.  
  364.                 if ($levels >= 0)
  365.                 {
  366.                     $subQuery->where('sub.level <= this.level + ' . $levels);
  367.                 }
  368.  
  369.                 // Add the subquery to the main query
  370.                 $query->where('(' . $categoryEquals . ' OR a.catid IN (' . $subQuery->__toString() . '))');
  371.             }
  372.             else
  373.             {
  374.                 $query->where($categoryEquals);
  375.             }
  376.         }
  377.         elseif (is_array($categoryId) && (count($categoryId) > 0))
  378.         {
  379.             JArrayHelper::toInteger($categoryId);
  380.             $categoryId = implode(',', $categoryId);
  381.  
  382.             if (!empty($categoryId))
  383.             {
  384.                 $type = $this->getState('filter.category_id.include', true) ? 'IN' : 'NOT IN';
  385.                 $query->where('a.catid ' . $type . ' (' . $categoryId . ')');
  386.             }
  387.         }
  388.  
  389.         // Filter by author
  390.         $authorId = $this->getState('filter.author_id');
  391.         $authorWhere = '';
  392.  
  393.         if (is_numeric($authorId))
  394.         {
  395.             $type = $this->getState('filter.author_id.include', true) ? '= ' : '<> ';
  396.             $authorWhere = 'a.created_by ' . $type . (int) $authorId;
  397.         }
  398.         elseif (is_array($authorId))
  399.         {
  400.             JArrayHelper::toInteger($authorId);
  401.             $authorId = implode(',', $authorId);
  402.  
  403.             if ($authorId)
  404.             {
  405.                 $type = $this->getState('filter.author_id.include', true) ? 'IN' : 'NOT IN';
  406.                 $authorWhere = 'a.created_by ' . $type . ' (' . $authorId . ')';
  407.             }
  408.         }
  409.  
  410.         // Filter by author alias
  411.         $authorAlias = $this->getState('filter.author_alias');
  412.         $authorAliasWhere = '';
  413.  
  414.         if (is_string($authorAlias))
  415.         {
  416.             $type = $this->getState('filter.author_alias.include', true) ? '= ' : '<> ';
  417.             $authorAliasWhere = 'a.created_by_alias ' . $type . $db->quote($authorAlias);
  418.         }
  419.         elseif (is_array($authorAlias))
  420.         {
  421.             $first = current($authorAlias);
  422.  
  423.             if (!empty($first))
  424.             {
  425.                 JArrayHelper::toString($authorAlias);
  426.  
  427.                 foreach ($authorAlias as $key => $alias)
  428.                 {
  429.                     $authorAlias[$key] = $db->quote($alias);
  430.                 }
  431.  
  432.                 $authorAlias = implode(',', $authorAlias);
  433.  
  434.                 if ($authorAlias)
  435.                 {
  436.                     $type = $this->getState('filter.author_alias.include', true) ? 'IN' : 'NOT IN';
  437.                     $authorAliasWhere = 'a.created_by_alias ' . $type . ' (' . $authorAlias .
  438.                         ')';
  439.                 }
  440.             }
  441.         }
  442.  
  443.         if (!empty($authorWhere) && !empty($authorAliasWhere))
  444.         {
  445.             $query->where('(' . $authorWhere . ' OR ' . $authorAliasWhere . ')');
  446.         }
  447.         elseif (empty($authorWhere) && empty($authorAliasWhere))
  448.         {
  449.             // If both are empty we don't want to add to the query
  450.         }
  451.         else
  452.         {
  453.             // One of these is empty, the other is not so we just add both
  454.             $query->where($authorWhere . $authorAliasWhere);
  455.         }
  456.  
  457.         // Filter by start and end dates.
  458.         $nullDate = $db->quote($db->getNullDate());
  459.         $nowDate = $db->quote(JFactory::getDate()->toSql());
  460.  
  461.         $query->where('(a.publish_up = ' . $nullDate . ' OR a.publish_up <= ' . $nowDate . ')')
  462.             ->where('(a.publish_down = ' . $nullDate . ' OR a.publish_down >= ' . $nowDate . ')');
  463.  
  464.         // Filter by Date Range or Relative Date
  465.         $dateFiltering = $this->getState('filter.date_filtering', 'off');
  466.         $dateField = $this->getState('filter.date_field', 'a.created');
  467.  
  468.         switch ($dateFiltering)
  469.         {
  470.             case 'range':
  471.                 $startDateRange = $db->quote($this->getState('filter.start_date_range', $nullDate));
  472.                 $endDateRange = $db->quote($this->getState('filter.end_date_range', $nullDate));
  473.                 $query->where(
  474.                     '(' . $dateField . ' >= ' . $startDateRange . ' AND ' . $dateField .
  475.                         ' <= ' . $endDateRange . ')'
  476.                 );
  477.                 break;
  478.  
  479.             case 'relative':
  480.                 $relativeDate = (int) $this->getState('filter.relative_date', 0);
  481.                 $query->where(
  482.                     $dateField . ' >= DATE_SUB(' . $nowDate . ', INTERVAL ' .
  483.                         $relativeDate . ' DAY)'
  484.                 );
  485.                 break;
  486.  
  487.             case 'off':
  488.             default:
  489.                 break;
  490.         }
  491.  
  492.         // Process the filter for list views with user-entered filters
  493.         $params = $this->getState('params');
  494.  
  495.         if ((is_object($params)) && ($params->get('filter_field') != 'hide') && ($filter = $this->getState('list.filter')))
  496.         {
  497.             // Clean filter variable
  498.             $filter = JString::strtolower($filter);
  499.             $hitsFilter = (int) $filter;
  500.             $filter = $db->quote('%' . $db->escape($filter, true) . '%', false);
  501.  
  502.             switch ($params->get('filter_field'))
  503.             {
  504.                 case 'author':
  505.                     $query->where(
  506.                         'LOWER( CASE WHEN a.created_by_alias > ' . $db->quote(' ') .
  507.                             ' THEN a.created_by_alias ELSE ua.name END ) LIKE ' . $filter . ' '
  508.                     );
  509.                     break;
  510.  
  511.                 case 'hits':
  512.                     $query->where('a.hits >= ' . $hitsFilter . ' ');
  513.                     break;
  514.  
  515.                 case 'title':
  516.                 default:
  517.                     // Default to 'title' if parameter is not valid
  518.                     $query->where('LOWER( a.title ) LIKE ' . $filter);
  519.                     break;
  520.             }
  521.         }
  522.  
  523.         // Filter by language
  524.         if ($this->getState('filter.language'))
  525.         {
  526.             $query->where('a.language in (' . $db->quote(JFactory::getLanguage()->getTag()) . ',' . $db->quote('*') . ')');
  527.         }
  528.  
  529.         // Add the list ordering clause.
  530.         $query->order($this->getState('list.ordering', 'a.ordering') . ' ' . $this->getState('list.direction', 'ASC'));
  531.  
  532.         return $query;
  533.     }
  534.  
  535.     /**
  536.      * Method to get a list of articles.
  537.      *
  538.      * Overriden to inject convert the attribs field into a JParameter object.
  539.      *
  540.      * @return  mixed  An array of objects on success, false on failure.
  541.      *
  542.      * @since   1.6
  543.      */
  544.     public function getItems()
  545.     {
  546.         $items = parent::getItems();
  547.         $user = JFactory::getUser();
  548.         $userId = $user->get('id');
  549.         $guest = $user->get('guest');
  550.         $groups = $user->getAuthorisedViewLevels();
  551.         $input = JFactory::getApplication()->input;
  552.  
  553.         // Get the global params
  554.         $globalParams = JComponentHelper::getParams('com_content', true);
  555.  
  556.         // Convert the parameter fields into objects.
  557.         foreach ($items as &$item)
  558.         {
  559.             $articleParams = new JRegistry;
  560.             $articleParams->loadString($item->attribs);
  561.  
  562.             // Unpack readmore and layout params
  563.             $item->alternative_readmore = $articleParams->get('alternative_readmore');
  564.             $item->layout = $articleParams->get('layout');
  565.  
  566.             $item->params = clone $this->getState('params');
  567.  
  568.             /*For blogs, article params override menu item params only if menu param = 'use_article'
  569.             Otherwise, menu item params control the layout
  570.             If menu item is 'use_article' and there is no article param, use global*/
  571.             if (($input->getString('layout') == 'blog') || ($input->getString('view') == 'featured')
  572.                 || ($this->getState('params')->get('layout_type') == 'blog'))
  573.             {
  574.                 // Create an array of just the params set to 'use_article'
  575.                 $menuParamsArray = $this->getState('params')->toArray();
  576.                 $articleArray = array();
  577.  
  578.                 foreach ($menuParamsArray as $key => $value)
  579.                 {
  580.                     if ($value === 'use_article')
  581.                     {
  582.                         // If the article has a value, use it
  583.                         if ($articleParams->get($key) != '')
  584.                         {
  585.                             // Get the value from the article
  586.                             $articleArray[$key] = $articleParams->get($key);
  587.                         }
  588.                         else
  589.                         {
  590.                             // Otherwise, use the global value
  591.                             $articleArray[$key] = $globalParams->get($key);
  592.                         }
  593.                     }
  594.                 }
  595.  
  596.                 // Merge the selected article params
  597.                 if (count($articleArray) > 0)
  598.                 {
  599.                     $articleParams = new JRegistry;
  600.                     $articleParams->loadArray($articleArray);
  601.                     $item->params->merge($articleParams);
  602.                 }
  603.             }
  604.             else
  605.             {
  606.                 // For non-blog layouts, merge all of the article params
  607.                 $item->params->merge($articleParams);
  608.             }
  609.  
  610.             // Get display date
  611.             switch ($item->params->get('list_show_date'))
  612.             {
  613.                 case 'modified':
  614.                     $item->displayDate = $item->modified;
  615.                     break;
  616.  
  617.                 case 'published':
  618.                     $item->displayDate = ($item->publish_up == 0) ? $item->created : $item->publish_up;
  619.                     break;
  620.  
  621.                 default:
  622.                 case 'created':
  623.                     $item->displayDate = $item->created;
  624.                     break;
  625.             }
  626.  
  627.             // Compute the asset access permissions.
  628.             // Technically guest could edit an article, but lets not check that to improve performance a little.
  629.             if (!$guest)
  630.             {
  631.                 $asset = 'com_content.article.' . $item->id;
  632.  
  633.                 // Check general edit permission first.
  634.                 if ($user->authorise('core.edit', $asset))
  635.                 {
  636.                     $item->params->set('access-edit', true);
  637.                 }
  638.  
  639.                 // Now check if edit.own is available.
  640.                 elseif (!empty($userId) && $user->authorise('core.edit.own', $asset))
  641.                 {
  642.                     // Check for a valid user and that they are the owner.
  643.                     if ($userId == $item->created_by)
  644.                     {
  645.                         $item->params->set('access-edit', true);
  646.                     }
  647.                 }
  648.             }
  649.  
  650.             $access = $this->getState('filter.access');
  651.  
  652.             if ($access)
  653.             {
  654.                 // If the access filter has been set, we already have only the articles this user can view.
  655.                 $item->params->set('access-view', true);
  656.             }
  657.             else
  658.             {
  659.                 // If no access filter is set, the layout takes some responsibility for display of limited information.
  660.                 if ($item->catid == 0 || $item->category_access === null)
  661.                 {
  662.                     $item->params->set('access-view', in_array($item->access, $groups));
  663.                 }
  664.                 else
  665.                 {
  666.                     $item->params->set('access-view', in_array($item->access, $groups) && in_array($item->category_access, $groups));
  667.                 }
  668.             }
  669.  
  670.             // Get the tags
  671.             $item->tags = new JHelperTags;
  672.             $item->tags->getItemTags('com_content.article', $item->id);
  673.         }
  674.  
  675.         return $items;
  676.     }
  677.  
  678.     /**
  679.      * Method to get the starting number of items for the data set.
  680.      *
  681.      * @return  integer  The starting number of items available in the data set.
  682.      *
  683.      * @since   12.2
  684.      */
  685.     public function getStart()
  686.     {
  687.         return $this->getState('list.start');
  688.     }
  689. }

Documentation generated on Tue, 19 Nov 2013 14:54:03 +0100 by phpDocumentor 1.4.3