dblist.php
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Wed, Jun 25, 1:04 PM

dblist.php
View Options

	<?php

	/**
	* DBList
	*
	* Desciption
	* @package kernel4
	*/
	class kDBList extends kDBBase {


	/**
	* Holds totals for fields specified in config
	*
	* @var Array
	*/
	var $Totals = Array();

	/**
	* Description
	*
	* @var array
	* @access public
	*/
	var $OrderFields;

	/**
	* Holds counted total number of records in the query - without pagination (system+user filters)
	*
	* @var int
	* @access public
	*/
	var $RecordsCount;


	/**
	* Records count with system filters only applied
	*
	* @var int
	* @access private
	*/
	var $NoFilterCount = 0;

	/**
	* Record count selected to be
	* showed on current page
	*
	* @var int
	*/
	var $SelectedCount=0;

	/**
	* Array of records selected
	*
	* @var Array
	* @access private
	*/
	var $Records;

	var $CurrentIndex = 0;

	/**
	* List items per-page
	*
	* @var int
	* @access public
	*/
	var $PerPage;

	/**
	* Pages count in list based on PerPage & RecordsCount attributes
	*
	* @var int
	* @access public
	*/
	var $TotalPages;

	/**
	* Description
	*
	* @var int
	* @access public
	*/

	var $Direction;
	/**
	* Holds current page number - used when forming LIMIT clause of SELECT statement
	*
	* @var int
	* @access public
	*/
	var $Page;

	/**
	* Holds offset for LIMIT clause, calculated in {@link kDBList::PerPage()}
	*
	* @var int
	* @access private
	*/
	var $Offset;

	/**
	* Count SQL was already issued on query
	*
	* @var bool
	* @access private
	*/
	var $hasCounted = false;

	/**
	* Holds list WHERE filter object
	*
	* @var kMultipleFilter
	* @access private
	*/
	var $WhereFilter = Array(FLT_SYSTEM => null, FLT_NORMAL => null, FLT_SEARCH => null, FLT_VIEW => null);

	/**
	* Holds list HAVING filter object
	*
	* @var kMultipleFilter
	* @access private
	*/
	var $HavingFilter = Array(FLT_SYSTEM => null, FLT_NORMAL => null, FLT_SEARCH => null, FLT_VIEW => null);

	var $AggregateFilter = Array(FLT_SYSTEM => null, FLT_NORMAL => null);

	var $GroupByFields = Array();

	var $Queried = false;
	var $Counted = false;
	var $TotalsCalculated = false;

	/**
	* Creates kDBList
	*
	* @return kDBList
	*/
	function kDBList()
	{
	parent::kDBBase();
	$this->OrderFields = Array();


	$filters = $this->getFilterStructure();

	foreach ($filters as $filter_params) {
	$filter =& $this->$filter_params['type'];
	$filter[ $filter_params['class'] ] =& $this->Application->makeClass('kMultipleFilter', $filter_params['join_using']);
	}

	$this->PerPage = -1;
	}

	/**
	* Returns information about all possible filter types
	*
	* @return Array
	*/
	function getFilterStructure()
	{
	$filters = Array (
	Array ('type' => 'WhereFilter', 'class' => FLT_SYSTEM, 'join_using' => FLT_TYPE_AND),
	Array ('type' => 'WhereFilter', 'class' => FLT_NORMAL, 'join_using' => FLT_TYPE_OR),
	Array ('type' => 'WhereFilter', 'class' => FLT_SEARCH, 'join_using' => FLT_TYPE_OR),
	Array ('type' => 'WhereFilter', 'class' => FLT_VIEW, 'join_using' => FLT_TYPE_AND),
	Array ('type' => 'WhereFilter', 'class' => FLT_CUSTOM, 'join_using' => FLT_TYPE_AND),

	Array ('type' => 'HavingFilter', 'class' => FLT_SYSTEM, 'join_using' => FLT_TYPE_AND),
	Array ('type' => 'HavingFilter', 'class' => FLT_NORMAL, 'join_using' => FLT_TYPE_OR),
	Array ('type' => 'HavingFilter', 'class' => FLT_SEARCH, 'join_using' => FLT_TYPE_OR),
	Array ('type' => 'HavingFilter', 'class' => FLT_VIEW, 'join_using' => FLT_TYPE_AND),
	Array ('type' => 'HavingFilter', 'class' => FLT_CUSTOM, 'join_using' => FLT_TYPE_AND),

	Array ('type' => 'AggregateFilter', 'class' => FLT_SYSTEM, 'join_using' => FLT_TYPE_AND),
	Array ('type' => 'AggregateFilter', 'class' => FLT_NORMAL, 'join_using' => FLT_TYPE_OR),
	Array ('type' => 'AggregateFilter', 'class' => FLT_VIEW, 'join_using' => FLT_TYPE_AND),
	);

	return $filters;
	}

	/**
	* Adds new or replaces old filter with same name
	*
	* @param string $name filter name (for internal use)
	* @param string $clause where/having clause part (no OR/AND allowed)
	* @param int $filter_type is filter having filter or where filter
	* @param int $filter_scope filter subtype: FLT_NORMAL,FLT_SYSTEM,FLT_SEARCH,FLT_VIEW,FLT_CUSTOM
	* @access public
	*/
	function addFilter($name, $clause, $filter_type = WHERE_FILTER, $filter_scope = FLT_SYSTEM)
	{
	$filter_source = Array( WHERE_FILTER => 'WhereFilter',
	HAVING_FILTER => 'HavingFilter',
	AGGREGATE_FILTER => 'AggregateFilter');
	$filter_name = $filter_source[$filter_type];

	$filter =& $this->$filter_name;
	$filter =& $filter[$filter_scope];
	$filter->addFilter($name,$clause);
	}

	/**
	* Reads filter content
	*
	* @param string $name filter name (for internal use)
	* @param int $filter_type is filter having filter or where filter
	* @param int $filter_scope filter subtype: FLT_NORMAL,FLT_SYSTEM,FLT_SEARCH,FLT_VIEW,FLT_CUSTOM
	* @access public
	*/
	function getFilter($name, $filter_type = WHERE_FILTER, $filter_scope = FLT_SYSTEM)
	{
	$filter_source = Array( WHERE_FILTER => 'WhereFilter',
	HAVING_FILTER => 'HavingFilter',
	AGGREGATE_FILTER => 'AggregateFilter');
	$filter_name = $filter_source[$filter_type];

	$filter =& $this->$filter_name;
	$filter =& $filter[$filter_scope];
	return $filter->getFilter($name);
	}

	/**
	* Removes specified filter from filters list
	*
	* @param string $name filter name (for internal use)
	* @param int $filter_type is filter having filter or where filter
	* @param int $filter_scope filter subtype: FLT_NORMAL,FLT_SYSTEM,FLT_SEARCH,FLT_VIEW,FLT_CUSTOM
	* @access public
	*/
	function removeFilter($name, $filter_type = WHERE_FILTER, $filter_scope = FLT_SYSTEM)
	{
	$filter_source = Array( WHERE_FILTER => 'WhereFilter',
	HAVING_FILTER => 'HavingFilter',
	AGGREGATE_FILTER => 'AggregateFilter');
	$filter_name = $filter_source[$filter_type];

	$filter =& $this->$filter_name;
	$filter =& $filter[$filter_scope];
	$filter->removeFilter($name);
	}

	/**
	* Clear list filters
	*
	*/
	function clearFilters()
	{
	$filters = $this->getFilterStructure();

	foreach ($filters as $filter_params) {
	$filter =& $this->$filter_params['type'];
	$filter[ $filter_params['class'] ]->clearFilters();
	}
	}

	/**
	* Counts the total number of records base on the query resulted from {@link kDBList::GetSelectSQL()}
	*
	* The method modifies the query to substitude SELECT part (fields listing) with COUNT(*).
	* Special care should be applied when working with lists based on grouped queries, all aggregate function fields
	* like SUM(), AVERAGE() etc. should be added to CountedSQL by using {@link kDBList::SetCountedSQL()}
	*
	* @access public
	* @param string
	* @return void
	*/
	function CountRecs()
	{
	$all_sql = $this->GetSelectSQL(true,false);
	$sql = $this->getCountSQL($all_sql);

	$this->Counted = true;

	if( $this->GetGroupClause() )
	{
	$this->RecordsCount = count( $this->Conn->GetCol($sql) );
	}
	else
	{
	$this->RecordsCount = (int)$this->Conn->GetOne($sql);
	}

	$system_sql = $this->GetSelectSQL(true,true);
	if($system_sql == $all_sql) //no need to query the same again
	{
	$this->NoFilterCount = $this->RecordsCount;
	return;
	}

	$sql = $this->getCountSQL($system_sql);
	if( $this->GetGroupClause() )
	{
	$this->NoFilterCount = count( $this->Conn->GetCol($sql) );
	}
	else
	{
	$this->NoFilterCount = (int)$this->Conn->GetOne($sql);
	}
	}

	function GetNoFilterCount()
	{
	if (!$this->Counted) {
	$this->CountRecs();
	}
	return $this->NoFilterCount;
	}

	function GetRecordsCount()
	{
	if (!$this->Counted) {
	$this->CountRecs();
	}
	return $this->RecordsCount;
	}

	function getCountSQL($sql)
	{
	if ( preg_match("/DISTINCT(.*?)FROM(?!_)/is",$sql,$regs ) )
	{
	return preg_replace("/^.SELECT DISTINCT(.?)FROM(?!_)/is", "SELECT COUNT(DISTINCT ".$regs[1].") AS count FROM", $sql);
	}
	else
	{
	return preg_replace("/^.SELECT(.?)FROM(?!_)/is", "SELECT COUNT(*) AS count FROM ", $sql);
	}
	}

	/**
	* Queries the database with SQL resulted from {@link kDBList::GetSelectSQL()} and stores result in {@link kDBList::SelectRS}
	*
	* All the sorting, pagination, filtration of the list should be set prior to calling Query().
	*
	* @access public
	* @param string
	* @return void
	*/
	function Query($force=false)
	{
	if (!$force && $this->Queried) return true;
	$q = $this->GetSelectSQL();

	//$rs = $this->Conn->SelectLimit($q, $this->PerPage, $this->Offset);

	//in case we have not counted records try to select one more item to find out if we have something more than perpage
	$limit = $this->Counted ? $this->PerPage : $this->PerPage+1;

	$sql = $q.' '.$this->Conn->getLimitClause($this->Offset,$limit);

	$this->Records = $this->Conn->Query($sql);

	if (!$this->Records && ($this->Page > 1)) {
	// no records & page > 1, try to reset to 1st page (works only when list in not counted before)
	$this->Application->StoreVar($this->getPrefixSpecial().'_Page', 1);
	$this->SetPage(1);
	$this->Query($force);
	}

	$this->SelectedCount = count($this->Records);
	if (!$this->Counted) $this->RecordsCount = $this->SelectedCount;
	if (!$this->Counted && $this->SelectedCount > $this->PerPage && $this->PerPage != -1) $this->SelectedCount--;

	if ($this->Records === false) {
	//handle errors here
	return false;
	}
	$this->Queried = true;
	return true;
	}

	function CalculateTotals()
	{
	$this->Totals = Array();

	$fields = Array();
	foreach($this->Fields as $field_name => $field_options)
	{
	$totals = getArrayValue($field_options, 'totals');
	if(!$totals) continue;

	$calculated_field = isset($this->CalculatedFields[$field_name]) && isset($this->VirtualFields[$field_name]);
	$db_field = !isset($this->VirtualFields[$field_name]);

	if($calculated_field \|\| $db_field)
	{
	$field_expression = $calculated_field ? $this->CalculatedFields[$field_name] : '`'.$this->TableName.'`.`'.$field_name.'`';
	$fields[$field_name] = $totals.'('.$field_expression.') AS '.$field_name.'_'.$totals;
	}
	}

	if(!$fields) return false;

	$sql = $this->GetSelectSQL(true, false);
	$fields = implode(', ', $fields);

	if ( preg_match("/DISTINCT(.*?)FROM(?!_)/is",$sql,$regs ) )
	{
	$sql = preg_replace("/^.SELECT DISTINCT(.?)FROM(?!_)/is", 'SELECT '.$fields.' FROM', $sql);
	}
	else
	{
	$sql = preg_replace("/^.SELECT(.?)FROM(?!_)/is", 'SELECT '.$fields.' FROM ', $sql);
	}

	$totals = $this->Conn->Query($sql);

	foreach($totals as $totals_row)
	{
	foreach($totals_row as $total_field => $field_value)
	{
	if(!isset($this->Totals[$total_field])) $this->Totals[$total_field] = 0;
	$this->Totals[$total_field] += $field_value;
	}
	}
	$this->TotalsCalculated = true;
	}

	function getTotal($field, $total_function)
	{
	if (!$this->TotalsCalculated) $this->CalculateTotals();
	return $this->Totals[$field.'_'.$total_function];
	}

	function GetFormattedTotal($field, $total_function)
	{
	$val = $this->getTotal($field, $total_function);
	$options = $this->GetFieldOptions($field);
	$res = $val;
	if (isset($options['formatter'])) {
	$formatter =& $this->Application->recallObject($options['formatter']);
	$res = $formatter->Format($val, $field, $this );
	}
	return $res;
	}

	/**
	* Builds full select query except for LIMIT clause
	*
	* @access public
	* @return string
	*/
	function GetSelectSQL($for_counting=false,$system_filters_only=false)
	{
	$q = parent::GetSelectSQL($this->SelectClause);
	$q = !$for_counting ? $this->addCalculatedFields($q, 0) : str_replace('%2$s', '', $q);

	$where = $this->GetWhereClause($for_counting,$system_filters_only);
	$having = $this->GetHavingClause($for_counting,$system_filters_only);
	$order = $this->GetOrderClause();
	$group = $this->GetGroupClause();

	if (!empty($where)) $q .= ' WHERE ' . $where;
	if (!empty($group)) $q .= ' GROUP BY ' . $group;
	if (!empty($having)) $q .= ' HAVING ' . $having;
	if ( !$for_counting && !empty($order) ) $q .= ' ORDER BY ' . $order;

	return $this->replaceModePrefix( str_replace('%1$s', $this->TableName, $q) );
	}

	/**
	* Enter description here...
	*
	* @param string $clause where clause to extract calculated fields from
	* @param int $aggregated 0 - having + aggregated, 1 - having only, 2 - aggregated only
	* @return string
	*/
	function extractCalculatedFields($clause, $aggregated = 1)
	{
	$fields = $this->getCalculatedFields($aggregated);
	if (is_array($fields) && count($fields) > 0) {
	foreach ($fields as $field_name => $field_expression) {
	$clause = preg_replace('/(\\(+)[(,` ]*'.$field_name.'[` ]{1}/', '\1 '.$field_expression.' ', $clause);
	$clause = preg_replace('/[,` ]{1}'.$field_name.'[` ]{1}/', ' '.$field_expression.' ', $clause);
	}
	}
	return $clause;
	}

	/**
	* Returns WHERE clause of the query
	*
	* @access public
	* @param bool $for_counting merge where filters with having filters + replace field names for having fields with their values
	* @return string
	*/
	function GetWhereClause($for_counting=false,$system_filters_only=false)
	{
	$where =& $this->Application->makeClass('kMultipleFilter');

	$where->addFilter('system_where', $this->WhereFilter[FLT_SYSTEM] );

	if (!$system_filters_only) {
	$where->addFilter('view_where', $this->WhereFilter[FLT_VIEW] );
	$search_w = $this->WhereFilter[FLT_SEARCH]->getSQL();
	if ($search_w \|\| $for_counting) { // move search_having to search_where in case search_where isset or we are counting
	$search_h = $this->extractCalculatedFields( $this->HavingFilter[FLT_SEARCH]->getSQL() );
	$search_w = ($search_w && $search_h) ? $search_w.' OR '.$search_h : $search_w.$search_h;
	$where->addFilter('search_where', $search_w );
	}

	// CUSTOM
	$search_w = $this->WhereFilter[FLT_CUSTOM]->getSQL();
	if ($search_w \|\| $for_counting) { // move search_having to search_where in case search_where isset or we are counting
	$search_h = $this->extractCalculatedFields( $this->HavingFilter[FLT_CUSTOM]->getSQL() );
	$search_w = ($search_w && $search_h) ? $search_w.' AND '.$search_h : $search_w.$search_h;
	$where->addFilter('custom_where', $search_w );
	}
	// CUSTOM
	}

	if( $for_counting ) // add system_having and view_having to where
	{
	$where->addFilter('system_having', $this->extractCalculatedFields($this->HavingFilter[FLT_SYSTEM]->getSQL()) );
	if (!$system_filters_only) $where->addFilter('view_having', $this->extractCalculatedFields( $this->HavingFilter[FLT_VIEW]->getSQL() ) );
	}

	return $where->getSQL();
	}

	/**
	* Depricated method
	*
	* @param string $clause
	* @todo REMOVE
	*/
	function SetWhereClause($clause)
	{
	if( $this->Application->isDebugMode() )
	{
	global $debugger;
	$debugger->appendTrace();
	}
	trigger_error('Depricated method <b>kDBList->SetWhereClause</b>. Use <b>kDBList->addFilter</b> instead.', E_USER_ERROR);
	}

	/**
	* Returns HAVING clause of the query
	*
	* @param bool $for_counting don't return having filter in case if this is counting sql
	* @param bool $system_filters_only return only system having filters
	* @param int $aggregated 0 - aggregated and having, 1 - having only, 2 - aggregated only
	* @return string
	* @access public
	*/
	function GetHavingClause($for_counting=false, $system_filters_only=false, $aggregated = 0)
	{
	if ($for_counting) {
	$aggregate_filter =& $this->Application->makeClass('kMultipleFilter');
	$aggregate_filter->addFilter('aggregate_system', $this->AggregateFilter[FLT_SYSTEM]);
	if (!$system_filters_only) {
	$aggregate_filter->addFilter('aggregate_view', $this->AggregateFilter[FLT_VIEW]);
	}
	return $this->extractCalculatedFields($aggregate_filter->getSQL(), 2);
	}

	$having =& $this->Application->makeClass('kMultipleFilter');

	$having->addFilter('system_having', $this->HavingFilter[FLT_SYSTEM] );
	if ($aggregated == 0) {
	if (!$system_filters_only) {
	$having->addFilter('view_aggregated', $this->AggregateFilter[FLT_VIEW] );
	}
	$having->addFilter('system_aggregated', $this->AggregateFilter[FLT_SYSTEM]);
	}

	if (!$system_filters_only) {
	$having->addFilter('view_having', $this->HavingFilter[FLT_VIEW] );
	$having->addFilter('custom_having', $this->HavingFilter[FLT_CUSTOM] );
	$search_w = $this->WhereFilter[FLT_SEARCH]->getSQL();
	if (!$search_w) {
	$having->addFilter('search_having', $this->HavingFilter[FLT_SEARCH] );
	}
	}

	return $having->getSQL();
	}

	/**
	* Returns GROUP BY clause of the query
	*
	* @access public
	* @return string
	*/
	function GetGroupClause()
	{
	return $this->GroupByFields ? implode(',', $this->GroupByFields) : '';
	}

	function AddGroupByField($field)
	{
	$this->GroupByFields[$field] = $field;
	}

	function RemoveGroupByField($field)
	{
	unset($this->GroupByFields[$field]);
	}

	/**
	* Adds order field to ORDER BY clause
	*
	* @access public
	* @param string $field Field name
	* @param string $direction Direction of ordering (asc\|desc)
	* @param bool $is_expression this is expression, that should not be escapted by "`" symbols
	* @return void
	*/
	function AddOrderField($field, $direction = 'asc', $is_expression = false)
	{
	// original multilanguage field - convert to current lang field
	$formatter = isset($this->Fields[$field]['formatter']) ? $this->Fields[$field]['formatter'] : false;
	if ($formatter == 'kMultiLanguage' && !isset($this->Fields[$field]['master_field'])) {
	$lang = $this->Application->GetVar('m_lang');
	$field = 'l'.$lang.'_'.$field;
	}

	if (!isset($this->Fields[$field]) && $field != 'RAND()' && !$is_expression) {
	trigger_error('<span class="debug_error">Incorrect sorting</span> defined (field = <b>'.$field.'</b>; direction = <b>'.$direction.'</b>) in config for prefix <b>'.$this->Prefix.'</b>', E_USER_WARNING);
	}

	$this->OrderFields[] = Array($field, $direction, $is_expression);
	}

	/**
	* Removes all order fields
	*
	* @access public
	* @return void
	*/
	function ClearOrderFields()
	{
	$this->OrderFields = Array();
	}

	/**
	* Returns ORDER BY Clause of the query
	*
	* The method builds order by clause by iterating {@link kDBList::OrderFields} array and concatenating it.
	*
	* @access public
	* @return string
	*/
	function GetOrderClause()
	{
	$ret = '';
	foreach ($this->OrderFields as $field) {

	$name = $field[0];
	$ret .= isset($this->Fields[$name]) && !isset($this->VirtualFields[$name]) ? '`'.$this->TableName.'`.' : '';

	if ($field[0] == 'RAND()' \|\| $field[2]) {
	$ret .= $field[0].' '.$field[1].',';
	}
	else {
	$ret .= '`'.$field[0] . '` ' . $field[1] . ',';
	}
	}
	$ret = rtrim($ret, ',');
	return $ret;
	}

	function GetOrderField($pos=NULL)
	{
	if(!(isset($this->OrderFields[$pos]) && $this->OrderFields[$pos]) )
	{
	$pos = 0;
	}
	return isset($this->OrderFields[$pos][0]) ? $this->OrderFields[$pos][0] : '';
	}

	function GetOrderDirection($pos=NULL)
	{
	if( !getArrayValue($this->OrderFields, $pos) ) $pos = 0;
	return getArrayValue($this->OrderFields, $pos, 1);
	}

	/**
	* Return unformatted field value
	*
	* @param string
	* @return mixed
	* @access public
	*/
	function GetDBField($name)
	{
	$row =& $this->getCurrentRecord();

	return $row[$name];
	}

	/**
	* Returns ID of currently processed record
	*
	* @return int
	* @access public
	*/
	function GetID()
	{
	return $this->Queried ? $this->GetDBField($this->IDField) : null;
	}

	/**
	* Allows kDBTagProcessor.SectionTitle to detect if it's editing or new item creation
	*
	* @return bool
	*/
	function IsNewItem()
	{
	// no such thing as NewItem for lists :)
	return false;
	}

	function HasField($name)
	{
	$row =& $this->getCurrentRecord();
	return isset($row[$name]);
	}

	function GetFieldValues()
	{
	return $this->getCurrentRecord();
	}

	/**
	* Returns current record from list
	*
	* @return Array
	*/
	function &getCurrentRecord()
	{
	return $this->Records[$this->CurrentIndex];
	}

	/**
	* Description
	*
	* @access public
	* @param string
	* @return void
	*/
	function GoFirst()
	{
	$this->CurrentIndex = 0;
	}

	/**
	* Description
	*
	* @access public
	* @return void
	*/
	function GoNext()
	{
	$this->CurrentIndex++;
	}

	/**
	* Description
	*
	* @access public
	* @return void
	*/
	function GoPrev()
	{
	if ($this->CurrentIndex>0)
	$this->CurrentIndex--;
	}

	/**
	* Description
	*
	* @access public
	* @return bool
	*/
	function EOL()
	{
	return ($this->CurrentIndex >= $this->SelectedCount);
	}

	/**
	* Description
	*
	* @access public
	* @param string
	* @return void
	*/
	function GetTotalPages()
	{
	if (!$this->Counted) $this->CountRecs();
	if ($this->PerPage == -1) return 1;
	$this->TotalPages = (($this->RecordsCount - ($this->RecordsCount % $this->PerPage)) / $this->PerPage) // integer part of division
	+ (($this->RecordsCount % $this->PerPage) != 0); // adds 1 if there is a reminder
	return $this->TotalPages;
	}

	/**
	* Sets number of records to query per page
	*
	* @access public
	* @param int $per_page Number of records to display per page
	* @return void
	*/
	function SetPerPage($per_page)
	{
	$this->PerPage = $per_page;
	}

	function GetPerPage()
	{
	return $this->PerPage == -1 ? $this->RecordsCount : $this->PerPage;
	}

	/**
	* Description
	*
	* @access public
	* @param int $page
	* @return void
	*/
	function SetPage($page)
	{
	if ($this->PerPage == -1) {
	$this->Page = 1;
	return;
	}
	if ($page < 1) $page = 1;
	$this->Offset = ($page-1)*$this->PerPage;
	if ($this->Counted && $this->Offset > $this->RecordsCount) {
	$this->SetPage(1);
	}
	else {
	$this->Page = $page;
	}
	//$this->GoFirst();
	}

	/**
	* Sets current item field value
	* (doesn't apply formatting)
	*
	* @access public
	* @param string $name Name of the field
	* @param mixed $value Value to set the field to
	* @return void
	*/
	function SetDBField($name,$value)
	{
	$this->Records[$this->CurrentIndex][$name] = $value;
	}

	/**
	* Apply where clause, that links this object to it's parent item
	*
	* @param string $special
	* @access public
	*/
	function linkToParent($special)
	{
	$parent_prefix = $this->Application->getUnitOption($this->Prefix, 'ParentPrefix');
	if($parent_prefix)
	{
	$parent_table_key = $this->Application->getUnitOption($this->Prefix, 'ParentTableKey');
	if (is_array($parent_table_key)) $parent_table_key = getArrayValue($parent_table_key, $parent_prefix);
	$foreign_key_field = $this->Application->getUnitOption($this->Prefix, 'ForeignKey');
	if (is_array($foreign_key_field)) $foreign_key_field = getArrayValue($foreign_key_field, $parent_prefix);

	if (!$parent_table_key \|\| !$foreign_key_field) return ;

	$parent_object =& $this->Application->recallObject($parent_prefix.'.'.$special);
	$parent_id = $parent_object->GetDBField($parent_table_key);

	if (!$parent_id) return ;

	$this->addFilter('parent_filter', '`'.$this->TableName.'`.`'.$foreign_key_field.'` = '.$parent_id); // only for list in this case
	}
	}

	/**
	* Returns true if list was queried (same name as for kDBItem for easy usage)
	*
	* @return bool
	*/
	function isLoaded()
	{
	return $this->Queried;
	}

	/**
	* Returns specified field value from all selected rows.
	* Don't affect current record index
	*
	* @param string $field
	* @return Array
	*/
	function GetCol($field)
	{
	$i = 0;
	$ret = Array ();
	while ($i < $this->SelectedCount) {
	$ret[] = $this->Records[$i][$field];
	$i++;
	}

	return $ret;
	}
	}

	?>

dblist.phpNo OneTemporaryActions

File Metadata

dblist.phpView Options

Event Timeline

dblist.php
No OneTemporary
Actions

dblist.php
View Options