in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sat, Nov 8, 8:29 PM

in-portal
View Options

	Index: trunk/core/kernel/utility/formatters.php
	===================================================================
	--- trunk/core/kernel/utility/formatters.php (revision 2356)
	+++ trunk/core/kernel/utility/formatters.php (revision 2357)
	@@ -1,1033 +1,1040 @@
	<?php

	class kFormatter extends kBase {


	/**
	* Convert's value to match type from config
	*
	* @param mixed $value
	* @param Array $options
	* @return mixed
	* @access protected
	*/
	function TypeCast($value, $options)
	{
	$ret = true;
	if( isset($options['type']) )
	{
	$field_type = $options['type'];
	$type_ok = preg_match('#int\|integer\|double\|float\|real\|numeric\|string#', $field_type);
	if($field_type == 'string') return $value;

	if ($value != '' && $type_ok)
	{
	$ret = is_numeric($value);
	if($ret)
	{
	$f = 'is_'.$field_type;
	settype($value, $field_type);
	$ret = $f($value);
	}
	}
	}

	return $ret ? $value : false;
	}

	//function Format($value, $options, &$errors)
	function Format($value, $field_name, &$object, $format=null)
	{
	if ( is_null($value) ) return '';

	$options = $object->GetFieldOptions($field_name);
	if ( isset($format) ) $options['format'] = $format;
	$tc_value = $this->TypeCast($value,$options);
	if( ($tc_value === false) \|\| ($tc_value != $value) ) return $value; // for leaving badly formatted date on the form

	if (isset($options['format'])) return sprintf($options['format'], $tc_value);

	return $tc_value;
	}

	//function Parse($value, $options, &$errors)
	function Parse($value, $field_name, &$object)
	{
	if ($value == '') return NULL;

	$options = $object->GetFieldOptions($field_name);
	$tc_value = $this->TypeCast($value,$options);
	if($tc_value === false) return $value; // for leaving badly formatted date on the form

	if( isset($options['type']) )
	{
	if( preg_match('#double\|float\|real\|numeric#', $options['type']) ) $tc_value = str_replace(',', '.', $tc_value);
	}

	if( isset($options['regexp']) )
	{
	if( !preg_match($options['regexp'], $value) )
	{
	$object->FieldErrors[$field_name]['pseudo'] = 'invalid_format';
	}
	}

	return $tc_value;
	}

	function HumanFormat($format)
	{
	return $format;
	}


	/**
	* The method is supposed to alter config options or cofigure object in some way based on its usage of formatters
	* The methods is called for every field with formatter defined when configuring item.
	* Could be used for adding additional VirtualFields to an object required by some special Formatter
	*
	* @param string $field_name
	* @param array $field_options
	* @param kDBBase $object
	*/
	function PrepareOptions($field_name, &$field_options, &$object)
	{

	}

	/**
	* Used for split fields like timestamp -> date, time
	* Called from DBItem to update sub fields values after loading item
	*
	* @param unknown_type $field
	* @param unknown_type $value
	* @param unknown_type $options
	* @param unknown_type $object
	*/
	function UpdateSubFields($field, $value, &$options, &$object)
	{

	}

	/**
	* Used for split fields like timestamp -> date, time
	* Called from DBItem Validate (before validation) to get back master field value from its sub_fields
	*
	* @param unknown_type $field
	* @param unknown_type $value
	* @param unknown_type $options
	* @param unknown_type $object
	*/
	function UpdateMasterFields($field, $value, &$options, &$object)
	{

	}

	/* function GetErrorMsg($pseudo_error, $options)
	{
	if ( isset($options['error_msgs'][$pseudo_error]) ) {
	return $options['error_msgs'][$pseudo_error];
	}
	else {
	return $this->ErrorMsgs[$pseudo_error];
	}
	}*/

	function GetSample($field, &$options, &$object)
	{

	}

	}

	class kOptionsFormatter extends kFormatter {

	//function Format($value, $options, &$errors)
	function Format($value, $field_name, &$object, $format=null)
	{
	if ( is_null($value) ) return '';

	$options = $object->GetFieldOptions($field_name);
	if ( isset($format) ) $options['format'] = $format;

	$label = getArrayValue($options['options'], $value);
	if( $label !== false )
	{
	if( getArrayValue($options,'use_phrases') )
	{
	return $this->Application->Phrase($label);
	}
	else
	{
	return $label;
	}
	}
	else
	{
	return $value;
	}
	}
	}

	/**
	* Replacement for kOptionsFormatter in case if options
	* should be selected from database. Use this formatter
	* only in case if formatter attached field is in edit form.
	*
	* For usage in grid just use LEFT JOIN clause to table
	* where requested options are located.
	*/
	class kLEFTFormatter extends kFormatter {

	//function Format($value, $options, &$errors)
	function Format($value, $field_name, &$object, $format=null)
	{
	if ( is_null($value) ) return '';

	$options = $object->GetFieldOptions($field_name);
	if ( isset($format) ) $options['format'] = $format;

	if( !isset($options['options'][$value]) )
	{
	// required option is not defined in config => query for it
	$db =& $this->Application->GetADODBConnection();
	$sql = sprintf($options['left_sql'],$options['left_title_field'],$options['left_key_field'],$value);
	$options['options'][$value] = $db->GetOne($sql);
	}
	return $options['options'][$value];
	}

	//function Parse($value, $options, &$errors)
	function Parse($value, $field_name, &$object)
	{
	if ($value == '') return NULL;

	$options = $object->GetFieldOptions($field_name);
	if( !array_search($value,$options['options']) )
	{
	// required option is not defined in config => query for it
	$db =& $this->Application->GetADODBConnection();
	$sql = sprintf($options['left_sql'],$options['left_key_field'],$options['left_title_field'],$value);
	$found = $db->GetOne($sql);
	if($found !== false) $options['options'][$found] = $value;
	}
	else
	{
	$found = array_search($value,$options['options']);
	}
	if($found === false) $found = $options['default'];
	return $found;
	}
	}


	class kDateFormatter extends kFormatter {

	/* function kDateFormatter()
	{
	parent::kFormatter();
	$this->ErrorMsgs['bad_dformat'] = 'Please use correct date format (%s) ex. (%s)';
	}
	*/

	function PrepareOptions($field_name, &$field_options, &$object)
	{
	$date_format = getArrayValue($field_options, 'date_format');
	$time_format = getArrayValue($field_options, 'time_format');

	$language =& $this->Application->recallObject('lang.current');

	if ($date_format === false) $date_format = $language->GetDBField('DateFormat');
	if ($time_format === false) $time_format = $language->GetDBField('TimeFormat');

	if (!isset($field_options['date_time_separator'])) $field_options['date_time_separator'] = ' ';
	$field_options['format'] = $date_format.$field_options['date_time_separator'].$time_format;
	$field_options['sub_fields'] = Array('date' => $field_name.'_date', 'time' => $field_name.'_time');

	$add_fields = Array();

	$opts = Array('master_field' => $field_name, 'formatter'=>'kDateFormatter', 'format'=>$date_format);
	if ( isset($field_options['default']) ) $opts['default'] = $field_options['default'];
	if ( isset($field_options['required']) ) $opts['required'] = $field_options['required'];

	$add_fields[$field_name.'_date'] = $opts;
	$opts['format'] = $time_format;
	$add_fields[$field_name.'_time'] = $opts;

	if ( !isset($object->VirtualFields[$field_name]) ) {
	// adding caluclated field to format date directly in the query
	if ( !isset($object->CalculatedFields) \|\| !is_array($object->CalculatedFields) ) {
	$object->CalculatedFields = Array();
	}
	$object->CalculatedFields[$field_name.'_formatted'] = 'FROM_UNIXTIME('.'`%1$s`.'.$field_name.', \''.$this->SQLFormat($field_options['format']).'\')';
	$opts['format'] = $field_options['format'];
	$opts['required'] = 0;
	unset($opts['master_field']);
	$add_fields[$field_name.'_formatted'] = $opts;
	}

	$add_fields = array_merge_recursive2($add_fields, $object->VirtualFields);
	$object->setVirtualFields($add_fields);
	}

	function UpdateSubFields($field, $value, &$options, &$object)
	{
	if ( $sub_fields = getArrayValue($options, 'sub_fields') ) {
	if( isset($value) && $value )
	{
	$object->SetDBField( $sub_fields['date'], $value );
	$object->SetDBField( $sub_fields['time'], $value );
	}
	}
	}

	function UpdateMasterFields($field, $value, &$options, &$object)
	{
	// when in master field - set own value from sub_fields
	if ( $sub_fields = getArrayValue($options, 'sub_fields') ) {
	// if date is not empty, but time is empty - set time to 0, otherwise master field fomratter will complain
	// when we have only date field on form, we need time hidden field always empty, don't ask me why!
	if ( $object->GetDBField($sub_fields['date']) != '' && $object->GetDBField($sub_fields['time']) == '' ) {
	$empty_time = getArrayValue($options,'empty_time');
	if($empty_time === false) $empty_time = mktime(0,0,0);
	$object->SetDBField($sub_fields['time'], $empty_time);
	}
	$object->SetField($field, $object->GetField($sub_fields['date']).$options['date_time_separator'].$object->GetField($sub_fields['time']));
	}
	// when in one of sub_fields - call update for master_field to update its value from sub_fields [are you following ? :) ]
	elseif ($master_field = getArrayValue($options, 'master_field') ) {
	$opt =& $object->GetFieldOptions($master_field);
	$this->UpdateMasterFields($master_field, null, $opt, $object);
	}
	}

	//function Format($value, $options, &$errors)
	function Format($value, $field_name, &$object, $format=null)
	{
	if ( is_null($value) ) return '';
	if ( !is_numeric($value) ) return $value; // for leaving badly formatted date on the form
	settype($value, 'int');
	if ( !is_int($value) ) return $value;

	$options = $object->GetFieldOptions($field_name);
	if ( isset($format) ) $options['format'] = $format;

	return date($options['format'], $value);
	}

	function HumanFormat($format)
	{
	$patterns = Array('/m/',
	'/n/',
	'/d/',
	'/j/',
	'/y/',
	'/Y/',
	'/h\|H/',
	'/g\|G/',
	'/i/',
	'/s/',
	'/a\|A/');
	$replace = Array( 'mm',
	'm',
	'dd',
	'd',
	'yy',
	'yyyy',
	'hh',
	'h',
	'mm',
	'ss',
	'AM');
	$res = preg_replace($patterns, $replace, $format);
	return $res;
	}

	function SQLFormat($format)
	{
	$mapping = Array(
	'/%/' => '%%',
	'/(?<!%)a/' => '%p', // Lowercase Ante meridiem and Post meridiem => MySQL provides only uppercase
	'/(?<!%)A/' => '%p', // Uppercase Ante meridiem and Post meridiem
	'/(?<!%)d/' => '%d', // Day of the month, 2 digits with leading zeros
	'/(?<!%)D/' => '%a', // A textual representation of a day, three letters
	'/(?<!%)F/' => '%M', // A full textual representation of a month, such as January or March
	'/(?<!%)g/' => '%l', // 12-hour format of an hour without leading zeros
	'/(?<!%)G/' => '%k', // 24-hour format of an hour without leading zeros
	'/(?<!%)h/' => '%h', // 12-hour format of an hour with leading zeros
	'/(?<!%)H/' => '%H', // 24-hour format of an hour with leading zeros
	'/(?<!%)i/' => '%i', // Minutes with leading zeros
	'/(?<!%)I/' => 'N/A', // Whether or not the date is in daylights savings time

	'/(?<!%)S/' => 'N/A', // English ordinal suffix for the day of the month, 2 characters, see below
	'/jS/' => '%D', // MySQL can't return separate suffix, but could return date with suffix
	'/(?<!%)j/' => '%e', // Day of the month without leading zeros
	'/(?<!%)l/' => '%W', // A full textual representation of the day of the week
	'/(?<!%)L/' => 'N/A', // Whether it's a leap year
	'/(?<!%)m/' => '%m', // Numeric representation of a month, with leading zeros
	'/(?<!%)M/' => '%b', // A short textual representation of a month, three letters
	'/(?<!%)n/' => '%c', // Numeric representation of a month, without leading zeros
	'/(?<!%)O/' => 'N/A', // Difference to Greenwich time (GMT) in hours
	'/(?<!%)r/' => 'N/A', // RFC 2822 formatted date
	'/(?<!%)s/' => '%s', // Seconds, with leading zeros
	// S and jS moved before j - see above
	'/(?<!%)t/' => 'N/A', // Number of days in the given month
	'/(?<!%)T/' => 'N/A', // Timezone setting of this machine
	'/(?<!%)U/' => 'N/A', // Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)
	'/(?<!%)w/' => '%w', // Numeric representation of the day of the week
	'/(?<!%)W/' => '%v', // ISO-8601 week number of year, weeks starting on Monday (added in PHP 4.1.0)
	'/(?<!%)Y/' => '%Y', // A full numeric representation of a year, 4 digits
	'/(?<!%)y/' => '%y', // A two digit representation of a year
	'/(?<!%)z/' => 'N/A', // The day of the year (starting from 0) => MySQL starts from 1
	'/(?<!%)Z/' => 'N/A', // Timezone offset in seconds. The offset for timezones west of UTC is always negative, and for those east of UTC is always positive.
	);

	$patterns = array_keys($mapping);
	$replacements = array_values($mapping);

	$res = preg_replace($patterns, $replacements, $format);
	return $res;
	}

	//function Parse($value, $options, &$errors)
	function Parse($value, $field_name, &$object)
	{
	$options = $object->GetFieldOptions($field_name);

	$dt_separator = getArrayValue($options,'date_time_separator');
	if($dt_separator) $value = trim($value, $dt_separator);
	if($value == '') return NULL;
	//return strtotime($value);

	$format = $options['format'];
	if($dt_separator) $format = trim($format, $dt_separator);

	$object->FieldErrors[$field_name]['params'] = Array( $this->HumanFormat($format), date($format) );
	$object->FieldErrors[$field_name]['value'] = $value;

	$hour = 0;
	$minute = 0;
	$second = 0;
	$month = 1;
	$day = 1;
	$year = 1970;

	$patterns['n'] = '([0-9]{1,2})';
	$patterns['m'] = '([0-9]{1,2})';
	$patterns['d'] = '([0-9]{1,2})';
	$patterns['j'] = '([0-9]{1,2})';
	$patterns['Y'] = '([0-9]{4})';
	$patterns['y'] = '([0-9]{2})';
	$patterns['G'] = '([0-9]{1,2})';
	$patterns['g'] = '([0-9]{1,2})';
	$patterns['H'] = '([0-9]{2})';
	$patterns['h'] = '([0-9]{2})';
	$patterns['i'] = '([0-9]{2})';
	$patterns['s'] = '([0-9]{2})';
	$patterns['a'] = '(am\|pm)';
	$patterns['A'] = '(AM\|PM)';

	$holders_mask = eregi_replace('[a-zA-Z]{1}', '([a-zA-Z]{1})', $format);
	if (!ereg($holders_mask, $format, $holders)) {
	$object->FieldErrors[$field_name]['pseudo'] = 'bad_date_format';
	return $value;
	}

	$values_mask = '/^'.str_replace('/','\/',$format).'$/';
	foreach ($patterns as $key => $val) {
	$values_mask = ereg_replace($key, $val, $values_mask);
	}
	// echo " values_mask : $values_mask <br>";

	if (!preg_match($values_mask, $value, $values)) {
	$object->FieldErrors[$field_name]['pseudo'] = 'bad_date_format';
	return $value;
	}

	for ($i = 1; $i < count($holders); $i++) {
	switch ($holders[$i]) {
	case 'n':
	case 'm':
	$month = $values[$i];
	$month = ereg_replace("^0{1}", '', $month);
	break;
	case 'd':
	$day = $values[$i];
	$day = ereg_replace("^0{1}", '', $day);
	break;
	case 'Y':
	$year = $values[$i];
	break;
	case 'y':
	$year = $values[$i] >= 70 ? 1900 + $values[$i] : 2000 + $values[$i];
	break;
	case 'H':
	case 'h':
	case 'G':
	case 'g':
	$hour = $values[$i];
	$hour = ereg_replace("^0{1}", '', $hour);
	break;
	case 'i':
	$minute = $values[$i];
	$minute = ereg_replace("^0{1}", '', $minute);
	break;
	case 's':
	$second = $values[$i];
	$second = ereg_replace("^0{1}", '', $second);
	break;
	case 'a':
	case 'A':
	if ($hour <= 12) { // if AM/PM used with 24-hour - could happen :)
	if ($values[$i] == 'pm' \|\| $values[$i] == 'PM') {
	$hour += 12;
	if ($hour == 24) $hour = 12;
	}
	elseif ($values[$i] == 'am' \|\| $values[$i] == 'AM') {
	if ($hour == 12) $hour = 0;
	}
	}
	break;
	}
	}

	//echo "day: $day, month: $month, year: $year, hour: $hour, minute: $minute<br>";

	/*if (!($year >= 1970 && $year <= 2037)) {
	$object->FieldErrors[$field_name]['pseudo'] = 'bad_date_format';
	return $value;
	}*/

	if (!($month >= 1 && $month <= 12)) {
	$object->FieldErrors[$field_name]['pseudo'] = 'bad_date_format';
	return $value;
	}

	$months_days = Array ( 1 => 31,2 => 28, 3 => 31, 4 => 30,5 => 31,6 => 30, 7 => 31, 8 => 31,9 => 30,10 => 31,11 => 30,12 => 31);
	if ($year % 4 == 0) $months_days[2] = 29;

	if (!($day >=1 && $day <= $months_days[$month])) {
	$object->FieldErrors[$field_name]['pseudo'] = 'bad_date_format';
	return $value;
	}

	if (!($hour >=0 && $hour <= 23)) {
	$object->FieldErrors[$field_name]['pseudo'] = 'bad_date_format';
	return $value;
	}

	if (!($minute >=0 && $minute <= 59)) {
	$object->FieldErrors[$field_name]['pseudo'] = 'bad_date_format';
	return $value;
	}

	if (!($second >=0 && $second <= 59)) {
	$object->FieldErrors[$field_name]['pseudo'] = 'bad_date_format';
	return $value;
	}
	// echo "day: $day, month: $month, year: $year, hour: $hour, minute: $minute<br>";
	return (mktime($hour, $minute, $second, $month, $day, $year));
	}

	function GetSample($field, &$options, &$object)
	{
	return $this->Format( time(), $field, $object);
	}
	}

	class kUploadFormatter extends kFormatter
	{
	var $DestinationPath;
	var $FullPath;

	function kUploadFormatter()
	{
	if ($this->DestinationPath)
	{
	$this->FullPath = DOC_ROOT.BASE_PATH.$this->DestinationPath;
	}
	parent::kBase();
	}


	//function Parse($value, $options, &$errors)
	function Parse($value, $field_name, &$object)
	{
	$ret = '';
	$options = $object->GetFieldOptions($field_name);

	if(getArrayValue($options, 'upload_dir'))
	{
	$this->DestinationPath = $options['upload_dir'];
	$this->FullPath = DOC_ROOT.BASE_PATH.$this->DestinationPath;
	}

	if (getArrayValue($value, 'upload') && getArrayValue($value, 'error') == UPLOAD_ERR_NO_FILE)
	{
	return getArrayValue($value, 'upload');
	}

	if ( is_array($value) && $value['size'] )
	{
	if ( is_array($value) && $value['error'] === UPLOAD_ERR_OK )
	{
	if ( getArrayValue($options, 'allowed_types') && !in_array($value['type'], $options['allowed_types']) )
	{
	$object->FieldErrors[$field_name]['pseudo'] = 'bad_file_format';
	}
	elseif ( $value['size'] > ($options['max_size'] ? $options['max_size'] : MAX_UPLOAD_SIZE) )
	{
	$object->FieldErrors[$field_name]['pseudo'] = 'bad_file_size';
	}
	elseif ( !is_writable($this->FullPath) )
	{
	$object->FieldErrors[$field_name]['pseudo'] = 'cant_save_file';
	}
	else
	{
	$real_name = $this->ValidateFileName($this->FullPath, $value['name']);
	$file_name = $this->FullPath.$real_name;
	if ( !move_uploaded_file($value['tmp_name'], $file_name) )
	{
	$object->FieldErrors[$field_name]['pseudo'] = 'cant_save_file';
	}
	else
	{
	if(getArrayValue($options, 'size_field'))
	{
	$object->SetDBField($options['size_field'], $value['size']);
	}
	if(getArrayValue($options, 'orig_name_field'))
	{
	$object->SetDBField($options['orig_name_field'], $value['name']);
	}
	$ret = getArrayValue($options, 'upload_dir') ? $real_name : $this->DestinationPath.$real_name;
	}
	}
	}
	else
	{
	$object->FieldErrors[$field_name]['pseudo'] = 'cant_save_file';
	}
	}
	+ else
	+ {
	+ if(getArrayValue($options, 'required'))
	+ {
	+ $object->FieldErrors[$field_name]['pseudo'] = 'required';
	+ }
	+ }

	if ($value['error'] && !( $value['error'] == UPLOAD_ERR_NO_FILE ) && !$object->FieldErrors[$field_name]['pseudo'])
	{
	$object->FieldErrors[$field_name]['pseudo'] = 'cant_save_file';
	}

	return $ret;
	}

	function ValidateFileName($path, $name)
	{
	$parts = pathinfo($name);
	$ext = '.'.$parts['extension'];
	$filename = substr($parts['basename'], 0, -strlen($ext));
	$new_name = $filename.$ext;
	while ( file_exists($path.'/'.$new_name) )
	{
	if ( preg_match("/({$filename}_)([0-9]*)($ext)/", $new_name, $regs) ) {
	$new_name = $regs[1].($regs[2]+1).$regs[3];
	}
	else {
	$new_name = $filename.'_1'.$ext;
	}
	}
	return $new_name;
	}

	}

	class kPictureFormatter extends kUploadFormatter
	{

	function kPictureFormatter()
	{
	$this->NakeLookupPath = IMAGES_PATH;
	$this->DestinationPath = IMAGES_PENDING_PATH;
	parent::kUploadFormatter();
	}

	}

	class kMultiLanguage extends kFormatter
	{

	function LangFieldName($field_name)
	{
	$lang = $this->Application->GetVar('m_lang');
	return 'l'.$lang.'_'.$field_name;
	}

	function PrepareOptions($field_name, &$field_options, &$object)
	{
	if (getArrayValue($object->Fields, $field_name, 'master_field')) return;

	$lang_field_name = $this->LangFieldName($field_name);

	//substitude title field
	$title_field = $this->Application->getUnitOption($object->Prefix, 'TitleField');
	if ($title_field == $field_name) {
	$this->Application->setUnitOption($object->Prefix, 'TitleField', $lang_field_name);
	}

	//substitude fields
	$fields = $this->Application->getUnitOption($object->Prefix, 'Fields');
	if ( isset($fields[$field_name]) ) {

	$fields[$lang_field_name] = $fields[$field_name];
	$fields[$lang_field_name]['master_field'] = $field_name;
	$object->Fields[$lang_field_name] = $fields[$lang_field_name];
	$fields[$field_name]['required'] = false;
	$object->Fields[$field_name]['required'] = false;
	$object->VirtualFields[$field_name] = $object->Fields[$field_name];
	}
	$this->Application->setUnitOption($object->Prefix, 'Fields', $fields);

	//substitude virtual fields
	$virtual_fields = $this->Application->getUnitOption($object->Prefix, 'VirtualFields');
	if ( isset($virtual_fields[$field_name]) ) {
	$virtual_fields[$lang_field_name] = $virtual_fields[$field_name];
	$virtual_fields[$lang_field_name]['master_field'] = $field_name;
	$object->VirtualFields[$lang_field_name] = $virtual_fields[$lang_field_name];
	$virtual_fields[$field_name]['required'] = false;
	$object->VirtualFields[$field_name]['required'] = false;
	}
	$this->Application->setUnitOption($object->Prefix, 'VirtualFields', $virtual_fields);

	//substitude grid fields
	$grids = $this->Application->getUnitOption($object->Prefix, 'Grids');
	foreach ($grids as $name => $grid) {
	if ( getArrayValue($grid, 'Fields', $field_name) ) {
	array_rename_key($grids[$name]['Fields'], $field_name, $lang_field_name);
	}
	}
	$this->Application->setUnitOption($object->Prefix, 'Grids', $grids);

	//substitude default sortings
	$sortings = $this->Application->getUnitOption($object->Prefix, 'ListSortings');
	foreach ($sortings as $special => $the_sortings) {
	if (isset($the_sortings['ForcedSorting'])) {
	array_rename_key($sortings[$special]['ForcedSorting'], $field_name, $lang_field_name);
	}
	if (isset($the_sortings['Sorting'])) {
	array_rename_key($sortings[$special]['Sorting'], $field_name, $lang_field_name);
	}
	}
	$this->Application->setUnitOption($object->Prefix, 'ListSortings', $sortings);

	//TODO: substitude possible language-fields sortings after changing language
	}

	/*function UpdateSubFields($field, $value, &$options, &$object)
	{

	}

	function UpdateMasterFields($field, $value, &$options, &$object)
	{

	}*/

	function Format($value, $field_name, &$object, $format=null)
	{
	$master_field = getArrayValue($object->Fields, $field_name, 'master_field');
	if (!$master_field) { // if THIS field is master it does NOT have reference to it's master_field
	$lang = $this->Application->GetVar('m_lang');
	$value = $object->GetDBField('l'.$lang.'_'.$field_name); //getting value of current language
	$master_field = $field_name; // THIS is master_field
	}
	if ( $value == '' && $format != 'no_default') { // try to get default language value
	$def_lang_value = $object->GetDBField('l'.$this->Application->GetDefaultLanguageId().'_'.$master_field);
	if ($def_lang_value == '') return NULL;
	return $def_lang_value; //return value from default language
	}
	return $value;
	}

	function Parse($value, $field_name, &$object)
	{
	$lang = $this->Application->GetVar('m_lang');
	$def_lang = $this->Application->GetDefaultLanguageId();
	$master_field = getArrayValue($object->Fields, $field_name, 'master_field');

	if ( getArrayValue($object->Fields, $field_name, 'required') && ( (string) $value == '' ) ) {
	$object->FieldErrors[$master_field]['pseudo'] = 'required';
	};

	if (!$this->Application->GetVar('allow_translation') && $lang != $def_lang && getArrayValue($object->Fields, $field_name, 'required')) {
	$def_lang_field = 'l'.$def_lang.'_'.$master_field;
	if ( !$object->ValidateRequired($def_lang_field, $object->Fields[$field_name]) ) {
	$object->FieldErrors[$master_field]['pseudo'] = 'primary_lang_required';
	}
	}

	if ($value == '') return NULL;
	return $value;
	}

	}


	class kPasswordFormatter extends kFormatter
	{

	function PrepareOptions($field_name, &$field_options, &$object)
	{
	if( isset( $field_options['verify_field'] ) )
	{
	$add_fields = Array();
	$options = Array('master_field' => $field_name, 'formatter'=>'kPasswordFormatter');
	$add_fields[ $field_options['verify_field'] ] = $options;

	$add_fields[$field_name.'_plain'] = Array('type'=>'string', 'error_field'=>$field_name);
	$add_fields[ $field_options['verify_field'].'_plain' ] = Array('type'=>'string', 'error_field'=>$field_options['verify_field'] );

	$add_fields = array_merge_recursive2($add_fields, $object->VirtualFields);
	$object->setVirtualFields($add_fields);
	}
	}

	function Format($value, $field_name, &$object, $format=null)
	{
	return $value;
	}

	function Parse($value, $field_name, &$object)
	{
	$options = $object->GetFieldOptions($field_name);

	$fields = Array('master_field','verify_field');
	$fields_set = true;
	$flip_count = 0;
	while($flip_count < 2)
	{
	if( getArrayValue($options,$fields[0]) )
	{
	$object->SetDBField($field_name.'_plain', $value);
	if( !getArrayValue($object->Fields[ $options[ $fields[0] ] ], $fields[1].'_set') )
	{
	$object->Fields[ $options[ $fields[0] ] ][$fields[1].'_set'] = true;
	}

	$password_field = $options[ $fields[0] ];
	$verify_field = $field_name;
	}
	$fields = array_reverse($fields);
	$flip_count++;
	}

	if( getArrayValue($object->Fields[$password_field], 'verify_field_set') && getArrayValue($object->Fields[$verify_field], 'master_field_set') )
	{
	$new_password = $object->GetDBField($password_field.'_plain');
	$verify_password = $object->GetDBField($verify_field.'_plain');

	if($new_password == '' && $verify_password == '')
	{
	if( $object->GetDBField($password_field) != $this->EncryptPassword('') )
	{
	return $this->EncryptPassword($value);
	}
	else
	{
	$object->Fields[$password_field.'_plain']['required'] = true;
	$object->Fields[$verify_field.'_plain']['required'] = true;
	return null;
	}
	}

	$min_length = $this->Application->ConfigValue('Min_Password');
	if( strlen($new_password) >= $min_length )
	{
	if($new_password != $verify_password)
	{
	$object->ErrorMsgs['passwords_do_not_match'] = $this->Application->Phrase('lu_passwords_do_not_match');
	$object->FieldErrors[$password_field]['pseudo'] = 'passwords_do_not_match';
	$object->FieldErrors[$verify_field]['pseudo'] = 'passwords_do_not_match';
	}
	}
	else
	{
	$object->ErrorMsgs['passwords_min_length'] = sprintf($this->Application->Phrase('lu_passwords_too_short'), $min_length);
	$object->FieldErrors[$password_field]['pseudo'] = 'passwords_min_length';
	$object->FieldErrors[$verify_field]['pseudo'] = 'passwords_min_length';
	}
	}
	if($value == '') return $object->GetDBField($field_name);
	return $this->EncryptPassword($value);
	}

	function EncryptPassword($value)
	{
	return md5($value);
	}
	}


	/**
	* Credit card expiration date formatter
	*
	*/
	class kCCDateFormatter extends kFormatter
	{
	function PrepareOptions($field_name, &$field_options, &$object)
	{
	$add_fields = Array();

	$i = 1;
	$options = Array('00' => '');
	while($i <= 12)
	{
	$options[ sprintf('%02d',$i) ] = sprintf('%02d',$i);
	$i++;
	}
	$add_fields[ $field_options['month_field'] ] = Array('formatter'=>'kOptionsFormatter', 'options' => $options, 'not_null' => true, 'default' => '00');
	$add_fields[ $field_options['year_field'] ] = Array('type' => 'string', 'default' => '');

	$add_fields = array_merge_recursive2($add_fields, $object->VirtualFields);
	$object->setVirtualFields($add_fields);
	}

	function UpdateSubFields($field, $value, &$options, &$object)
	{
	if(!$value) return false;
	$date = explode('/', $value);
	$object->SetDBField( $options['month_field'], $date[0] );
	$object->SetDBField( $options['year_field'], $date[1] );
	}

	/**
	* Will work in future if we could attach 2 formatters to one field
	*
	* @param string $value
	* @param string $field_name
	* @param kBase $object
	* @return string
	*/
	function Parse($value, $field_name, &$object)
	{
	// if ( is_null($value) ) return '';

	$options = $object->GetFieldOptions($field_name);

	$month = $object->GetDirtyField($options['month_field']);
	$year = $object->GetDirtyField($options['year_field']);

	if( !(int)$month && !(int)$year ) return NULL;
	$is_valid = ($month >= 1 && $month <= 12) && ($year >= 0 && $year <= 99);

	if(!$is_valid) $object->FieldErrors[$field_name]['pseudo'] = 'bad_type';
	return $month.'/'.$year;
	}

	}

	class kUnitFormatter extends kFormatter {

	function PrepareOptions($field_name, &$field_options, &$object)
	{
	if( !isset($field_options['master_field']) )
	{
	$regional =& $this->Application->recallObject('lang.current');
	$add_fields = Array();
	$options_a = Array('type' => 'int','error_field' => $field_name,'master_field' => $field_name,'format' => '%d','min_value_inc' => 0 );
	$options_b = Array('type' => 'double','error_field' => $field_name,'master_field' => $field_name,'format' => '%0.1f','min_value_inc' => 0);
	switch( $regional->GetDBField('UnitSystem') )
	{
	case 2: // US/UK
	$field_options_copy = $field_options;
	unset($field_options_copy['min_value_exc']);
	$add_fields[$field_name.'_a'] = array_merge_recursive2($field_options_copy, $options_a);
	$add_fields[$field_name.'_b'] = array_merge_recursive2($field_options_copy, $options_b);
	break;
	default:
	}
	$add_fields = array_merge_recursive2($add_fields, $object->VirtualFields);
	$object->setVirtualFields($add_fields);
	}
	}

	function UpdateMasterFields($field, $value, &$options, &$object)
	{
	if( !isset($options['master_field']) )
	{
	$regional =& $this->Application->recallObject('lang.current');
	switch( $regional->GetDBField('UnitSystem') )
	{
	case 2: // US/UK
	$major = $object->GetDirtyField($field.'_a');
	$minor = $object->GetDirtyField($field.'_b');
	if($major === '' && $minor === '')
	{
	$value = null;
	}
	elseif($major === null && $minor === null)
	{
	unset($object->Fields[$field]);
	return;
	}
	else
	{
	$value = $major / 2 + $minor / 32;
	}
	break;
	default:
	}
	$object->SetDBField($field, $value);
	}
	}

	function UpdateSubFields($field, $value, &$options, &$object)
	{
	if( !isset($options['master_field']) )
	{
	$regional =& $this->Application->recallObject('lang.current');
	switch( $regional->GetDBField('UnitSystem') )
	{
	case 2: // US/UK
	if($value === null)
	{
	$major = null;
	$minor = null;
	}
	else
	{
	$major = floor( $value / 0.5 );
	$minor = ($value - $major * 0.5) * 32;
	}
	$object->SetDBField($field.'_a', $major);
	$object->SetDBField($field.'_b', $minor);
	break;
	default:
	}
	}
	}
	}

	class kFilesizeFormatter extends kFormatter {

	function Format($value, $field_name, &$object, $format=null)
	{
	if ($value >= 1099511627776) {
	$return = round($value / 1024 / 1024 / 1024 / 1024, 2);
	$suffix = "Tb";
	} elseif ($value >= 1073741824) {
	$return = round($value / 1024 / 1024 / 1024, 2);
	$suffix = "Gb";
	} elseif ($value >= 1048576) {
	$return = round($value / 1024 / 1024, 2);
	$suffix = "Mb";
	} elseif ($value >= 1024) {
	$return = round($value / 1024, 2);
	$suffix = "Kb";
	} else {
	$return = $value;
	$suffix = "B";
	}
	$return .= ' '.$suffix;
	return $return;
	}
	}

	?>

	Property changes on: trunk/core/kernel/utility/formatters.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.18
	\ No newline at end of property
	+1.19
	\ No newline at end of property
	Index: trunk/core/kernel/db/dbitem.php
	===================================================================
	--- trunk/core/kernel/db/dbitem.php (revision 2356)
	+++ trunk/core/kernel/db/dbitem.php (revision 2357)
	@@ -1,819 +1,820 @@
	<?php

	/**
	* DBItem
	*
	* Desciption
	* @package kernel4
	*/
	class kDBItem extends kDBBase {

	/**
	* Description
	*
	* @var array Associative array of current item' field values
	* @access public
	*/
	var $FieldValues;

	/**
	* Unformatted field values, before parse
	*
	* @var Array
	* @access private
	*/
	var $DirtyFieldValues = Array();

	var $FieldErrors;

	var $ErrorMsgs = Array();

	/**
	* If set to true, Update will skip Validation before running
	*
	* @var array Associative array of current item' field values
	* @access public
	*/
	var $IgnoreValidation = false;

	var $Loaded = false;

	/**
	* Holds item' primary key value
	*
	* @var int Value of primary key field for current item
	* @access public
	*/
	var $ID;

	function kDBItem()
	{
	parent::kDBBase();
	$this->ErrorMsgs['required'] = 'Field is required';
	$this->ErrorMsgs['unique'] = 'Field value must be unique';
	$this->ErrorMsgs['value_out_of_range'] = 'Field is out of range, possible values from %s to %s';
	$this->ErrorMsgs['length_out_of_range'] = 'Field is out of range';
	$this->ErrorMsgs['bad_type'] = 'Incorrect data format, please use %s';
	$this->ErrorMsgs['bad_date_format'] = 'Incorrect date format, please use (%s) ex. (%s)';
	}

	function SetDirtyField($field_name, $field_value)
	{
	$this->DirtyFieldValues[$field_name] = $field_value;
	}

	function GetDirtyField($field_name)
	{
	return $this->DirtyFieldValues[$field_name];
	}

	/**
	* Set's default values for all fields
	*
	* @access public
	*/
	function SetDefaultValues()
	{
	parent::SetDefaultValues();
	foreach ($this->Fields as $field => $params) {
	if ( isset($params['default']) ) {
	$this->SetDBField($field, $params['default']);
	}
	else {
	$this->SetDBField($field, NULL);
	}
	}
	}

	/**
	* Sets current item field value
	* (applies formatting)
	*
	* @access public
	* @param string $name Name of the field
	* @param mixed $value Value to set the field to
	* @return void
	*/
	function SetField($name,$value)
	{
	$options = $this->GetFieldOptions($name);
	$parsed = $value;
	if ($value == '') $parsed = NULL;
	if (isset($options['formatter'])) {
	$formatter =& $this->Application->recallObject($options['formatter']);
	// $parsed = $formatter->Parse($value, $options, $err);
	$parsed = $formatter->Parse($value, $name, $this);
	}
	$this->SetDBField($name,$parsed);
	}

	/**
	* 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->FieldValues[$name] = $value;
	/*if (isset($this->Fields[$name]['formatter'])) {
	$formatter =& $this->Application->recallObject($this->Fields[$name]['formatter']);
	$formatter->UpdateSubFields($name, $value, $this->Fields[$name], $this);
	}*/
	}

	/**
	* Set's field error, if pseudo passed not found then create it with message text supplied.
	* Don't owerrite existing pseudo translation.
	*
	* @param string $field
	* @param string $pseudo
	* @param string $error_label
	*/
	function SetError($field, $pseudo, $error_label = '')
	{
	$error_msg = $this->Application->Phrase($error_label);
	if( !($error_msg && getArrayValue($this->ErrorMsgs,$pseudo)) )
	{
	$this->ErrorMsgs[$pseudo] = $error_msg;
	}
	$this->FieldErrors[$field]['pseudo'] = $pseudo;
	}

	/**
	* Return current item' field value by field name
	* (doesn't apply formatter)
	*
	* @access public
	* @param string $name field name to return
	* @return mixed
	*/
	function GetDBField($name)
	{
	return $this->FieldValues[$name];
	}

	function HasField($name)
	{
	return isset($this->FieldValues[$name]);
	}

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

	/**
	* Sets item' fields corresponding to elements in passed $hash values.
	*
	* The function sets current item fields to values passed in $hash, by matching $hash keys with field names
	* of current item. If current item' fields are unknown {@link kDBItem::PrepareFields()} is called before acutally setting the fields
	*
	* @access public
	* @param Array $hash
	* @param Array $set_fields Optional param, field names in target object to set, other fields will be skipped
	* @return void
	*/
	function SetFieldsFromHash($hash, $set_fields=null)
	{
	// used in formatter which work with multiple fields together
	foreach($hash as $field_name => $field_value)
	{
	if( eregi("^[0-9]+$", $field_name) \|\| !array_key_exists($field_name,$this->Fields) ) continue;
	if ( is_array($set_fields) && !in_array($field_name, $set_fields) ) continue;
	$this->SetDirtyField($field_name, $field_value);
	}

	// formats all fields using associated formatters
	foreach ($hash as $field_name => $field_value)
	{
	if( eregi("^[0-9]+$", $field_name) \|\| !array_key_exists($field_name,$this->Fields) ) continue;
	if ( is_array($set_fields) && !in_array($field_name, $set_fields) ) continue;
	$this->SetField($field_name,$field_value);
	}
	}

	function SetDBFieldsFromHash($hash, $set_fields=null)
	{
	foreach ($hash as $field_name => $field_value)
	{
	if( eregi("^[0-9]+$", $field_name) \|\| !array_key_exists($field_name,$this->Fields) ) continue;
	if ( is_array($set_fields) && !in_array($field_name, $set_fields) ) continue;

	$this->SetDBField($field_name, $field_value);
	}
	}

	/**
	* Returns part of SQL WHERE clause identifing the record, ex. id = 25
	*
	* @access public
	* @param string $method Child class may want to know who called GetKeyClause, Load(), Update(), Delete() send its names as method
	* @return void
	* @see kDBItem::Load()
	* @see kDBItem::Update()
	* @see kDBItem::Delete()
	*/
	function GetKeyClause($method=null)
	{
	return '`'.$this->TableName.'`.'.$this->IDField.' = '.$this->Conn->qstr($this->ID);
	}

	/**
	* Loads item from the database by given id
	*
	* @access public
	* @param int $id Primery Key Id to load
	* @param string $id_field_name Optional parameter to load item by given Id field
	* @return bool True if item has been loaded, false otherwise
	*/
	function Load($id, $id_field_name=null)
	{
	if (is_array($id)) {
	$keys = $id;
	foreach ($keys as $field => $value) {
	$sqls[] = '`'.$this->TableName.'`.'.$field.' = '.$this->Conn->qstr($value);
	}
	$keys_sql = '('.implode(') AND (', $sqls).')';
	}

	if (isset($id_field_name)) $this->SetIDField($id_field_name);
	if (!isset($id) && !isset($keys_sql)) return false;

	if( !$this->raiseEvent('OnBeforeItemLoad',$id) ) return false;

	$this->ID = $id;

	$q = $this->GetSelectSQL().' WHERE '.(isset($keys_sql) ? $keys_sql : $this->GetKeyClause('load'));
	if ($this->DisplayQueries) {
	echo get_class($this)." Load SQL: $q<br>";
	}
	$this->FieldValues = array_merge_recursive2( $this->FieldValues, $this->Conn->GetRow($q) );

	if ($this->FieldValues === false) {
	//Error handling could be here
	return false;
	}
	if (isset($keys_sql)) {
	$this->setID($this->FieldValues[$this->IDField]);
	}
	else {
	$this->setID($id);
	}

	$this->UpdateFormattersSubFields(); // used for updating separate virtual date/time fields from DB timestamp (for example)

	$this->raiseEvent('OnAfterItemLoad');
	$this->Loaded = true;
	return true;
	}

	/**
	* Builds select sql, SELECT ... FROM parts only
	*
	* @access public
	* @return string
	*/
	function GetSelectSQL()
	{
	$sql = $this->addCalculatedFields($this->SelectClause);
	return parent::GetSelectSQL($sql);
	}

	function UpdateFormattersMasterFields()
	{
	foreach ($this->Fields as $field => $options) {
	if (isset($options['formatter'])) {
	$formatter =& $this->Application->recallObject($options['formatter']);
	$formatter->UpdateMasterFields($field, $this->GetDBField($field), $options, $this);
	}
	}
	}

	function SkipField($field_name, $force_id=false)
	{
	$skip = false;
	$skip = $skip \|\| ( isset($this->VirtualFields[$field_name]) ); //skipping 'virtual' field
	$skip = $skip \|\| ( !getArrayValue($this->FieldValues, $field_name) && getArrayValue($this->Fields[$field_name], 'skip_empty') ); //skipping 'virtual' field
	// $skip = $skip \|\| ($field_name == $this->IDField && !$force_id); //skipping Primary Key

	// $table_name = preg_replace("/^(.*)\./", "$1", $field_name);
	// $skip = $skip \|\| ($table_name && ($table_name != $this->TableName)); //skipping field from other tables

	$skip = $skip \|\| ( !isset($this->Fields[$field_name]) ); //skipping field not in Fields (nor virtual, nor real)

	return $skip;
	}

	/**
	* Updates previously loaded record with current item' values
	*
	* @access public
	* @param int Primery Key Id to update
	* @return bool
	*/
	function Update($id=null, $system_update=false)
	{
	if( isset($id) ) $this->setID($id);

	if( !$this->raiseEvent('OnBeforeItemUpdate') ) return false;

	if( !isset($this->ID) ) return false;

	// Validate before updating
	if( !$this->IgnoreValidation && !$this->Validate() ) return false;
	if( !$this->raiseEvent('OnAfterItemValidate') ) return false;

	//Nothing to update
	if(!$this->FieldValues) return true;

	$sql = sprintf('UPDATE %s SET ',$this->TableName);
	foreach ($this->FieldValues as $field_name => $field_value)
	{
	if ($this->SkipField($field_name)) continue;

	$real_field_name = eregi_replace("^.*\.", '',$field_name); //removing table names from field names

	//Adding part of SET clause for current field, escaping data with ADODB' qstr
	if (is_null( $this->FieldValues[$field_name] )) {
	if (isset($this->Fields[$field_name]['not_null']) && $this->Fields[$field_name]['not_null']) {
	$sql .= '`'.$real_field_name.'` = '.$this->Conn->qstr($this->Fields[$field_name]['default']).', ';
	}
	else {
	$sql .= '`'.$real_field_name.'` = NULL, ';
	}
	}
	else {
	$sql.= sprintf('`%s`=%s, ', $real_field_name, $this->Conn->qstr($this->FieldValues[$field_name], 0));
	}
	}
	$sql = ereg_replace(", $", '', $sql); //Removing last comma and space

	$sql.= sprintf(' WHERE %s', $this->GetKeyClause('update')); //Adding WHERE clause with Primary Key

	if ($this->DisplayQueries) echo "Sql: $sql<br>";

	if ($this->Conn->ChangeQuery($sql) === false) { //Executing query and checking results
	if ($this->DisplayQueries)
	{
	echo "Error executing statement: ".$adodbConnection->ErrorMsg()."<br>";
	}
	return false;
	}

	$affected = $this->Conn->getAffectedRows();
	if (!$system_update && $affected == 1){
	$this->setModifiedFlag();
	}

	$this->raiseEvent('OnAfterItemUpdate');
	return true;
	}

	/**
	* Validate all item fields based on
	* constraints set in each field options
	* in config
	*
	* @return bool
	* @access private
	*/
	function Validate()
	{
	$this->UpdateFormattersMasterFields(); //order is critical - should be called BEFORE checking errors
	$global_res = true;
	foreach ($this->Fields as $field => $params) {
	$res = true;
	$res = $res && $this->ValidateType($field, $params);
	$res = $res && $this->ValidateRange($field, $params);
	$res = $res && $this->ValidateUnique($field, $params);
	$res = $res && $this->ValidateRequired($field, $params);

	// If Formatter has set some error messages during values parsing
	$error_field = isset($params['error_field']) ? $params['error_field'] : $field;
	if (isset($this->FieldErrors[$error_field]['pseudo']) && $this->FieldErrors[$error_field] != '') {
	$global_res = false;
	}

	$global_res = $global_res && $res;
	}

	if (!$global_res && $this->Application->isDebugMode() )
	{
	global $debugger;
	$error_msg = "Validation failed in prefix <b>".$this->Prefix."</b>, FieldErrors follow (look at items with 'pseudo' key set)<br>
	You may ignore this notice if submitted data really has a validation error ";
	trigger_error( $error_msg, E_USER_NOTICE);
	$debugger->dumpVars($this->FieldErrors);
	}

	return $global_res;
	}

	function HasErrors()
	{
	$global_res = false;
	foreach ($this->Fields as $field => $params) {
	// If Formatter has set some error messages during values parsing
	if (isset($this->FieldErrors[$field]['pseudo']) && $this->FieldErrors[$field] != '') {
	$global_res = true;
	}
	}
	return $global_res;
	}

	/**
	* Check if value in field matches field type specified in config
	*
	* @param string $field field name
	* @param Array $params field options from config
	* @return bool
	*/
	function ValidateType($field, $params)
	{
	$res = true;
	$val = $this->FieldValues[$field];
	$error_field = isset($params['error_field']) ? $params['error_field'] : $field;
	if ( $val != '' &&
	isset($params['type']) &&
	preg_match("#int\|integer\|double\|float\|real\|numeric\|string#", $params['type'])
	) {
	$res = is_numeric($val);
	if($params['type']=='string' \|\| $res)
	{
	$f = 'is_'.$params['type'];
	settype($val, $params['type']);
	$res = $f($val) && ($val==$this->FieldValues[$field]);
	}
	if (!$res)
	{
	$this->FieldErrors[$error_field]['pseudo'] = 'bad_type';
	$this->FieldErrors[$error_field]['params'] = $params['type'];
	}
	}
	return $res;
	}

	/**
	* Check if value is set for required field
	*
	* @param string $field field name
	* @param Array $params field options from config
	* @return bool
	* @access private
	*/
	function ValidateRequired($field, $params)
	{
	$res = true;
	$error_field = isset($params['error_field']) ? $params['error_field'] : $field;
	if ( getArrayValue($params,'required') )
	{
	$res = ( (string) $this->FieldValues[$field] != '');
	}
	- if (!$res) $this->FieldErrors[$error_field]['pseudo'] = 'required';
	+ $options = $this->GetFieldOptions($field);
	+ if (!$res && getArrayValue($options, 'formatter') != 'kUploadFormatter') $this->FieldErrors[$error_field]['pseudo'] = 'required';
	return $res;
	}

	/**
	* Validates that current record has unique field combination among other table records
	*
	* @param string $field field name
	* @param Array $params field options from config
	* @return bool
	* @access private
	*/
	function ValidateUnique($field, $params)
	{
	$res = true;
	$error_field = isset($params['error_field']) ? $params['error_field'] : $field;
	$unique_fields = getArrayValue($params,'unique');
	if($unique_fields !== false)
	{
	$where = Array();
	array_push($unique_fields,$field);
	foreach($unique_fields as $unique_field)
	{
	$where[] = '`'.$unique_field.'` = '.$this->Conn->qstr( $this->GetDBField($unique_field) );
	}

	$sql = 'SELECT COUNT(*) FROM %s WHERE ('.implode(') AND (',$where).') AND ('.$this->IDField.' <> '.(int)$this->ID.')';

	$res_temp = $this->Conn->GetOne( sprintf($sql, $this->TableName ) );
	$res_live = $this->Conn->GetOne( sprintf($sql, kTempTablesHandler::GetLiveName($this->TableName) ) );
	$res = ($res_temp == 0) && ($res_live == 0);

	if(!$res) $this->FieldErrors[$error_field]['pseudo'] = 'unique';
	}
	return $res;
	}

	/**
	* Check if field value is in range specified in config
	*
	* @param string $field field name
	* @param Array $params field options from config
	* @return bool
	* @access private
	*/
	function ValidateRange($field, $params)
	{
	$res = true;
	$val = $this->FieldValues[$field];
	$error_field = isset($params['error_field']) ? $params['error_field'] : $field;

	if ( isset($params['type']) && preg_match("#int\|integer\|double\|float\|real#", $params['type']) && strlen($val) > 0 ) {
	if ( isset($params['max_value_inc'])) {
	$res = $res && $val <= $params['max_value_inc'];
	$max_val = $params['max_value_inc'].' (inclusive)';
	}
	if ( isset($params['min_value_inc'])) {
	$res = $res && $val >= $params['min_value_inc'];
	$min_val = $params['min_value_inc'].' (inclusive)';
	}
	if ( isset($params['max_value_exc'])) {
	$res = $res && $val < $params['max_value_exc'];
	$max_val = $params['max_value_exc'].' (exclusive)';
	}
	if ( isset($params['min_value_exc'])) {
	$res = $res && $val > $params['min_value_exc'];
	$min_val = $params['min_value_exc'].' (exclusive)';
	}
	}
	if (!$res) {
	$this->FieldErrors[$error_field]['pseudo'] = 'value_out_of_range';

	if ( !isset($min_val) ) $min_val = '-∞';
	if ( !isset($max_val) ) $max_val = '∞';

	$this->FieldErrors[$error_field]['params'] = Array( $min_val, $max_val );
	return $res;
	}
	if ( isset($params['max_len'])) {
	$res = $res && strlen($val) <= $params['max_len'];
	}
	if ( isset($params['min_len'])) {
	$res = $res && strlen($val) >= $params['min_len'];
	}
	if (!$res) {
	$this->FieldErrors[$error_field]['pseudo'] = 'length_out_of_range';
	$this->FieldErrors[$error_field]['params'] = Array( getArrayValue($params,'min_len'), getArrayValue($params,'max_len') );
	return $res;
	}
	return $res;
	}

	/**
	* Return error message for field
	*
	* @param string $field
	* @return string
	* @access public
	*/
	function GetErrorMsg($field)
	{
	if( !isset($this->FieldErrors[$field]) ) return '';

	$err = getArrayValue($this->FieldErrors[$field], 'pseudo');
	if( isset($this->Fields[$field]['error_msgs'][$err]) )
	{
	$msg = $this->Fields[$field]['error_msgs'][$err];
	$msg = $this->Application->ReplaceLanguageTags($msg);
	}
	else
	{
	if( !isset($this->ErrorMsgs[$err]) ) return $err;
	$msg = $this->ErrorMsgs[$err];
	}

	if ( isset($this->FieldErrors[$field]['params']) )
	{
	return vsprintf($msg, $this->FieldErrors[$field]['params']);
	}
	return $msg;
	}

	/**
	* Creates a record in the database table with current item' values
	*
	* @param mixed $force_id Set to TRUE to force creating of item's own ID or to value to force creating of passed id. Do not pass 1 for true, pass exactly TRUE!
	* @access public
	* @return bool
	*/
	function Create($force_id=false, $system_create=false)
	{
	if( !$this->raiseEvent('OnBeforeItemCreate') ) return false;

	// Validating fields before attempting to create record
	if( !$this->IgnoreValidation && !$this->Validate() ) return false;
	if( !$this->raiseEvent('OnAfterItemValidate') ) return false;

	if (is_int($force_id)) {
	$this->FieldValues[$this->IDField] = $force_id;
	}
	elseif (!$force_id \|\| !is_bool($force_id)) {
	$this->FieldValues[$this->IDField] = $this->generateID();
	}


	$fields_sql = '';
	$values_sql = '';
	foreach ($this->FieldValues as $field_name => $field_value)
	{
	if ($this->SkipField($field_name, $force_id)) continue;

	$fields_sql .= sprintf('`%s`, ',$field_name); //Adding field name to fields block of Insert statement
	//Adding field' value to Values block of Insert statement, escaping it with ADODB' qstr
	if (is_null( $this->FieldValues[$field_name] )) {
	if (isset($this->Fields[$field_name]['not_null']) && $this->Fields[$field_name]['not_null']) {
	$values_sql .= $this->Conn->qstr($this->Fields[$field_name]['default']).', ';
	}
	else {
	$values_sql .= 'NULL, ';
	}
	}
	else
	{
	$values_sql .= sprintf('%s, ',$this->Conn->qstr($this->FieldValues[$field_name], 0));
	}

	}
	//Cutting last commas and spaces
	$fields_sql = ereg_replace(", $", '', $fields_sql);
	$values_sql = ereg_replace(", $", '', $values_sql);
	$sql = sprintf('INSERT INTO %s (%s) VALUES (%s)', $this->TableName, $fields_sql, $values_sql); //Formatting query

	//Executing the query and checking the result

	if ($this->Conn->ChangeQuery($sql) === false)
	{
	if($this->DisplayQueries)
	{
	echo "Error executing statement: ".$this->Conn->getErrorMsg().'<br>';
	}
	return false;
	}

	$insert_id = $this->Conn->getInsertID();
	if($insert_id == 0) $insert_id = $this->FieldValues[$this->IDField];
	$this->setID($insert_id);

	if (!$system_create){
	$this->setModifiedFlag();
	}

	$this->raiseEvent('OnAfterItemCreate');
	return true;
	}

	/**
	* Deletes the record from databse
	*
	* @access public
	* @return bool
	*/
	function Delete($id=null)
	{
	if( isset($id) ) {
	$this->setID($id);
	}

	if( !$this->raiseEvent('OnBeforeItemDelete') ) return false;

	$q = 'DELETE FROM '.$this->TableName.' WHERE '.$this->GetKeyClause('Delete');
	if ($this->DisplayQueries)
	{
	echo get_class($this).' Delete SQL: '.$q.'<br>';
	}
	$ret = $this->Conn->ChangeQuery($q);

	$this->setModifiedFlag();

	$this->raiseEvent('OnAfterItemDelete');

	return $ret;
	}

	/**
	* Sets new name for item in case if it is beeing copied
	* in same table
	*
	* @param array $master Table data from TempHandler
	* @param int $foreign_key ForeignKey value to filter name check query by
	* @access private
	*/
	function NameCopy($master=null, $foreign_key=null)
	{
	$title_field = $this->Application->getUnitOption($this->Prefix, 'TitleField');
	if (!$title_field \|\| isset($this->CalculatedFields[$title_field]) ) return;

	$new_name = $this->GetDBField($title_field);
	$original_checked = false;
	do {
	if ( preg_match('/Copy ([0-9]) of (.*)/', $new_name, $regs) ) {
	$new_name = 'Copy '.($regs[1]+1).' of '.$regs[2];
	}
	elseif ($original_checked) {
	$new_name = 'Copy of '.$new_name;
	}

	// if we are cloning in temp table this will look for names in temp table,
	// since object' TableName contains correct TableName (for temp also!)
	// if we are cloning live - look in live
	$query = 'SELECT '.$title_field.' FROM '.$this->TableName.'
	WHERE '.$title_field.' = '.$this->Conn->qstr($new_name);

	if (getArrayValue($master, 'ForeignKey') && isset($foreign_key)) {
	$query .= ' AND '.$master['ForeignKey'].' = '.$foreign_key;
	}

	$res = $this->Conn->GetOne($query);

	/*// if not found in live table, check in temp table if applicable
	if ($res === false && $object->Special == 'temp') {
	$query = 'SELECT '.$name_field.' FROM '.$this->GetTempName($master['TableName']).'
	WHERE '.$name_field.' = '.$this->Conn->qstr($new_name);
	$res = $this->Conn->GetOne($query);
	}*/

	$original_checked = true;
	} while ($res !== false);
	$this->SetDBField($title_field, $new_name);
	}

	function raiseEvent($name, $id=null)
	{
	if( !isset($id) ) $id = $this->GetID();
	$event = new kEvent( Array('name'=>$name,'prefix'=>$this->Prefix,'special'=>$this->Special) );
	$event->setEventParam('id', $id);
	$this->Application->HandleEvent($event);
	return $event->status == erSUCCESS ? true : false;
	}

	/**
	* Set's new ID for item
	*
	* @param int $new_id
	* @access public
	*/
	function setID($new_id)
	{
	$this->ID=$new_id;
	$this->SetDBField($this->IDField,$new_id);
	}

	/**
	* Generate and set new temporary id
	*
	* @access private
	*/
	function setTempID()
	{
	$new_id = (int)$this->Conn->GetOne('SELECT MIN('.$this->IDField.') FROM '.$this->TableName);
	if($new_id > 0) $new_id = 0;
	--$new_id;

	$this->Conn->Query('UPDATE '.$this->TableName.' SET `'.$this->IDField.'` = '.$new_id.' WHERE `'.$this->IDField.'` = '.$this->GetID());
	$this->SetID($new_id);
	}

	/**
	* Set's modification flag for main prefix of current prefix to true
	*
	* @access private
	* @author Alexey
	*/
	function setModifiedFlag()
	{
	$main_prefix = $this->Application->GetTopmostPrefix($this->Prefix);
	$this->Application->StoreVar($main_prefix.'_modified', '1');
	}

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

	/**
	* Generates ID for new items before inserting into database
	*
	* @return int
	* @access private
	*/
	function generateID()
	{
	return 0;
	}
	}



	?>
	\ No newline at end of file

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

in-portalNo OneTemporaryActions

File Metadata

in-portalView Options

Event Timeline

in-portal
No OneTemporary
Actions

in-portal
View Options