in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sat, Feb 1, 1:19 PM

in-portal
View Options

	Index: branches/RC/core/kernel/kbase.php
	===================================================================
	--- branches/RC/core/kernel/kbase.php (revision 11894)
	+++ branches/RC/core/kernel/kbase.php (revision 11895)
	@@ -1,739 +1,739 @@
	<?php
	/**
	* @version $Id$
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2009 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.net/license/ for copyright notices and details.
	*/

	/**
	* 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()
	{
	$object = new kBase();
	return $object;
	}

	/**
	* 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
	*
	* @param bool $from_submit if true, then joins prefix & special by "_", uses "." otherwise
	* @return string
	* @access protected
	*/
	function getPrefixSpecial($from_submit = false)
	{
	$separator = !$from_submit ? '.' : '_';
	$ret = $this->Prefix.$separator.$this->Special;
	return rtrim($ret, $separator);
	}

	function &getProperty($property_name)
	{
	return $this->$property_name;
	}

	function setProperty($property_name, &$property_value)
	{
	$this->$property_name =& $property_value;
	}
	}

	class kHelper extends kBase {

	/**
	* Connection to database
	*
	* @var kDBConnection
	* @access public
	*/
	var $Conn;

	function kHelper()
	{
	parent::kBase();
	$this->Conn =& $this->Application->GetADODBConnection();
	}

	function InitHelper()
	{

	}

	}

	class kDBBase extends kBase {
	/**
	* Connection to database
	*
	* @var kDBConnection
	* @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;

	/**
	* Fields allowed to be set (from table + virtual)
	*
	* @var Array
	* @access private
	*/
	var $Fields = Array();

	/**
	* Holds custom field names for item
	*
	* @var Array
	*/
	var $customFields = 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();


	/**
	* Calculated fields, that contain aggregated functions, e.g. COUNT, SUM, etc.
	*
	* @var Array
	*/
	var $AggregatedCalculatedFields = 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');
	$this->mode = '';
	}

	/**
	* Set object' TableName to Temp table from config
	*
	* @access public
	*/
	function SwitchToTemp()
	{
	$this->TableName = $this->Application->getUnitOption($this->Prefix, 'TableName');
	$this->SetTableName( $this->Application->GetTempName($this->TableName, 'prefix:'.$this->Prefix) );
	$this->mode = 't';
	}

	/**
	* Checks if object uses temp table
	*
	* @return bool
	*/
	function IsTempTable()
	{
	return $this->Application->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;
	}
	$query = str_replace( Array('%1$s','%s'), $this->TableName, $base_query);
	$query = $this->replaceModePrefix($query);
	return $query;
	}


	/**
	* Returns required mixing of aggregated & non-aggregated calculated fields
	*
	* @param int $aggregated 0 - having + aggregated, 1 - having only, 2 - aggregated only
	* @return Array
	*/
	function getCalculatedFields($aggregated = 0)
	{
	switch ($aggregated) {
	case 0:
	$fields = array_merge($this->CalculatedFields, $this->AggregatedCalculatedFields);
	break;

	case 1:
	$fields = $this->CalculatedFields;
	break;

	case 2:
	$fields = $this->AggregatedCalculatedFields;
	break;

	default:
	$fields = Array();
	break;
	}

	return $fields;
	}

	/**
	* Insert calculated fields sql into query in place of %2$s,
	* return processed query.
	*
	* @param string $query
	* @param int $aggregated 0 - having + aggregated, 1 - having only, 2 - aggregated only
	* @return string
	*/
	function addCalculatedFields($query, $aggregated = 1)
	{
	$fields = $this->getCalculatedFields($aggregated);
	if ($fields) {
	$sql = Array();
	foreach ($fields 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);
	}
	}

	/**
	* Allows substables to be in same mode as main item (e.g. LEFT JOINED ones)
	*
	* @param string $query
	* @return string
	*/
	function replaceModePrefix($query)
	{
	$live_table = substr($this->Application->GetLiveName($this->TableName), strlen(TABLE_PREFIX));
	if (preg_match('/'.preg_quote(TABLE_PREFIX, '/').'(.*)'.preg_quote($live_table, '/').'/', $this->TableName, $rets)) {
	// will only happen, when table has a prefix (like in K4)
	return str_replace('%3$s', $rets[1], $query);
	}

	// will happen, when K3 table without prefix is used
	return $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;
	}

	/**
	* Performs initial object configuration
	*
	* @param bool $populate_ml_fields create all ml fields from db in config or not
	*/
	function Configure($populate_ml_fields = false)
	{
	$this->setTableName( $this->Application->getUnitOption($this->Prefix, 'TableName') );
	$this->setIDField( $this->Application->getUnitOption($this->Prefix, 'IDField') );

	$this->defineFields();

	$this->ApplyFieldModifiers(); // should be called only after all fields definitions been set
	$this->prepareConfigOptions(); // this should go last, but before setDefaultValues, order is significant!

	$this->SetDefaultValues($populate_ml_fields);
	}

	/**
	* Add field definitions from all possible sources (DB Fields, Virtual Fields, Calcualted Fields, e.t.c.)
	*
	*/
	function defineFields()
	{
	$this->setConfigFields( $this->Application->getUnitOption($this->Prefix, 'Fields') );
	$this->setCustomFields( $this->Application->getUnitOption($this->Prefix, 'CustomFields', Array()) );
	$this->setVirtualFields( $this->Application->getUnitOption($this->Prefix, 'VirtualFields') );
	$this->setCalculatedFields( $this->Application->getUnitOption($this->Prefix, 'CalculatedFields', Array()) );
	$this->setAggragatedCalculatedFields( $this->Application->getUnitOption($this->Prefix, 'AggregatedCalculatedFields', Array()) );
	}

	function setCalculatedFields($fields)
	{
	$this->CalculatedFields = isset($fields[$this->Special]) ? $fields[$this->Special] : (isset($fields['']) ? $fields[''] : Array());
	}

	function setAggragatedCalculatedFields($fields)
	{
	$this->AggregatedCalculatedFields = isset($fields[$this->Special]) ? $fields[$this->Special] : (isset($fields['']) ? $fields[''] : Array());
	}

	/**
	* Set's field names from table
	* from config
	*
	* @param Array $fields
	* @access public
	*/
	function setCustomFields($fields)
	{
	$this->customFields = $fields;
	}

	/**
	* Set's field names from table
	* from config
	*
	* @param Array $fields
	* @access public
	*/
	function setConfigFields($fields)
	{
	$this->Fields = $fields;
	}

	/**
	* Override field options with ones defined in submit via "field_modfiers" array (common for all prefixes)
	*
	* @access private
	* @author Alex
	*/
	function ApplyFieldModifiers($field_modifiers = null)
	{
	- $allowed_modifiers = Array('required');
	+ $allowed_modifiers = Array('required', 'multiple');

	if ($this->Application->IsAdmin()) {
	// can change upload dir on the fly (admin only!)
	$allowed_modifiers[] = 'upload_dir';
	}

	if (!isset($field_modifiers)) {
	$field_modifiers = $this->Application->GetVar('field_modifiers');
	if (!$field_modifiers) {
	// no field modifiers
	return false;
	}

	$field_modifiers = getArrayValue($field_modifiers, $this->getPrefixSpecial());
	}

	if (!$field_modifiers) {
	// no field modifiers for current prefix_special
	return false;
	}

	foreach ($field_modifiers as $field => $field_options)
	{
	foreach ($field_options as $option_name => $option_value)
	{
	if ( !in_array(strtolower($option_name), $allowed_modifiers) ) continue;
	$this->Fields[$field][$option_name] = $option_value;
	}
	}
	}

	/**
	* 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($this->VirtualFields, $this->Fields);
	// $this->Fields = array_merge_recursive2($this->VirtualFields, $this->Fields);
	}
	}

	function SetDefaultValues($populate_ml_fields = false)
	{
	foreach($this->Fields as $field => $options)
	{
	if( isset($options['default']) && $options['default'] === '#NOW#')
	{
	$this->Fields[$field]['default'] = adodb_mktime();
	}
	}
	}

	function SetFieldOptions($field, $options)
	{
	$this->Fields[$field] = $options;
	}

	function GetFieldOptions($field)
	{
	if (isset($this->Fields[$field])) {
	$options_prepared = array_key_exists('options_prepared', $this->Fields[$field]) ? $this->Fields[$field]['options_prepared'] : false;
	if (!$options_prepared) {
	$this->PrepareFieldOptions($field);
	$this->Fields[$field]['options_prepared'] = true;
	}

	return $this->Fields[$field];
	}
	else {
	return 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($fields=null)
	{
	if (!is_array($fields)) {
	$fields = array_keys($this->Fields);
	}
	foreach ($fields as $field) {
	if ( isset($this->Fields[$field]['formatter']) ) {
	$formatter =& $this->Application->recallObject($this->Fields[$field]['formatter']);
	$formatter->UpdateSubFields($field, $this->GetDBField($field), $this->Fields[$field], $this);
	}
	}
	}

	function prepareConfigOptions()
	{
	foreach (array_keys($this->Fields) as $field_name)
	{
	// $this->PrepareFieldOptions($field_name);
	$this->PrepareOptions($field_name);
	}
	}

	/**
	* Escapes fields only, not expressions
	*
	* @param string $field_expr
	* @return string
	*/
	function escapeField($field_expr)
	{
	return preg_match('/[.(]/', $field_expr) ? $field_expr : '`'.$field_expr.'`';
	}

	/**
	* Replaces current language id in given field options
	*
	* @param string $field_name
	* @param Array $field_option_names
	*/
	function _replaceLanguageId($field_name, $field_option_names)
	{
	$language_id = $this->Application->GetVar('m_lang');

	$field_options =& $this->Fields[$field_name];
	foreach ($field_option_names as $option_name) {
	$field_options[$option_name] = str_replace('%2$s', $language_id, $field_options[$option_name]);
	}
	}

	function PrepareFieldOptions($field_name)
	{
	$field_options =& $this->Fields[$field_name];
	if (array_key_exists('options_sql', $field_options) ) {
	// get options based on given sql
	$replace_options = Array ('option_title_field', 'option_key_field', 'options_sql');
	$this->_replaceLanguageId($field_name, $replace_options);

	$select_clause = $this->escapeField($field_options['option_title_field']) . ',' . $this->escapeField($field_options['option_key_field']);
	$sql = sprintf($field_options['options_sql'], $select_clause);
	$dynamic_options = $this->Conn->GetCol($sql, preg_replace('/^.*?\./', '', $field_options['option_key_field']));

	$options_hash = array_key_exists('options', $field_options) ? $field_options['options'] : Array ();
	$field_options['options'] = array_merge_recursive2($options_hash, $dynamic_options);
	}
	}

	function PrepareOptions($field_name)
	{
	if ( isset($this->Fields[$field_name]['formatter']) )
	{
	$formatter =& $this->Application->recallObject( $this->Fields[$field_name]['formatter'] );
	$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);
	}

	/**
	* Allows kDBTagProcessor.SectionTitle to detect if it's editing or new item creation
	*
	* @return bool
	*/
	function IsNewItem()
	{
	return $this->GetID() ? false : true;
	}

	/**
	* Returns parent table information
	*
	* @param bool $from_temp load parent item from temp table
	* @param string $special special of main item
	* @param bool $guess_special if object retrieved with specified special is not loaded, then try not to use special
	* @return Array
	*/
	function getLinkedInfo($special = '', $guess_special = false)
	{
	$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
	);

	if (is_array($table_info['ForeignKey'])) {
	$table_info['ForeignKey'] = getArrayValue($table_info, 'ForeignKey', $parent_prefix);
	}

	if (is_array($table_info['ParentTableKey'])) {
	$table_info['ParentTableKey'] = getArrayValue($table_info, 'ParentTableKey', $parent_prefix);
	}

	$main_object =& $this->Application->recallObject($parent_prefix.'.'.$special, null, Array ('raise_warnings' => 0));
	/* @var $main_object kDBItem */

	if (!$main_object->isLoaded() && $guess_special) {
	$main_object =& $this->Application->recallObject($parent_prefix);
	}

	return array_merge($table_info, Array('ParentId'=> $main_object->GetDBField( $table_info['ParentTableKey'] ) ) );
	}

	return false;
	}

	/**
	* Returns true if item was queried/loaded
	*
	* @return bool
	*/
	function isLoaded()
	{
	return false;
	}

	/**
	* Returns specified field value from all selected rows.
	* Don't affect current record index
	*
	* @param string $field
	* @return Array
	*/
	function GetCol($field)
	{
	return Array ();
	}
	}

	?>
	\ No newline at end of file
	Index: branches/RC/core/units/custom_data/custom_data_event_handler.php
	===================================================================
	--- branches/RC/core/units/custom_data/custom_data_event_handler.php (revision 11894)
	+++ branches/RC/core/units/custom_data/custom_data_event_handler.php (revision 11895)
	@@ -1,176 +1,177 @@
	<?php
	/**
	* @version $Id$
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2009 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.net/license/ for copyright notices and details.
	*/

	class CustomDataEventHandler extends kDBEventHandler {

	/**
	* [HOOK] Allows to apply custom fields functionality to specific config
	* When main item is created, then cdata config is cloned
	*
	* @param kEvent $event
	*/
	function OnDefineCustomFields(&$event)
	{
	// 1. clone customdata table
	$clones = $this->Application->getUnitOption('cdata', 'Clones');
	$clones[$event->MasterEvent->Prefix.'-cdata'] = Array (
	'ParentPrefix' => $event->MasterEvent->Prefix,
	'TableName' => $this->Application->getUnitOption($event->MasterEvent->Prefix, 'TableName').'CustomData',
	);
	$this->Application->setUnitOption('cdata', 'Clones', $clones);

	// 2. add custom field information to main item
	$this->createCustomFields($event->MasterEvent->Prefix);
	}

	function scanCustomFields($prefix)
	{
	static $custom_fields = Array ();

	if (defined('IS_INSTALL') && IS_INSTALL && !$this->Application->TableFound('CustomField')) {
	return false;
	}

	if (!$prefix) {
	// prefix not specified
	return false;
	}

	$item_type = $this->Application->getUnitOption($prefix, 'ItemType');
	if (!$item_type) {
	// no main config of such type
	return false;
	}

	if (!$custom_fields \|\| (defined('IS_INSTALL') && IS_INSTALL)) {
	// query all custom fields at once -> saves 4 sqls queries
	$sql = 'SELECT *
	FROM '.TABLE_PREFIX.'CustomField';
	$all_custom_fields = $this->Conn->Query($sql, 'CustomFieldId');
	ksort($all_custom_fields);

	foreach ($all_custom_fields as $custom_field_id => $custom_field_data) {
	$cf_type = $custom_field_data['Type'];
	if (!array_key_exists($cf_type, $custom_fields)) {
	$custom_fields[$cf_type] = Array ();
	}

	$custom_fields[$cf_type][$custom_field_id] = $custom_field_data;
	}
	}

	return array_key_exists($item_type, $custom_fields) ? $custom_fields[$item_type] : false;
	}

	/**
	* Fills cloned cdata config with data from it's parent
	*
	* @param kEvent $event
	*/
	function OnAfterConfigRead(&$event)
	{
	$main_prefix = $this->Application->getUnitOption($event->Prefix, 'ParentPrefix');
	if (!$main_prefix) {
	return false;
	}

	$custom_fields = $this->scanCustomFields($main_prefix);
	if (!$custom_fields) {
	return false;
	}

	// 2. create fields (for customdata item)
	$fields = $this->Application->getUnitOption($event->Prefix, 'Fields', Array());
	$field_options = Array('type' => 'string', 'formatter' => 'kMultiLanguage', 'db_type' => 'text', 'default' => '');
	foreach ($custom_fields as $custom_id => $custom_params) {
	if (isset($fields['cust_'.$custom_id])) continue;
	$fields['cust_'.$custom_id] = $field_options;
	$fields['cust_'.$custom_id]['force_primary'] = !$custom_params['MultiLingual'];
	}
	$this->Application->setUnitOption($event->Prefix, 'Fields', $fields);
	}

	/**
	* Creates "cust_<custom_name>" virtual fields for main item
	*
	* @param string $prefix
	*/
	function createCustomFields($prefix)
	{
	$custom_fields = $this->scanCustomFields($prefix);
	if (!$custom_fields) {
	return false;
	}

	$calculated_fields = Array();
	$virtual_fields = $this->Application->getUnitOption($prefix, 'VirtualFields', Array());

	$cf_helper =& $this->Application->recallObject('InpCustomFieldsHelper');
	$ml_formatter =& $this->Application->recallObject('kMultiLanguage');
	/* @var $ml_formatter kMultiLanguage */

	foreach ($custom_fields as $custom_id => $custom_params) {
	$custom_name = $custom_params['FieldName'];
	$field_options = Array('type' => 'string', 'not_null' => 1, 'default' => $custom_params['DefaultValue']);

	// raises warnings during 4.3.9 -> 5.0.0 upgrade, no fatal sqls though
	if ($custom_params['IsRequired']) {
	$field_options['required'] = 1;
	}

	switch ($custom_params['ElementType']) {
	case 'date':
	case 'datetime':
	unset($field_options['options']);
	$field_options['formatter'] = 'kDateFormatter';
	break;

	case 'select':
	case 'multiselect':
	case 'radio':
	if ($custom_params['ValueList']) {
	$field_options['options'] = $cf_helper->GetValuesHash($custom_params['ValueList']);
	$field_options['formatter'] = 'kOptionsFormatter';
	+ $field_options['multiple'] = $custom_params['ElementType'] == 'multiselect';
	}
	break;

	default:
	if ($custom_params['MultiLingual']) {
	$calculated_fields['cust_'.$custom_name.'_Primary'] = 'cust.'.$ml_formatter->LangFieldName('cust_'.$custom_id, true);
	$virtual_fields['cust_'.$custom_name.'_Primary'] = $field_options;
	$field_options['master_field'] = 'cust_'.$custom_name.'_Primary';
	$field_options['formatter'] = 'kCustomFieldFormatter';
	}
	break;
	}

	$calculated_fields['cust_'.$custom_name] = 'cust.'.$ml_formatter->LangFieldName('cust_'.$custom_id, !$custom_params['MultiLingual']);
	if (!isset($virtual_fields['cust_'.$custom_name])) {
	$virtual_fields['cust_'.$custom_name] = Array();
	}
	$virtual_fields['cust_'.$custom_name] = array_merge_recursive2($field_options, $virtual_fields['cust_'.$custom_name]);
	$custom_fields[$custom_id] = $custom_name;
	}

	$config_calculated_fields = $this->Application->getUnitOption($prefix, 'CalculatedFields', Array());
	foreach ($config_calculated_fields as $special => $special_fields) {
	$config_calculated_fields[$special] = array_merge_recursive2($config_calculated_fields[$special], $calculated_fields);
	}
	$this->Application->setUnitOption($prefix, 'CalculatedFields', $config_calculated_fields);

	$this->Application->setUnitOption($prefix, 'CustomFields', $custom_fields);
	$this->Application->setUnitOption($prefix, 'VirtualFields', $virtual_fields);
	}
	}
	?>
	\ No newline at end of file
	Index: branches/RC/core/units/general/helpers/search_helper.php
	===================================================================
	--- branches/RC/core/units/general/helpers/search_helper.php (revision 11894)
	+++ branches/RC/core/units/general/helpers/search_helper.php (revision 11895)
	@@ -1,698 +1,706 @@
	<?php
	/**
	* @version $Id$
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2009 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.net/license/ for copyright notices and details.
	*/

	class kSearchHelper extends kHelper {


	/**
	* Splits search phrase into keyword using quotes,plus and minus sings and spaces as split criteria
	*
	* @param string $keyword
	* @return string
	*/
	function splitKeyword($keyword)
	{
	if ($this->Application->ConfigValue('CheckStopWords')) {
	$keyword_after_remove = $this->_removeStopWords($keyword);
	if ($keyword_after_remove) {
	// allow to search through stop word grid
	$keyword = $keyword_after_remove;
	}
	}

	$quotes_re = '/([+\-]?)"(.*?)"/';
	$no_quotes_re = '/([+\-]?)([^ ]+)/';

	$quoted_kw = preg_match_all($quotes_re, $keyword, $res);
	foreach ($res[2] as $index => $kw) $final[$kw] = $res[1][$index];
	$keyword = preg_replace($quotes_re, '', $keyword);
	$not_quoted_kw = preg_match_all($no_quotes_re, $keyword, $res);
	foreach ($res[2] as $index => $kw) $final[$kw] = $res[1][$index];

	return $final;
	}

	function getPositiveKeywords($keyword)
	{
	$keywords = $this->splitKeyword($keyword);

	$ret = Array();
	foreach ($keywords as $keyword => $sign) {
	if ($sign == '+' \|\| $sign == '') {
	$ret[] = $keyword;
	}
	}
	return $ret;
	}

	function buildWhereClause($keyword, $fields)
	{
	$keywords = $this->splitKeyword($keyword);

	$normal_conditions = Array();
	$plus_conditions = Array();
	$minus_conditions = Array();

	foreach ($keywords as $keyword => $sign) {
	switch ($sign) {
	case '+':
	$plus_conditions[] = implode(' LIKE "%'.$keyword.'%" OR ', $fields).' LIKE "%'.$keyword.'%"';
	break;

	case '-':
	foreach ($fields as $field) {
	$condition[] = $field.' NOT LIKE "%'.$keyword.'%" OR '.$field.' IS NULL';
	}
	$minus_conditions[] = '('.implode(') AND (', $condition).')';
	break;

	case '':
	$keyword = str_replace('"', '\"', $keyword);
	$normal_conditions[] = implode(' LIKE "%'.$keyword.'%" OR ', $fields).' LIKE "%'.$keyword.'%"';
	break;
	}
	}

	// building where clause
	if ($normal_conditions) {
	$where_clause = '('.implode(') OR (', $normal_conditions).')';
	}
	else {
	$where_clause = '1';
	}

	if ($plus_conditions) {
	$where_clause = '('.$where_clause.') AND ('.implode(') AND (', $plus_conditions).')';
	}

	if ($minus_conditions) {
	$where_clause = '('.$where_clause.') AND ('.implode(') AND (', $minus_conditions).')';
	}

	return $where_clause;
	}

	/**
	* Returns additional information about search field
	*
	* @param kDBList $object
	* @param string $field_name
	* @return Array
	*/
	function _getFieldInformation(&$object, $field_name)
	{
	$sql_filter_type = isset($object->VirtualFields[$field_name]) ? 'having' : 'where';
	$field_type = isset($object->Fields[$field_name]['type']) ? $object->Fields[$field_name]['type'] : 'string';

	if (preg_match('/(.)\.(.)/', $field_name, $regs)) {
	$table_name = '`'.$regs[1].'`.'; // field from external table
	$field_name = $regs[2];
	}
	elseif ($sql_filter_type == 'where') {
	$table_name = '`'.$object->TableName.'`.'; // field from local table
	}

	$table_name = ($sql_filter_type == 'where') ? $table_name : '';

	// replace wid inside table name to WID_MARK constant value
	$is_temp_table = preg_match('/(.)'.TABLE_PREFIX.'ses_'.$this->Application->GetSID().'(_[\d]+){0,1}_edit_(.)/', $table_name, $regs);
	if ($is_temp_table) {
	$table_name = $regs[1].TABLE_PREFIX.'ses_'.EDIT_MARK.'_edit_'.$regs[3]; // edit_mark will be replaced with sid[_main_wid] in AddFilters
	}

	return Array ($field_name, $field_type, $table_name, $sql_filter_type);
	}

	/**
	* Removes stop words from keyword
	*
	* @param string $keyword
	* @return string
	*/
	function _removeStopWords($keyword)
	{
	static $stop_words = Array ();

	if (!$stop_words) {
	$sql = 'SELECT StopWord
	FROM ' . $this->Application->getUnitOption('stop-word', 'TableName') . '
	ORDER BY LENGTH(StopWord) DESC, StopWord ASC';
	$stop_words = $this->Conn->GetCol($sql);

	foreach ($stop_words as $index => $stop_word) {
	$stop_words[$index] = '/(^\| )' . preg_quote($stop_word, '/') . '( \|$)/';
	}
	}

	$keyword = preg_replace($stop_words, ' ', $keyword);

	return trim( preg_replace('/[ ]+/', ' ', $keyword) );
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function performSearch(&$event)
	{
	$object =& $event->getObject();

	// process search keyword
	$search_keyword = $this->Application->GetVar( $event->getPrefixSpecial(true).'_search_keyword');
	$this->Application->StoreVar( $event->getPrefixSpecial().'_search_keyword', $search_keyword);
	$search_keyword = str_replace('*', '%', $search_keyword);

	$custom_filter = $this->processCustomFilters($event);

	if(!$search_keyword && $custom_filter === false) {
	$this->resetSearch($event);
	return true;
	}

	if ($search_keyword) {
	$this->processAutomaticFilters($event, $search_keyword, $custom_filter);
	}
	}


	function processAutomaticFilters(&$event, $search_keyword, $custom_filter)
	{
	$grid_name = $this->Application->GetVar('grid_name');
	$grids = $this->Application->getUnitOption($event->Prefix, 'Grids');
	$search_fields = array_keys($grids[$grid_name]['Fields']);

	$search_filter = Array();
	$object =& $event->getObject();

	foreach ($search_fields as $search_field) {
	$custom_search = isset($custom_filter[$search_field]);

	$filter_data = $this->getSearchClause($object, $search_field, $search_keyword, $custom_search);

	if ($filter_data) {
	$search_filter[$search_field] = $filter_data;
	}
	else {
	unset($search_filter[$search_field]);
	}
	}
	$this->Application->StoreVar($event->getPrefixSpecial().'_search_filter', serialize($search_filter) );
	}

	/**
	* Returns search clause for any particular field
	*
	* @param kDBList $object
	* @param string $search_field
	* @param string $search_keyword what we are searching (false, when building custom filter clause)
	* @param string $custom_search already found using custom filter
	* @return Array
	*/
	function getSearchClause(&$object, $field_name, $search_keyword, $custom_search)
	{
	if (array_key_exists($field_name, $object->VirtualFields) && !array_key_exists($field_name, $object->CalculatedFields)) {
	// Virtual field, that is shown in grid, but it doesn't have corresponding calculated field.
	// Happens, when field value is calculated on the fly (during grid display) and it is not searchable.
	return '';
	}

	$search_keywords = $this->splitKeyword($search_keyword);

	list ($field_name, $field_type, $table_name, $sql_filter_type) = $this->_getFieldInformation($object, $field_name);

	$filter_value = '';

	// get field clause by formatter name and/or parameters
	$formatter = getArrayValue($object->Fields[$field_name], 'formatter');
	switch ($formatter) {
	case 'kOptionsFormatter':
	$search_keys = Array();

	if ($custom_search === false) {
	// if keywords passed through simple search filter (on each grid)
	$use_phrases = getArrayValue($object->Fields[$field_name], 'use_phrases');
	$field_options = $object->GetFieldOptions($field_name);
	+ $multiple = array_key_exists('multiple', $field_options) && $field_options['multiple'];
	+
	foreach ($field_options['options'] as $key => $val) {
	foreach ($search_keywords as $keyword => $sign) {
	$pattern = '#'.$keyword.'#i';
	if (!preg_match($pattern, $use_phrases ? $this->Application->Phrase($val) : $val)) {
	if ($sign == '+') {
	$filter_value = $table_name.'`'.$field_name.'` = NULL';
	break;
	}
	else {
	continue;
	}
	}

	if ($sign == '+' \|\| $sign == '') {
	- $search_keys[$key] = $this->Conn->qstr($key);
	+ // don't add single quotes to found option ids when multiselect (but escape string anyway)
	+ $search_keys[$key] = $multiple ? mysql_real_escape_string($key) : $this->Conn->qstr($key);
	}
	elseif($sign == '-') {
	// if same value if found as exclusive too, then remove from search result
	unset($search_keys[$key]);
	}
	}
	}
	}

	if ($search_keys) {
	- $filter_value = $table_name.'`'.$field_name.'` IN ('.implode(',', $search_keys).')';
	+ if ($multiple) {
	+ $filter_value = $table_name.'`'.$field_name.'` LIKE "%\|' . implode('\|%" OR ' . $table_name.'`'.$field_name.'` LIKE "%\|', $search_keys) . '\|%"';
	+ }
	+ else {
	+ $filter_value = $table_name.'`'.$field_name.'` IN ('.implode(',', $search_keys).')';
	+ }
	}

	$field_processed = true;
	break;

	case 'kDateFormatter':
	// if date is searched using direct filter, then do nothing here, otherwise search using LIKE clause
	$field_processed = ($custom_search !== false) ? true : false;
	break;

	default:
	$field_processed = false;
	break;
	}

	// if not already processed by formatter, then get clause by field type
	if (!$field_processed && $search_keywords) {
	switch($field_type)
	{
	case 'int':
	case 'integer':
	case 'numeric':
	$search_keys = Array();
	foreach ($search_keywords as $keyword => $sign) {
	if (!is_numeric($keyword) \|\| ($sign == '-')) continue;
	$search_keys[] = $this->Conn->qstr($keyword);
	}

	if ($search_keys) {
	$filter_value = $table_name.'`'.$field_name.'` IN ('.implode(',', $search_keys).')';
	}
	break;

	case 'double':
	case 'float':
	case 'real':
	$search_keys = Array();
	foreach ($search_keywords as $keyword => $sign) {
	$keyword = str_replace(',', '.', $keyword);
	if (!is_numeric($keyword) \|\| ($sign == '-')) continue;
	$search_keys[] = 'ABS('.$table_name.'`'.$field_name.'` - '.$this->Conn->qstr($keyword).') <= 0.0001';
	}

	if ($search_keys) {
	$filter_value = '('.implode(') OR (', $search_keys).')';
	}
	break;

	case 'string':
	$filter_value = $this->buildWhereClause($search_keyword, Array($table_name.'`'.$field_name.'`'));
	break;
	}
	}

	if ($filter_value) {
	return Array('type' => $sql_filter_type, 'value' => $filter_value);
	}

	return false;
	}

	/**
	* Processes custom filters from submit
	*
	* @param KEvent $event
	* @return bool
	*/
	function processCustomFilters(&$event)
	{
	$grid_name = $this->Application->GetVar('grid_name');

	// update "custom filter" with values from submit: begin
	$view_name = $this->Application->RecallVar($event->getPrefixSpecial().'_current_view');
	$custom_filters = $this->Application->RecallPersistentVar($event->getPrefixSpecial().'_custom_filter.'.$view_name/, ALLOW_DEFAULT_SETTINGS/);
	if ($custom_filters) {
	$custom_filters = unserialize($custom_filters);
	$custom_filter = isset($custom_filters[$grid_name]) ? $custom_filters[$grid_name] : Array ();
	}
	else {
	$custom_filter = Array ();
	}

	// submit format custom_filters[prefix_special][field]
	$submit_filters = $this->Application->GetVar('custom_filters');
	if ($submit_filters) {
	$submit_filters = getArrayValue($submit_filters, $event->getPrefixSpecial(), $grid_name);
	if ($submit_filters) {
	foreach ($submit_filters as $field_name => $field_options) {
	list ($filter_type, $field_value) = each($field_options);
	$is_empty = strlen(is_array($field_value) ? implode('', $field_value) : $field_value) == 0;
	if ($is_empty) {
	if (isset($custom_filter[$field_name])) {
	// use isset, because non-existing key will cause "php notice"!
	unset($custom_filter[$field_name][$filter_type]); // remove filter

	if (!$custom_filter[$field_name]) {
	// if no filters left for field, then delete record at all
	unset($custom_filter[$field_name]);
	}
	}
	}
	else {
	$custom_filter[$field_name][$filter_type]['submit_value'] = $field_value;
	}
	}
	}
	}

	if ($custom_filter) {
	$custom_filters[$grid_name] = $custom_filter;
	}
	else {
	unset($custom_filters[$grid_name]);
	}
	// update "custom filter" with values from submit: end

	if (!$custom_filter) {
	// in case when no filters specified, there are nothing to process
	$this->Application->StorePersistentVar($event->getPrefixSpecial().'_custom_filter.'.$view_name, serialize($custom_filters) );
	return false;
	}

	$object =& $event->getObject(); // don't recall it each time in getCustomFilterSearchClause
	$grid_info = $this->Application->getUnitOption($event->Prefix.'.'.$grid_name, 'Grids');
	foreach ($custom_filter as $field_name => $field_options) {
	list ($filter_type, $field_options) = each($field_options);
	$field_options['grid_options'] = $grid_info['Fields'][$field_name];
	$field_options = $this->getCustomFilterSearchClause($object, $field_name, $filter_type, $field_options);
	if ($field_options['value']) {
	unset($field_options['grid_options']);
	$custom_filter[$field_name][$filter_type] = $field_options;
	}
	}

	$custom_filters[$grid_name] = $custom_filter;
	$this->Application->StorePersistentVar($event->getPrefixSpecial().'_custom_filter.'.$view_name, serialize($custom_filters) );
	return $custom_filter;
	}

	/**
	* Checks, that range filters "To" part is defined for given grid
	*
	* @param string $prefix_special
	* @param string $grid_name
	* @return bool
	*/
	function rangeFiltersUsed($prefix_special, $grid_name)
	{
	static $cache = Array ();
	$cache_key = $prefix_special . $grid_name;

	if (array_key_exists($cache_key, $cache)) {
	return $cache[$cache_key];
	}

	$view_name = $this->Application->RecallVar($prefix_special . '_current_view');
	$custom_filters = $this->Application->RecallPersistentVar($prefix_special . '_custom_filter.' . $view_name/, ALLOW_DEFAULT_SETTINGS/);
	if (!$custom_filters) {
	// filters not defined for given prefix
	$cache[$cache_key] = false;
	return false;
	}

	$custom_filters = unserialize($custom_filters);
	if (!array_key_exists($grid_name, $custom_filters)) {
	// filters not defined for given grid
	$cache[$cache_key] = false;
	return false;
	}

	$range_filter_defined = false;

	$custom_filter = $custom_filters[$grid_name];
	foreach ($custom_filter as $field_name => $field_options) {
	list ($filter_type, $field_options) = each($field_options);

	if (strpos($filter_type, 'range') === false) {
	continue;
	}

	$to_value = (string)$field_options['submit_value']['to'];
	if ($to_value !== '') {
	$range_filter_defined = true;
	break;
	}
	}

	$cache[$cache_key] = $range_filter_defined;
	return $range_filter_defined;
	}

	/**
	* Return numeric range filter value + checking that it's number
	*
	* @param Array $value array containing range filter value
	* @return unknown
	*/
	function getRangeValue($value)
	{
	return strlen($value) && is_numeric($value) ? $this->Conn->qstr($value) : false;
	}

	function getCustomFilterSearchClause(&$object, $field_name, $filter_type, $field_options)
	{
	// this is usually used for mutlilingual fields and date fields
	if (isset($field_options['grid_options']['sort_field'])) {
	$field_name = $field_options['grid_options']['sort_field'];
	}
	list ($field_name, $field_type, $table_name, $sql_filter_type) = $this->_getFieldInformation($object, $field_name);

	$filter_value = '';

	switch ($filter_type) {
	case 'range':
	$from = $this->getRangeValue($field_options['submit_value']['from']);
	$to = $this->getRangeValue($field_options['submit_value']['to']);

	if ($from !== false && $to !== false) {
	// add range filter
	$filter_value = $table_name.'`'.$field_name.'` >= '.$from.' AND '.$table_name.'`'.$field_name.'` <= '.$to;
	}
	elseif ($from !== false) {
	// add equals filter on $from
	$filter_value = $table_name.'`'.$field_name.'` = '.$from;
	}
	elseif ($to !== false) {
	// add equals filter on $to
	$filter_value = $table_name.'`'.$field_name.'` = '.$to;
	}
	break;

	case 'float_range':
	// MySQL can't compare values in "float" type columns using "=" operator
	$from = $this->getRangeValue($field_options['submit_value']['from']);
	$to = $this->getRangeValue($field_options['submit_value']['to']);

	if ($from !== false && $to !== false) {
	// add range filter
	$filter_value = $table_name.'`'.$field_name.'` >= '.$from.' AND '.$table_name.'`'.$field_name.'` <= '.$to;
	}
	elseif ($from !== false) {
	// add equals filter on $from
	$filter_value = 'ABS('.$table_name.'`'.$field_name.'` - '.$from.') <= 0.0001';
	}
	elseif ($to !== false) {
	// add equals filter on $to
	$filter_value = 'ABS('.$table_name.'`'.$field_name.'` - '.$to.') <= 0.0001';
	}
	break;

	case 'date_range':
	$from = $this->processRangeField($object, $field_name, $field_options['submit_value'], 'from');
	$to = $this->processRangeField($object, $field_name, $field_options['submit_value'], 'to');

	$day_seconds = 23 * 60 * 60 + 59 * 60 + 59;
	if ($from !== false && $to === false) {
	$from = strtotime(date('Y-m-d', $from) . ' 00:00:00', $from); // reset to morning
	$to = $from + $day_seconds;
	}
	elseif ($from === false && $to !== false) {
	$to = strtotime(date('Y-m-d', $to) . ' 23:59:59', $to); // reset to evening
	$from = $to - $day_seconds;
	}

	if ($from !== false && $to !== false) {
	$filter_value = $table_name.'`'.$field_name.'` >= '.$from.' AND '.$table_name.'`'.$field_name.'` <= '.$to;
	}
	break;

	case 'equals':
	case 'options':
	$field_value = strlen($field_options['submit_value']) ? $this->Conn->qstr($field_options['submit_value']) : false;
	if ($field_value) {
	$filter_value = $table_name.'`'.$field_name.'` = '.$field_value;
	}
	break;

	case 'picker':
	$field_value = strlen($field_options['submit_value']) ? $field_options['submit_value'] : false;
	if ($field_value) {
	$filter_value = $table_name.'`'.$field_name.'` LIKE "%\|'.$field_value.'\|%"';
	}
	break;

	case 'like':
	$filter_value = $this->buildWhereClause($field_options['submit_value'], Array($table_name.'`'.$field_name.'`'));
	break;

	default:
	break;
	}

	$field_options['sql_filter_type'] = $sql_filter_type;
	$field_options['value'] = $filter_value;

	return $field_options;
	}

	/**
	* Enter description here...
	*
	* @param kdbItem $object
	* @param string $search_field
	* @param string $value
	* @param string $type
	*/
	function processRangeField(&$object, $search_field, $value, $type)
	{
	if (!strlen($value[$type])) {
	return false;
	}

	$options = $object->GetFieldOptions($search_field);
	$dt_separator = array_key_exists('date_time_separator', $options) ? $options['date_time_separator'] : ' ';
	$value[$type] = trim($value[$type], $dt_separator); // trim any

	$tmp_value = explode($dt_separator, $value[$type], 2);
	if (count($tmp_value) == 1) {
	$time_format = $this->_getInputTimeFormat($options);
	if ($time_format) {
	// time is missing, but time format available -> guess time and add to date
	$time = ($type == 'from') ? adodb_mktime(0, 0, 0) : adodb_mktime(23, 59, 59);
	$time = adodb_date($time_format, $time);
	$value[$type] .= $dt_separator . $time;
	}
	}

	$formatter =& $this->Application->recallObject($object->Fields[$search_field]['formatter']);

	$value_ts = $formatter->Parse($value[$type], $search_field, $object);
	$pseudo = getArrayValue($object->FieldErrors, $search_field, 'pseudo');
	if ($pseudo) {
	unset($object->FieldErrors[$search_field]); // remove error!
	// invalid format -> ignore this date in search
	return false;
	}
	return $value_ts;
	}

	/**
	* Returns InputTimeFormat using given field options
	*
	* @param Array $field_options
	* @return string
	*/
	function _getInputTimeFormat($field_options)
	{
	if (array_key_exists('input_time_format', $field_options)) {
	return $field_options['input_time_format'];
	}

	$lang_current =& $this->Application->recallObject('lang.current');
	return $lang_current->GetDBField('InputTimeFormat');
	}

	/**
	* Resets current search
	*
	* @param kEvent $event
	*/
	function resetSearch(&$event)
	{
	$this->Application->RemoveVar($event->getPrefixSpecial().'_search_filter');
	$this->Application->RemoveVar($event->getPrefixSpecial().'_search_keyword');

	$view_name = $this->Application->RecallVar($event->getPrefixSpecial().'_current_view');
	$this->Application->RemovePersistentVar($event->getPrefixSpecial().'_custom_filter.'.$view_name);
	}

	/**
	* Creates filters based on "types" & "except" parameters from PrintList
	*
	* @param kEvent $event
	* @param Array $type_clauses
	* @param string $types
	* @param string $except_types
	*/
	function SetComplexFilter(&$event, &$type_clauses, $types, $except_types)
	{
	$includes_or_filter =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_OR);
	$excepts_and_filter =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_AND);

	$includes_or_filter_h =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_OR);
	$excepts_and_filter_h =& $this->Application->makeClass('kMultipleFilter', FLT_TYPE_AND);

	if ($types) {
	$types = explode(',', $types);
	foreach ($types as $type) {
	$type = trim($type);

	if (isset($type_clauses[$type])) {
	if ($type_clauses[$type]['having_filter']) {
	$includes_or_filter_h->addFilter('filter_'.$type, $type_clauses[$type]['include']);
	} else {
	$includes_or_filter->addFilter('filter_'.$type, $type_clauses[$type]['include']);
	}
	}
	}
	}

	if ($except_types) {
	$except_types = explode(',', $except_types);
	foreach ($except_types as $type) {
	$type = trim($type);

	if (isset($type_clauses[$type])) {
	if ($type_clauses[$type]['having_filter']) {
	$excepts_and_filter_h->addFilter('filter_'.$type, $type_clauses[$type]['except']);
	} else {
	$excepts_and_filter->addFilter('filter_'.$type, $type_clauses[$type]['except']);
	}
	}
	}
	}

	$object =& $event->getObject();

	$object->addFilter('includes_filter', $includes_or_filter);
	$object->addFilter('excepts_filter', $excepts_and_filter);

	$object->addFilter('includes_filter_h', $includes_or_filter_h, HAVING_FILTER);
	$object->addFilter('excepts_filter_h', $excepts_and_filter_h, HAVING_FILTER);
	}
	}

	?>
	\ No newline at end of file

in-portalNo OneTemporaryActions

File Metadata

in-portalView Options

Event Timeline

in-portal
No OneTemporary
Actions

in-portal
View Options