b2evolution

Multilingual multiuser multiblog engine

Home About Demo Download Hosting Extend Docs Support
b2evolution Technical Documentation (Version 2.4) [ class tree: evocore ] [ index: evocore ] [ all elements ]

Source for file _itemlistlight.class.php

Documentation is available at _itemlistlight.class.php

  1. <?php
  2. /**
  3.  * This file implements the ItemListLight class.
  4.  *
  5.  * This object handles item/post/article lists WITHOUT FULL FUNCTIONNALITY
  6.  * but with a LOWER MEMORY FOOTPRINT.
  7.  *
  8.  * This file is part of the evoCore framework - {@link http://evocore.net/}
  9.  * See also {@link http://sourceforge.net/projects/evocms/}.
  10.  *
  11.  * @copyright (c)2003-2008 by Francois PLANQUE - {@link http://fplanque.net/}
  12.  *
  13.  *  {@internal License choice
  14.  *  - If you have received this file as part of a package, please find the license.txt file in
  15.  *    the same folder or the closest folder above for complete license terms.
  16.  *  - If you have received this file individually (e-g: from http://evocms.cvs.sourceforge.net/)
  17.  *    then you must choose one of the following licenses before using the file:
  18.  *    - GNU General Public License 2 (GPL) - http://www.opensource.org/licenses/gpl-license.php
  19.  *    - Mozilla Public License 1.1 (MPL) - http://www.opensource.org/licenses/mozilla1.1.php
  20.  *  }}}
  21.  *
  22.  *  {@internal Open Source relicensing agreement:
  23.  *  }}}
  24.  *
  25.  * @package evocore
  26.  *
  27.  *  {@internal Below is a list of authors who have contributed to design/coding of this file: }}
  28.  * @author fplanque: Francois PLANQUE.
  29.  *
  30.  * @version $Id: _itemlistlight.class.php,v 1.19.2.1 2009/03/16 11:33:12 tblue246 Exp $
  31.  */
  32. if( !defined('EVO_MAIN_INIT') ) die( 'Please, do not access this page directly.' );
  33.  
  34. load_class('_core/model/dataobjects/_dataobjectcache.class.php');
  35. load_class('_core/model/dataobjects/_dataobjectlist2.class.php');
  36. load_class('items/model/_item.class.php');
  37. load_funcs('items/model/_item.funcs.php');
  38.  
  39. /**
  40.  * Item List Class LIGHT
  41.  *
  42.  * Contrary to ItemList2, we only do 1 query here and we extract only a few selected params.
  43.  * Basically all we want is being able to generate permalinks.
  44.  *
  45.  * @package evocore
  46.  */
  47. class ItemListLight extends DataObjectList2
  48. {
  49.     /**
  50.      * SQL object for the Query
  51.      */
  52.     var $ItemQuery;
  53.  
  54.     /**
  55.      * Blog object this ItemList refers to
  56.      */
  57.     var $Blog;
  58.  
  59.     /**
  60.      * list unit: 'posts' or 'days'
  61.      */
  62.     var $unit;
  63.  
  64.     /**
  65.      * Did we request a single post?
  66.      */
  67.      var $single_post = false;
  68.  
  69.     /**
  70.      * Last date that has been output by date_if_changed()
  71.      */
  72.     var $last_displayed_date = '';
  73.  
  74.     /**
  75.      * Lazy filled
  76.      * @access private
  77.      */
  78.     var $advertised_start_date;
  79.     var $advertised_stop_date;
  80.     /**
  81.      * Anti infinite loops:
  82.      */
  83.     var $getting_adv_start_date = false;
  84.     var $getting_adv_stop_date = false;
  85.  
  86.     var $group_by_cat = 0;
  87.  
  88.  
  89.     /**
  90.      * Constructor
  91.      *
  92.      * @todo  add param for saved session filter set
  93.      *
  94.      * @param Blog 
  95.      * @param mixed Default filter set: Do not show posts before this timestamp, can be 'now'
  96.      * @param mixed Default filter set: Do not show posts after this timestamp, can be 'now'
  97.      * @param integer|NULLLimit
  98.      * @param string name of cache to be used (for table prefix info)
  99.      * @param string prefix to differentiate page/order params when multiple Results appear one same page
  100.      * @param array restrictions for itemlist (position, contact, firm, ...) key: restriction name, value: ID of the restriction
  101.      */
  102.     function ItemListLight(
  103.             & $Blog,
  104.             $timestamp_min = NULL,       // Do not show posts before this timestamp
  105.             $timestamp_max = NULL,            // Do not show posts after this timestamp
  106.             $limit = 20,
  107.             $cache_name = 'ItemCacheLight',     // name of cache to be used (for table prefix info)
  108.             $param_prefix = '',
  109.             $filterset_name = '',                // Name to be used when saving the filterset (leave empty to use default for collection)
  110.             $restrict_to = array()            // Restrict the item list to a position, or contact, firm..... /* not used yet(?) */
  111.         )
  112.     {
  113.         global $Settings;
  114.  
  115.         // Call parent constructor:
  116.         parent::DataObjectList2( get_Cache($cache_name), $limit, $param_prefix, NULL );
  117.  
  118.         // The SQL Query object:
  119.         $this->ItemQuery = & new ItemQuery( $this->Cache->dbtablename, $this->Cache->dbprefix, $this->Cache->dbIDname );
  120.  
  121.         $this->Blog = & $Blog;
  122.  
  123.         if( !empty( $filterset_name ) )
  124.         {    // Set the filterset_name with the filterset_name param
  125.             $this->filterset_name = 'ItemList_filters_'.$filterset_name;
  126.         }
  127.         else
  128.         {    // Set a generic filterset_name
  129.             $this->filterset_name = 'ItemList_filters_coll'.$this->Blog->ID;
  130.         }
  131.  
  132.         $this->page_param = $param_prefix.'paged';
  133.  
  134.         $this->restrict_to = $restrict_to;
  135.  
  136.         // Initialize the default filter set:
  137.         $this->set_default_filters( array(
  138.                 'filter_preset' => NULL,
  139.                 'ts_min' => $timestamp_min,
  140.                 'ts_max' => $timestamp_max,
  141.                 'ts_created_max' => NULL,
  142.                 'cat_array' => array(),
  143.                 'cat_modifier' => NULL,
  144.                 'cat_focus' => 'wide',                    // Search in extra categories, not just main cat
  145.                 'tags' => NULL,
  146.                 'authors' => NULL,
  147.                 'assignees' => NULL,
  148.                 'author_assignee' => NULL,
  149.                 'lc' => 'all',                                    // Filter on requested locale
  150.                 'keywords' => NULL,
  151.                 'phrase' => 'AND',
  152.                 'exact' => 0,
  153.                 'post_ID' => NULL,
  154.                 'post_ID_list' => NULL,
  155.                 'post_title' => NULL,
  156.                 'ymdhms' => NULL,
  157.                 'week' => NULL,
  158.                 'ymdhms_min' => NULL,
  159.                 'ymdhms_max' => NULL,
  160.                 'statuses' => NULL,
  161.                 'types' => '-1000',                            // All types except pages
  162.                 'visibility_array' => array( 'published', 'protected', 'private' ),
  163.                 'orderby' => $this->Blog->get_setting('orderby'),
  164.                 'order' => $this->Blog->get_setting('orderdir'),
  165.                 'unit' => $this->Blog->get_setting('what_to_show'),
  166.                 'posts' => $this->limit,
  167.                 'page' => 1,
  168.             ) );
  169.     }
  170.  
  171.  
  172.     /**
  173.      * Set default filter values we always want to use if not individually specified otherwise:
  174.      *
  175.      * @param array default filters to be merged with the class defaults
  176.      * @param array default filters for each preset, to be merged with general default filters if the preset is used
  177.      */
  178.     function set_default_filters( $default_filters, $preset_filters = array() )
  179.     {
  180.         $this->default_filters = array_merge( $this->default_filters, $default_filters );
  181.         $this->preset_filters = $preset_filters;
  182.     }
  183.  
  184.  
  185.     /**
  186.      * Set/Activate filterset
  187.      *
  188.      * This will also set back the GLOBALS !!! needed for regenerate_url().
  189.      *
  190.      * @param array 
  191.      * @param boolean 
  192.      */
  193.     function set_filters( $filters, $memorize = true )
  194.     {
  195.         if( !empty( $filters ) )
  196.         { // Activate the filterset (fallback to default filter when a value is not set):
  197.             $this->filters = array_merge( $this->default_filters, $filters );
  198.         }
  199.  
  200.         // Activate preset filters if necessary:
  201.         $this->activate_preset_filters();
  202.  
  203.         // Funky oldstyle params:
  204.         $this->limit = $this->filters['posts']; // for compatibility with parent class
  205.         $this->page = $this->filters['page'];
  206.  
  207.  
  208.         if( $memorize )
  209.         {    // set back the GLOBALS !!! needed for regenerate_url() :
  210.  
  211.             /*
  212.              * Selected filter preset:
  213.              */
  214.             memorize_param( $this->param_prefix.'filter_preset', 'string', $this->default_filters['filter_preset'], $this->filters['filter_preset'] );  // List of authors to restrict to
  215.  
  216.  
  217.             /*
  218.              * Blog & Chapters/categories restrictions:
  219.              */
  220.             // Get chapters/categories (and compile those values right away)
  221.             memorize_param( 'cat', '/^[*\-]?([0-9]+(,[0-9]+)*)?$/', $this->default_filters['cat_modifier'], $this->filters['cat_modifier'] );  // List of authors to restrict to
  222.             memorize_param( 'catsel', 'array', $this->default_filters['cat_array'], $this->filters['cat_array'] );
  223.             memorize_param( $this->param_prefix.'cat_focus', 'string', $this->default_filters['cat_focus'], $this->filters['cat_focus'] );  // Categories to search on
  224.             // TEMP until we get this straight:
  225.             // fp> this would only be used for the categories widget and setting it here overwtrites the interesting values when a post list widget is tirggered
  226.             // fp> if we need it here we want to use a $set_globals params to this function
  227.             // global $cat_array, $cat_modifier;
  228.             // $cat_array = $this->default_filters['cat_array'];
  229.             // $cat_modifier = $this->default_filters['cat_modifier'];
  230.  
  231.  
  232.             /*
  233.              * Restrict to selected tags:
  234.              */
  235.             memorize_param( $this->param_prefix.'tags', 'string', $this->default_filters['tags'], $this->filters['tags'] );
  236.  
  237.  
  238.             /*
  239.              * Restrict to selected authors:
  240.              */
  241.             memorize_param( $this->param_prefix.'author', 'string', $this->default_filters['authors'], $this->filters['authors'] );  // List of authors to restrict to
  242.  
  243.             /*
  244.              * Restrict to selected assignees:
  245.              */
  246.             memorize_param( $this->param_prefix.'assgn', 'string', $this->default_filters['assignees'], $this->filters['assignees'] );  // List of assignees to restrict to
  247.  
  248.             /*
  249.              * Restrict to selected author OR assignee:
  250.              */
  251.             memorize_param( $this->param_prefix.'author_assignee', 'string', $this->default_filters['author_assignee'], $this->filters['author_assignee'] );
  252.  
  253.             /*
  254.              * Restrict to selected locale:
  255.              */
  256.             memorize_param( $this->param_prefix.'lc', 'string', $this->default_filters['lc'], $this->filters['lc'] );  // Locale to restrict to
  257.  
  258.             /*
  259.              * Restrict to selected statuses:
  260.              */
  261.             memorize_param( $this->param_prefix.'status', 'string', $this->default_filters['statuses'], $this->filters['statuses'] );  // List of statuses to restrict to
  262.  
  263.             /*
  264.              * Restrict to selected item type:
  265.              */
  266.             memorize_param( $this->param_prefix.'types', 'integer', $this->default_filters['types'], $this->filters['types'] );  // List of item types to restrict to
  267.  
  268.             /*
  269.              * Restrict by keywords
  270.              */
  271.             memorize_param( $this->param_prefix.'s', 'string', $this->default_filters['keywords'], $this->filters['keywords'] );             // Search string
  272.             memorize_param( $this->param_prefix.'sentence', 'string', $this->default_filters['phrase'], $this->filters['phrase'] ); // Search for sentence or for words
  273.             memorize_param( $this->param_prefix.'exact', 'integer', $this->default_filters['exact'], $this->filters['exact'] );     // Require exact match of title or contents
  274.  
  275.             /*
  276.              * Specific Item selection?
  277.              */
  278.             memorize_param( $this->param_prefix.'m', '/^\d{4}(0[1-9]|1[0-2])?(?(1)(0[1-9]|[12][0-9]|3[01])?)(?(2)([01][0-9]|2[0-3])?)(?(3)([0-5][0-9]){0,2})$/', $this->default_filters['ymdhms'], $this->filters['ymdhms'] );          // YearMonth(Day) to display
  279.             memorize_param( $this->param_prefix.'w', '/^(0?[0-9]|[1-4][0-9]|5[0-3])$/', $this->default_filters['week'], $this->filters['week'] );            // Week number
  280.             memorize_param( $this->param_prefix.'dstart', 'integer', $this->default_filters['ymdhms_min'], $this->filters['ymdhms_min'] ); // YearMonth(Day) to start at
  281.             memorize_param( $this->param_prefix.'dstop', 'integer', $this->default_filters['ymdhms_max'], $this->filters['ymdhms_max'] ); // YearMonth(Day) to start at
  282.  
  283.             // TODO: show_past/future should probably be wired on dstart/dstop instead on timestamps -> get timestamps out of filter perimeter
  284.             if( is_null($this->default_filters['ts_min'])
  285.                 && is_null($this->default_filters['ts_max'] ) )
  286.             {    // We have not set a strict default -> we allow overridding:
  287.                 memorize_param( $this->param_prefix.'show_past', 'integer', 0, ($this->filters['ts_min'] == 'now') ? 0 : 1 );
  288.                 memorize_param( $this->param_prefix.'show_future', 'integer', 0, ($this->filters['ts_max'] == 'now') ? 0 : 1 );
  289.             }
  290.  
  291.             /*
  292.              * Restrict to the statuses we want to show:
  293.              */
  294.             // Note: oftentimes, $show_statuses will have been preset to a more restrictive set of values
  295.             memorize_param( $this->param_prefix.'show_statuses', 'array', $this->default_filters['visibility_array'], $this->filters['visibility_array'] );    // Array of sharings to restrict to
  296.  
  297.             /*
  298.              * OLD STYLE orders:
  299.              */
  300.             memorize_param( $this->param_prefix.'order', 'string', $this->default_filters['order'], $this->filters['order'] );           // ASC or DESC
  301.             memorize_param( $this->param_prefix.'orderby', 'string', $this->default_filters['orderby'], $this->filters['orderby'] );  // list of fields to order by (TODO: change that crap)
  302.  
  303.             /*
  304.              * Paging limits:
  305.              */
  306.             memorize_param( $this->param_prefix.'unit', 'string', $this->default_filters['unit'], $this->filters['unit'] );            // list unit: 'posts' or 'days'
  307.  
  308.             memorize_param( $this->param_prefix.'posts', 'integer', $this->default_filters['posts'], $this->filters['posts'] );             // # of units to display on the page
  309.  
  310.             // 'paged'
  311.             memorize_param( $this->page_param, 'integer', 1, $this->filters['page'] );      // List page number in paged display
  312.         }
  313.     }
  314.  
  315.  
  316.     /**
  317.      * Init filter params from Request params
  318.      *
  319.      * @param boolean do we want to use saved filters ?
  320.      * @return boolean true if we could apply a filterset based on Request params (either explicit or reloaded)
  321.      */
  322.     function load_from_Request( $use_filters = true )
  323.     {
  324.         // fp> 2007-09-23> Let's always start with clean filters.
  325.         // If we don't do this, then $this->filters will end up with filters in a different order than $this->default_filters.
  326.         // And orders are different, then $this->is_filtered() will say it's filtered even if it's not.
  327.         $this->filters = $this->default_filters;
  328.  
  329.         if( $use_filters )
  330.         {
  331.             // Do we want to restore filters or do we want to create a new filterset
  332.             $filter_action = param( $this->param_prefix.'filter', 'string', 'save' );
  333.             // echo ' filter action: ['.$filter_action.'] ';
  334.             switch( $filter_action )
  335.             {
  336.                 case 'restore':
  337.                     return $this->restore_filterset();
  338.                     /* BREAK */
  339.  
  340.                 case 'reset':
  341.                     // We want to reset the memorized filterset:
  342.                     global $Session;
  343.                     $Session->delete( $this->filterset_name );
  344.  
  345.                     // Memorize global variables:
  346.                     $this->set_filters( array(), true );
  347.  
  348.                     // We have applied no filterset:
  349.                     return false;
  350.                     /* BREAK */
  351.             }
  352.  
  353.             /**
  354.              * Filter preset
  355.              */
  356.             $this->filters['filter_preset'] = param( $this->param_prefix.'filter_preset', 'string', $this->default_filters['filter_preset'], true );
  357.  
  358.             // Activate preset default filters if necessary:
  359.             $this->activate_preset_filters();
  360.         }
  361.  
  362.  
  363.         // fp> TODO: param( 'loc', 'string', '', true );                            // Locale of the posts (all by default)
  364.  
  365.  
  366.         /*
  367.          * Blog & Chapters/categories restrictions:
  368.          */
  369.         // Get chapters/categories (and compile those values right away)
  370.         param_compile_cat_array( /* TODO: check $this->Blog->ID == 1 ? 0 :*/ $this->Blog->ID,
  371.                                 $this->default_filters['cat_modifier'], $this->default_filters['cat_array'] );
  372.  
  373.         $this->filters['cat_array'] = get_param( 'cat_array' );
  374.         $this->filters['cat_modifier'] = get_param( 'cat_modifier' );
  375.  
  376.         $this->filters['cat_focus'] = param( $this->param_prefix.'cat_focus', 'string', $this->default_filters['cat_focus'], true );
  377.  
  378.  
  379.         /*
  380.          * Restrict to selected tags:
  381.          */
  382.         $this->filters['tags'] = param( $this->param_prefix.'tag', 'string', $this->default_filters['tags'], true );
  383.  
  384.  
  385.         /*
  386.          * Restrict to selected authors:
  387.          */
  388.         $this->filters['authors'] = param( $this->param_prefix.'author', '/^-?[0-9]+(,[0-9]+)*$/', $this->default_filters['authors'], true );      // List of authors to restrict to
  389.  
  390.  
  391.         /*
  392.          * Restrict to selected assignees:
  393.          */
  394.         $this->filters['assignees'] = param( $this->param_prefix.'assgn', '/^(-|-[0-9]+|[0-9]+)(,[0-9]+)*$/', $this->default_filters['assignees'], true );      // List of assignees to restrict to
  395.  
  396.  
  397.         /*
  398.          * Restrict to selected author or assignee:
  399.          */
  400.         $this->filters['author_assignee'] = param( $this->param_prefix.'author_assignee', '/^[0-9]+$/', $this->default_filters['author_assignee'], true );
  401.  
  402.  
  403.         /*
  404.          * Restrict to selected locale:
  405.          */
  406.         $this->filters['lc'] = param( $this->param_prefix.'lc', 'string', $this->default_filters['lc'], true );
  407.  
  408.  
  409.         /*
  410.          * Restrict to selected statuses:
  411.          */
  412.         $this->filters['statuses'] = param( $this->param_prefix.'status', '/^(-|-[0-9]+|[0-9]+)(,[0-9]+)*$/', $this->default_filters['statuses'], true );      // List of statuses to restrict to
  413.  
  414.         /*
  415.          * Restrict to selected types:
  416.          */
  417.         $this->filters['types'] = param( $this->param_prefix.'types', '/^(-|-[0-9]+|[0-9]+)(,[0-9]+)*$/', $this->default_filters['types'], true );      // List of types to restrict to
  418.  
  419.  
  420.         /*
  421.          * Restrict by keywords
  422.          */
  423.         $this->filters['keywords'] = param( $this->param_prefix.'s', 'string', $this->default_filters['keywords'], true );         // Search string
  424.         $this->filters['phrase'] = param( $this->param_prefix.'sentence', 'string', $this->default_filters['phrase'], true );         // Search for sentence or for words
  425.         $this->filters['exact'] = param( $this->param_prefix.'exact', 'integer', $this->default_filters['exact'], true );        // Require exact match of title or contents
  426.  
  427.  
  428.         /*
  429.          * Specific Item selection?
  430.          */
  431.         $this->filters['post_ID'] = param( $this->param_prefix.'p', 'integer', $this->default_filters['post_ID'] );          // Specific post number to display
  432.         $this->filters['post_title'] = param( $this->param_prefix.'title', 'string', $this->default_filters['post_title'] );      // urtitle of post to display
  433.  
  434.  
  435.         /*
  436.          * multiple Item selection ?
  437.          */
  438.         $this->filters['post_ID_list'] = param( $this->param_prefix.'pl', 'string', $this->default_filters['post_ID_list'] );  // Specific list of post numbers to display
  439.  
  440.  
  441.         $this->single_post = !empty($this->filters['post_ID']) || !empty($this->filters['post_title']);
  442.  
  443.  
  444.         /*
  445.          * If a timeframe is specified in the querystring, restrict to that timeframe:
  446.          */
  447.         $this->filters['ymdhms'] = param( $this->param_prefix.'m', '/^\d{4}(0[1-9]|1[0-2])?(?(1)(0[1-9]|[12][0-9]|3[01])?)(?(2)([01][0-9]|2[0-3])?)(?(3)([0-5][0-9]){0,2})$/', $this->default_filters['ymdhms'], true );          // YearMonth(Day) to display
  448.         $this->filters['week'] = param( $this->param_prefix.'w', '/^(0?[0-9]|[1-4][0-9]|5[0-3])$/', $this->default_filters['week'], true );            // Week number
  449.  
  450.         $this->filters['ymdhms_min'] = param_compact_date( $this->param_prefix.'dstart', $this->default_filters['ymdhms_min'], true, T_( 'Invalid date' ) ); // YearMonth(Day) to start at
  451.         $this->filters['ymdhms_max'] = param_compact_date( $this->param_prefix.'dstop', $this->default_filters['ymdhms_max'], true, T_( 'Invalid date' ) ); // YearMonth(Day) to stop at
  452.  
  453.  
  454.         // TODO: show_past/future should probably be wired on dstart/dstop instead on timestamps -> get timestamps out of filter perimeter
  455.         // So far, these act as SILENT filters. They will not advertise their filtering in titles etc.
  456.         $this->filters['ts_min'] = $this->default_filters['ts_min'];
  457.         $this->filters['ts_max'] = $this->default_filters['ts_max'];
  458.         if( is_null($this->default_filters['ts_min'])
  459.             && is_null($this->default_filters['ts_max'] ) )
  460.         {    // We have not set a strict default -> we allow overridding:
  461.             $show_past = param( $this->param_prefix.'show_past', 'integer', 0, true );
  462.             $show_future = param( $this->param_prefix.'show_future', 'integer', 0, true );
  463.             if( $show_past != $show_future )
  464.             {    // There is a point in overridding:
  465.                 $this->filters['ts_min'] = ( $show_past == 0 ) ? 'now' : '';
  466.                 $this->filters['ts_max'] = ( $show_future == 0 ) ? 'now' : '';
  467.             }
  468.         }
  469.  
  470.         /*
  471.          * Restrict to the statuses we want to show:
  472.          */
  473.         // Note: oftentimes, $show_statuses will have been preset to a more restrictive set of values
  474.         $this->filters['visibility_array'] = param( $this->param_prefix.'show_statuses', 'array', $this->default_filters['visibility_array']
  475.                         , true, false, true, false );    // Array of sharings to restrict to
  476.  
  477.         /*
  478.          * Ordering:
  479.          */
  480.         $this->filters['order'] = param( $this->param_prefix.'order', '/^(ASC|asc|DESC|desc)$/', $this->default_filters['order'], true );        // ASC or DESC
  481.         $this->filters['orderby'] = param( $this->param_prefix.'orderby', '/^([A-Za-z0-9_]+([ ,][A-Za-z0-9_]+)*)?$/', $this->default_filters['orderby'], true );   // list of fields to order by (TODO: change that crap)
  482.  
  483.         /*
  484.          * Paging limits:
  485.          */
  486.         $this->filters['unit'] = param( $this->param_prefix.'unit', 'string', $this->default_filters['unit'], true );            // list unit: 'posts' or 'days'
  487.  
  488.         $this->filters['posts'] = param( $this->param_prefix.'posts', 'integer', $this->default_filters['posts'], true );             // # of units to display on the page
  489.         $this->limit = $this->filters['posts']; // for compatibility with parent class
  490.  
  491.         // 'paged'
  492.         $this->filters['page'] = param( $this->page_param, 'integer', 1, true );      // List page number in paged display
  493.         $this->page = $this->filters['page'];
  494.  
  495.         if( param_errors_detected() )
  496.         {
  497.             return false;
  498.         }
  499.  
  500.         if( $this->single_post )
  501.         {    // We have requested a specific post
  502.             // Do not attempt to save or load any filterset:
  503.             return true;
  504.         }
  505.  
  506.         //echo ' Got filters from URL?:'.($this->is_filtered() ? 'YES' : 'NO');
  507.         //pre_dump( $this->default_filters );
  508.         //pre_dump( $this->filters );
  509.  
  510.         if( $use_filters && $filter_action == 'save' )
  511.         {
  512.             $this->save_filterset();
  513.         }
  514.  
  515.         return true;
  516.     }
  517.  
  518.  
  519.     /**
  520.      * Activate preset default filters if necessary
  521.      *
  522.      */
  523.     function activate_preset_filters()
  524.     {
  525.         $filter_preset = $this->filters['filter_preset'];
  526.  
  527.         if( empty( $filter_preset ) )
  528.         { // No filter preset, there are no additional defaults to use:
  529.             return;
  530.         }
  531.  
  532.         // Override general defaults with the specific defaults for the preset:
  533.         $this->default_filters = array_merge( $this->default_filters, $this->preset_filters[$filter_preset] );
  534.  
  535.         // Save the name of the preset in order for is_filtered() to work properly:
  536.         $this->default_filters['filter_preset'] = $this->filters['filter_preset'];
  537.     }
  538.  
  539.  
  540.     /**
  541.      * Save current filterset to session.
  542.      */
  543.     function save_filterset()
  544.     {
  545.         /**
  546.          * @var Session
  547.          */
  548.         global $Session, $Debuglog;
  549.  
  550.         $Debuglog->add( 'Saving filterset <strong>'.$this->filterset_name.'</strong>', 'filters' );
  551.  
  552.         $Session->set( $this->filterset_name, $this->filters );
  553.     }
  554.  
  555.  
  556.     /**
  557.      * Load previously saved filterset from session.
  558.      *
  559.      * @return boolean true if we could restore something
  560.      */
  561.     function restore_filterset()
  562.     {
  563.       /**
  564.        * @var Session
  565.        */
  566.         global $Session;
  567.       /**
  568.        * @var Request
  569.        */
  570.  
  571.         global $Debuglog;
  572.  
  573.         $filters = $Session->get( $this->filterset_name );
  574.  
  575.         /*
  576.         fp> 2007-09-26> even if there are no filters, we need to "set" them in order to set global variables like $show_statuses
  577.         if( empty($filters) )
  578.         { // We have no saved filters:
  579.             return false;
  580.         }
  581.         */
  582.  
  583.         if( empty($filters) )
  584.         { // set_filters() expects array
  585.             $filters = array();
  586.         }
  587.  
  588.         $Debuglog->add( 'Restoring filterset <strong>'.$this->filterset_name.'</strong>', 'filters' );
  589.  
  590.         // Restore filters:
  591.         $this->set_filters( $filters );
  592.  
  593.         return true;
  594.     }
  595.  
  596.  
  597.     /**
  598.      *
  599.      *
  600.      * @todo count?
  601.      */
  602.     function query_init()
  603.     {
  604.         global $current_User;
  605.  
  606.         if( empty( $this->filters ) )
  607.         {    // Filters have not been set before, we'll use the default filterset:
  608.             // If there is a preset filter, we need to activate its specific defaults:
  609.             $this->filters['filter_preset'] = param( $this->param_prefix.'filter_preset', 'string', $this->default_filters['filter_preset'], true );
  610.             $this->activate_preset_filters();
  611.  
  612.             // Use the default filters:
  613.             $this->set_filters( $this->default_filters );
  614.         }
  615.  
  616.  
  617.         // echo '<br />ItemListLight query';
  618.         //pre_dump( $this->filters );
  619.  
  620.         // GENERATE THE QUERY:
  621.  
  622.         /*
  623.          * filtering stuff:
  624.          */
  625.         $this->ItemQuery->where_chapter2( $this->Blog, $this->filters['cat_array'], $this->filters['cat_modifier'],
  626.                                                                             $this->filters['cat_focus'] );
  627.         $this->ItemQuery->where_tags( $this->filters['tags'] );
  628.         $this->ItemQuery->where_author( $this->filters['authors'] );
  629.         $this->ItemQuery->where_assignees( $this->filters['assignees'] );
  630.         $this->ItemQuery->where_author_assignee( $this->filters['author_assignee'] );
  631.         $this->ItemQuery->where_locale( $this->filters['lc'] );
  632.         $this->ItemQuery->where_statuses( $this->filters['statuses'] );
  633.         $this->ItemQuery->where_types( $this->filters['types'] );
  634.         $this->ItemQuery->where_keywords( $this->filters['keywords'], $this->filters['phrase'], $this->filters['exact'] );
  635.         $this->ItemQuery->where_ID( $this->filters['post_ID'], $this->filters['post_title'] );
  636.         $this->ItemQuery->where_ID_list( $this->filters['post_ID_list'] );
  637.         $this->ItemQuery->where_datestart( $this->filters['ymdhms'], $this->filters['week'],
  638.                                            $this->filters['ymdhms_min'], $this->filters['ymdhms_max'],
  639.                                            $this->filters['ts_min'], $this->filters['ts_max'] );
  640.         $this->ItemQuery->where_datecreated( $this->filters['ts_created_max'] );
  641.         $this->ItemQuery->where_visibility( $this->filters['visibility_array'] );
  642.  
  643.         /*
  644.          * ORDER BY stuff:
  645.          */
  646.         $order = $this->filters['order'];
  647.         if( strtoupper( $order ) == 'RAND' )
  648.         {
  649.             $order_by = 'RAND()';
  650.         }
  651.         else
  652.         {
  653.             $orderby = str_replace( ' ', ',', $this->filters['orderby'] );
  654.             $orderby_array = explode( ',', $orderby );
  655.  
  656.             // Format each order param with default column names:
  657.             $orderby_array = preg_replace( '#^(.+)$#', $this->Cache->dbprefix.'$1 '.$order, $orderby_array );
  658.             // walter>fp> $order_cols_to_select = $orderby_array;
  659.  
  660.             // Add an ID parameter to make sure there is no ambiguity in ordering on similar items:
  661.             $orderby_array[] = $this->Cache->dbIDname.' '.$order;
  662.  
  663.             $order_by = implode( ', ', $orderby_array );
  664.         }
  665.  
  666.  
  667.         $this->ItemQuery->order_by( $order_by );
  668.  
  669.  
  670.  
  671.         /*
  672.          * GET TOTAL ROW COUNT:
  673.          */
  674.         if( $this->single_post )   // p or title
  675.         { // Single post: no paging required!
  676.             $this->total_rows = 1;
  677.             $this->total_pages = 1;
  678.             $this->page = 1;
  679.         }
  680.         /*
  681.         elseif( !empty($this->filters['ymdhms']) // no restriction if we request a month... some permalinks may point to the archive!
  682.         */
  683.         elseif( $this->filters['unit'] == 'days'    // We are going to limit to x days: no limit
  684.                   || $this->filters['unit'] == 'all' )     // We want ALL results!
  685.         {
  686.             $this->total_rows = NULL; // unknown!
  687.             $this->total_pages = 1;
  688.             $this->page = 1;
  689.         }
  690.         elseif( $this->filters['unit'] == 'posts' )
  691.         {
  692.             /*
  693.              * TODO: The result is incorrect when using AND on categories
  694.              * We would need to use a HAVING close and thyen COUNT, which would be a subquery
  695.              * This is nto compatible with mysql 3.23
  696.              * We need fallback code.
  697.              */
  698.             $sql_count = '
  699.                 SELECT COUNT( DISTINCT '.$this->Cache->dbIDname.') '
  700.                     .$this->ItemQuery->get_from()
  701.                     .$this->ItemQuery->get_where();
  702.  
  703.             //echo $DB->format_query( $sql_count );
  704.  
  705.             parent::count_total_rows( $sql_count );
  706.             //echo '<br />'.$this->total_rows;
  707.         }
  708.         else
  709.         {
  710.             debug_die( 'Unhandled LIMITING mode in ItemList:'.$this->filters['unit'].' (paged mode is obsolete)' );
  711.         }
  712.  
  713.  
  714.         /*
  715.          * Paging LIMITs:
  716.          */
  717.         if( $this->single_post )   // p or title
  718.         { // Single post: no paging required!
  719.         }
  720.         /*
  721.             fp> 2007-11-25 : a very high post count can now be configured in the admin for this. Default is 100.
  722.             elseif( !empty($this->filters['ymdhms']) )
  723.             { // no restriction if we request a month... some permalinks may point to the archive!
  724.                 // echo 'ARCHIVE - no limits';
  725.             }
  726.         */
  727.         elseif( $this->filters['unit'] == 'all' )
  728.         {    // We want ALL results!
  729.         }
  730.         elseif( $this->filters['unit'] == 'posts' )
  731.         {
  732.             // TODO: dh> check if $limit is NULL!? - though it should not arrive at $page>1 then..
  733.             // echo 'LIMIT POSTS ';
  734.             $pgstrt = '';
  735.             if( $this->page > 1 )
  736.             { // We have requested a specific page number
  737.                 $pgstrt = (intval($this->page) -1) * $this->limit. ', ';
  738.             }
  739.             $this->ItemQuery->LIMIT( $pgstrt.$this->limit );
  740.         }
  741.         elseif( $this->filters['unit'] == 'days' )
  742.         { // We are going to limit to x days:
  743.             // echo 'LIMIT DAYS ';
  744.             if( empty( $this->filters['ymdhms_min'] ) )
  745.             { // We have no start date, we'll display the last x days:
  746.                 if( !empty($this->filters['keywords'])
  747.                     || !empty($this->filters['cat_array'])
  748.                     || !empty($this->filters['authors']) )
  749.                 { // We are in DAYS mode but we can't restrict on these! (TODO: ?)
  750.                     $limits = '';
  751.                 }
  752.                 else
  753.                 { // We are going to limit to LAST x days:
  754.                     $lastpostdate = $this->get_lastpostdate();
  755.                     $lastpostdate = mysql2date('Y-m-d 00:00:00',$lastpostdate);
  756.                     $lastpostdate = mysql2date('U',$lastpostdate);
  757.                     // go back x days
  758.                     $otherdate = date('Y-m-d H:i:s', ($lastpostdate - (($this->limit-1) * 86400)));
  759.                     $this->ItemQuery->WHERE_and( $this->Cache->dbprefix.'datestart > \''. $otherdate.'\'' );
  760.                 }
  761.             }
  762.             else
  763.             { // We have a start date, we'll display x days starting from that point:
  764.                 // $dstart_mysql has been calculated earlier
  765.  
  766.                 // TODO: this is redundant with previous dstart processing:
  767.                 // Add trailing 0s: YYYYMMDDHHMMSS
  768.                 $dstart0 = $this->filters['ymdhms_min'].'00000000000000';
  769.  
  770.                 $dstart_mysql = substr($dstart0,0,4).'-'.substr($dstart0,4,2).'-'.substr($dstart0,6,2).' '
  771.                                                 .substr($dstart0,8,2).':'.substr($dstart0,10,2).':'.substr($dstart0,12,2);
  772.                 $dstart_ts = mysql2timestamp( $dstart_mysql );
  773.                 // go forward x days
  774.                 $enddate_ts = date('Y-m-d H:i:s', ($dstart_ts + ($this->limit * 86400)));
  775.                 $this->ItemQuery->WHERE_and( $this->Cache->dbprefix.'datestart < \''. $enddate_ts.'\'' );
  776.             }
  777.         }
  778.         else
  779.             debug_die( 'Unhandled LIMITING mode in ItemList:'.$this->filters['unit'].' (paged mode is obsolete)' );
  780.     }
  781.  
  782.  
  783.   /**
  784.      * Run Query: GET DATA ROWS *** LIGHT ***
  785.      *
  786.      * Contrary to ItemList2, we only do 1 query here and we extract only a few selected params.
  787.      * Basically all we want is being able to generate permalinks.
  788.      */
  789.     function query()
  790.     {
  791.         global $DB;
  792.  
  793.         if( !is_null( $this->rows ) )
  794.         { // Query has already executed:
  795.             return;
  796.         }
  797.  
  798.         // INNIT THE QUERY:
  799.         $this->query_init();
  800.  
  801.         // QUERY:
  802.         $this->sql = 'SELECT DISTINCT '.$this->Cache->dbIDname.', post_datestart, post_datemodified, post_title, post_url,
  803.                                     post_excerpt, post_urltitle, post_main_cat_ID, post_ptyp_ID '
  804.                                     .$this->ItemQuery->get_from()
  805.                                     .$this->ItemQuery->get_where()
  806.                                     .$this->ItemQuery->get_group_by()
  807.                                     .$this->ItemQuery->get_order_by()
  808.                                     .$this->ItemQuery->get_limit();
  809.  
  810.         // echo $DB->format_query( $this->sql );
  811.  
  812.         parent::query( false, false, false, 'ItemListLight::query()' );
  813.     }
  814.  
  815.  
  816.  
  817.  
  818.     /**
  819.      * Get datetime of the last post/item
  820.      * @todo dh> Optimize this, if this can be said after having done {@link query()} already.
  821.      * @todo dh> Cache result
  822.      * @todo dh> Add $dateformat param
  823.      * @return string 'Y-m-d H:i:s' formatted; If there are no items this will be {@link $localtimenow}.
  824.      */
  825.     function get_lastpostdate()
  826.     {
  827.         global $localtimenow, $DB;
  828.  
  829.         if( empty( $this->filters ) )
  830.         {    // Filters have no been set before, we'll use the default filterset:
  831.             // echo ' Query:Setting default filterset ';
  832.             $this->set_filters( $this->default_filters );
  833.         }
  834.  
  835.         // GENERATE THE QUERY:
  836.  
  837.         // The SQL Query object:
  838.         $lastpost_ItemQuery = & new ItemQuery( $this->Cache->dbtablename, $this->Cache->dbprefix, $this->Cache->dbIDname );
  839.  
  840.         /*
  841.          * filtering stuff:
  842.          */
  843.         $lastpost_ItemQuery->where_chapter2( $this->Blog, $this->filters['cat_array'], $this->filters['cat_modifier'],
  844.                                                                                  $this->filters['cat_focus']  );
  845.         $lastpost_ItemQuery->where_author( $this->filters['authors'] );
  846.         $lastpost_ItemQuery->where_assignees( $this->filters['assignees'] );
  847.         $lastpost_ItemQuery->where_locale( $this->filters['lc'] );
  848.         $lastpost_ItemQuery->where_statuses( $this->filters['statuses'] );
  849.         $lastpost_ItemQuery->where_types( $this->filters['types'] );
  850.         $lastpost_ItemQuery->where_keywords( $this->filters['keywords'], $this->filters['phrase'], $this->filters['exact'] );
  851.         $lastpost_ItemQuery->where_ID( $this->filters['post_ID'], $this->filters['post_title'] );
  852.         $lastpost_ItemQuery->where_datestart( $this->filters['ymdhms'], $this->filters['week'],
  853.                                            $this->filters['ymdhms_min'], $this->filters['ymdhms_max'],
  854.                                            $this->filters['ts_min'], $this->filters['ts_max'] );
  855.         $lastpost_ItemQuery->where_visibility( $this->filters['visibility_array'] );
  856.  
  857.         /*
  858.          * order by stuff:
  859.          * LAST POST FIRST!!! (That's the whole point!)
  860.          */
  861.         $lastpost_ItemQuery->order_by( $this->Cache->dbprefix.'datestart DESC' );
  862.  
  863.         /*
  864.          * Paging limits:
  865.          * ONLY THE LAST POST!!!
  866.          */
  867.         $lastpost_ItemQuery->LIMIT( '1' );
  868.  
  869.         // Select the datestart:
  870.         $lastpost_ItemQuery->select( $this->Cache->dbprefix.'datestart' );
  871.  
  872.         $lastpostdate = $DB->get_var( $lastpost_ItemQuery->get(), 0, 0, 'Get last post date' );
  873.  
  874.         if( empty( $lastpostdate ) )
  875.         {
  876.             // echo 'we have no last item';
  877.             $lastpostdate = date('Y-m-d H:i:s', $localtimenow);
  878.         }
  879.  
  880.         // echo $lastpostdate;
  881.  
  882.         return $lastpostdate;
  883.     }
  884.  
  885.  
  886.     /**
  887.      * Generate a title for the current list, depending on its filtering params
  888.      *
  889.      * @todo cleanup some displays
  890.      * @todo implement HMS part of YMDHMS
  891.      *
  892.      * @return array 
  893.      */
  894.     function get_filter_titles( $ignore = array(), $params = array() )
  895.     {
  896.         global $month, $post_statuses;
  897.  
  898.         $params = array_merge( array(
  899.                 'category_text' => T_('Category').': ',
  900.                 'categories_text' => T_('Categories').': ',
  901.                 // 'tag_text' => T_('Tag').': ',
  902.                 'tags_text' => T_('Tags').': ',
  903.             ), $params );
  904.  
  905.         if( empty( $this->filters ) )
  906.         {    // Filters have no been set before, we'll use the default filterset:
  907.             // echo ' setting default filterset ';
  908.             $this->set_filters( $this->default_filters );
  909.         }
  910.  
  911.         $title_array = array();
  912.  
  913.         if( $this->single_post )
  914.         {    // We have requested a specific post:
  915.             // Should be in first position
  916.             $Item = & $this->get_by_idx( 0 );
  917.  
  918.             if( is_null($Item) )
  919.             {
  920.                 $title_array[] = T_('Invalid request');
  921.             }
  922.             else
  923.             {
  924.                 $title_array[] = $Item->get('title');
  925.             }
  926.             return $title_array;
  927.         }
  928.  
  929.  
  930.         // CATEGORIES:
  931.         if( !empty($this->filters['cat_array']) )
  932.         { // We have requested specific categories...
  933.             $cat_names = array();
  934.             foreach( $this->filters['cat_array'] as $cat_ID )
  935.             {
  936.                 if( ($my_cat = get_the_category_by_ID( $cat_ID, false ) ) !== false )
  937.                 { // It is almost never meaningful to die over an invalid cat when generating title
  938.                     $cat_names[] = $my_cat['cat_name'];
  939.                 }
  940.             }
  941.             if( $this->filters['cat_modifier'] == '*' )
  942.             {
  943.                 $cat_names_string = implode( ' + ', $cat_names );
  944.             }
  945.             else
  946.             {
  947.                 $cat_names_string = implode( ', ', $cat_names );
  948.             }
  949.             if( !empty( $cat_names_string ) )
  950.             {
  951.                 if( $this->filters['cat_modifier'] == '-' )
  952.                 {
  953.                     $cat_names_string = T_('All but ').' '.$cat_names_string;
  954.                     $title_array['cats'] = $params['categories_text'].$cat_names_string;
  955.                 }
  956.                 else
  957.                 {
  958.                     if( count($this->filters['cat_array']) > 1 )
  959.                         $title_array['cats'] = $params['categories_text'].$cat_names_string;
  960.                     else
  961.                         $title_array['cats'] = $params['category_text'].$cat_names_string;
  962.                 }
  963.             }
  964.         }
  965.  
  966.  
  967.         // ARCHIVE TIMESLOT:
  968.         if( !empty($this->filters['ymdhms']) )
  969.         {    // We have asked for a specific timeframe:
  970.  
  971.             $my_year = substr($this->filters['ymdhms'],0,4);
  972.  
  973.             if( strlen($this->filters['ymdhms']) > 4 )
  974.             { // We have requested a month too:
  975.                 $my_month = T_($month[substr($this->filters['ymdhms'],4,2)]);
  976.             }
  977.             else
  978.             {
  979.                 $my_month = '';
  980.             }
  981.  
  982.             // Requested a day?
  983.             $my_day = substr($this->filters['ymdhms'],6,2);
  984.  
  985.             $arch = T_('Archives for').': '.$my_month.' '.$my_year;
  986.  
  987.             if( !empty( $my_day ) )
  988.             {    // We also want to display a day
  989.                 $arch .= ", $my_day";
  990.             }
  991.  
  992.             if( !empty($this->filters['week']) || ($this->filters['week'] === 0) ) // Note: week # can be 0
  993.             {    // We also want to display a week number
  994.                 $arch .= ', '.T_('week').' '.$this->filters['week'];
  995.             }
  996.  
  997.             $title_array['ymdhms'] = $arch;
  998.         }
  999.  
  1000.  
  1001.         // KEYWORDS:
  1002.         if( !empty($this->filters['keywords']) )
  1003.         {
  1004.             $title_array['keywords'] = T_('Keyword(s)').': '.$this->filters['keywords'];
  1005.         }
  1006.  
  1007.  
  1008.         // TAGS:
  1009.         if( !empty($this->filters['tags']) )
  1010.         {
  1011.             $title_array[] = $params['tags_text'].$this->filters['tags'];
  1012.         }
  1013.  
  1014.  
  1015.         // AUTHORS:
  1016.         if( !empty($this->filters['authors']) )
  1017.         {
  1018.             $title_array[] = T_('Author(s)').': '.$this->filters['authors'];
  1019.         }
  1020.  
  1021.  
  1022.         // ASSIGNEES:
  1023.         if( !empty($this->filters['assignees']) )
  1024.         {
  1025.             if( $this->filters['assignees'] == '-' )
  1026.             {
  1027.                 $title_array[] = T_('Not assigned');
  1028.             }
  1029.             else
  1030.             {
  1031.                 $title_array[] = T_('Assigned to').': '.$this->filters['assignees'];
  1032.             }
  1033.         }
  1034.  
  1035.  
  1036.         // LOCALE:
  1037.         if( $this->filters['lc'] != 'all' )
  1038.         {
  1039.             $title_array[] = T_('Locale').': '.$this->filters['lc'];
  1040.         }
  1041.  
  1042.  
  1043.         // EXTRA STATUSES:
  1044.         if( !empty($this->filters['statuses']) )
  1045.         {
  1046.             if( $this->filters['statuses'] == '-' )
  1047.             {
  1048.                 $title_array[] = T_('Without status');
  1049.             }
  1050.             else
  1051.             {
  1052.                 $title_array[] = T_('Status(es)').': '.$this->filters['statuses'];
  1053.             }
  1054.         }
  1055.  
  1056.  
  1057.         // SHOW STATUSES
  1058.         if( count( $this->filters['visibility_array'] ) < 5
  1059.             && !in_array( 'visibility', $ignore ) )
  1060.         {
  1061.             $status_titles = array();
  1062.             foreach( $this->filters['visibility_array'] as $status )
  1063.             {
  1064.                 $status_titles[] = T_( $post_statuses[$status] );
  1065.             }
  1066.             $title_array[] = T_('Visibility').': '.implode( ', ', $status_titles );
  1067.         }
  1068.  
  1069.  
  1070.         // START AT
  1071.         if( !empty($this->filters['ymdhms_min'] ) )
  1072.         {
  1073.             $title_array['ymdhms_min'] = T_('Start at').': '.$this->filters['ymdhms_min'] ;
  1074.         }
  1075.         if( !empty($this->filters['ts_min'] ) )
  1076.         {
  1077.             if( $this->filters['ts_min'] == 'now' )
  1078.             {
  1079.                 $title_array['ts_min'] = T_('Hide past');
  1080.             }
  1081.             else
  1082.             {
  1083.                 $title_array['ts_min'] = T_('Start at').': '.$this->filters['ts_min'];
  1084.             }
  1085.         }
  1086.  
  1087.  
  1088.         // STOP AT
  1089.         if( !empty($this->filters['ymdhms_max'] ) )
  1090.         {
  1091.             $title_array['ymdhms_max'] = T_('Stop at').': '.$this->filters['ymdhms_max'];
  1092.         }
  1093.         if( !empty($this->filters['ts_max'] ) )
  1094.         {
  1095.             if( $this->filters['ts_max'] == 'now' )
  1096.             {
  1097.                 if( !in_array( 'hide_future', $ignore ) )
  1098.                 {
  1099.                     $title_array['ts_max'] = T_('Hide future');
  1100.                 }
  1101.             }
  1102.             else
  1103.             {
  1104.                 $title_array['ts_max'] = T_('Stop at').': '.$this->filters['ts_max'];
  1105.             }
  1106.         }
  1107.  
  1108.  
  1109.         // LIMIT TO
  1110.         if( $this->single_post )   // p or title
  1111.         { // Single post: no paging required!
  1112.         }
  1113.         elseif( !empty($this->filters['ymdhms']) )
  1114.         { // no restriction if we request a month... some permalinks may point to the archive!
  1115.         }
  1116.         elseif( $this->filters['unit'] == 'posts' || $this->filters['unit'] == 'all' )
  1117.         { // We're going to page, so there's no real limit here...
  1118.         }
  1119.         elseif( $this->filters['unit'] == 'days' )
  1120.         { // We are going to limit to x days:
  1121.             // echo 'LIMIT DAYS ';
  1122.             if( empty( $this->filters['ymdhms_min'] ) )
  1123.             { // We have no start date, we'll display the last x days:
  1124.                 if( !empty($this->filters['keywords'])
  1125.                     || !empty($this->filters['cat_array'])
  1126.                     || !empty($this->filters['authors']) )
  1127.                 { // We are in DAYS mode but we can't restrict on these! (TODO: ?)
  1128.                 }
  1129.                 else
  1130.                 { // We are going to limit to LAST x days:
  1131.                     // TODO: rename 'posts' to 'limit'
  1132.                     $title_array['posts'] = sprintf( T_('Limited to %d last days'), $this->limit );
  1133.                 }
  1134.             }
  1135.             else
  1136.             { // We have a start date, we'll display x days starting from that point:
  1137.                 $title_array['posts'] = sprintf( T_('Limited to %d days'), $this->limit );
  1138.             }
  1139.         }
  1140.         else
  1141.             debug_die( 'Unhandled LIMITING mode in ItemList:'.$this->filters['unit'].' (paged mode is obsolete)' );
  1142.  
  1143.  
  1144.         return $title_array;
  1145.     }
  1146.  
  1147.  
  1148.     /**
  1149.      * return total number of posts
  1150.      *
  1151.      * This is basically just a stub for backward compatibility
  1152.      *
  1153.      * @deprecated
  1154.      */
  1155.     function get_total_num_posts()
  1156.     {
  1157.         return $this->total_rows;
  1158.     }
  1159.  
  1160.  
  1161.     /**
  1162.      * If the list is sorted by category...
  1163.      *
  1164.      * Note: this only supports one level of categories (nested cats will be flatened)
  1165.      */
  1166.     function & get_category_group()
  1167.     {
  1168.         global $row;
  1169.  
  1170.         if( empty( $this->current_Obj ) )
  1171.         {    // Very first call
  1172.             // Do a normal get_next()
  1173.             parent::get_next();
  1174.         }
  1175.  
  1176.         if( empty( $this->current_Obj ) )
  1177.         {    // We have reached the end of the list
  1178.             return $this->current_Obj;
  1179.         }
  1180.  
  1181.         $this->group_by_cat = 1;
  1182.  
  1183.         // Memorize main cat
  1184.         $this->main_cat_ID = $this->current_Obj->main_cat_ID;
  1185.  
  1186.         return $this->current_Obj;
  1187.     }
  1188.  
  1189.  
  1190.     /**
  1191.      * If the list is sorted by category...
  1192.       *
  1193.       * This is basically just a stub for backward compatibility
  1194.      */
  1195.     function & get_item()
  1196.     {
  1197.         if( $this->group_by_cat == 1 )
  1198.         {    // This is the first call to get_item() after get_category_group()
  1199.             $this->group_by_cat = 2;
  1200.             // Return the object we already got in get_category_group():
  1201.             return $this->current_Obj;
  1202.         }
  1203.  
  1204.         $Item = & $this->get_next();
  1205.  
  1206.         if( !empty($Item) && $this->group_by_cat == 2 && $Item->main_cat_ID != $this->main_cat_ID )
  1207.         {    // We have just hit a new category!
  1208.             $this->group_by_cat == 0; // For info only.
  1209.             $r = false;
  1210.             return $r;
  1211.         }
  1212.  
  1213.         //pre_dump( $Item );
  1214.  
  1215.         return $Item;
  1216.     }
  1217.  
  1218.  
  1219.     /**
  1220.      * Get the adverstised start date (does not include timestamp_min)
  1221.      *
  1222.      * Note: there is a priority order in the params to determine the start date:
  1223.      *  -dstart
  1224.      *  -week + m
  1225.      *  -m
  1226.      *  -dstop - x days
  1227.      * @see ItemQuery::where_datestart()
  1228.      */
  1229.     function get_advertised_start_date()
  1230.     {
  1231.         if( $this->getting_adv_start_date )
  1232.         {    // We would be entering an infinite loop, stop now:
  1233.             // We cannot determine a start date, save an empty string (to differentiate from NULL)
  1234.             $this->advertised_start_date = '';
  1235.  
  1236.             // Reset anti infinite loop:
  1237.             $this->getting_adv_start_date = false;
  1238.  
  1239.             return $this->advertised_start_date;
  1240.         }
  1241.  
  1242.         // Anti infinite loop:
  1243.         $this->getting_adv_start_date = true;
  1244.  
  1245.  
  1246.         if( is_null( $this->advertised_start_date ) )
  1247.         {    // We haven't determined the start date yet:
  1248.  
  1249.             if( !empty( $this->filters['ymdhms_min'] ) )
  1250.             {    // We have requested start date (8 digits)
  1251.                 $m = $this->filters['ymdhms_min'];
  1252.                 $this->advertised_start_date = mktime( 0, 0, 0, substr($m,4,2), substr($m,6,2), substr($m,0,4) );
  1253.             }
  1254.             elseif( !is_null($this->filters['week'])         // note: 0 is a valid week number
  1255.                         && !empty( $this->filters['ymdhms'] ) )
  1256.             {    // we want to restrict on a specific week
  1257.                 $this->advertised_start_date = get_start_date_for_week( substr($this->filters['ymdhms'],0,4), $this->filters['week'], locale_startofweek() );
  1258.             }
  1259.             elseif( strlen( $this->filters['ymdhms'] ) >= 4 )
  1260.             {    // We have requested an interval
  1261.                 $m = $this->filters['ymdhms'].'0101';
  1262.                 $this->advertised_start_date = mktime( 0, 0, 0, substr($m,4,2), substr($m,6,2), substr($m,0,4) );
  1263.             }
  1264.             elseif( $this->filters['unit'] == 'days'
  1265.                         && ($stop_date = $this->get_advertised_stop_date()) != '' )
  1266.             {    // We want to restrict on a specific number of days after the start date:
  1267.                 $this->advertised_start_date = $stop_date - ($this->limit-1) * 86400;
  1268.             }
  1269.             else
  1270.             {    // We cannot determine a start date, save an empty string (to differentiate from NULL)
  1271.                 $this->advertised_start_date = '';
  1272.             }
  1273.  
  1274.         }
  1275.  
  1276.         // Reset anti infinite loop:
  1277.         $this->getting_adv_start_date = false;
  1278.  
  1279.         return $this->advertised_start_date;
  1280.     }
  1281.  
  1282.  
  1283.     /**
  1284.      * Get the adverstised stop date (does not include timestamp_max)
  1285.      *
  1286.      * Note: there is a priority order in the params to determine the stop date.
  1287.      *  -dstop
  1288.      *  -week + m
  1289.      *  -m
  1290.      *  -dstart + x days
  1291.      */
  1292.     function get_advertised_stop_date()
  1293.     {
  1294.         if( $this->getting_adv_stop_date )
  1295.         {    // We would be entering an infinite loop, stop now:
  1296.             // We cannot determine a stop date, save an empty string (to differentiate from NULL)
  1297.             $this->advertised_stop_date = '';
  1298.  
  1299.             // Reset anti infinite loop:
  1300.             $this->getting_adv_stop_date = false;
  1301.  
  1302.             return $this->advertised_stop_date;
  1303.         }
  1304.  
  1305.         // Anti infinite loop:
  1306.         $this->getting_adv_stop_date = true;
  1307.  
  1308.  
  1309.         if( is_null( $this->advertised_stop_date ) )
  1310.         {    // We haven't determined the stop date yet:
  1311.  
  1312.             if( !empty( $this->filters['ymdhms_max'] ) )
  1313.             {    // We have requested an end date (8 digits)
  1314.                 $m = $this->filters['ymdhms_max'];
  1315.                 $this->advertised_stop_date = mktime( 0, 0, 0, substr($m,4,2), substr($m,6,2), substr($m,0,4) );
  1316.             }
  1317.             elseif( !is_null($this->filters['week'])         // note: 0 is a valid week number
  1318.                         && !empty( $this->filters['ymdhms'] ) )
  1319.             {    // we want to restrict on a specific week
  1320.                 $this->advertised_stop_date = get_start_date_for_week( substr($this->filters['ymdhms'],0,4), $this->filters['week'], locale_startofweek() );
  1321.                 $this->advertised_stop_date += 518400; // + 6 days
  1322.             }
  1323.             elseif( !empty( $this->filters['ymdhms'] ) )
  1324.             {    // We want to restrict on an interval:
  1325.                 if( strlen( $this->filters['ymdhms'] ) >= 8 )
  1326.                 {    // We have requested a day interval
  1327.                     $m = $this->filters['ymdhms'];
  1328.                     $this->advertised_stop_date = mktime( 0, 0, 0, substr($m,4,2), substr($m,6,2), substr($m,0,4) );
  1329.                 }
  1330.                 elseif( strlen( $this->filters['ymdhms'] ) == 6 )
  1331.                 { // We want to go to the end of the month:
  1332.                     $m = $this->filters['ymdhms'];
  1333.                     $this->advertised_stop_date = mktime( 0, 0, 0, substr($m,4,2)+1, 0, substr($m,0,4) ); // 0th day of next mont = last day of month
  1334.                 }
  1335.                 elseif( strlen( $this->filters['ymdhms'] ) == 4 )
  1336.                 { // We want to go to the end of the year:
  1337.                     $m = $this->filters['ymdhms'];
  1338.                     $this->advertised_stop_date = mktime( 0, 0, 0, 12, 31, substr($m,0,4) );
  1339.                 }
  1340.             }
  1341.             elseif( $this->filters['unit'] == 'days'
  1342.                         && ($start_date = $this->get_advertised_start_date()) != '' )
  1343.             {    // We want to restrict on a specific number of days after the start date:
  1344.                 $this->advertised_stop_date = $start_date + ($this->limit-1) * 86400;
  1345.             }
  1346.             else
  1347.             {    // We cannot determine a stop date, save an empty string (to differentiate from NULL)
  1348.                 $this->advertised_stop_date = '';
  1349.             }
  1350.  
  1351.         }
  1352.  
  1353.         // Reset anti infinite loop:
  1354.         $this->getting_adv_stop_date = false;
  1355.  
  1356.         return $this->advertised_stop_date;
  1357.     }
  1358.  
  1359.  
  1360.     /**
  1361.      * Make sure date displaying starts at the beginning of the current filter interval
  1362.      *
  1363.      * Note: we're talking about strict dates (no times involved)
  1364.      */
  1365.     function set_start_date( )
  1366.     {
  1367.         $start_date = $this->get_advertised_start_date();
  1368.  
  1369.         if( !empty( $start_date ) )
  1370.         {    // Memorize the last displayed as the day BEFORE the one we're going to display
  1371.             //echo ' start at='.date( locale_datefmt(), $start_date );
  1372.             $this->last_displayed_date = $start_date - 86400;
  1373.         }
  1374.     }
  1375.  
  1376.  
  1377.     /**
  1378.      * Template function: display potentially remaining empty days until the end of the filter interval
  1379.      *
  1380.      * @param string string to display before the date (if changed)
  1381.      * @param string string to display after the date (if changed)
  1382.      * @param string date/time format: leave empty to use locale default time format
  1383.      */
  1384.     function dates_to_end( $before_empty_day = '<h2>', $after_empty_day = '</h2>', $format = '' )
  1385.     {
  1386.         $stop_date = $this->get_advertised_stop_date();
  1387.  
  1388.         if( !is_null( $stop_date ) )
  1389.         {    // There is a stop date, we want to display days:
  1390.             //echo ' - stop at='.date( locale_datefmt(), $stop_date );
  1391.             //echo ' - last displayed='.date( locale_datefmt(), $this->last_displayed_date );
  1392.             while( $this->last_displayed_date < $stop_date )
  1393.             {
  1394.                 $this->last_displayed_date += 86400;    // Add one day's worth of seconds
  1395.                 echo date_sprintf( $before_empty_day, $this->last_displayed_date )
  1396.                         .date_i18n( $format, $this->last_displayed_date )
  1397.                         .date_sprintf( $after_empty_day, $this->last_displayed_date );
  1398.             }
  1399.         }
  1400.     }
  1401.  
  1402.  
  1403.     /**
  1404.      * Template tag: Display the date if it has changed since last call
  1405.      *
  1406.      * Optionally also displays empty dates in between.
  1407.      *
  1408.      * @param array 
  1409.      */
  1410.     function date_if_changed( $params = array() )
  1411.     {
  1412.         if( $this->current_Obj->ptyp_ID == 1000 )
  1413.         {    // This is not applicable to pages
  1414.             return;
  1415.         }
  1416.  
  1417.         // Make sure we are not missing any param:
  1418.         $params = array_merge( array(
  1419.                 'before'      => '<h2>',
  1420.                 'after'       => '</h2>',
  1421.                 'empty_day_display' => false,
  1422.                 'empty_day_before' => '<h2>',
  1423.                 'empty_day_after'  => '</h2>',
  1424.                 'date_format' => '#',
  1425.             ), $params );
  1426.  
  1427.         // Get a timestamp for the date WITHOUT the time:
  1428.         $current_item_date = mysql2datestamp( $this->current_Obj->issue_date );
  1429.  
  1430.         if( $current_item_date != $this->last_displayed_date )
  1431.         {    // Date has changed...
  1432.  
  1433.  
  1434.             if( $params['date_format'] == '#' )
  1435.             {    // No format specified, use default locale format:
  1436.                 $params['date_format'] = locale_datefmt();
  1437.             }
  1438.  
  1439.             if( $params['empty_day_display'] && !empty($this->last_displayed_date) )
  1440.             {    // We want to display ALL dates from the previous to the current:
  1441.                 while( $this->last_displayed_date < $current_item_date-86400 )
  1442.                 {
  1443.                     $this->last_displayed_date += 86400;    // Add one day's worth of seconds
  1444.                     echo date_sprintf( $params['empty_day_before'], $this->last_displayed_date )
  1445.                             .date_i18n( $params['date_format'], $this->last_displayed_date )
  1446.                             .date_sprintf( $params['empty_day_after'], $this->last_displayed_date );
  1447.                 }
  1448.             }
  1449.  
  1450.             // Display the new current date:
  1451.             echo date_sprintf( $params['before'], $this->last_displayed_date )
  1452.                     .date_i18n( $params['date_format'], $current_item_date )
  1453.                     .date_sprintf( $params['after'], $this->last_displayed_date );
  1454.  
  1455.             $this->last_displayed_date = $current_item_date;
  1456.         }
  1457.     }
  1458.  
  1459.  
  1460.     /**
  1461.      * Template tag
  1462.      */
  1463.     function page_links( $params = array() )
  1464.     {
  1465.         global $generating_static;
  1466.  
  1467.         $default_params = array(
  1468.                 'block_start' => '<p class="center">',
  1469.                 'block_end' => '</p>',
  1470.                 'block_single' => '',
  1471.                 'links_format' => '#',
  1472.                 'page_url' => '', // All generated links will refer to the current page
  1473.                 'prev_text' => '&lt;&lt;',
  1474.                 'next_text' => '&gt;&gt;',
  1475.                 'no_prev_text' => '',
  1476.                 'no_next_text' => '',
  1477.                 'list_prev_text' => '...',
  1478.                 'list_next_text' => '...',
  1479.                 'list_span' => 11,
  1480.                 'scroll_list_range' => 5,
  1481.             );
  1482.       if( !empty($generating_static) )
  1483.       {    // When generating a static page, act as if we were currently on the blog main page:
  1484.           $default_params['page_url'] = $this->Blog->get('url');
  1485.         }
  1486.  
  1487.         // Use defaults + overrides:
  1488.         $params = array_merge( $default_params, $params );
  1489.  
  1490.         if( $this->total_pages <= 1 )
  1491.         {    // Single page:
  1492.             echo $params['block_single'];
  1493.             return;
  1494.         }
  1495.  
  1496.         if( $params['links_format'] == '#' )
  1497.         {
  1498.             $params['links_format'] = '$prev$ $first$ $list_prev$ $list$ $list_next$ $last$ $next$';
  1499.         }
  1500.  
  1501.          if( $this->Blog->get_setting( 'paged_nofollowto' ) )
  1502.         {    // We prefer robots not to follow to pages:
  1503.             $this-> nofollow_pagenav = true;
  1504.         }
  1505.  
  1506.         echo $params['block_start'];
  1507.         echo $this->replace_vars( $params['links_format'], $params );
  1508.         echo $params['block_end'];
  1509.     }
  1510.  
  1511.  
  1512. }
  1513.  
  1514. /*
  1515.  * $Log: _itemlistlight.class.php,v $
  1516.  * Revision 1.19.2.1  2009/03/16 11:33:12  tblue246
  1517.  * Validate w and m params -> fix possible PHP notice
  1518.  *
  1519.  * Revision 1.19  2008/01/21 09:35:31  fplanque
  1520.  * (c) 2008
  1521.  *
  1522.  * Revision 1.18  2007/12/26 23:12:00  yabs
  1523.  * changing RANDOM to RAND
  1524.  *
  1525.  * Revision 1.17  2007/12/26 17:53:24  fplanque
  1526.  * minor
  1527.  *
  1528.  * Revision 1.16  2007/12/26 11:27:47  yabs
  1529.  * added post_ID_list to filters
  1530.  *
  1531.  * Revision 1.15  2007/12/24 10:37:19  yabs
  1532.  * adding random order
  1533.  *
  1534.  * Revision 1.14  2007/11/27 22:31:57  fplanque
  1535.  * debugged blog moderation
  1536.  *
  1537.  * Revision 1.13  2007/11/25 14:28:17  fplanque
  1538.  * additional SEO settings
  1539.  *
  1540.  * Revision 1.12  2007/11/24 21:41:12  fplanque
  1541.  * additional SEO settings
  1542.  *
  1543.  * Revision 1.11  2007/11/11 23:43:37  blueyed
  1544.  * Proper fix for array_merge warnings (http://forums.b2evolution.net/viewtopic.php?t=12944); Props Afwas
  1545.  *
  1546.  * Revision 1.10  2007/11/03 21:04:27  fplanque
  1547.  * skin cleanup
  1548.  *
  1549.  * Revision 1.9  2007/11/01 03:19:34  blueyed
  1550.  * Fix for array_merge in PHP5, props yettyn
  1551.  *
  1552.  * Revision 1.8  2007/10/10 09:02:36  fplanque
  1553.  * PHP5 fix
  1554.  *
  1555.  * Revision 1.7  2007/10/01 01:06:31  fplanque
  1556.  * Skin/template functions cleanup.
  1557.  *
  1558.  * Revision 1.6  2007/09/26 20:26:36  fplanque
  1559.  * improved ItemList filters
  1560.  *
  1561.  * Revision 1.5  2007/09/23 18:57:15  fplanque
  1562.  * filter handling fixes
  1563.  *
  1564.  * Revision 1.4  2007/09/19 20:03:18  yabs
  1565.  * minor bug fix ( http://forums.b2evolution.net/viewtopic.php?p=60493#60493 )
  1566.  *
  1567.  * Revision 1.3  2007/09/03 16:46:58  fplanque
  1568.  * minor
  1569.  *
  1570.  * Revision 1.2  2007/06/29 00:24:43  fplanque
  1571.  * $cat_array cleanup tentative
  1572.  *
  1573.  * Revision 1.1  2007/06/25 11:00:27  fplanque
  1574.  * MODULES (refactored MVC)
  1575.  *
  1576.  * Revision 1.8  2007/06/21 00:44:37  fplanque
  1577.  * linkblog now a widget
  1578.  *
  1579.  * Revision 1.7  2007/05/27 00:35:26  fplanque
  1580.  * tag display + tag filtering
  1581.  *
  1582.  * Revision 1.6  2007/05/13 22:53:31  fplanque
  1583.  * allow feeds restricted to post excerpts
  1584.  *
  1585.  * Revision 1.5  2007/05/13 22:02:09  fplanque
  1586.  * removed bloated $object_def
  1587.  *
  1588.  * Revision 1.4  2007/03/26 14:21:30  fplanque
  1589.  * better defaults for pages implementation
  1590.  *
  1591.  * Revision 1.3  2007/03/26 12:59:18  fplanque
  1592.  * basic pages support
  1593.  *
  1594.  * Revision 1.2  2007/03/19 21:57:36  fplanque
  1595.  * ItemLists: $cat_focus and $unit extensions
  1596.  *
  1597.  * Revision 1.1  2007/03/18 03:43:19  fplanque
  1598.  * EXPERIMENTAL
  1599.  * Splitting Item/ItemLight and ItemList/ItemListLight
  1600.  * Goal: Handle Items with less footprint than with their full content
  1601.  * (will be even worse with multiple languages/revisions per Item)
  1602.  *
  1603.  * Revision 1.53  2007/03/18 01:39:54  fplanque
  1604.  * renamed _main.php to main.page.php to comply with 2.0 naming scheme.
  1605.  * (more to come)
  1606.  *
  1607.  * Revision 1.52  2007/03/12 14:02:41  waltercruz
  1608.  * Adding the columns in order by to the query to satisfy the SQL Standarts
  1609.  *
  1610.  * Revision 1.51  2007/03/03 03:37:56  fplanque
  1611.  * extended prev/next item links
  1612.  *
  1613.  * Revision 1.50  2007/03/03 01:14:12  fplanque
  1614.  * new methods for navigating through posts in single item display mode
  1615.  *
  1616.  * Revision 1.49  2007/01/26 04:49:17  fplanque
  1617.  * cleanup
  1618.  *
  1619.  * Revision 1.48  2007/01/23 09:25:40  fplanque
  1620.  * Configurable sort order.
  1621.  *
  1622.  * Revision 1.47  2007/01/20 23:05:11  blueyed
  1623.  * todos
  1624.  *
  1625.  * Revision 1.46  2007/01/19 21:48:09  blueyed
  1626.  * Fixed possible notice in preview_from_request()
  1627.  *
  1628.  * Revision 1.45  2006/12/17 23:42:38  fplanque
  1629.  * Removed special behavior of blog #1. Any blog can now aggregate any other combination of blogs.
  1630.  * Look into Advanced Settings for the aggregating blog.
  1631.  * There may be side effects and new bugs created by this. Please report them :]
  1632.  *
  1633.  * Revision 1.44  2006/12/05 00:01:15  fplanque
  1634.  * enhanced photoblog skin
  1635.  *
  1636.  * Revision 1.43  2006/12/04 18:16:50  fplanque
  1637.  * Each blog can now have its own "number of page/days to display" settings
  1638.  *
  1639.  * Revision 1.42  2006/11/28 00:33:01  blueyed
  1640.  * Removed DB::compString() (never used) and DB::get_list() (just a macro and better to have in the 4 used places directly; Cleanup/normalization; no extended regexp, when not needed!
  1641.  *
  1642.  * Revision 1.41  2006/11/24 18:27:24  blueyed
  1643.  * Fixed link to b2evo CVS browsing interface in file docblocks
  1644.  *
  1645.  * Revision 1.40  2006/11/17 00:19:22  blueyed
  1646.  * Switch to user locale for validating item_issue_date, because it uses T_()
  1647.  *
  1648.  * Revision 1.39  2006/11/17 00:09:15  blueyed
  1649.  * TODO: error/E_NOTICE with invalid issue date
  1650.  *
  1651.  * Revision 1.38  2006/11/12 02:13:19  blueyed
  1652.  * doc, whitespace
  1653.  *
  1654.  * Revision 1.37  2006/11/11 17:33:50  blueyed
  1655.  * doc
  1656.  *
  1657.  * Revision 1.36  2006/11/04 19:38:53  blueyed
  1658.  * Fixes for hook move
  1659.  *
  1660.  * Revision 1.35  2006/11/02 16:00:42  blueyed
  1661.  * Moved AppendItemPreviewTransact hook, so it can throw error messages
  1662.  *
  1663.  * Revision 1.34  2006/10/31 00:33:26  blueyed
  1664.  * Fixed item_issue_date for preview
  1665.  *
  1666.  * Revision 1.33  2006/10/10 17:09:39  blueyed
  1667.  * doc
  1668.  *
  1669.  * Revision 1.32  2006/10/08 22:35:01  blueyed
  1670.  * TODO: limit===NULL handling
  1671.  *
  1672.  * Revision 1.31  2006/10/05 01:17:36  blueyed
  1673.  * Removed unnecessary/doubled call to Item::update_renderers_from_Plugins()
  1674.  *
  1675.  * Revision 1.30  2006/10/05 01:06:36  blueyed
  1676.  * Removed dirty "hack"; added ItemApplyAsRenderer hook instead.
  1677.  */
  1678. ?>
evocore

Packages

main
admin
admin-skin
conf
evocore
evoskins
htsrv
install
libs
plugins
xmlsrv

Documentation generated on Sat, 06 Mar 2010 03:36:11 +0100 by phpDocumentor 1.4.2. This site is hosted and maintained by Daniel HAHLER (Contact).