in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sat, Feb 22, 12:02 AM

in-portal
View Options

	Index: branches/5.2.x/core/kernel/globals.php
	===================================================================
	--- branches/5.2.x/core/kernel/globals.php (revision 15999)
	+++ branches/5.2.x/core/kernel/globals.php (revision 16000)
	@@ -1,1047 +1,1049 @@
	<?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.org/license for copyright notices and details.
	*/

	defined('FULL_PATH') or die('restricted access!');

	class kUtil {

	// const KG_TO_POUND = 2.20462262;

	const POUND_TO_KG = 0.45359237;

	/**
	* Escape text as HTML.
	*
	* @see escape
	*/
	const ESCAPE_HTML = 'html';

	/**
	* Escape text as JavaScript.
	*
	* @see escape
	*/
	const ESCAPE_JS = 'js';

	/**
	* Escape text as Url.
	*/
	const ESCAPE_URL = 'url';

	/**
	* Don't escape anything.
	*/
	const ESCAPE_RAW = 'raw';

	/**
	* Current escape strategy.
	*
	* @var string
	* @see escape
	*/
	public static $escapeStrategy = self::ESCAPE_HTML;

	/**
	* Similar to array_merge_recursive but keyed-valued are always overwritten.
	* Priority goes to the 2nd array.
	*
	* @param $paArray1 array
	* @param $paArray2 array
	* @return array
	* @access public
	*/
	public static function array_merge_recursive($paArray1, $paArray2)
	{
	if (!is_array($paArray1) or !is_array($paArray2)) {
	return $paArray2;
	}

	foreach ($paArray2 AS $sKey2 => $sValue2) {
	$paArray1[$sKey2] = isset($paArray1[$sKey2]) ? self::array_merge_recursive($paArray1[$sKey2], $sValue2) : $sValue2;
	}

	return $paArray1;
	}

	/**
	* Prepend a reference to an element to the beginning of an array.
	* Renumbers numeric keys, so $value is always inserted to $array[0]
	*
	* @param $array array
	* @param $value mixed
	* @return int
	* @access public
	*/
	public static function array_unshift_ref(&$array, &$value)
	{
	$return = array_unshift($array,'');
	$array[0] =& $value;
	return $return;
	}

	/**
	* Rename key in associative array, maintaining keys order
	*
	* @param Array $array Associative Array
	* @param mixed $old Old key name
	* @param mixed $new New key name
	* @access public
	*/
	public static function array_rename_key(&$array, $old, $new)
	{
	$new_array = Array ();

	foreach ($array as $key => $val) {
	$new_array[ $key == $old ? $new : $key] = $val;
	}

	$array = $new_array;
	}

	/**
	* Same as print_r, but outputs result on screen or in debugger report (when in debug mode)
	*
	* @param Array $data
	* @param string $label
	* @param bool $on_screen
	* @access public
	*/
	public static function print_r($data, $label = '', $on_screen = false)
	{
	$is_debug = false;

	if ( class_exists('kApplication') && !$on_screen ) {
	$application =& kApplication::Instance();
	$is_debug = $application->isDebugMode();
	}

	if ( $is_debug && isset($application) ) {
	if ( $label ) {
	$application->Debugger->appendHTML('<strong>' . $label . '</strong>');
	}

	$application->Debugger->dumpVars($data);
	}
	else {
	if ( $label ) {
	echo '<strong>' . $label . '</strong><br/>';
	}

	echo '<pre>', print_r($data, true), '</pre>';
	}
	}

	/**
	* Define constant if it was not already defined before
	*
	* @param string $const_name
	* @param string $const_value
	* @access public
	*/
	public static function safeDefine($const_name, $const_value)
	{
	if ( !defined($const_name) ) {
	define($const_name, $const_value);
	}
	}

	/**
	* Parses "/system/config.php" file and returns the result
	*
	* @param bool $parse_section
	* @return Array
	* @access public
	*/
	public static function parseConfig($parse_section = false)
	{
	$file = FULL_PATH . DIRECTORY_SEPARATOR . 'system' . DIRECTORY_SEPARATOR . 'config.php';

	if ( !file_exists($file) ) {
	return Array ();
	}

	if ( file_exists($file) && !is_readable($file) ) {
	die('Could Not Open Ini File');
	}

	$contents = file($file);

	if ( $contents && $contents[0] == '<' . '?' . 'php die() ?' . ">\n" ) {
	// format of "config.php" file before 5.1.0 version
	array_shift($contents);

	return parse_ini_string(implode('', $contents), $parse_section);
	}

	$_CONFIG = Array ();
	require($file);

	if ( $parse_section ) {
	if ( isset($_CONFIG['Database']['LoadBalancing']) && $_CONFIG['Database']['LoadBalancing'] ) {
	require FULL_PATH . DIRECTORY_SEPARATOR . 'system' . DIRECTORY_SEPARATOR . 'db_servers.php';
	}

	return $_CONFIG;
	}

	$ret = Array ();

	foreach ($_CONFIG as $section => $section_variables) {
	$ret = array_merge($ret, $section_variables);
	}

	return $ret;
	}

	/**
	* Returns parsed variables from "config.php" file
	*
	* @return Array
	* @access public
	*/
	public static function getConfigVars()
	{
	static $vars = NULL;

	if ( !isset($vars) ) {
	$vars = self::parseConfig();
	}

	return $vars;
	}

	/**
	* Same as "include_once", but also profiles file includes in debug mode and DBG_PROFILE_INCLUDES constant is set
	*
	* @param string $file
	* @access public
	*/
	public static function includeOnce($file)
	{
	global $debugger;

	if ( defined('DEBUG_MODE') && DEBUG_MODE && isset($debugger) && defined('DBG_PROFILE_INCLUDES') && DBG_PROFILE_INCLUDES ) {

	if ( in_array($file, get_included_files()) ) {
	return ;
	}

	global $debugger;

	/*$debugger->IncludeLevel++;
	$before_mem = memory_get_usage();*/

	$debugger->ProfileStart('inc_'.crc32($file), $file);
	include_once($file);
	$debugger->ProfileFinish('inc_'.crc32($file));
	$debugger->profilerAddTotal('includes', 'inc_'.crc32($file));

	/*$used_mem = memory_get_usage() - $before_mem;
	$debugger->IncludeLevel--;
	$debugger->IncludesData['file'][] = str_replace(FULL_PATH, '', $file);
	$debugger->IncludesData['mem'][] = $used_mem;
	$debugger->IncludesData['time'][] = $used_time;
	$debugger->IncludesData['level'][] = $debugger->IncludeLevel;*/
	}
	else {
	include_once($file);
	}
	}

	/**
	* Checks if given string is a serialized array
	*
	* @param string $string
	* @return bool
	* @access public
	*/
	public static function IsSerialized($string)
	{
	if ( is_array($string) ) {
	return false;
	}

	return preg_match('/a:([\d]+):{/', $string);
	}

	/**
	* Generates password of given length
	*
	* @param int $length
	* @return string
	* @access public
	*/
	public static function generatePassword($length = 10)
	{
	$pass_length = $length;

	$p1 = Array ('b','c','d','f','g','h','j','k','l','m','n','p','q','r','s','t','v','w','x','y','z');
	$p2 = Array ('a','e','i','o','u');
	$p3 = Array ('1','2','3','4','5','6','7','8','9');
	$p4 = Array ('(','&',')',';','%'); // if you need real strong stuff

	// how much elements in the array
	// can be done with a array count but counting once here is faster

	$s1 = 21;// this is the count of $p1
	$s2 = 5; // this is the count of $p2
	$s3 = 9; // this is the count of $p3
	$s4 = 5; // this is the count of $p4

	// possible readable combinations

	$c1 = '121'; // will be like 'bab'
	$c2 = '212'; // will be like 'aba'
	$c3 = '12'; // will be like 'ab'
	$c4 = '3'; // will be just a number '1 to 9' if you dont like number delete the 3
	//$c5 = '4'; // uncomment to active the strong stuff

	$comb = '4'; // the amount of combinations you made above (and did not comment out)

	for ($p = 0; $p < $pass_length;) {
	mt_srand((double)microtime() * 1000000);
	$strpart = mt_rand(1, $comb);

	// checking if the stringpart is not the same as the previous one
	if ($strpart != $previous) {
	$pass_structure .= ${'c' . $strpart};

	// shortcutting the loop a bit
	$p = $p + mb_strlen(${'c' . $strpart});
	}
	$previous = $strpart;
	}

	// generating the password from the structure defined in $pass_structure
	for ($g = 0; $g < mb_strlen($pass_structure); $g++) {
	mt_srand((double)microtime() * 1000000);
	$sel = mb_substr($pass_structure, $g, 1);
	$pass .= ${'p' . $sel}[ mt_rand(0,-1+${'s'.$sel}) ];
	}

	return $pass;
	}

	/**
	* submits $url with $post as POST
	*
	* @param string $url
	* @param mixed $data
	* @param Array $headers
	* @param string $request_type
	* @param Array $curl_options
	* @return string
	* @access public
	* @deprecated
	*/
	public static function curl_post($url, $data, $headers = NULL, $request_type = 'POST', $curl_options = NULL)
	{
	$application =& kApplication::Instance();

	$curl_helper = $application->recallObject('CurlHelper');
	/* @var $curl_helper kCurlHelper */

	if ($request_type == 'POST') {
	$curl_helper->SetRequestMethod(kCurlHelper::REQUEST_METHOD_POST);
	}

	$curl_helper->SetRequestData($data);

	if (!is_null($headers)) {
	// not an associative array, so don't use kCurlHelper::SetHeaders method
	$curl_helper->setOptions( Array (CURLOPT_HTTPHEADER => $headers) );
	}

	if (is_array($curl_options)) {
	$curl_helper->setOptions($curl_options);
	}

	$curl_helper->followLocation = false;
	$ret = $curl_helper->Send($url);

	$GLOBALS['curl_errorno'] = $curl_helper->lastErrorCode;
	$GLOBALS['curl_error'] = $curl_helper->lastErrorMsg;

	return $ret;
	}

	/**
	* Checks if constant is defined and has positive value
	*
	* @param string $const_name
	* @return bool
	* @access public
	*/
	public static function constOn($const_name)
	{
	return defined($const_name) && constant($const_name);
	}

	/**
	* Converts KG to Pounds
	*
	* @param float $kg
	* @param bool $pounds_only
	* @return float
	* @access public
	*/
	public static function Kg2Pounds($kg, $pounds_only = false)
	{
	$major = floor( round($kg / self::POUND_TO_KG, 3) );
	$minor = abs(round(($kg - $major * self::POUND_TO_KG) / self::POUND_TO_KG * 16, 2));

	if ($pounds_only) {
	$major += round($minor * 0.0625, 2);
	$minor = 0;
	}
	return array($major, $minor);
	}

	/**
	* Converts Pounds to KG
	*
	* @param float $pounds
	* @param float $ounces
	* @return float
	* @access public
	*/
	public static function Pounds2Kg($pounds, $ounces = 0.00)
	{
	return round(($pounds + ($ounces / 16)) * self::POUND_TO_KG, 5);
	}

	/**
	* Formats file/memory size in nice way
	*
	* @param int $bytes
	* @return string
	* @access public
	*/
	public static function formatSize($bytes)
	{
	if ($bytes >= 1099511627776) {
	$return = round($bytes / 1024 / 1024 / 1024 / 1024, 2);
	$suffix = "TB";
	} elseif ($bytes >= 1073741824) {
	$return = round($bytes / 1024 / 1024 / 1024, 2);
	$suffix = "GB";
	} elseif ($bytes >= 1048576) {
	$return = round($bytes / 1024 / 1024, 2);
	$suffix = "MB";
	} elseif ($bytes >= 1024) {
	$return = round($bytes / 1024, 2);
	$suffix = "KB";
	} else {
	$return = $bytes;
	$suffix = "Byte";
	}

	$return .= ' '.$suffix;

	return $return;
	}

	/**
	* Enter description here...
	*
	* @param resource $filePointer the file resource to write to
	* @param Array $data the data to write out
	* @param string $delimiter the field separator
	* @param string $enclosure symbol to enclose field data to
	* @param string $recordSeparator symbols to separate records with
	* @access public
	*/
	public static function fputcsv($filePointer, $data, $delimiter = ',', $enclosure = '"', $recordSeparator = "\r\n")
	{
	fwrite($filePointer, self::getcsvline($data, $delimiter, $enclosure, $recordSeparator));
	}

	/**
	* Enter description here...
	*
	* @param Array $data the data to write out
	* @param string $delimiter the field separator
	* @param string $enclosure symbol to enclose field data to
	* @param string $recordSeparator symbols to separate records with
	* @return string
	* @access public
	*/
	public static function getcsvline($data, $delimiter = ',', $enclosure = '"', $recordSeparator = "\r\n")
	{
	- foreach($data as $field_index => $field_value) {
	- // replaces an enclosure with two enclosures
	- $data[$field_index] = str_replace($enclosure, $enclosure.$enclosure, $field_value);
	- }
	+ $file = new SplFileObject('php://output', 'w');
	+
	+ ob_start();
	+ $file->fputcsv($data, $delimiter, $enclosure);
	+ $ret = ob_get_clean();

	- $line = $enclosure.implode($enclosure.$delimiter.$enclosure, $data).$enclosure.$recordSeparator;
	- $line = preg_replace('/'.preg_quote($enclosure, '/').'([0-9\.]+)'.preg_quote($enclosure, '/').'/', '$1', $line);
	+ if ( $recordSeparator != "\n" ) {
	+ return substr($ret, 0, -1) . $recordSeparator;
	+ }

	- return $line;
	+ return $ret;
	}

	/**
	* Allows to replace #section# within any string with current section
	*
	* @param string $string
	* @return string
	* @access public
	*/
	public static function replaceModuleSection($string)
	{
	$application =& kApplication::Instance();
	$module_section = $application->RecallVar('section');

	if ($module_section) {
	// substitute section instead of #section# parameter in title preset name
	$module_section = explode(':', $module_section);
	$section = preg_replace('/(configuration\|configure)_(.*)/i', '\\2', $module_section[count($module_section) == 2 ? 1 : 0]);
	$string = str_replace('#section#', mb_strtolower($section), $string);
	}

	return $string;
	}

	/**
	* Checks, that user IP address is within allowed range
	*
	* @param string $ip_list semi-column (by default) separated ip address list
	* @param string $separator ip address separator (default ";")
	*
	* @return bool
	* @access public
	*/
	public static function ipMatch($ip_list, $separator = ';')
	{
	if ( php_sapi_name() == 'cli' ) {
	return false;
	}

	$ip_match = false;
	$ip_addresses = $ip_list ? explode($separator, $ip_list) : Array ();

	$application =& kApplication::Instance();
	$client_ip = $application->getClientIp();

	foreach ($ip_addresses as $ip_address) {
	if ( self::netMatch($ip_address, $client_ip) ) {
	$ip_match = true;
	break;
	}
	}

	return $ip_match;
	}

	/**
	* Checks, that given ip belongs to given subnet
	*
	* @param string $network
	* @param string $ip
	* @return bool
	* @access public
	*/
	public static function netMatch($network, $ip)
	{
	$network = trim($network);
	$ip = trim($ip);

	if ( preg_replace('/[\d\.\/-]/', '', $network) != '' ) {
	$network = gethostbyname($network);
	}

	if ($network == $ip) {
	// comparing two ip addresses directly
	return true;
	}

	$d = strpos($network, '-');
	if ($d !== false) {
	// ip address range specified
	$from = ip2long(trim(substr($network, 0, $d)));
	$to = ip2long(trim(substr($network, $d + 1)));

	$ip = ip2long($ip);
	return ($ip >= $from && $ip <= $to);
	}
	elseif (strpos($network, '/') !== false) {
	// single subnet specified
	$ip_arr = explode('/', $network);

	if (!preg_match("@\d\.\d\.\d\.\d@", $ip_arr[0], $matches)) {
	$ip_arr[0] .= '.0'; // Alternate form 194.1.4/24
	}

	$network_long = ip2long($ip_arr[0]);
	$x = ip2long($ip_arr[1]);

	$mask = long2ip($x) == $ip_arr[1] ? $x : (0xffffffff << (32 - $ip_arr[1]));
	$ip_long = ip2long($ip);

	return ($ip_long & $mask) == ($network_long & $mask);
	}

	return false;
	}

	/**
	* Returns mime type corresponding to given file
	* @param string $file
	* @return string
	* @access public
	*/
	public static function mimeContentType($file)
	{
	$ret = self::vendorMimeContentType($file);

	if ( $ret ) {
	// vendor-specific mime types override any automatic detection
	return $ret;
	}

	if ( function_exists('finfo_open') && function_exists('finfo_file') ) {
	$mime_magic_resource = finfo_open(FILEINFO_MIME_TYPE);

	if ( $mime_magic_resource ) {
	$ret = finfo_file($mime_magic_resource, $file);
	finfo_close($mime_magic_resource);
	}
	}
	elseif ( function_exists('mime_content_type') ) {
	$ret = mime_content_type($file);
	}

	return $ret ? $ret : self::mimeContentTypeByExtension($file);
	}

	/**
	* Determines vendor-specific mime type from a given file
	*
	* @param string $file
	* @return bool
	* @access public
	* @static
	*/
	public static function vendorMimeContentType($file)
	{
	$file_extension = mb_strtolower(pathinfo(self::removeTempExtension($file), PATHINFO_EXTENSION));

	$mapping = Array (
	'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
	'dotx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
	'docm' => 'application/vnd.ms-word.document.macroEnabled.12',
	'dotm' => 'application/vnd.ms-word.template.macroEnabled.12',
	'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
	'xltx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
	'xlsm' => 'application/vnd.ms-excel.sheet.macroEnabled.12',
	'xltm' => 'application/vnd.ms-excel.template.macroEnabled.12',
	'xlam' => 'application/vnd.ms-excel.addin.macroEnabled.12',
	'xlsb' => 'application/vnd.ms-excel.sheet.binary.macroEnabled.12',
	'pptx' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
	'potx' => 'application/vnd.openxmlformats-officedocument.presentationml.template',
	'ppsx' => 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
	'ppam' => 'application/vnd.ms-powerpoint.addin.macroEnabled.12',
	'pptm' => 'application/vnd.ms-powerpoint.presentation.macroEnabled.12',
	'potm' => 'application/vnd.ms-powerpoint.template.macroEnabled.12',
	'ppsm' => 'application/vnd.ms-powerpoint.slideshow.macroEnabled.12'
	);

	return isset($mapping[$file_extension]) ? $mapping[$file_extension] : false;
	}

	/**
	* Detects mime type of the file purely based on it's extension
	*
	* @param string $file
	* @return string
	* @access public
	*/
	public static function mimeContentTypeByExtension($file)
	{
	$file_extension = mb_strtolower(pathinfo(self::removeTempExtension($file), PATHINFO_EXTENSION));

	$mapping = '(xls:application/excel)(hqx:application/macbinhex40)(doc,dot,wrd:application/msword)(pdf:application/pdf)
	(pgp:application/pgp)(ps,eps,ai:application/postscript)(ppt:application/powerpoint)(rtf:application/rtf)
	(tgz,gtar:application/x-gtar)(gz:application/x-gzip)(php,php3:application/x-httpd-php)(js:application/x-javascript)
	(ppd,psd:application/x-photoshop)(swf,swc,rf:application/x-shockwave-flash)(tar:application/x-tar)(zip:application/zip)
	(mid,midi,kar:audio/midi)(mp2,mp3,mpga:audio/mpeg)(ra:audio/x-realaudio)(wav:audio/wav)(bmp:image/bitmap)(bmp:image/bitmap)
	(gif:image/gif)(iff:image/iff)(jb2:image/jb2)(jpg,jpe,jpeg:image/jpeg)(jpx:image/jpx)(png:image/png)(tif,tiff:image/tiff)
	(wbmp:image/vnd.wap.wbmp)(xbm:image/xbm)(css:text/css)(txt:text/plain)(htm,html:text/html)(xml:text/xml)
	(mpg,mpe,mpeg:video/mpeg)(qt,mov:video/quicktime)(avi:video/x-ms-video)(eml:message/rfc822)
	(sxw:application/vnd.sun.xml.writer)(sxc:application/vnd.sun.xml.calc)(sxi:application/vnd.sun.xml.impress)
	(sxd:application/vnd.sun.xml.draw)(sxm:application/vnd.sun.xml.math)
	(odt:application/vnd.oasis.opendocument.text)(oth:application/vnd.oasis.opendocument.text-web)
	(odm:application/vnd.oasis.opendocument.text-master)(odg:application/vnd.oasis.opendocument.graphics)
	(odp:application/vnd.oasis.opendocument.presentation)(ods:application/vnd.oasis.opendocument.spreadsheet)
	(odc:application/vnd.oasis.opendocument.chart)(odf:application/vnd.oasis.opendocument.formula)
	(odi:application/vnd.oasis.opendocument.image)';

	if ( preg_match('/[$,]' . $file_extension . '[,]{0,1}.?:(.?)$/s', $mapping, $regs) ) {
	return $regs[1];
	}

	return 'application/octet-stream';
	}

	/**
	* Strips ".tmp" suffix (added by flash uploader) from a filename
	*
	* @param string $file
	* @return string
	* @access public
	* @static
	*/
	public static function removeTempExtension($file)
	{
	return preg_replace('/(_[\d]+)?\.tmp$/', '', $file);
	}

	/**
	* Return param value and removes it from params array
	*
	* @param string $name
	* @param Array $params
	* @param bool $default
	* @return string
	*/
	public static function popParam($name, &$params, $default = false)
	{
	if ( isset($params[$name]) ) {
	$value = $params[$name];
	unset($params[$name]);

	return $value;
	}

	return $default;
	}

	/**
	* Generate subpath from hashed value
	*
	* @param string $name
	* @param int $levels
	* @return string
	*/
	public static function getHashPathForLevel($name, $levels = 2)
	{
	if ( $levels == 0 ) {
	return '';
	}
	else {
	$path = '';
	$hash = md5($name);

	for ($i = 0; $i < $levels; $i++) {
	$path .= substr($hash, $i, 1) . '/';
	}

	return $path;
	}
	}

	/**
	* Calculates the crc32 polynomial of a string (always positive number)
	*
	* @param string $str
	* @return int
	*/
	public static function crc32($str)
	{
	return sprintf('%u', crc32($str));
	}

	/**
	* Returns instance of DateTime class with date set based on timestamp
	*
	* @static
	* @param int $timestamp
	* @return DateTime
	* @access public
	*/
	public static function dateFromTimestamp($timestamp)
	{
	if ( version_compare(PHP_VERSION, '5.3.0', '<') ) {
	$date = new DateTime('@' . $timestamp);
	$date->setTimezone(new DateTimeZone(date_default_timezone_get()));
	}
	else {
	$date = new DateTime();
	$date->setTimestamp($timestamp);
	}

	return $date;
	}

	/**
	* Returns timestamp from given DateTime class instance
	*
	* @static
	* @param DateTime $date_time
	* @return int\|string
	* @access public
	*/
	public static function timestampFromDate(DateTime $date_time)
	{
	if ( version_compare(PHP_VERSION, '5.3.0', '<') ) {
	return $date_time->format('U');
	}

	return $date_time->getTimestamp();
	}

	/**
	* Generates random numeric id
	*
	* @static
	* @return string
	* @access public
	*/
	public static function generateId()
	{
	list($usec, $sec) = explode(' ', microtime());

	$id_part_1 = substr($usec, 4, 4);
	$id_part_2 = mt_rand(1, 9);
	$id_part_3 = substr($sec, 6, 4);
	$digit_one = substr($id_part_1, 0, 1);

	if ( $digit_one == 0 ) {
	$digit_one = mt_rand(1, 9);
	$id_part_1 = preg_replace('/^0/', '', $id_part_1);
	$id_part_1 = $digit_one . $id_part_1;
	}

	return $id_part_1 . $id_part_2 . $id_part_3;
	}

	/**
	* Changes script resource limits. Omitted argument results in limit removal.
	*
	* @static
	* @param string\|int $memory_limit
	* @param int $time_limit
	* @return void
	* @access public
	*/
	public static function setResourceLimit($memory_limit = null, $time_limit = null)
	{
	set_time_limit(isset($time_limit) ? $time_limit : 0);
	ini_set('memory_limit', isset($memory_limit) ? $memory_limit : -1);
	}

	/**
	* Escapes a string.
	*
	* @param string $text Text to escape.
	* @param string $strategy Escape strategy.
	*
	* @return string
	* @throws InvalidArgumentException When unknown escape strategy is given.
	*/
	public static function escape($text, $strategy = null)
	{
	if ( !isset($strategy) ) {
	$strategy = self::$escapeStrategy;
	}

	if ( strpos($strategy, '+') !== false ) {
	$previous_strategy = '';
	$strategies = explode('+', $strategy);

	foreach ($strategies as $current_strategy) {
	// apply default strategy
	if ( $current_strategy == '' ) {
	$current_strategy = self::$escapeStrategy;
	}

	// don't double-escape
	if ( $current_strategy != $previous_strategy ) {
	$text = self::escape($text, $current_strategy);
	$previous_strategy = $current_strategy;
	}
	}

	return $text;
	}

	if ( $strategy == self::ESCAPE_HTML ) {
	return htmlspecialchars($text, ENT_QUOTES, CHARSET);
	}

	if ( $strategy == self::ESCAPE_JS ) {
	// TODO: consider using "addcslashes", because "addslashes" isn't really for JavaScript escaping (according to docs)
	$text = addslashes($text);
	$text = str_replace(array("\r", "\n"), array('\r', '\n'), $text);
	$text = str_replace('</script>', "</'+'script>", $text);

	return $text;
	}

	if ( $strategy == self::ESCAPE_URL ) {
	return rawurlencode($text);
	}

	if ( $strategy == self::ESCAPE_RAW ) {
	return $text;
	}

	throw new InvalidArgumentException(sprintf('Unknown escape strategy "%s"', $strategy));
	}

	}

	/**
	* Returns array value if key exists
	* Accepts infinite number of parameters
	*
	* @param Array $array searchable array
	* @param int $key array key
	* @return string
	*/
	function getArrayValue(&$array, $key)
	{
	$ret = isset($array[$key]) ? $array[$key] : false;

	if ( $ret && func_num_args() > 2 ) {
	for ($i = 2; $i < func_num_args(); $i++) {
	$cur_key = func_get_arg($i);
	$ret = getArrayValue($ret, $cur_key);

	if ( $ret === false ) {
	break;
	}
	}
	}

	return $ret;
	}

	if ( !function_exists('parse_ini_string') ) {
	/**
	* Equivalent for "parse_ini_string" function available since PHP 5.3.0
	*
	* @param string $ini
	* @param bool $process_sections
	* @param int $scanner_mode
	* @return Array
	*/
	function parse_ini_string($ini, $process_sections = false, $scanner_mode = NULL)
	{
	# Generate a temporary file.
	$tempname = tempnam('/tmp', 'ini');
	$fp = fopen($tempname, 'w');
	fwrite($fp, $ini);
	$ini = parse_ini_file($tempname, !empty($process_sections));
	fclose($fp);
	@unlink($tempname);

	return $ini;
	}
	}

	if ( !function_exists('memory_get_usage') ) {
	// PHP 4.x and compiled without --enable-memory-limit option
	function memory_get_usage() { return -1; }
	}

	if ( !function_exists('imagecreatefrombmp') ) {
	// just in case if GD will add this function in future
	function imagecreatefrombmp($filename)
	{
	//Ouverture du fichier en mode binaire
	if (! $f1 = fopen($filename,"rb")) return FALSE;

	//1 : Chargement des ent�tes FICHIER
	$FILE = unpack("vfile_type/Vfile_size/Vreserved/Vbitmap_offset", fread($f1,14));
	if ($FILE['file_type'] != 19778) return FALSE;

	//2 : Chargement des ent�tes BMP
	$BMP = unpack('Vheader_size/Vwidth/Vheight/vplanes/vbits_per_pixel'.
	'/Vcompression/Vsize_bitmap/Vhoriz_resolution'.
	'/Vvert_resolution/Vcolors_used/Vcolors_important', fread($f1,40));
	$BMP['colors'] = pow(2,$BMP['bits_per_pixel']);
	if ($BMP['size_bitmap'] == 0) $BMP['size_bitmap'] = $FILE['file_size'] - $FILE['bitmap_offset'];
	$BMP['bytes_per_pixel'] = $BMP['bits_per_pixel']/8;
	$BMP['bytes_per_pixel2'] = ceil($BMP['bytes_per_pixel']);
	$BMP['decal'] = ($BMP['width']*$BMP['bytes_per_pixel']/4);
	$BMP['decal'] -= floor($BMP['width']*$BMP['bytes_per_pixel']/4);
	$BMP['decal'] = 4-(4*$BMP['decal']);
	if ($BMP['decal'] == 4) $BMP['decal'] = 0;

	//3 : Chargement des couleurs de la palette
	$PALETTE = array();
	if ($BMP['colors'] < 16777216)
	{
	$PALETTE = unpack('V'.$BMP['colors'], fread($f1,$BMP['colors']*4));
	}

	//4 : Cr�ation de l'image
	$IMG = fread($f1,$BMP['size_bitmap']);
	$VIDE = chr(0);

	$res = imagecreatetruecolor($BMP['width'],$BMP['height']);
	$P = 0;
	$Y = $BMP['height']-1;
	while ($Y >= 0)
	{
	$X=0;
	while ($X < $BMP['width'])
	{
	if ($BMP['bits_per_pixel'] == 24)
	$COLOR = unpack("V",substr($IMG,$P,3).$VIDE);
	elseif ($BMP['bits_per_pixel'] == 16)
	{
	$COLOR = unpack("n",substr($IMG,$P,2));
	$COLOR[1] = $PALETTE[$COLOR[1]+1];
	}
	elseif ($BMP['bits_per_pixel'] == 8)
	{
	$COLOR = unpack("n",$VIDE.substr($IMG,$P,1));
	$COLOR[1] = $PALETTE[$COLOR[1]+1];
	}
	elseif ($BMP['bits_per_pixel'] == 4)
	{
	$COLOR = unpack("n",$VIDE.substr($IMG,floor($P),1));
	if (($P*2)%2 == 0) $COLOR[1] = ($COLOR[1] >> 4) ; else $COLOR[1] = ($COLOR[1] & 0x0F);
	$COLOR[1] = $PALETTE[$COLOR[1]+1];
	}
	elseif ($BMP['bits_per_pixel'] == 1)
	{
	$COLOR = unpack("n",$VIDE.substr($IMG,floor($P),1));
	if (($P*8)%8 == 0) $COLOR[1] = $COLOR[1] >>7;
	elseif (($P*8)%8 == 1) $COLOR[1] = ($COLOR[1] & 0x40)>>6;
	elseif (($P*8)%8 == 2) $COLOR[1] = ($COLOR[1] & 0x20)>>5;
	elseif (($P*8)%8 == 3) $COLOR[1] = ($COLOR[1] & 0x10)>>4;
	elseif (($P*8)%8 == 4) $COLOR[1] = ($COLOR[1] & 0x8)>>3;
	elseif (($P*8)%8 == 5) $COLOR[1] = ($COLOR[1] & 0x4)>>2;
	elseif (($P*8)%8 == 6) $COLOR[1] = ($COLOR[1] & 0x2)>>1;
	elseif (($P*8)%8 == 7) $COLOR[1] = ($COLOR[1] & 0x1);
	$COLOR[1] = $PALETTE[$COLOR[1]+1];
	}
	else
	return FALSE;
	imagesetpixel($res,$X,$Y,$COLOR[1]);
	$X++;
	$P += $BMP['bytes_per_pixel'];
	}
	$Y--;
	$P+=$BMP['decal'];
	}

	//Fermeture du fichier
	fclose($f1);

	return $res;
	}
	}
	\ No newline at end of file
	Index: branches/5.2.x/core/units/helpers/cat_dbitem_export_helper.php
	===================================================================
	--- branches/5.2.x/core/units/helpers/cat_dbitem_export_helper.php (revision 15999)
	+++ branches/5.2.x/core/units/helpers/cat_dbitem_export_helper.php (revision 16000)
	@@ -1,1573 +1,1577 @@
	<?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.org/license for copyright notices and details.
	*/

	defined('FULL_PATH') or die('restricted access!');

	define('EXPORT_STEP', 100); // export by 200 items (e.g. links)
	define('IMPORT_STEP', 20); // export by 200 items (e.g. links)
	define('IMPORT_CHUNK', 10240); // 10240); //30720); //50120); // 5 KB

	define('IMPORT_TEMP', 1);
	define('IMPORT_LIVE', 2);

	class kCatDBItemExportHelper extends kHelper {

	var $false = false;

	var $cache = Array();

	/**
	* Allows to find out what items are new in cache
	*
	* @var Array
	*/
	var $cacheStatus = Array();

	var $cacheTable = '';

	var $exportFields = Array();

	/**
	* Export options
	*
	* @var Array
	*/
	var $exportOptions = Array();

	/**
	* Item beeing currenly exported
	*
	* @var kCatDBItem
	*/
	var $curItem = null;

	/**
	* Dummy category object
	*
	* @var CategoriesItem
	*/
	var $dummyCategory = null;

	/**
	* Pointer to opened file
	*
	* @var resource
	*/
	var $filePointer = null;

	/**
	* Custom fields definition of current item
	*
	* @var Array
	*/
	var $customFields = Array();

	public function __construct()
	{
	parent::__construct();

	$this->cacheTable = TABLE_PREFIX.'ImportCache';
	}

	/**
	* Returns value from cache if found or false otherwise
	*
	* @param string $type
	* @param int $key
	* @return mixed
	*/
	function getFromCache($type, $key)
	{
	return getArrayValue($this->cache, $type, $key);
	}

	/**
	* Adds value to be cached
	*
	* @param string $type
	* @param int $key
	* @param mixed $value
	* @param bool $is_new
	*/
	function addToCache($type, $key, $value, $is_new = true)
	{
	/*if ( !isset($this->cache[$type]) ) {
	$this->cache[$type] = Array ();
	}*/

	$this->cache[$type][$key] = $value;

	if ( $is_new ) {
	$this->cacheStatus[$type][$key] = true;
	}
	}

	function storeCache($cache_types)
	{
	$fields_hash = Array ();
	$cache_types = explode(',', $cache_types);

	foreach ($cache_types as $cache_type) {
	$fields_hash = Array ('CacheName' => $cache_type);
	$cache = getArrayValue($this->cacheStatus, $cache_type);

	if ( !$cache ) {
	$cache = Array ();
	}

	foreach ($cache as $var_name => $cache_status) {
	$fields_hash['VarName'] = $var_name;
	$fields_hash['VarValue'] = $this->cache[$cache_type][$var_name];

	$this->Conn->doInsert($fields_hash, $this->cacheTable, 'INSERT', false);
	}
	}

	if ( isset($fields_hash['VarName']) ) {
	$this->Conn->doInsert($fields_hash, $this->cacheTable, 'INSERT');
	}
	}

	function loadCache()
	{
	$this->cache = Array ();

	$sql = 'SELECT *
	FROM ' . $this->cacheTable;
	$records = $this->Conn->GetIterator($sql);

	foreach ($records as $record) {
	$this->addToCache($record['CacheName'], $record['VarName'], $record['VarValue'], false);
	}
	}

	/**
	* Fill required fields with dummy values
	*
	* @param kEvent\|bool $event
	* @param kCatDBItem\|bool $object
	* @param bool $set_status
	*/
	function fillRequiredFields($event, &$object, $set_status = false)
	{
	if ( $object == $this->false ) {
	$object = $event->getObject();
	/* @var $object kCatDBItem */
	}

	$has_empty = false;
	$fields = $object->getFields();

	if ( $object->isField('CreatedById') ) {
	// CSV file was created without required CreatedById column
	if ( $object->isRequired('CreatedById') ) {
	$object->setRequired('CreatedById', false);
	}

	if ( !is_numeric( $object->GetDBField('CreatedById') ) ) {
	$object->SetDBField('CreatedById', $this->Application->RecallVar('user_id'));
	}
	}

	foreach ($fields as $field_name => $field_options) {
	if ( $object->isVirtualField($field_name) \|\| !$object->isRequired($field_name) ) {
	continue;
	}

	if ( $object->GetDBField($field_name) ) {
	continue;
	}

	$formatter_class = getArrayValue($field_options, 'formatter');

	if ( $formatter_class ) {
	// not tested
	$formatter = $this->Application->recallObject($formatter_class);
	/* @var $formatter kFormatter */

	$sample_value = $formatter->GetSample($field_name, $field_options, $object);
	}

	$has_empty = true;
	$object->SetField($field_name, isset($sample_value) && $sample_value ? $sample_value : 'no value');
	}
	$object->UpdateFormattersSubFields();

	if ( $set_status && $has_empty ) {
	$object->SetDBField('Status', 0);
	}
	}

	/**
	* Verifies that all user entered export params are correct
	*
	* @param kEvent $event
	* @return bool
	* @access protected
	*/
	protected function verifyOptions($event)
	{
	if ($this->Application->RecallVar($event->getPrefixSpecial().'_ForceNotValid'))
	{
	$this->Application->StoreVar($event->getPrefixSpecial().'_ForceNotValid', 0);
	return false;
	}

	$this->fillRequiredFields($event, $this->false);

	$object = $event->getObject();
	/* @var $object kCatDBItem */

	$cross_unique_fields = Array('FieldsSeparatedBy', 'FieldsEnclosedBy');
	if (($object->GetDBField('CategoryFormat') == 1) \|\| ($event->Special == 'import')) // in one field
	{
	$object->setRequired('CategorySeparator');
	$cross_unique_fields[] = 'CategorySeparator';
	}

	$ret = $object->Validate();

	// check if cross unique fields has no same values
	foreach ($cross_unique_fields as $field_index => $field_name)
	{
	if ($object->GetErrorPseudo($field_name) == 'required') {
	continue;
	}

	$check_fields = $cross_unique_fields;
	unset($check_fields[$field_index]);

	foreach ($check_fields as $check_field)
	{
	if ($object->GetDBField($field_name) == $object->GetDBField($check_field))
	{
	$object->SetError($check_field, 'unique');
	}
	}
	}

	if ($event->Special == 'import')
	{
	$this->exportOptions = $this->loadOptions($event);

	$automatic_fields = ($object->GetDBField('FieldTitles') == 1);
	$object->setRequired('ExportColumns', !$automatic_fields);
	$category_prefix = '__CATEGORY__';
	if ( $automatic_fields && ($this->exportOptions['SkipFirstRow']) ) {
	$this->openFile($event);
	$this->exportOptions['ExportColumns'] = $this->readRecord();

	if (!$this->exportOptions['ExportColumns']) {
	$this->exportOptions['ExportColumns'] = Array ();
	}

	$this->closeFile();

	// remove additional (non-parseble columns)
	foreach ($this->exportOptions['ExportColumns'] as $field_index => $field_name) {
	if (!$this->validateField($field_name, $object)) {
	unset($this->exportOptions['ExportColumns'][$field_index]);
	}
	}
	$category_prefix = '';
	}

	// 1. check, that we have column definitions
	if (!$this->exportOptions['ExportColumns']) {
	$object->setError('ExportColumns', 'required');
	$ret = false;
	}
	else {
	// 1.1. check that all required fields are present in imported file
	$missing_columns = Array();
	$fields = $object->getFields();

	foreach ($fields as $field_name => $field_options) {
	if ($object->skipField($field_name)) continue;
	if ( $object->isRequired($field_name) && !in_array($field_name, $this->exportOptions['ExportColumns']) ) {
	$missing_columns[] = $field_name;
	$object->setError('ExportColumns', 'required_fields_missing', 'la_error_RequiredColumnsMissing');
	$ret = false;
	}
	}

	if (!$ret && $this->Application->isDebugMode()) {
	$this->Application->Debugger->appendHTML('Missing required for import/export:');
	$this->Application->Debugger->dumpVars($missing_columns);
	}
	}


	// 2. check, that we have only mixed category field or only separated category fields
	$category_found['mixed'] = false;
	$category_found['separated'] = false;

	foreach ($this->exportOptions['ExportColumns'] as $import_field) {
	if (preg_match('/^'.$category_prefix.'Category(Path\|[0-9]+)/', $import_field, $rets)) {
	$category_found[$rets[1] == 'Path' ? 'mixed' : 'separated'] = true;
	}
	}
	if ($category_found['mixed'] && $category_found['separated']) {
	$object->SetError('ExportColumns', 'unique_category', 'la_error_unique_category_field');
	$ret = false;
	}

	// 3. check, that duplicates check fields are selected & present in imported fields
	if ($this->exportOptions['ReplaceDuplicates']) {
	if ($this->exportOptions['CheckDuplicatesMethod'] == 1) {
	$check_fields = Array($object->IDField);
	}
	else {
	$check_fields = $this->exportOptions['DuplicateCheckFields'] ? explode('\|', substr($this->exportOptions['DuplicateCheckFields'], 1, -1)) : Array();
	$object = $event->getObject();

	$fields = $object->getFields();
	$language_id = $this->Application->GetDefaultLanguageId();

	foreach ($check_fields as $index => $check_field) {
	foreach ($fields as $field_name => $field_options) {
	if ($field_name == 'l'.$language_id.'_'.$check_field) {
	$check_fields[$index] = 'l'.$language_id.'_'.$check_field;
	break;
	}
	}
	}
	}
	$this->exportOptions['DuplicateCheckFields'] = $check_fields;

	if (!$check_fields) {
	$object->setError('CheckDuplicatesMethod', 'required');
	$ret = false;
	}
	else {
	foreach ($check_fields as $check_field) {
	$check_field = preg_replace('/^cust_(.*)/', 'Custom_\\1', $check_field);
	if (!in_array($check_field, $this->exportOptions['ExportColumns'])) {
	$object->setError('ExportColumns', 'required');
	$ret = false;
	break;
	}
	}
	}
	}
	$this->saveOptions($event);
	}

	return $ret;
	}

	/**
	* Returns filename to read import data from
	*
	* @return string
	*/
	function getImportFilename()
	{
	if ($this->exportOptions['ImportSource'] == 1)
	{
	$ret = $this->exportOptions['ImportFilename']; // ['name']; commented by Kostja
	}
	else {
	$ret = $this->exportOptions['ImportLocalFilename'];
	}
	return EXPORT_PATH.'/'.$ret;
	}

	/**
	* Returns filename to write export data to
	*
	* @return string
	*/
	function getExportFilename()
	{
	$extension = $this->getFileExtension();
	$filename = preg_replace('/(.*)\.' . $extension . '$/', '\1', $this->exportOptions['ExportFilename']) . '.' . $extension;

	return EXPORT_PATH . DIRECTORY_SEPARATOR . $filename;
	}

	/**
	* Opens file required for export/import operations
	*
	* @param kEvent $event
	*/
	function openFile($event)
	{
	$file_helper = $this->Application->recallObject('FileHelper');
	/* @var $file_helper FileHelper */

	$file_helper->CheckFolder(EXPORT_PATH);

	- if ($event->Special == 'export') {
	- $write_mode = ($this->exportOptions['start_from'] == 0) ? 'w' : 'a';
	- $this->filePointer = fopen($this->getExportFilename(), $write_mode);
	+ if ( $event->Special == 'export' ) {
	+ $first_step = $this->exportOptions['start_from'] == 0;
	+ $this->filePointer = fopen($this->getExportFilename(), $first_step ? 'w' : 'r+');
	+
	+ if ( !$first_step ) {
	+ fseek($this->filePointer, 0, SEEK_END);
	+ }
	}
	else {
	$this->filePointer = fopen($this->getImportFilename(), 'r');
	- }

	- // skip UTF-8 BOM Modifier
	- $first_chars = fread($this->filePointer, 3);
	- if (bin2hex($first_chars) != 'efbbbf') {
	- fseek($this->filePointer, 0);
	+ // skip UTF-8 BOM Modifier
	+ $first_chars = fread($this->filePointer, 3);
	+ if ( bin2hex($first_chars) != 'efbbbf' ) {
	+ fseek($this->filePointer, 0);
	+ }
	}
	}

	/**
	* Closes opened file
	*
	*/
	function closeFile()
	{
	fclose($this->filePointer);
	}

	function getCustomSQL()
	{
	$ml_formatter = $this->Application->recallObject('kMultiLanguage');
	/* @var $ml_formatter kMultiLanguage */

	$custom_sql = '';

	foreach ($this->customFields as $custom_id => $custom_name) {
	$custom_sql .= 'custom_data.' . $ml_formatter->LangFieldName('cust_' . $custom_id) . ' AS cust_' . $custom_name . ', ';
	}

	return substr($custom_sql, 0, -2);
	}

	function getPlainExportSQL($count_only = false)
	{
	if ( $count_only && isset($this->exportOptions['ForceCountSQL']) ) {
	$sql = $this->exportOptions['ForceCountSQL'];
	}
	elseif ( !$count_only && isset($this->exportOptions['ForceSelectSQL']) ) {
	$sql = $this->exportOptions['ForceSelectSQL'];
	}
	else {
	$items_list = $this->Application->recallObject($this->curItem->Prefix . '.export-items-list', $this->curItem->Prefix . '_List');
	/* @var $items_list kDBList */

	$items_list->SetPerPage(-1);

	if ( $this->exportOptions['export_ids'] != '' ) {
	$items_list->addFilter('export_ids', $items_list->TableName . '.' . $items_list->IDField . ' IN (' . implode(',', $this->exportOptions['export_ids']) . ')');
	}

	if ( $count_only ) {
	$sql = $items_list->getCountSQL($items_list->GetSelectSQL(true, false));
	}
	else {
	$sql = $items_list->GetSelectSQL();
	}
	}

	if ( !$count_only ) {
	$sql .= ' LIMIT ' . $this->exportOptions['start_from'] . ',' . EXPORT_STEP;
	}
	/*else {
	$sql = preg_replace("/^\sSELECT(.?\s)FROM(?!_)/is", "SELECT COUNT(*) AS count FROM ", $sql);
	}*/

	return $sql;
	}

	function getExportSQL($count_only = false)
	{
	if ( !$this->Application->getUnitOption($this->curItem->Prefix, 'CatalogItem') ) {
	return $this->GetPlainExportSQL($count_only); // in case this is not a CategoryItem
	}

	if ( $this->exportOptions['export_ids'] === false ) {
	// get links from current category & all it's subcategories
	$join_clauses = Array ();

	$custom_sql = $this->getCustomSQL();

	if ( $custom_sql ) {
	$custom_table = $this->Application->getUnitOption($this->curItem->Prefix . '-cdata', 'TableName');
	$join_clauses[$custom_table . ' custom_data'] = 'custom_data.ResourceId = item_table.ResourceId';
	}

	$join_clauses[TABLE_PREFIX . 'CategoryItems ci'] = 'ci.ItemResourceId = item_table.ResourceId';
	$join_clauses[TABLE_PREFIX . 'Categories c'] = 'c.CategoryId = ci.CategoryId';

	$sql = 'SELECT item_table.*, ci.CategoryId' . ($custom_sql ? ', ' . $custom_sql : '') . '
	FROM ' . $this->curItem->TableName . ' item_table';

	foreach ($join_clauses as $table_name => $join_expression) {
	$sql .= ' LEFT JOIN ' . $table_name . ' ON ' . $join_expression;
	}

	$sql .= ' WHERE ';

	if ( $this->exportOptions['export_cats_ids'][0] == 0 ) {
	$sql .= '1';
	}
	else {
	foreach ($this->exportOptions['export_cats_ids'] as $category_id) {
	$sql .= '(c.ParentPath LIKE "%\|' . $category_id . '\|%") OR ';
	}

	$sql = substr($sql, 0, -4);
	}

	$sql .= ' ORDER BY ci.PrimaryCat DESC'; // NEW
	}
	else {
	// get only selected links
	$sql = 'SELECT item_table.*, ' . $this->exportOptions['export_cats_ids'][0] . ' AS CategoryId
	FROM ' . $this->curItem->TableName . ' item_table
	WHERE ' . $this->curItem->IDField . ' IN (' . implode(',', $this->exportOptions['export_ids']) . ')';
	}

	if ( !$count_only ) {
	$sql .= ' LIMIT ' . $this->exportOptions['start_from'] . ',' . EXPORT_STEP;
	}
	else {
	$sql = preg_replace("/^\sSELECT(.?\s)FROM(?!_)/is", "SELECT COUNT(*) AS count FROM ", $sql);
	}

	return $sql;
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function performExport($event)
	{
	$this->exportOptions = $this->loadOptions($event);
	$this->exportFields = $this->exportOptions['ExportColumns'];
	$this->curItem = $event->getObject( Array('skip_autoload' => true) );
	$this->customFields = $this->Application->getUnitOption($event->Prefix, 'CustomFields');
	$this->openFile($event);

	if ($this->exportOptions['start_from'] == 0) // first export step
	{
	if (!getArrayValue($this->exportOptions, 'IsBaseCategory')) {
	$this->exportOptions['IsBaseCategory'] = 0;
	}

	if ($this->exportOptions['IsBaseCategory'] ) {
	$sql = 'SELECT ParentPath
	FROM '.TABLE_PREFIX.'Categories
	WHERE CategoryId = ' . (int)$this->Application->GetVar('m_cat_id');
	$parent_path = $this->Conn->GetOne($sql);
	$parent_path = explode('\|', substr($parent_path, 1, -1));
	if ($parent_path && $parent_path[0] == $this->Application->getBaseCategory()) {
	array_shift($parent_path);
	}

	$this->exportOptions['BaseLevel'] = count($parent_path); // level to cut from other categories
	}

	// 1. export field titles if required
	if ($this->exportOptions['IncludeFieldTitles'])
	{
	$data_array = Array();
	foreach ($this->exportFields as $export_field)
	{
	$data_array = array_merge($data_array, $this->getFieldCaption($export_field));
	}
	$this->writeRecord($data_array);
	}
	$this->exportOptions['total_records'] = $this->Conn->GetOne( $this->getExportSQL(true) );
	}

	// 2. export data
	$records = $this->Conn->Query( $this->getExportSQL() );
	$records_exported = 0;
	foreach ($records as $record_info) {
	$this->curItem->LoadFromHash($record_info);

	$data_array = Array();
	foreach ($this->exportFields as $export_field)
	{
	$data_array = array_merge($data_array, $this->getFieldValue($export_field) );
	}
	$this->writeRecord($data_array);
	$records_exported++;
	}
	$this->closeFile();

	$this->exportOptions['start_from'] += $records_exported;
	$this->saveOptions($event);

	return $this->exportOptions;
	}

	function getItemFields()
	{
	// just in case dummy user selected automtic mode & moved columns too :(
	$src_options = $this->curItem->GetFieldOption('ExportColumns', 'options');
	$dst_options = $this->curItem->GetFieldOption('AvailableColumns', 'options');

	return array_merge($dst_options, $src_options);
	}

	/**
	* Checks if field really belongs to importable field list
	*
	* @param string $field_name
	* @param kCatDBItem $object
	* @return bool
	*/
	function validateField($field_name, &$object)
	{
	// 1. convert custom field
	$field_name = preg_replace('/^Custom_(.*)/', '__CUSTOM__\\1', $field_name);

	// 2. convert category field (mixed version & separated version)
	$field_name = preg_replace('/^Category(Path\|[0-9]+)/', '__CATEGORY__Category\\1', $field_name);

	$valid_fields = $object->getPossibleExportColumns();
	return isset($valid_fields[$field_name]) \|\| isset($valid_fields['__VIRTUAL__'.$field_name]);
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	*/
	function performImport($event)
	{
	if (!$this->exportOptions) {
	// load import options in case if not previously loaded in verification function
	$this->exportOptions = $this->loadOptions($event);
	}

	$backup_category_id = $this->Application->GetVar('m_cat_id');
	$this->Application->SetVar('m_cat_id', (int)$this->Application->RecallVar('ImportCategory') );

	$this->openFile($event);

	$bytes_imported = 0;
	if ($this->exportOptions['start_from'] == 0) // first export step
	{
	// 1st time run
	if ($this->exportOptions['SkipFirstRow']) {
	$this->readRecord();
	$this->exportOptions['start_from'] = ftell($this->filePointer);
	$bytes_imported = ftell($this->filePointer);
	}

	$current_category_id = $this->Application->GetVar('m_cat_id');
	if ($current_category_id > 0) {
	$sql = 'SELECT ParentPath FROM '.TABLE_PREFIX.'Categories WHERE CategoryId = '.$current_category_id;
	$this->exportOptions['ImportCategoryPath'] = $this->Conn->GetOne($sql);
	}
	else {
	$this->exportOptions['ImportCategoryPath'] = '';
	}
	$this->exportOptions['total_records'] = filesize($this->getImportFilename());
	}
	else {
	$this->loadCache();
	}

	$this->exportFields = $this->exportOptions['ExportColumns'];
	$this->addToCache('category_parent_path', $this->Application->GetVar('m_cat_id'), $this->exportOptions['ImportCategoryPath']);

	// 2. import data
	$this->dummyCategory = $this->Application->recallObject('c.-tmpitem', 'c', Array('skip_autoload' => true));
	fseek($this->filePointer, $this->exportOptions['start_from']);

	$items_processed = 0;
	while (($bytes_imported < IMPORT_CHUNK && $items_processed < IMPORT_STEP) && !feof($this->filePointer)) {
	$data = $this->readRecord();
	if ($data) {
	if ($this->exportOptions['ReplaceDuplicates']) {
	// set fields used as keys for replace duplicates code
	$this->resetImportObject($event, IMPORT_TEMP, $data);
	}

	$this->processCurrentItem($event, $data);
	}
	$bytes_imported = ftell($this->filePointer) - $this->exportOptions['start_from'];
	$items_processed++;
	}

	$this->closeFile();
	$this->Application->SetVar('m_cat_id', $backup_category_id);

	$this->exportOptions['start_from'] += $bytes_imported;
	$this->storeCache('new_ids');

	$this->saveOptions($event);

	if ($this->exportOptions['start_from'] == $this->exportOptions['total_records']) {
	$this->Conn->Query('TRUNCATE TABLE '.$this->cacheTable);
	}

	return $this->exportOptions;
	}

	function setCurrentID()
	{
	$this->curItem->setID( $this->curItem->GetDBField($this->curItem->IDField) );
	}

	/**
	* Sets value of import/export object
	* @param int $field_index
	* @param mixed $value
	* @return void
	* @access protected
	*/
	protected function setFieldValue($field_index, $value)
	{
	if ( empty($value) ) {
	$value = null;
	}

	$field_name = getArrayValue($this->exportFields, $field_index);
	if ( $field_name == 'ResourceId' ) {
	return ;
	}

	if ( substr($field_name, 0, 7) == 'Custom_' ) {
	$field_name = 'cust_' . substr($field_name, 7);
	$this->curItem->SetField($field_name, $value);
	}
	elseif ( $field_name == 'CategoryPath' \|\| $field_name == '__CATEGORY__CategoryPath' ) {
	$this->curItem->CategoryPath = $value ? explode($this->exportOptions['CategorySeparator'], $value) : Array ();
	}
	elseif ( substr($field_name, 0, 8) == 'Category' ) {
	$this->curItem->CategoryPath[(int)substr($field_name, 8) - 1] = $value;
	}
	elseif ( substr($field_name, 0, 20) == '__CATEGORY__Category' ) {
	$this->curItem->CategoryPath[(int)substr($field_name, 20) - 1] = $value;
	}
	elseif ( substr($field_name, 0, 11) == '__VIRTUAL__' ) {
	$field_name = substr($field_name, 11);
	$this->curItem->SetField($field_name, $value);
	}
	else {
	$this->curItem->SetField($field_name, $value);
	}

	if ( $this->curItem->GetErrorPseudo($field_name) ) {
	$this->curItem->SetDBField($field_name, null);
	$this->curItem->RemoveError($field_name);
	}
	}

	/**
	* Resets import object
	*
	* @param kEvent $event
	* @param int $object_type
	* @param Array $record_data
	* @return void
	*/
	function resetImportObject($event, $object_type, $record_data = null)
	{
	switch ($object_type) {
	case IMPORT_TEMP:
	$this->curItem = $event->getObject( Array('skip_autoload' => true) );
	break;

	case IMPORT_LIVE:
	$this->curItem = $this->Application->recallObject($event->Prefix.'.-tmpitem'.$event->Special, $event->Prefix, Array('skip_autoload' => true));
	break;
	}
	$this->curItem->Clear();
	$this->curItem->SetDBField('CategoryId', NULL); // since default value is import root category
	$this->customFields = $this->Application->getUnitOption($event->Prefix, 'CustomFields');

	if (isset($record_data)) {
	$this->setImportData($record_data);
	}
	}

	function setImportData($record_data)
	{
	foreach ($record_data as $field_index => $field_value) {
	$this->setFieldValue($field_index, $field_value);
	}
	$this->setCurrentID();
	}


	function getItemCategory()
	{
	static $lang_prefix = null;
	$backup_category_id = $this->Application->GetVar('m_cat_id');

	$category_id = $this->getFromCache('category_names', implode(':', $this->curItem->CategoryPath));
	if ($category_id) {
	$this->Application->SetVar('m_cat_id', $category_id);
	return $category_id;
	}

	if (is_null($lang_prefix)) {
	$lang_prefix = 'l'.$this->Application->GetVar('m_lang').'_';
	}

	foreach ($this->curItem->CategoryPath as $category_index => $category_name) {
	if (!$category_name) continue;
	$category_key = kUtil::crc32( implode(':', array_slice($this->curItem->CategoryPath, 0, $category_index + 1) ) );

	$category_id = $this->getFromCache('category_names', $category_key);
	if ($category_id === false) {
	// get parent category path to search only in it
	$current_category_id = $this->Application->GetVar('m_cat_id');
	// $parent_path = $this->getParentPath($current_category_id);

	// get category id from database by name
	$sql = 'SELECT CategoryId
	FROM '.TABLE_PREFIX.'Categories
	WHERE ('.$lang_prefix.'Name = '.$this->Conn->qstr($category_name).') AND (ParentId = '.(int)$current_category_id.')';
	$category_id = $this->Conn->GetOne($sql);

	if ( $category_id === false ) {
	// category not in db -> create
	$category_fields = Array (
	$lang_prefix.'Name' => $category_name, $lang_prefix.'Description' => $category_name,
	'Status' => STATUS_ACTIVE, 'ParentId' => $current_category_id, 'AutomaticFilename' => 1
	);

	$this->dummyCategory->Clear();
	$this->dummyCategory->SetDBFieldsFromHash($category_fields);

	if ( $this->dummyCategory->Create() ) {
	$category_id = $this->dummyCategory->GetID();
	$this->addToCache('category_parent_path', $category_id, $this->dummyCategory->GetDBField('ParentPath'));
	$this->addToCache('category_names', $category_key, $category_id);
	}
	}
	else {
	$this->addToCache('category_names', $category_key, $category_id);
	}
	}

	if ($category_id) {
	$this->Application->SetVar('m_cat_id', $category_id);
	}
	}
	if (!$this->curItem->CategoryPath) {
	$category_id = $backup_category_id;
	}

	return $category_id;
	}

	/**
	* Enter description here...
	*
	* @param kEvent $event
	* @param Array $record_data
	* @return bool
	*/
	function processCurrentItem($event, $record_data)
	{
	$save_method = 'Create';
	$load_keys = Array();

	// create/update categories
	$backup_category_id = $this->Application->GetVar('m_cat_id');

	// perform replace duplicates code
	if ($this->exportOptions['ReplaceDuplicates']) {
	// get replace keys first, then reset current item to empty one
	$category_id = $this->getItemCategory();
	if ($this->exportOptions['CheckDuplicatesMethod'] == 1) {
	if ($this->curItem->GetID()) {
	$load_keys = Array($this->curItem->IDField => $this->curItem->GetID());
	}
	}
	else {
	$key_fields = $this->exportOptions['DuplicateCheckFields'];
	foreach ($key_fields as $key_field) {
	$load_keys[$key_field] = $this->curItem->GetDBField($key_field);
	}
	}

	$this->resetImportObject($event, IMPORT_LIVE);

	if (count($load_keys)) {
	$where_clause = '';
	$language_id = (int)$this->Application->GetVar('m_lang');

	if (!$language_id) {
	$language_id = 1;
	}

	foreach ($load_keys as $field_name => $field_value) {
	if (preg_match('/^cust_(.*)/', $field_name, $regs)) {
	$custom_id = array_search($regs[1], $this->customFields);
	$field_name = 'l'.$language_id.'_cust_'.$custom_id;
	$where_clause .= '(custom_data.`'.$field_name.'` = '.$this->Conn->qstr($field_value).') AND ';
	}
	else {
	$where_clause .= '(item_table.`'.$field_name.'` = '.$this->Conn->qstr($field_value).') AND ';
	}

	}
	$where_clause = substr($where_clause, 0, -5);

	$item_id = $this->getFromCache('new_ids', kUtil::crc32($where_clause));
	if (!$item_id) {
	if ($this->exportOptions['CheckDuplicatesMethod'] == 2) {
	// by other fields
	$parent_path = $this->getParentPath($category_id);
	$where_clause = '(c.ParentPath LIKE "'.$parent_path.'%") AND '.$where_clause;
	}

	$cdata_table = $this->Application->getUnitOption($event->Prefix.'-cdata', 'TableName');
	$sql = 'SELECT '.$this->curItem->IDField.'
	FROM '.$this->curItem->TableName.' item_table
	LEFT JOIN '.$cdata_table.' custom_data ON custom_data.ResourceId = item_table.ResourceId
	LEFT JOIN '.TABLE_PREFIX.'CategoryItems ci ON ci.ItemResourceId = item_table.ResourceId
	LEFT JOIN '.TABLE_PREFIX.'Categories c ON c.CategoryId = ci.CategoryId
	WHERE '.$where_clause;
	$item_id = $this->Conn->GetOne($sql);
	}
	$save_method = $item_id && $this->curItem->Load($item_id) ? 'Update' : 'Create';
	if ($save_method == 'Update') {
	// replace id from csv file with found id (only when ID is found in cvs file)
	if (in_array($this->curItem->IDField, $this->exportFields)) {
	$record_data[ array_search($this->curItem->IDField, $this->exportFields) ] = $item_id;
	}
	}
	}

	$this->setImportData($record_data);
	}
	else {
	$this->resetImportObject($event, IMPORT_LIVE, $record_data);
	$category_id = $this->getItemCategory();
	}

	// create main record
	if ($save_method == 'Create') {
	$this->fillRequiredFields($this->false, $this->curItem, true);
	}

	// $sql_start = microtime(true);
	if (!$this->curItem->$save_method()) {
	$this->Application->SetVar('m_cat_id', $backup_category_id);
	return false;
	}
	// $sql_end = microtime(true);
	// $this->saveLog('SQL ['.$save_method.'] Time: '.($sql_end - $sql_start).'s');

	if ($load_keys && ($save_method == 'Create') && $this->exportOptions['ReplaceDuplicates']) {
	// map new id to old id
	$this->addToCache('new_ids', kUtil::crc32($where_clause), $this->curItem->GetID() );
	}

	// assign item to categories
	$this->curItem->assignToCategory($category_id, false);

	$this->Application->SetVar('m_cat_id', $backup_category_id);
	return true;
	}

	/*function saveLog($msg)
	{
	static $first_time = true;

	$fp = fopen((defined('RESTRICTED') ? RESTRICTED : FULL_PATH) . '/sqls.log', $first_time ? 'w' : 'a');
	fwrite($fp, $msg."\n");
	fclose($fp);

	$first_time = false;
	}*/

	/**
	* Returns category parent path, if possible, then from cache
	*
	* @param int $category_id
	* @return string
	*/
	function getParentPath($category_id)
	{
	$parent_path = $this->getFromCache('category_parent_path', $category_id);
	if ($parent_path === false) {
	$sql = 'SELECT ParentPath
	FROM '.TABLE_PREFIX.'Categories
	WHERE CategoryId = '.$category_id;
	$parent_path = $this->Conn->GetOne($sql);
	$this->addToCache('category_parent_path', $category_id, $parent_path);
	}
	return $parent_path;
	}

	function getFileExtension()
	{
	return $this->exportOptions['ExportFormat'] == 1 ? 'csv' : 'xml';
	}

	function getLineSeparator($option = 'LineEndings')
	{
	return $this->exportOptions[$option] == 1 ? "\r\n" : "\n";
	}

	/**
	* Returns field caption for any exported field
	*
	* @param string $field
	* @return string
	*/
	function getFieldCaption($field)
	{
	if (substr($field, 0, 10) == '__CUSTOM__')
	{
	$ret = 'Custom_'.substr($field, 10, strlen($field) );
	}
	elseif (substr($field, 0, 12) == '__CATEGORY__')
	{
	return $this->getCategoryTitle();
	}
	elseif (substr($field, 0, 11) == '__VIRTUAL__') {
	$ret = substr($field, 11);
	}
	else
	{
	$ret = $field;
	}

	return Array($ret);
	}

	/**
	* Returns requested field value (including custom fields and category fields)
	*
	* @param string $field
	* @return string
	*/
	function getFieldValue($field)
	{
	if (substr($field, 0, 10) == '__CUSTOM__') {
	$field = 'cust_'.substr($field, 10, strlen($field));
	$ret = $this->curItem->GetField($field);
	}
	elseif (substr($field, 0, 12) == '__CATEGORY__') {
	return $this->getCategoryPath();
	}
	elseif (substr($field, 0, 11) == '__VIRTUAL__') {
	$field = substr($field, 11);
	$ret = $this->curItem->GetField($field);
	}
	else
	{
	$ret = $this->curItem->GetField($field);
	}

	$ret = str_replace("\r\n", $this->getLineSeparator('LineEndingsInside'), $ret);
	return Array($ret);
	}

	/**
	* Returns category field(-s) caption based on export mode
	*
	* @return string
	*/
	function getCategoryTitle()
	{
	// category path in separated fields
	$category_count = $this->getMaxCategoryLevel();
	if ($this->exportOptions['CategoryFormat'] == 1)
	{
	// category path in one field
	return $category_count ? Array('CategoryPath') : Array();
	}
	else
	{
	$i = 0;
	$ret = Array();
	while ($i < $category_count) {
	$ret[] = 'Category'.($i + 1);
	$i++;
	}
	return $ret;
	}
	}

	/**
	* Returns category path in required format for current link
	*
	* @return string
	*/
	function getCategoryPath()
	{
	$category_id = $this->curItem->GetDBField('CategoryId');
	$category_path = $this->getFromCache('category_path', $category_id);

	if ( !$category_path ) {
	$ml_formatter = $this->Application->recallObject('kMultiLanguage');
	/* @var $ml_formatter kMultiLanguage */

	$sql = 'SELECT ' . $ml_formatter->LangFieldName('CachedNavbar') . '
	FROM ' . TABLE_PREFIX . 'Categories
	WHERE CategoryId = ' . $category_id;
	$category_path = $this->Conn->GetOne($sql);

	$category_path = $category_path ? explode('&\|&', $category_path) : Array ();

	if ( $category_path && strtolower($category_path[0]) == 'content' ) {
	array_shift($category_path);
	}

	if ( $this->exportOptions['IsBaseCategory'] ) {
	$i = $this->exportOptions['BaseLevel'];
	while ( $i > 0 ) {
	array_shift($category_path);
	$i--;
	}
	}

	$category_count = $this->getMaxCategoryLevel();

	if ( $this->exportOptions['CategoryFormat'] == 1 ) {
	// category path in single field
	$category_path = $category_count ? Array (implode($this->exportOptions['CategorySeparator'], $category_path)) : Array ();
	}
	else {
	// category path in separated fields
	$levels_used = count($category_path);

	if ( $levels_used < $category_count ) {
	$i = 0;
	while ( $i < $category_count - $levels_used ) {
	$category_path[] = '';
	$i++;
	}
	}
	}
	$this->addToCache('category_path', $category_id, $category_path);
	}

	return $category_path;
	}

	/**
	* Get maximal category deep level from links beeing exported
	*
	* @return int
	*/
	function getMaxCategoryLevel()
	{
	static $max_level = -1;

	if ($max_level != -1)
	{
	return $max_level;
	}

	$sql = 'SELECT IF(c.CategoryId IS NULL, 0, MAX( LENGTH(c.ParentPath) - LENGTH( REPLACE(c.ParentPath, "\|", "") ) - 1 ))
	FROM '.$this->curItem->TableName.' item_table
	LEFT JOIN '.TABLE_PREFIX.'CategoryItems ci ON item_table.ResourceId = ci.ItemResourceId
	LEFT JOIN '.TABLE_PREFIX.'Categories c ON c.CategoryId = ci.CategoryId
	WHERE (ci.PrimaryCat = 1) AND ';

	$where_clause = '';
	if ($this->exportOptions['export_ids'] === false) {
	// get links from current category & all it's subcategories
	if ($this->exportOptions['export_cats_ids'][0] == 0) {
	$where_clause = 1;
	}
	else {
	foreach ($this->exportOptions['export_cats_ids'] as $category_id) {
	$where_clause .= '(c.ParentPath LIKE "%\|'.$category_id.'\|%") OR ';
	}
	$where_clause = substr($where_clause, 0, -4);
	}
	}
	else {
	// get only selected links
	$where_clause = $this->curItem->IDField.' IN ('.implode(',', $this->exportOptions['export_ids']).')';
	}

	$max_level = $this->Conn->GetOne($sql.'('.$where_clause.')');

	if ($this->exportOptions['IsBaseCategory'] ) {
	$max_level -= $this->exportOptions['BaseLevel'];
	}

	return $max_level;
	}

	/**
	* Saves one record to export file
	*
	* @param Array $fields_hash
	*/
	function writeRecord($fields_hash)
	{
	kUtil::fputcsv($this->filePointer, $fields_hash, $this->exportOptions['FieldsSeparatedBy'], $this->exportOptions['FieldsEnclosedBy'], $this->getLineSeparator() );
	}

	function readRecord()
	{
	return fgetcsv($this->filePointer, 10000, $this->exportOptions['FieldsSeparatedBy'], $this->exportOptions['FieldsEnclosedBy']);
	}

	/**
	* Saves import/export options
	*
	* @param kEvent $event
	* @param Array $options
	* @return void
	*/
	function saveOptions($event, $options = null)
	{
	if ( !isset($options) ) {
	$options = $this->exportOptions;
	}

	$this->Application->StoreVar($event->getPrefixSpecial() . '_options', serialize($options));
	}

	/**
	* Loads import/export options
	*
	* @param kEvent $event
	* @return Array
	*/
	function loadOptions($event)
	{
	return unserialize( $this->Application->RecallVar($event->getPrefixSpecial() . '_options') );
	}

	/**
	* Sets correct available & export fields
	*
	* @param kEvent $event
	*/
	function prepareExportColumns($event)
	{
	$object = $event->getObject( Array('skip_autoload' => true) );
	/* @var $object kCatDBItem */

	if ( !$object->isField('ExportColumns') ) {
	// import/export prefix was used (see kDBEventHandler::prepareObject) but object don't plan to be imported/exported
	return ;
	}

	$available_columns = Array();

	if ($this->Application->getUnitOption($event->Prefix, 'CatalogItem')) {
	// category field (mixed)
	$available_columns['__CATEGORY__CategoryPath'] = 'CategoryPath';

	if ($event->Special == 'import') {
	// category field (separated fields)
	$max_level = $this->Application->ConfigValue('MaxImportCategoryLevels');
	$i = 0;
	while ($i < $max_level) {
	$available_columns['__CATEGORY__Category'.($i + 1)] = 'Category'.($i + 1);
	$i++;
	}
	}
	}

	// db fields
	$fields = $object->getFields();

	foreach ($fields as $field_name => $field_options) {
	if ( !$object->skipField($field_name) ) {
	$available_columns[$field_name] = $field_name.( $object->isRequired($field_name) ? '*' : '');
	}
	}

	$handler = $this->Application->recallObject($event->Prefix.'_EventHandler');
	/* @var $handler kDBEventHandler */

	$available_columns = array_merge($available_columns, $handler->getCustomExportColumns($event));

	// custom fields
	$custom_fields = $object->getCustomFields();

	foreach ($custom_fields as $custom_id => $custom_name)
	{
	$available_columns['__CUSTOM__'.$custom_name] = $custom_name;
	}

	// columns already in use
	$items_info = $this->Application->GetVar( $event->getPrefixSpecial(true) );
	if ($items_info)
	{
	list($item_id, $field_values) = each($items_info);
	$export_keys = $field_values['ExportColumns'];
	$export_keys = $export_keys ? explode('\|', substr($export_keys, 1, -1) ) : Array();
	}
	else {
	$export_keys = Array();
	}

	$export_columns = Array();
	foreach ($export_keys as $field_key)
	{
	$field_name = $this->getExportField($field_key);
	$export_columns[$field_key] = $field_name;
	unset($available_columns[$field_key]);
	}

	$options = $object->GetFieldOptions('ExportColumns');
	$options['options'] = $export_columns;
	$object->SetFieldOptions('ExportColumns', $options);

	$options = $object->GetFieldOptions('AvailableColumns');
	$options['options'] = $available_columns;
	$object->SetFieldOptions('AvailableColumns', $options);

	$this->updateImportFiles($event);
	$this->PrepareExportPresets($event);
	}

	/**
	* Prepares export presets
	*
	* @param kEvent $event
	* @return void
	*/
	function PrepareExportPresets($event)
	{
	$object = $event->getObject(Array ('skip_autoload' => true));
	/* @var $object kDBItem */

	$options = $object->GetFieldOptions('ExportPresets');
	$export_settings = $this->Application->RecallPersistentVar('export_settings');

	if ( !$export_settings ) {
	return;
	}

	$export_settings = unserialize($export_settings);

	if ( !isset($export_settings[$event->Prefix]) ) {
	return;
	}

	$export_presets = array ('' => '');

	foreach ($export_settings[$event->Prefix] as $key => $val) {
	$export_presets[implode('\|', $val['ExportColumns'])] = $key;
	}

	$options['options'] = $export_presets;
	$object->SetFieldOptions('ExportPresets', $options);
	}

	function getExportField($field_key)
	{
	$prepends = Array('__CUSTOM__', '__CATEGORY__');
	foreach ($prepends as $prepend)
	{
	if (substr($field_key, 0, strlen($prepend) ) == $prepend)
	{
	$field_key = substr($field_key, strlen($prepend), strlen($field_key) );
	break;
	}
	}
	return $field_key;
	}

	/**
	* Updates uploaded files list
	*
	* @param kEvent $event
	* @return void
	* @access protected
	*/
	protected function updateImportFiles($event)
	{
	if ( $event->Special != 'import' ) {
	return ;
	}

	$file_helper = $this->Application->recallObject('FileHelper');
	/* @var $file_helper FileHelper */

	$import_filenames = Array ();
	$file_helper->CheckFolder(EXPORT_PATH);

	$iterator = new DirectoryIterator(EXPORT_PATH);
	/* @var $file_info DirectoryIterator */

	foreach ($iterator as $file_info) {
	$file = $file_info->getFilename();

	if ( $file_info->isDir() \|\| $file == 'dummy' \|\| $file_info->getSize() == 0 ) {
	continue;
	}

	$import_filenames[$file] = $file . ' (' . kUtil::formatSize( $file_info->getSize() ) . ')';
	}

	$object = $event->getObject();
	/* @var $object kDBItem */

	$object->SetFieldOption('ImportLocalFilename', 'options', $import_filenames);
	}

	/**
	* Returns module folder
	*
	* @param kEvent $event
	* @return string
	*/
	function getModuleName($event)
	{
	$module_path = $this->Application->getUnitOption($event->Prefix, 'ModuleFolder') . '/';
	$module_name = $this->Application->findModule('Path', $module_path, 'Name');

	return mb_strtolower($module_name);
	}

	/**
	* Export form validation & processing
	*
	* @param kEvent $event
	*/
	function OnExportBegin($event)
	{
	$items_info = $this->Application->GetVar($event->getPrefixSpecial(true));

	if ( !$items_info ) {
	$items_info = unserialize($this->Application->RecallVar($event->getPrefixSpecial() . '_ItemsInfo'));
	$this->Application->SetVar($event->getPrefixSpecial(true), $items_info);
	}

	list($item_id, $field_values) = each($items_info);

	$object = $event->getObject(Array ('skip_autoload' => true));
	/* @var $object kDBItem */

	$object->SetFieldsFromHash($field_values);
	$field_values['ImportFilename'] = $object->GetDBField('ImportFilename'); //if upload formatter has renamed the file during moving !!!

	$object->setID($item_id);
	$this->setRequiredFields($event);

	// save export/import options
	if ( $event->Special == 'export' ) {
	$export_ids = $this->Application->RecallVar($event->Prefix . '_export_ids');
	$export_cats_ids = $this->Application->RecallVar($event->Prefix . '_export_cats_ids');

	// used for multistep export
	$field_values['export_ids'] = $export_ids ? explode(',', $export_ids) : false;
	$field_values['export_cats_ids'] = $export_cats_ids ? explode(',', $export_cats_ids) : Array ($this->Application->GetVar('m_cat_id'));
	}

	$field_values['ExportColumns'] = $field_values['ExportColumns'] ? explode('\|', substr($field_values['ExportColumns'], 1, -1) ) : Array();
	$field_values['start_from'] = 0;

	$nevent = new kEvent($event->Prefix . ':OnBeforeExportBegin');
	$nevent->setEventParam('options', $field_values);
	$this->Application->HandleEvent($nevent);
	$field_values = $nevent->getEventParam('options');

	$this->saveOptions($event, $field_values);

	if ( $this->verifyOptions($event) ) {
	if ( $this->_getExportSavePreset($object) ) {
	$name = $object->GetDBField('ExportPresetName');

	$export_settings = $this->Application->RecallPersistentVar('export_settings');
	$export_settings = $export_settings ? unserialize($export_settings) : array ();
	$export_settings[$event->Prefix][$name] = $field_values;
	$this->Application->StorePersistentVar('export_settings', serialize($export_settings));
	}

	$progress_t = $this->Application->RecallVar('export_progress_t');
	if ( $progress_t ) {
	$this->Application->RemoveVar('export_progress_t');
	}
	else {
	$progress_t = $this->getModuleName($event) . '/' . $event->Special . '_progress';
	}
	$event->redirect = $progress_t;

	if ( $event->Special == 'import' ) {
	$import_category = (int)$this->Application->RecallVar('ImportCategory');

	// in future could use module root category if import category will be unavailable :)
	$event->SetRedirectParam('m_cat_id', $import_category); // for template permission checking
	$this->Application->StoreVar('m_cat_id', $import_category); // for event permission checking
	}
	}
	else {
	// make uploaded file local & change source selection
	$filename = getArrayValue($field_values, 'ImportFilename');

	if ( $filename ) {
	$this->updateImportFiles($event);
	$object->SetDBField('ImportSource', 2);
	$field_values['ImportSource'] = 2;
	$object->SetDBField('ImportLocalFilename', $filename);
	$field_values['ImportLocalFilename'] = $filename;
	$this->saveOptions($event, $field_values);
	}

	$event->status = kEvent::erFAIL;
	$event->redirect = false;
	}
	}

	/**
	* Returns export save preset name, when used at all
	*
	* @param kDBItem $object
	* @return string
	*/
	function _getExportSavePreset(&$object)
	{
	if ( !$object->isField('ExportSavePreset') ) {
	return '';
	}

	return $object->GetDBField('ExportSavePreset');
	}

	/**
	* set required fields based on import or export params
	*
	* @param kEvent $event
	*/
	function setRequiredFields($event)
	{
	$required_fields['common'] = Array('FieldsSeparatedBy', 'LineEndings', 'CategoryFormat');

	$required_fields['export'] = Array('ExportFormat', 'ExportFilename','ExportColumns');

	$object = $event->getObject();
	/* @var $object kDBItem */

	if ($this->_getExportSavePreset($object)) {
	$required_fields['export'][] = 'ExportPresetName';
	}

	$required_fields['import'] = Array('FieldTitles', 'ImportSource', 'CheckDuplicatesMethod'); // ImportFilename, ImportLocalFilename

	if ($event->Special == 'import')
	{
	$import_source = Array(1 => 'ImportFilename', 2 => 'ImportLocalFilename');
	$used_field = $import_source[ $object->GetDBField('ImportSource') ];

	$required_fields[$event->Special][] = $used_field;
	$object->SetFieldOption($used_field, 'error_field', 'ImportSource');

	if ($object->GetDBField('FieldTitles') == 2) $required_fields[$event->Special][] = 'ExportColumns'; // manual field titles
	}

	$required_fields = array_merge($required_fields['common'], $required_fields[$event->Special]);
	$object->setRequired($required_fields);
	}

	}
	\ 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