Index: trunk/core/kernel/kbase.php
===================================================================
--- trunk/core/kernel/kbase.php	(revision 2229)
+++ trunk/core/kernel/kbase.php	(revision 2230)
@@ -1,472 +1,472 @@
 <?php
 /**
 * Base
 *
 * Desciption
 * @package kernel4
 */
 class kBase {
 	/**
 	* Holds reference to global KernelApplication instance
 	* @access public
 	* @var kApplication
 	*/
 	var $Application;
 
 	/**
 	 * Prefix, that was used
 	 * to create an object
 	 *
 	 * @var string
 	 * @access public
 	 */
 	var $Prefix='';
 	
 	/**
 	 * Special, that was used
 	 * to create an object
 	 *
 	 * @var string
 	 * @access public
 	 */
 	var $Special='';
 	
 	var $OriginalParams;
 	
 	/**
 	 * Set's application
 	 *
 	 * @return kBase
 	 * @access public
 	 */
 	function kBase()
 	{
 		$this->Application =& kApplication::Instance();
 	}
 	
 	/**
 	 * Create new instance of object
 	 *
 	 * @return kBase
 	 */
 	function &makeClass()
 	{
 		return new kBase();
 	}
 	
 	/**
 	 * Set's prefix and special
 	 *
 	 * @param string $prefix
 	 * @param string $special
 	 * @access public
 	 */
 	function Init($prefix,$special,$event_params=null)
 	{
 		$prefix=explode('_',$prefix,2);
 		$this->Prefix=$prefix[0];
 		$this->Special=$special;
 		$this->OriginalParams = $event_params;
 	}
 	
 	/**
 	 * Returns joined prefix
 	 * and special if any
 	 *
 	 * @return string
 	 * @access protected
 	 */
 	function getPrefixSpecial()
 	{
 		return rtrim($this->Prefix.'.'.$this->Special,'.');
 	}
 	
 	function &getProperty($property_name)
 	{
 		return $this->$property_name;
 	}
 	
 	function setProperty($property_name, &$property_value)
 	{
 		$this->$property_name =& $property_value;
 	}
 }
 
 class kDBBase extends kBase {
 	/**
 	* Description
 	*
 	* @var DBConnection
 	* @access public
 	*/
 	var $Conn;
 	
 	/**
 	* Description
 	*
 	* @var string Name of primary key field for the item
 	* @access public
 	*/
 	var $IDField;
 	
 	/**
 	* Holds SELECT, FROM, JOIN parts of SELECT query
 	*
 	* @var string
 	* @access public
 	*/
 	var $SelectClause;
 	
 	/**
 	* Display queries executed by the class
 	*
 	* @var bool 
 	* @access public
 	*/
 	var $DisplayQueries = false;
 	
 	/**
 	* Fields allowed to be set (from table + virtual)
 	*
 	* @var Array
 	* @access private
 	*/
 	var $Fields=Array();
 	
 	/**
 	 * All virtual field names
 	 *
 	 * @var Array
 	 * @access private
 	 */
 	var $VirtualFields=Array();
 	
 	/**
 	 * Fields that need to be queried using custom expression, e.g. IF(...) AS value
 	 *
 	 * @var Array
 	 * @access private
 	 */
 	var $CalculatedFields = Array();
 	
 	/**
 	* Description
 	*
 	* @var string Item' database table name, without prefix
 	* @access public
 	*/
 	var $TableName;
 	
 	/**
 	 * Allows to determine object's table status ('temp' - temp table, '' - live table)
 	 *
 	 * @var string
 	 * @access public
 	 */
 	var $mode='';
 	
 	function kDBBase()
 	{
 		parent::kBase();
 		$this->Conn =& $this->Application->GetADODBConnection();
 	}
 	
 	/**
 	* Set current item' database table name
 	*
 	* @access public
 	* @param string $table_name
 	* @return void
 	*/
 	function setTableName($table_name)
 	{
 		$this->TableName = $table_name;
 	}
 	
 	/**
 	 * Set object' TableName to Live table from config
 	 *
 	 * @access public
 	 */
 	function SwitchToLive()
 	{
 		$this->TableName = $this->Application->getUnitOption($this->Prefix, 'TableName');
 	}
 	
 	/**
 	 * Set object' TableName to Temp table from config
 	 *
 	 * @access public
 	 */
 	function SwitchToTemp()
 	{
 		$this->TableName = $this->Application->getUnitOption($this->Prefix, 'TableName');
 		$this->SetTableName( kTempTablesHandler::GetTempName($this->TableName) );
 		$this->mode = 't';
 	}
 	
 	/**
 	 * Checks if object uses temp table
 	 *
 	 * @return bool
 	 */
 	function IsTempTable()
 	{
 		return kTempTablesHandler::IsTempTable($this->TableName);
 	}
 	
 	/**
 	* Sets SELECT part of list' query
 	*
 	* @access public
 	* @param string $sql SELECT and FROM [JOIN] part of the query up to WHERE
 	* @return void
 	*/
 	function SetSelectSQL($sql)
 	{
 		$this->SelectClause = $sql;
 	}
 	
 	function GetSelectSQL($base_query=null)
 	{
 		if( !isset($base_query) ) $base_query = $this->SelectClause;
 		return $q = str_replace( Array('%1$s','%s'), $this->TableName, $base_query);
 	}
 	
 	/**
 	 * Insert calculated fields sql into query in place of %2$s,
 	 * return processed query.
 	 *
 	 * @param string $query
 	 * @return string
 	 */
 	function addCalculatedFields($query)
 	{
 		if($this->CalculatedFields)
 		{
 			$sql = Array();
 			foreach($this->CalculatedFields as $field_name => $field_expression)
 			{
 				$sql[] = '('.$field_expression.') AS '.$field_name;
 			}
 			$sql = implode(',',$sql);
 			return $this->Application->ReplaceLanguageTags( str_replace('%2$s', ','.$sql, $query) );
 		}
 		else
 		{
 			return str_replace('%2$s', '', $query);
 		}
 	}
 	
 	/**
 	 * Adds calculated field declaration to object.
 	 *
 	 * @param string $name
 	 * @param string $sql_clause
 	 */
 	function addCalculatedField($name, $sql_clause)
 	{
 		$this->CalculatedFields[$name] = $sql_clause;
 	}
 	
 	/**
 	* Sets ID Field name used as primary key for loading items
 	*
 	* @access public
 	* @param string $field_name
 	* @return void
 	* @see kDBBase::IDField
 	*/
 	function setIDField($field_name)
 	{
 		$this->IDField = $field_name;
 	}
 	
 	function Configure()
 	{
 		$this->setTableName( $this->Application->getUnitOption($this->Prefix, 'TableName') );
 		$this->setIDField( $this->Application->getUnitOption($this->Prefix, 'IDField') );
 		$this->setConfigFields( $this->Application->getUnitOption($this->Prefix, 'Fields') );
 		$this->setVirtualFields( $this->Application->getUnitOption($this->Prefix, 'VirtualFields') );
 		$this->setCalculatedFields( $this->Application->getUnitOption($this->Prefix, 'CalculatedFields') );
 		$this->prepareConfigOptions(); // this should go last, but before setDefaultValues, order is significant!
 		$this->SetDefaultValues();
 	}
 	
 	function setCalculatedFields($fields)
 	{
 		$this->CalculatedFields = isset($fields[$this->Special]) ? $fields[$this->Special] : (isset($fields['']) ? $fields[''] : false);
 	}
 	
 	/**
 	 * Set's field names from table
 	 * from config
 	 *
 	 * @param Array $fields
 	 * @access public
 	 */
 	function setConfigFields($fields)
 	{
 		$this->Fields=$fields;
 	}
 	
 	/**
 	 * Set fields (+options) for fields that physically doesn't exist in database 
 	 *
 	 * @param Array $fields
 	 * @access public
 	 */
 	function setVirtualFields($fields)
 	{
 		if($fields)
 		{
 			$this->VirtualFields = $fields;
 			$this->Fields = array_merge_recursive2($this->VirtualFields, $this->Fields);
 		}
 	}
 	
 	function SetDefaultValues()
 	{
 		foreach($this->Fields as $field => $options)
 		{
-			if($options['default'] === '#NOW#')
+			if( getArrayValue($options, 'default') === '#NOW#')
 			{
 				$this->Fields[$field]['default'] = mktime();
 			}
 		}
 	}
 	
 	function SetFieldOptions($field, $options)
 	{
 		$this->Fields[$field] = $options;
 	}
 	
 	function GetFieldOptions($field)
 	{
 		return isset($this->Fields[$field]) ? $this->Fields[$field] : Array();
 	}
 	
 	/**
 	 * Returns formatted field value
 	 *
 	 * @param string $field
 	 * @return string
 	 * @access public
 	 */
 	function GetField($name, $format=null)
 	{
 		$options = $this->GetFieldOptions($name);
 		$val = $this->GetDBField($name);
 		$res = $val;
 		if (isset($options['formatter'])) {
 			$formatter =& $this->Application->recallObject($options['formatter']);
 			$res = $formatter->Format($val, $name, $this, $format );
 		}
 		return $res;
 	}
 	
 	function HasField($name)
 	{
 				
 	}
 	
 	function GetFieldValues()
 	{
 		
 	}
 	
 	function UpdateFormattersSubFields()
 	{
 		foreach ($this->Fields as $field => $options) {
 			if (isset($options['formatter'])) {
 				$formatter =& $this->Application->recallObject($options['formatter']);
 				$formatter->UpdateSubFields($field, $this->GetDBField($field), $options, $this);
 			}
 		}
 	}
 	
 	function prepareConfigOptions()
 	{
 		foreach (array_keys($this->Fields) as $field_name)
 		{
 			$field_options =& $this->Fields[$field_name];
 			if( isset($field_options['options_sql']) )
 			{
 				// replace with query result
 				$select_clause = $field_options['option_title_field'].','.$field_options['option_key_field'];
 				$sql = sprintf($field_options['options_sql'], $select_clause);
 				
 				$options_hash = getArrayValue($field_options,'options');
 				if($options_hash === false) $options_hash = Array();
 								
 				$dynamic_options = $this->Conn->GetCol($sql, $field_options['option_key_field']);
 				$field_options['options'] = array_merge_recursive2($options_hash, $dynamic_options);
 				
 				unset($field_options['options_sql']);
 			}
 			$this->PrepareOptions($field_name);
 		}
 	}
 	
 	function PrepareOptions($field_name)
 	{
 		if( $formatter_class = getArrayValue($this->Fields[$field_name], 'formatter') )
 		{
 			$formatter =& $this->Application->recallObject($formatter_class);
 			$formatter->PrepareOptions($field_name, $this->Fields[$field_name], $this);
 		}
 	}
 	
 	/**
 	 * Returns unformatted field value
 	 *
 	 * @param string $field
 	 * @return string
 	 * @access public
 	 */
 	function GetDBField($field)
 	{
 		
 	}
 	
 	/**
 	 * Returns ID of currently processed record
 	 *
 	 * @return int
 	 * @access public
 	 */
 	function GetID()
 	{
 		return $this->GetDBField($this->IDField);
 	}
 	
 	/**
 	 * Returns parent table information
 	 *
 	 * @param bool $from_temp load parent item from temp table
 	 * @param string $special special of main item
 	 * @return Array
 	 */
 	function getLinkedInfo($special = '')
 	{
 		$parent_prefix = $this->Application->getUnitOption($this->Prefix, 'ParentPrefix');
 		if($parent_prefix)
 		{
 			// if this is linked table, then set id from main table
 			$table_info = Array(
 				'TableName' => $this->Application->getUnitOption($this->Prefix,'TableName'),
 				'IdField' => $this->Application->getUnitOption($this->Prefix,'IDField'),
 				'ForeignKey' => $this->Application->getUnitOption($this->Prefix,'ForeignKey'),
 				'ParentTableKey' => $this->Application->getUnitOption($this->Prefix,'ParentTableKey'),
 				'ParentPrefix' => $parent_prefix
 			);
 			
 			$main_object = $this->Application->recallObject($parent_prefix.'.'.$special);
 			return array_merge($table_info, Array('ParentId'=> $main_object->GetDBField( $table_info['ParentTableKey'] ) ) );
 		}
 		return false;
 	}
 	
 }
 
 ?>
\ No newline at end of file

Property changes on: trunk/core/kernel/kbase.php
___________________________________________________________________
Modified: cvs2svn:cvs-rev
## -1 +1 ##
-1.7
\ No newline at end of property
+1.8
\ No newline at end of property