in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Wed, Jul 23, 10:49 AM

in-portal
View Options

	Index: branches/unlabeled/unlabeled-1.1.2/core/admin_templates/js/tree.js
	===================================================================
	--- branches/unlabeled/unlabeled-1.1.2/core/admin_templates/js/tree.js (revision 7369)
	+++ branches/unlabeled/unlabeled-1.1.2/core/admin_templates/js/tree.js (revision 7370)
	@@ -1,577 +1,585 @@
	var last_hightlighted = null;
	var last_highlighted_key = null;

	function TreeItem(title, url, icon, onclick)
	{
	this.Title = title;
	this.Url = url;
	this.Rendered = false;
	this.Displayed = false;
	this.Level = 0;
	this.Icon = icon;
	this.Onclick = onclick;
	+ this.Children = false;
	}

	TreeItem.prototype.Render = function(before, force)
	{
	if (!this.Rendered \|\| force) {
	if (!isset(before)) {before = null}

	tr = document.createElement('tr');
	this.ParentElement.insertBefore(tr, before);
	if (!this.Displayed) { tr.style.display = 'none' }
	td = document.createElement('td');
	td.TreeElement = this;
	tr.appendChild(td);

	this.appendLevel(td);
	if (this.ParentFolder != null) this.appendNodeImage(td);
	this.appendIcon(td);
	this.appendLink(td);

	this.Tr = tr;
	this.Rendered = true;
	// alert(this.Tr.innerHTML)
	}
	}

	TreeItem.prototype.remove = function()
	{
	var p = this.Tr.parentNode;
	p.removeChild(this.Tr);
	}

	TreeItem.prototype.appendLevel = function(td)
	{
	for (var i=0; i < this.Level; i++)
	{
	img = document.createElement('img');
	img.src = TREE_ICONS_PATH+'/ftv2blank.gif';
	img.style.verticalAlign = 'middle';
	td.appendChild(img);
	}
	}

	TreeItem.prototype.getNodeImage = function(is_last)
	{
	return is_last ? TREE_ICONS_PATH+'/ftv2lastnode.gif' : TREE_ICONS_PATH+'/ftv2node.gif';
	}

	TreeItem.prototype.appendNodeImage = function(td)
	{
	img = document.createElement('img');
	img.src = this.getNodeImage();
	img.style.verticalAlign = 'middle';
	td.appendChild(img);
	}

	TreeItem.prototype.appendIcon = function (td)
	{
	img = document.createElement('img');
	if (this.Icon.indexOf('http://') != -1) {
	img.src = this.Icon;
	}
	else {
	img.src = this.Icon;
	}
	img.style.verticalAlign = 'middle';
	td.appendChild(img);
	}

	TreeItem.prototype.appendLink = function (td)
	{
	var $node_text = document.createElement('span');
	$node_text.innerHTML = this.Title;

	link = document.createElement('a');
	link.nodeValue = this.Title;
	link.href = this.Url;
	link.target = 'main';
	link.appendChild($node_text);

	link.treeItem = this;
	//addEvent(link, 'click',

	link.onclick =
	function(ev) {
	var e = is.ie ? window.event : ev;

	res = true;
	if (isset(this.treeItem.Onclick)) {
	res = eval(this.treeItem.Onclick);
	}
	if (!res) { // if we need to cancel onclick action
	if (is.ie) {
	window.event.cancelBubble = true;
	window.event.returnValue = false;
	} else {
	ev.preventDefault();
	ev.stopPropagation();
	}
	return res;
	}
	else {
	// ensures, that click is made before AJAX request will be sent
	if (res === true) {
	// only in case of "true" is returned, used in catalog
	getFrame(link.target).location.href = this.href;
	}

	if (!this.treeItem.Expanded && typeof(this.treeItem.folderClick) == 'function') {
	if (this.treeItem.folderClick());
	}
	this.treeItem.highLight();
	return false;
	}
	}

	td.appendChild(link);

	/*
	if (this.LateLoadURL) {
	var span = document.createElement('span');
	span.innerHTML = ' Reload';
	span.treeItem = this;
	span.onclick = function(ev) {
	this.treeItem.reload();
	}
	td.appendChild(span);
	}
	*/
	}

	TreeItem.prototype.display = function()
	{
	this.Tr.style.display = is.ie ? 'block' : 'table-row';
	this.Displayed = true;

	var do_sub = TreeManager.isExpanded(this.Key);
	if (this.Children && do_sub && !this.Expanding) {
	this.expand();
	}

	}

	TreeItem.prototype.hide = function()
	{
	this.Tr.style.display = 'none';
	this.Displayed = false;
	}

	TreeItem.prototype.highLight = function()
	{
	if (last_hightlighted) last_hightlighted.Tr.className = '';
	+ if (this.Children && this.Children.length > 0 && this.Children[0].Url.replace('&', '&') == this.Url.replace('&', '&')) {
	+ this.Children[0].highLight();
	+ return;
	+ }
	+
	this.Tr.className = "highlighted";
	last_hightlighted = this;
	last_highlighted_key = this.Key;
	+ this.expand();
	}

	TreeItem.prototype.expand = function() { this.display() }

	TreeItem.prototype.collapse = function() { this.hide() }

	TreeItem.prototype.updateLastNodes = function(is_last, lines_pattern)
	{
	if (!isset(is_last)) is_last = true;
	if (!isset(this.Tr)) return;
	if (!isset(lines_pattern)) { var lines_pattern = new Array() }

	imgs = this.Tr.getElementsByTagName('img');
	found = false;
	for (var i=0; i<imgs.length; i++)
	{
	the_img = imgs.item(i);
	if (in_array(i, lines_pattern) && the_img.src.indexOf('ftv2blank.gif') != -1) {
	the_img.src = TREE_ICONS_PATH+'/ftv2vertline.gif';
	}
	if (this.isNodeImage(the_img))
	{
	found = true;
	break;
	}
	}
	if (found) {
	the_img.src = this.getNodeImage(is_last);
	}
	this.isLast = is_last;
	return lines_pattern;
	}

	TreeItem.prototype.isNodeImage = function(img)
	{
	return (
	img.src.indexOf('ftv2node.gif') != -1 \|\|
	img.src.indexOf('ftv2lastnode.gif') != -1
	)

	}

	TreeItem.prototype.locateLastItem = function()
	{
	return this;
	}

	TreeItem.prototype.locateItemByURL = function(url)
	{
	if (this.Url == url) return this;
	return false;
	}

	TreeItem.prototype.locateItemByKey = function(key)
	{
	if (this.Key == key) return this;
	return false;
	}

	TreeItem.prototype.reload = function()
	{
	}

	/* FOLDER */

	function TreeFolder(parent_id, title, url, icon, late_load_url, onclick)
	{
	var render = false;
	if (isset(parent_id)) {
	this.ParentElement = document.getElementById(parent_id);
	render = true;
	}
	else {


	}

	this.Title = title;
	this.Url = url;
	this.Rendered = false;
	this.Displayed = false;
	this.Expanded = false;
	this.Level = 0;
	this.Id = 0;
	this.Tr = null;
	this.Icon = icon;
	this.LateLoadURL = isset(late_load_url) ? late_load_url : false;
	this.Loaded = false;
	this.Onclick = onclick;

	this.Children = new Array();
	this.ChildIndex = 0;
	if (render) {
	this.Expanded = true;
	this.Displayed = true;
	this.Render();
	this.expand();
	}
	}

	TreeFolder.prototype = new TreeItem;

	TreeFolder.prototype.locateLastItem = function()
	{
	if (this.Children.length == 0) return this;

	for (var i=0; i<this.Children.length; i++)
	{
	last_item = this.Children[i].locateLastItem()
	}
	return last_item;
	}

	TreeFolder.prototype.locateItemByURL = function(url)
	{
	last_item = false;
	if (this.Url == url) {
	return this;
	}

	for (var i=0; i<this.Children.length; i++)
	{
	last_item = this.Children[i].locateItemByURL(url)
	if (last_item) return last_item;
	}
	return last_item;
	}

	TreeFolder.prototype.locateItemByKey = function(key)
	{
	last_item = false;
	if (this.Key == key) {
	return this;
	}

	for (var i=0; i<this.Children.length; i++)
	{
	last_item = this.Children[i].locateItemByKey(key)
	if (last_item) return last_item;
	}
	return last_item;
	}

	TreeFolder.prototype.locateTopItem = function()
	{
	if (this.ParentFolder == null) return this;
	return this.ParentFolder.locateTopItem();
	}

	TreeFolder.prototype.AddItem = function(an_item, render, display) {
	an_item.ParentElement = this.ParentElement;
	an_item.Level = this.ParentFolder != null ? this.Level + 1 : 0;
	an_item.ParentFolder = this;

	last_item = this.locateLastItem();
	this.Children.push(an_item);
	an_item.Id = this.Children.length;
	an_item.Render(last_item.Tr.nextSibling);

	var keys = new Array()
	var tmp = an_item;
	keys.push(tmp.Level + '_' + tmp.Id);
	while (tmp.ParentFolder) {
	tmp = tmp.ParentFolder
	keys.push(tmp.Level + '_' + tmp.Id);
	}
	keys = keys.reverse();
	key_str = keys.join('-');
	an_item.Key = key_str;

	if (this.Expanded)
	{
	an_item.display();
	}

	return an_item;
	}

	TreeFolder.prototype.AddFromXML = function(xml, render)
	{
	// start = new Date();
	if (!isset(render)) render = true;
	doc = getDocumentFromXML(xml);
	this.LastFolder = this;
	this.ProcessXMLNode(doc, render);
	// end = new Date();
	this.locateTopItem().updateLastNodes();
	// alert('AddFromXML took: '+(end - start))
	}

	TreeFolder.prototype.ProcessXMLNode = function(node, render)
	{
	if (!isset(render)) render = true;
	if (!isset(this.LastFolder)) this.LastFolder = this;
	for (var i=0; i<node.childNodes.length; i++)
	{
	child = node.childNodes.item(i);
	if (child.tagName == 'folder') {
	var backupLastFolder = this.LastFolder;
	this.LastFolder = this.LastFolder.AddItem(new TreeFolder(null, child.getAttribute('name'), child.getAttribute('href'), child.getAttribute('icon'), child.getAttribute('load_url'), child.getAttribute('onclick')), render);
	if (child.hasChildNodes) {
	this.ProcessXMLNode(child);
	}
	this.LastFolder = backupLastFolder;
	}
	else if (child.tagName == 'item') {
	this.LastFolder.AddItem(new TreeItem(child.firstChild.nodeValue, child.getAttribute('href'), child.getAttribute('icon'), child.getAttribute('onclick')), render)
	}
	else if (child.tagName == 'tree') {
	this.LastFolder = this;
	this.ProcessXMLNode(child);
	}
	}
	}

	TreeFolder.prototype.getNodeImage = function(is_last)
	{
	if (is_last) {
	return this.Expanded ? TREE_ICONS_PATH+'/ftv2mlastnode.gif' : TREE_ICONS_PATH+'/ftv2plastnode.gif';
	}
	else {
	return this.Expanded ? TREE_ICONS_PATH+'/ftv2mnode.gif' : TREE_ICONS_PATH+'/ftv2pnode.gif';
	}
	}

	TreeFolder.prototype.appendNodeImage = function(td, is_last)
	{
	img = document.createElement('img');
	img.src = this.getNodeImage(is_last);
	img.style.cursor = 'hand';
	img.style.cursor = 'pointer';
	img.style.verticalAlign = 'middle';
	img.onclick = function() { this.parentNode.TreeElement.folderClick(this) }
	this.Img = img;
	td.appendChild(img);
	}

	TreeFolder.prototype.updateLastNodes = function(is_last, lines_pattern)
	{
	if (!isset(is_last)) is_last = true;
	if (!isset(lines_pattern)) { var lines_pattern = new Array() }
	if (!is_last && !in_array(this.Level, lines_pattern)) { lines_pattern.push(this.Level) }

	lines_pattern = TreeItem.prototype.updateLastNodes.apply(this, new Array(is_last, lines_pattern))

	for (var i=0; i<this.Children.length; i++)
	{
	lines_pattern = this.Children[i].updateLastNodes((i+1) == this.Children.length, lines_pattern)
	}
	lines_pattern[array_search(this.Level, lines_pattern)] = -1;
	return lines_pattern;
	}

	TreeFolder.prototype.isNodeImage = function(img)
	{
	return (
	img.src.indexOf('ftv2mlastnode.gif') != -1 \|\|
	img.src.indexOf('ftv2plastnode.gif') != -1 \|\|
	img.src.indexOf('ftv2mnode.gif') != -1 \|\|
	img.src.indexOf('ftv2pnode.gif') != -1
	)

	}

	TreeFolder.prototype.folderClick = function(img)
	{
	if (this.Expanded) {
	this.collapse();
	}
	else {
	this.expand();
	}
	}

	TreeFolder.prototype.remove = function()
	{
	this.removeChildren();
	var p = this.Tr.parentNode;
	p.removeChild(this.Tr);
	}

	TreeFolder.prototype.removeChildren = function()
	{
	for (var i in this.Children) {
	this.Children[i].remove();
	}
	this.Children = new Array();
	}

	TreeFolder.prototype.successCallback = function ($request, $params, $object) {
	if ($params == 'reload') {
	$object.removeChildren();
	}
	$object.Loaded = true;
	$object.ProcessXMLNode($request.responseXML);
	$object.Render();
	$object.locateTopItem().updateLastNodes();
	$object.expand();
	if (last_highlighted_key) {
	var fld = $object.locateItemByKey(last_highlighted_key)
	if (fld) {
	fld.highLight();
	}
	}
	}

	TreeFolder.prototype.reload = function()
	{
	Request.headers['Content-type'] = 'text/xml';
	Request.makeRequest(this.LateLoadURL, false, '', this.successCallback, this.errorCallback, 'reload', this);
	}

	TreeFolder.prototype.errorCallback = function($request, $params, $object) {
	alert('AJAX ERROR: ' + Request.getErrorHtml($request));
	}

	TreeFolder.prototype.expand = function(mode)
	{
	+ if (this.Expanding) return;
	this.Expanding = true;

	if (!isset(mode)) mode = 0;
	this.display();
	if (mode == 0 \|\| this.Expanded ) {
	for (var i=0; i<this.Children.length; i++)
	{
	this.Children[i].expand(mode+1);
	}
	}
	if (mode == 0) {
	if (this.LateLoadURL && !this.Loaded) {
	Request.headers['Content-type'] = 'text/xml';
	Request.makeRequest(this.LateLoadURL, false, '', this.successCallback, this.errorCallback, '', this);
	}
	this.Expanded = true;
	TreeManager.markStatus(this.Key, 1)
	if (isset(this.Img)) {
	this.Img.src = this.getNodeImage(this.isLast);
	}
	}
	this.Expanding = false;
	}

	TreeFolder.prototype.collapse = function(mode)
	{
	if (!isset(mode)) mode = 0;
	for (var i=0; i<this.Children.length; i++)
	{
	this.Children[i].collapse(mode+1);
	this.Children[i].hide();
	}
	if (mode == 0) {
	this.Expanded = false;
	TreeManager.markStatus(this.Key, 0)
	if (isset(this.Img)) {
	this.Img.src = this.getNodeImage(this.isLast);
	}
	}
	}


	function TreeManager() {}

	TreeManager.ExpandStatus = [];

	TreeManager.markStatus = function(id, status)
	{
	this.ExpandStatus[id] = status;
	if (!status) {
	for (var i in this.ExpandStatus) {
	if (i.indexOf(id) == 0) { // if i starts with the same as id, meaning it is its child node
	this.ExpandStatus[i] = 0;
	}
	}
	}
	TreeManager.saveStatus()
	}

	TreeManager.isExpanded = function(id)
	{
	return (this.ExpandStatus[id] == 1);
	}

	TreeManager.saveStatus = function ()
	{
	var cookieString = new Array();

	for (var i in this.ExpandStatus) {
	if (this.ExpandStatus[i] == 1) {
	cookieString.push(i);
	}
	}
	document.cookie = 'TreeExpandStatus=' + cookieString.join(':');
	}

	TreeManager.loadStatus = function ()
	{
	var doc_cookies = document.cookie.split('; ');

	for (var i=0; i < doc_cookies.length; i++) {
	var pair = doc_cookies[i].split('=');
	if ('TreeExpandStatus' == pair[0] && pair[1]) {
	var expandedBranches = pair[1].split(':');
	for (var j=0; j<expandedBranches.length; j++) {
	this.ExpandStatus[expandedBranches[j]] = true;
	}
	}
	}
	// print_pre(this.ExpandStatus)
	}

	TreeManager.loadStatus();

	Property changes on: branches/unlabeled/unlabeled-1.1.2/core/admin_templates/js/tree.js
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.1.2.3
	\ No newline at end of property
	+1.1.2.4
	\ No newline at end of property
	Index: branches/unlabeled/unlabeled-1.10.2/core/units/categories/categories_item.php
	===================================================================
	--- branches/unlabeled/unlabeled-1.10.2/core/units/categories/categories_item.php (revision 7369)
	+++ branches/unlabeled/unlabeled-1.10.2/core/units/categories/categories_item.php (revision 7370)
	@@ -1,181 +1,181 @@
	<?php

	class CategoriesItem extends kDBItem
	{
	function Create($force_id=false, $system_create=false)
	{
	+ $this->checkFilename();
	+ $this->generateFilename();
	+
	if (!$this->Validate()) return false;

	$this->SetDBField('ResourceId', $this->Application->NextResourceId());
	$this->SetDBField('CreatedById', $this->Application->RecallVar('user_id') );
	$this->SetDBField('CreatedOn_date', adodb_mktime() );
	$this->SetDBField('CreatedOn_time', adodb_mktime() );

	- $this->checkFilename();
	- $this->generateFilename();
	-
	$parent_category = $this->GetDBField('ParentId') > 0 ? $this->GetDBField('ParentId') : $this->Application->GetVar('m_cat_id');
	$this->SetDBField('ParentId', $parent_category);

	$ret = parent::Create($force_id, $system_create);
	if ($ret) {
	$sql = 'UPDATE %s SET ParentPath = %s WHERE CategoryId = %s';
	$parent_path = $this->buildParentPath();
	$this->Conn->Query( sprintf($sql, $this->TableName, $this->Conn->qstr($parent_path), $this->GetID() ) );

	$this->SetDBField('ParentPath', $parent_path);
	}
	return $ret;

	}

	function Update($id=null, $system_update=false)
	{
	$this->checkFilename();
	$this->generateFilename();

	$ret = parent::Update($id, $system_update);
	return $ret;
	}

	function buildParentPath()
	{
	$parent_id = $this->GetDBField('ParentId');

	if ($parent_id == 0) {
	$parent_path = '\|';
	}
	else {
	$cat_table = $this->Application->getUnitOption($this->Prefix, 'TableName');
	$sql = 'SELECT ParentPath FROM '.$cat_table.' WHERE CategoryId = %s';
	$parent_path = $this->Conn->GetOne( sprintf($sql, $parent_id) );
	}

	return $parent_path.$this->GetID().'\|';
	}

	/**
	* replace not allowed symbols with "_" chars + remove duplicate "_" chars in result
	*
	* @param string $string
	* @return string
	*/
	function stripDisallowed($string)
	{
	$not_allowed = Array( ' ', '\\', '/', ':', '*', '?', '"', '<', '>', '\|', '`',
	'~', '!', '@', '#', '$', '%', '^', '&', '(', ')', '~',
	'+', '=', '-', '{', '}', ']', '[', "'", ';', '.', ',');

	$string = str_replace($not_allowed, '_', $string);
	$string = preg_replace('/(_+)/', '_', $string);
	$string = $this->checkAutoFilename($string);

	return $string;
	}

	function checkFilename()
	{
	if( !$this->GetDBField('AutomaticFilename') )
	{
	$filename = $this->GetDBField('Filename');
	$this->SetDBField('Filename', $this->stripDisallowed($filename) );
	}
	}

	function checkAutoFilename($filename)
	{
	if(!$filename) return $filename;

	$item_id = !$this->GetID() ? 0 : $this->GetID();

	// check temp table
	$sql_temp = 'SELECT '.$this->IDField.' FROM '.$this->TableName.' WHERE Filename = '.$this->Conn->qstr($filename);
	$found_temp_ids = $this->Conn->GetCol($sql_temp);

	// check live table
	$sql_live = 'SELECT '.$this->IDField.' FROM '.$this->Application->GetLiveName($this->TableName).' WHERE Filename = '.$this->Conn->qstr($filename);
	$found_live_ids = $this->Conn->GetCol($sql_live);

	$found_item_ids = array_unique( array_merge($found_temp_ids, $found_live_ids) );

	$has_page = preg_match('/(.)_([\d]+)([a-z])$/', $filename, $rets);

	$duplicates_found = (count($found_item_ids) > 1) \|\| ($found_item_ids && $found_item_ids[0] != $item_id);
	if ($duplicates_found \|\| $has_page) // other category has same filename as ours OR we have filename, that ends with _number
	{
	$append = $duplicates_found ? '_a' : '';
	if($has_page)
	{
	$filename = $rets[1].'_'.$rets[2];
	$append = $rets[3] ? $rets[3] : '_a';
	}

	// check live & temp table
	$sql_temp = 'SELECT '.$this->IDField.' FROM '.$this->TableName.' WHERE (Filename = %s) AND ('.$this->IDField.' != '.$item_id.')';
	$sql_live = 'SELECT '.$this->IDField.' FROM '.$this->Application->GetLiveName($this->TableName).' WHERE (Filename = %s) AND ('.$this->IDField.' != '.$item_id.')';
	while ( $this->Conn->GetOne( sprintf($sql_temp, $this->Conn->qstr($filename.$append)) ) > 0 \|\|
	$this->Conn->GetOne( sprintf($sql_live, $this->Conn->qstr($filename.$append)) ) > 0 )
	{
	if (substr($append, -1) == 'z') $append .= 'a';
	$append = substr($append, 0, strlen($append) - 1) . chr( ord( substr($append, -1) ) + 1 );
	}

	return $filename.$append;
	}

	return $filename;
	}

	/**
	* Generate item's filename based on it's title field value
	*
	* @return string
	*/
	function generateFilename()
	{
	if ( !$this->GetDBField('AutomaticFilename') && $this->GetDBField('Filename') ) return false;

	$ml_formatter =& $this->Application->recallObject('kMultiLanguage');
	$name = $this->stripDisallowed( $this->GetDBField( $ml_formatter->LangFieldName('Name', true) ) );

	if ( $name != $this->GetDBField('Filename') ) $this->SetDBField('Filename', $name);
	}

	/**
	* Allows to detect if root category being edited
	*
	* @param Array $params
	*/
	function IsRoot()
	{
	$category_id = $this->Application->GetVar($this->getPrefixSpecial().'_id');
	if (is_numeric($category_id) && $category_id == 0 && !$this->Application->GetVar($this->getPrefixSpecial().'_PreCreate')) {
	$sql = 'SELECT '.$this->IDField.'
	FROM '.$this->TableName.'
	WHERE '.$this->IDField.' = '.$category_id;
	if ($this->Conn->GetOne($sql) === false) {
	return true;
	}
	}

	return false;
	}

	/**
	* Sets correct name to Home category while editing it
	*
	* @return bool
	*/
	function IsNewItem()
	{
	if ($this->IsRoot() && $this->Prefix == 'c') {
	$title_field = $this->Application->getUnitOption($this->Prefix, 'TitleField');
	$category_name = $this->Application->Phrase( $this->Application->ConfigValue('Root_Name') );
	$this->SetDBField($title_field, $category_name);
	return false;
	}
	return parent::IsNewItem();
	}
	}

	?>
	\ No newline at end of file

	Property changes on: branches/unlabeled/unlabeled-1.10.2/core/units/categories/categories_item.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.10.2.4
	\ No newline at end of property
	+1.10.2.5
	\ No newline at end of property
	Index: branches/unlabeled/unlabeled-1.8.2/core/units/categories/cache_updater.php
	===================================================================
	--- branches/unlabeled/unlabeled-1.8.2/core/units/categories/cache_updater.php (revision 7369)
	+++ branches/unlabeled/unlabeled-1.8.2/core/units/categories/cache_updater.php (revision 7370)
	@@ -1,415 +1,416 @@
	<?php
	class clsRecursionStack
	{
	var $Stack;

	function clsRecursionStack()
	{
	$this->Stack = Array();
	}

	function Push($values)
	{
	array_push($this->Stack, $values);
	}

	function Pop()
	{
	if ($this->Count() > 0) {
	return array_pop($this->Stack);
	}
	else {
	return false;
	}
	}

	function Get()
	{
	if ($this->Count() > 0) {
	// return end($this->Stack);
	return $this->Stack[count($this->Stack)-1];
	}
	else {
	return false;
	}
	}

	function Update($values)
	{
	$this->Stack[count($this->Stack)-1] = $values;
	}

	function Count()
	{
	return count($this->Stack);
	}
	}


	class clsCachedPermissions
	{
	var $Allow = Array();
	var $Deny = Array();
	var $CatId;

	function clsCachedPermissions($CatId)
	{
	$this->CatId = $CatId;
	}

	function SetCatId($CatId)
	{
	$this->CatId = $CatId;
	}

	function CheckPermArray($Perm)
	{
	if (!isset($this->Allow[$Perm])) {
	$this->Allow[$Perm] = array();
	$this->Deny[$Perm] = array();
	}
	}

	function AddAllow($Perm, $GroupId)
	{
	$this->CheckPermArray($Perm);
	if (!in_array($GroupId, $this->Allow[$Perm])) {
	array_push($this->Allow[$Perm], $GroupId);
	$this->RemoveDeny($Perm, $GroupId);
	}
	}

	function AddDeny($Perm, $GroupId)
	{
	$this->CheckPermArray($Perm);
	if (!in_array($GroupId, $this->Deny[$Perm])) {
	array_push($this->Deny[$Perm], $GroupId);
	$this->RemoveAllow($Perm, $GroupId);
	}
	}

	function RemoveDeny($Perm, $GroupId)
	{
	if (in_array($GroupId, $this->Deny[$Perm])) {
	array_splice($this->Deny[$Perm], array_search($GroupId, $this->Deny[$Perm]), 1);
	}
	}

	function RemoveAllow($Perm, $GroupId)
	{
	if (in_array($GroupId, $this->Allow[$Perm])) {
	array_splice($this->Allow[$Perm], array_search($GroupId, $this->Allow[$Perm]), 1);
	}
	}

	function GetInsertSQL()
	{
	$values = array();

	$has_deny = array();

	// don't write DACL at all
	/*foreach ($this->Deny as $perm => $groups) {
	if (count($groups) > 0) {
	$values[] = '('.$this->CatId.', '.$perm.', "", "'.join(',', $groups).'")';
	$has_deny[] = $perm;
	}
	}*/

	foreach ($this->Allow as $perm => $groups) {
	// if (in_array($perm, $has_deny)) continue;
	if (count($groups) > 0) {
	$values[] = '(' .$this->CatId. ', ' .$perm. ', "' .join(',', $groups). '", "")';
	}
	}
	if (!$values) return '';
	$sql = 'INSERT INTO '.TABLE_PREFIX.'PermCache (CategoryId, PermId, ACL, DACL) VALUES '.join(',', $values);
	return $sql;
	}
	}

	class kPermCacheUpdater extends kHelper
	{
	/**
	* Holds Stack
	*
	* @var clsRecursionStack
	*/
	var $Stack;
	var $iteration;
	var $totalCats;
	var $doneCats;
	var $table;

	var $primaryLanguageId = 0;
	var $languageCount = 0;
	var $root_prefixes = Array();
	var $StrictPath = false;

	function Init($prefix, $special, $event_params = null)
	{
	parent::Init($prefix, $special, $event_params);

	$continuing = isset($event_params['continue']) ? $event_params['continue'] : 1;
	$this->StrictPath = isset($event_params['strict_path']) ? $event_params['strict_path'] : false;
	if ($this->StrictPath && !is_array($this->StrictPath)) {
	$this->StrictPath = explode('\|', trim($this->StrictPath, '\|'));
	}

	// cache widely used values to speed up process: begin
	$ml_helper =& $this->Application->recallObject('kMultiLanguageHelper');
	$this->languageCount = $ml_helper->getLanguageCount();
	$this->primaryLanguageId = $this->Application->GetDefaultLanguageId();
	// cache widely used values to speed up process: end

	foreach ($this->Application->ModuleInfo as $module_name => $module_info) {
	$this->root_prefixes[ $module_info['RootCat'] ] = $module_info['Var'];
	}

	$this->iteration = 0;
	$this->table = $this->Application->GetTempName('permCacheUpdate');

	if ($continuing == 1) {
	$this->InitUpdater();
	}
	elseif ($continuing == 2) {
	$this->getData();
	}
	}

	function InitUpdater()
	{
	$this->Stack =& new clsRecursionStack();
	$sql = 'DELETE FROM '.TABLE_PREFIX.'PermCache';
	if ($this->StrictPath) {
	$sql .= ' WHERE CategoryId IN ('.implode(',',$this->StrictPath).')';
	}
	$this->Conn->Query($sql);
	$this->initData();
	}

	function getDonePercent()
	{
	if(!$this->totalCats)return 0;
	return min(100, intval( round( $this->doneCats / $this->totalCats * 100 ) ));
	}

	function getData()
	{
	$tmp = $this->Conn->GetOne('SELECT data FROM '.$this->table);
	if ($tmp) $tmp = unserialize($tmp);

	$this->totalCats = isset($tmp['totalCats']) ? $tmp['totalCats'] : 0;
	$this->doneCats = isset($tmp['doneCats']) ? $tmp['doneCats'] : 0;
	if (isset($tmp['stack'])) {
	$this->Stack = $tmp['stack'];
	}
	else {
	$this->Stack = & new clsRecursionStack();
	}
	}

	function setData()
	{
	$tmp = Array (
	'totalCats' => $this->totalCats,
	'doneCats' => $this->doneCats,
	'stack' => $this->Stack,
	);

	$this->Conn->Query('DELETE FROM '.$this->table);

	$fields_hash = Array('data' => serialize($tmp));
	$this->Conn->doInsert($fields_hash, $this->table);
	}

	function initData()
	{
	$this->clearData(); // drop table before starting anyway

	$this->Conn->Query('CREATE TABLE '.$this->table.'(data LONGTEXT)');

	$this->totalCats = (int)$this->Conn->GetOne('SELECT COUNT(*) FROM '.TABLE_PREFIX.'Category');
	$this->doneCats = 0;
	}

	function clearData()
	{
	$this->Conn->Query('DROP TABLE IF EXISTS '.$this->table);
	$this->Conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = \'ForcePermCacheUpdate\'');
	}

	function DoTheJob()
	{
	$data = $this->Stack->Get();
	if ($data === false) { //If Stack is empty
	$data['current_id'] = 0;
	$data['titles'] = Array();
	$data['parent_path'] = Array();
	$data['named_path'] = Array();
	$data['category_template'] = '';
	$data['item_template'] = '';
	$data['children_count'] = 0;
	$this->Stack->Push($data);
	}

	if (!isset($data['queried'])) {
	$this->QueryTitle($data);
	$this->QueryChildren($data);
	$data['children_count'] = count($data['children']);
	$this->QueryPermissions($data);
	$data['queried'] = 1;

	if ($sql = $data['perms']->GetInsertSQL()) {
	$this->Conn->Query($sql);
	// $this->doneCats++; // moved to the place where it pops out of the stack by Kostja
	}
	$this->iteration++;
	}

	// start with first child if we haven't started yet
	if (!isset($data['current_child'])) $data['current_child'] = 0;

	// if we have more children
	if (isset($data['children'][$data['current_child']])) {
	if ($this->StrictPath) {
	while ( isset($data['children'][ $data['current_child'] ]) && !in_array($data['children'][ $data['current_child'] ], $this->StrictPath) ) {
	$data['current_child']++;
	continue;
	}
	if (!isset($data['children'][ $data['current_child'] ])) return false; //error
	}
	$next_data = Array();
	$next_data['titles'] = $data['titles'];
	$next_data['parent_path'] = $data['parent_path'];
	$next_data['named_path'] = $data['named_path'];
	$next_data['category_template'] = $data['category_template'];
	$next_data['item_template'] = $data['item_template'];
	$next_data['current_id'] = $data['children'][ $data['current_child'] ]; //next iteration should process child
	$next_data['perms'] = $data['perms']; //we should copy our permissions to child - inheritance
	$next_data['perms']->SetCatId($next_data['current_id']);
	$data['current_child']++;
	$this->Stack->Update($data); //we need to update ourself for the iteration after the next (or further) return to next child
	$this->Stack->Push($next_data); //next iteration should process this child
	return true;
	}
	else {
	$this->UpdateCachedPath($data);
	$prev_data = $this->Stack->Pop(); //remove ourself from stack if we have finished all the childs (or there are none)
	// we are getting here if we finished with current level, so check if it's first level - then bail out.

	$this->doneCats++; // moved by Kostja from above, seems to fix the prob
	$has_more = $this->Stack->Count() > 0;
	if ($has_more) {
	$next_data = $this->Stack->Get();
	$next_data['children_count'] += $data['children_count'];
	$this->Stack->Update($next_data);
	}
	return $has_more;
	}
	}

	function UpdateCachedPath(&$data)
	{
	$fields_hash = Array (
	'ParentPath' => '\|'.implode('\|', $data['parent_path']).'\|',
	'NamedParentPath' => implode('/', $data['named_path'] ),
	'CachedCategoryTemplate' => $data['category_template'],
	'CachedDescendantCatsQty' => $data['children_count'],
	);

	$i = 1;
	while ($i <= $this->languageCount) {
	$fields_hash['l'.$i.'_CachedNavbar'] = implode('&\|&', $data['titles'][$i]);
	$i++;
	}

	$this->Conn->doUpdate($fields_hash, TABLE_PREFIX.'Category', 'CategoryId = '.$data['current_id']);
	}

	function QueryTitle(&$data)
	{
	$category_id = $data['current_id'];
	$sql = 'SELECT *
	FROM '.TABLE_PREFIX.'Category
	WHERE CategoryId = '.$category_id;

	$record = $this->Conn->GetRow($sql);
	if ($record) {
	$i = 1;
	while ($i <= $this->languageCount) {
	$data['titles'][$i][] = $record['l'.$i.'_Name'] ? $record['l'.$i.'_Name'] : $record['l'.$this->primaryLanguageId.'_Name'];
	$i++;
	}

	$data['parent_path'][] = $category_id;
	$data['named_path'][] = $record['Filename'];

	// it is one of the modules root category
	$root_prefix = isset($this->root_prefixes[$category_id]) ? $this->root_prefixes[$category_id] : false;
	if ($root_prefix) {
	$fields_hash = Array();
	if (!$record['CategoryTemplate']) {
	$record['CategoryTemplate'] = $this->Application->ConfigValue($root_prefix.'_CategoryTemplate');
	$fields_hash['CategoryTemplate'] = $record['CategoryTemplate'];
	}

	$this->Conn->doUpdate($fields_hash, TABLE_PREFIX.'Category', 'CategoryId = '.$category_id);
	}

	// if explicitly set, then use it; use parent template otherwise
	if ($record['CategoryTemplate']) {
	$data['category_template'] = $record['CategoryTemplate'];
	}
	}

	}

	function QueryChildren(&$data)
	{
	$sql = 'SELECT CategoryId
	FROM '.TABLE_PREFIX.'Category
	WHERE ParentId = '.$data['current_id'];
	$data['children'] = $this->Conn->GetCol($sql);
	}

	function QueryPermissions(&$data)
	{
	// don't search for section "view" permissions here :)
	$sql = 'SELECT ipc.PermissionConfigId, ip.GroupId, ip.PermissionValue
	FROM '.TABLE_PREFIX.'Permissions AS ip
	LEFT JOIN '.TABLE_PREFIX.'PermissionConfig AS ipc ON ipc.PermissionName = ip.Permission
	WHERE (CatId = '.$data['current_id'].') AND (Permission LIKE "%.VIEW") AND (ip.Type = 0)';

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

	//create permissions array only if we don't have it yet (set by parent)
	if (!isset($data['perms'])) {
	$data['perms'] = new clsCachedPermissions($data['current_id']);
	}

	foreach ($records as $record) {
	if ($record['PermissionValue'] == 1) {
	$data['perms']->AddAllow($record['PermissionConfigId'], $record['GroupId']);
	}
	else {
	$data['perms']->AddDeny($record['PermissionConfigId'], $record['GroupId']);
	}
	}
	}

	/**
	* Rebuild all cache in one step
	*
	*/
	function OneStepRun($path='')
	{
	+ $this->InitUpdater();
	$needs_more = true;
	while ($needs_more) {
	// until proceeeded in this step category count exceeds category per step limit
	$needs_more = $this->DoTheJob();
	}
	$this->clearData();
	}
	}
	?>
	\ No newline at end of file

	Property changes on: branches/unlabeled/unlabeled-1.8.2/core/units/categories/cache_updater.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.8.2.3
	\ No newline at end of property
	+1.8.2.4
	\ No newline at end of property
	Index: branches/unlabeled/unlabeled-1.25.2/core/units/categories/categories_event_handler.php
	===================================================================
	--- branches/unlabeled/unlabeled-1.25.2/core/units/categories/categories_event_handler.php (revision 7369)
	+++ branches/unlabeled/unlabeled-1.25.2/core/units/categories/categories_event_handler.php (revision 7370)
	@@ -1,558 +1,559 @@
	<?php

	class CategoriesEventHandler extends kDBEventHandler {

	/**
	* Allows to override standart permission mapping
	*
	*/
	function mapPermissions()
	{
	parent::mapPermissions();
	$permissions = Array(
	'OnRebuildCache' => Array('self' => 'add\|edit'),
	// 'OnSave' => Array('self' => 'add\|edit')
	);
	$this->permMapping = array_merge($this->permMapping, $permissions);
	}

	/**
	* Checks permissions of user
	*
	* @param kEvent $event
	*/
	function CheckPermission(&$event)
	{
	if (!$this->Application->IsAdmin()) {
	if ($event->Name == 'OnSetSortingDirect') {
	// allow sorting on front event without view permission
	return true;
	}
	}

	if ($event->Name == 'OnEdit' \|\| $event->Name == 'OnSave') {
	// check each id from selected individually and only if all are allowed proceed next
	if ($event->Name == 'OnEdit') {
	$selected_ids = implode(',', $this->StoreSelectedIDs($event));
	}
	else {
	$selected_ids = implode(',', $this->getSelectedIDs($event, true));
	}

	$id_field = $this->Application->getUnitOption($event->Prefix, 'IDField');

	if (strlen($selected_ids) > 0) {
	$table_name = $this->Application->getUnitOption($event->Prefix, 'TableName');
	$sql = 'SELECT '.$id_field.', CreatedById
	FROM '.$table_name.' item_table
	WHERE '.$id_field.' IN ('.$selected_ids.')';
	$items = $this->Conn->Query($sql, $id_field);
	}
	else {
	// when creating new category, then no IDs are stored in session
	$parent_cat = $this->Application->RecallVar('m_cat_id');
	$items[$parent_cat] = Array (
	$id_field => $parent_cat,
	'CreatedById' => $this->Application->RecallVar('user_id'),
	);
	}
	$perm_value = true;
	$perm_helper =& $this->Application->recallObject('PermissionsHelper');
	/* @var $perm_helper kPermissionsHelper */

	foreach ($items as $item_id => $item_data) {
	if ($perm_helper->ModifyCheckPermission($item_data['CreatedById'], $item_data[$id_field], $event->Prefix) == 0) {
	// one of items selected has no permission
	$perm_value = false;
	break;
	}
	}

	if (!$perm_value) {
	$event->status = erPERM_FAIL;
	}

	return $perm_value;
	}

	return parent::CheckPermission($event);
	}

	/**
	* Apply system filter to categories list
	*
	* @param kEvent $event
	*/
	function SetCustomQuery(&$event)
	{
	parent::SetCustomQuery($event);

	$types=$event->getEventParam('types');
	$except_types=$event->getEventParam('except');
	$object =& $event->getObject();
	$type_clauses = Array();

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

	// hide categories with status = 4 (system categories)
	$object->addFilter('system_categories', '%1$s.Status <> 4');

	if ( $event->getEventParam('parent_cat_id') ) {
	$parent_cat_id = $event->getEventParam('parent_cat_id');

	if ($parent_cat_id == 'Root') {
	$module_name = $event->getEventParam('module') ? $event->getEventParam('module') : 'In-Commerce';
	$module =& $this->Application->recallObject('mod.'.$module_name);
	$parent_cat_id = $module->GetDBField('RootCat');
	}

	}
	else {
	$parent_cat_id = $this->Application->GetVar('c_id');
	if (!$parent_cat_id) {
	$parent_cat_id = $this->Application->GetVar('m_cat_id');
	}
	if (!$parent_cat_id) {
	$parent_cat_id = 0;
	}
	}

	if ("$parent_cat_id" != 'any') {
	if ($event->getEventParam('recursive')) {
	$current_path = $this->Conn->GetOne('SELECT ParentPath FROM '.TABLE_PREFIX.'Category WHERE CategoryId='.$parent_cat_id);
	$subcats = $this->Conn->GetCol('SELECT CategoryId FROM '.TABLE_PREFIX.'Category WHERE ParentPath LIKE "'.$current_path.'%" ');
	$object->addFilter('parent_filter', 'ParentId IN ('.implode(', ', $subcats).')');
	}
	else {
	$object->addFilter('parent_filter', 'ParentId = '.$parent_cat_id);
	}
	}

	$object->addFilter('perm_filter', 'PermId = 1'); // check for CATEGORY.VIEW permission
	if ($this->Application->RecallVar('user_id') != -1) {
	// apply permission filters to all users except "root"
	$groups = explode(',',$this->Application->RecallVar('UserGroups'));
	foreach ($groups as $group) {
	$view_filters[] = 'FIND_IN_SET('.$group.', acl)';
	}
	$view_filter = implode(' OR ', $view_filters);
	$object->addFilter('perm_filter2', $view_filter);
	}

	if (!$this->Application->IsAdmin()) {
	// apply status filter only on front
	$object->addFilter('status_filter', $object->TableName.'.Status = 1');
	}

	if(strpos($types, 'category_related') !== false)
	{
	$object->removeFilter('parent_filter');
	$resource_id = $this->Conn->GetOne('
	SELECT ResourceId FROM '.$this->Application->getUnitOption($event->Prefix, 'TableName').'
	WHERE CategoryId = '.$parent_cat_id
	);

	$sql = 'SELECT DISTINCT(TargetId) FROM '.TABLE_PREFIX.'Relationship
	WHERE SourceId = '.$resource_id.' AND SourceType = 1';
	$related_cats = $this->Conn->GetCol($sql);
	$related_cats = is_array($related_cats) ? $related_cats : Array();
	$sql = 'SELECT DISTINCT(SourceId) FROM '.TABLE_PREFIX.'Relationship
	WHERE TargetId = '.$resource_id.' AND TargetType = 1 AND Type = 1';
	$related_cats2 = $this->Conn->GetCol($sql);
	$related_cats2 = is_array($related_cats2) ? $related_cats2 : Array();
	$related_cats = array_unique( array_merge( $related_cats2, $related_cats ) );

	if($related_cats)
	{
	$type_clauses['category_related']['include'] = '%1$s.ResourceId IN ('.implode(',', $related_cats).')';
	$type_clauses['category_related']['except'] = '%1$s.ResourceId NOT IN ('.implode(',', $related_cats).')';
	}
	else
	{
	$type_clauses['category_related']['include'] = '0';
	$type_clauses['category_related']['except'] = '1';
	}
	$type_clauses['category_related']['having_filter'] = false;
	}

	if(strpos($types, 'product_related') !== false)
	{
	$object->removeFilter('parent_filter');

	$product_id = $event->getEventParam('product_id') ? $event->getEventParam('product_id') : $this->Application->GetVar('p_id');
	$resource_id = $this->Conn->GetOne('
	SELECT ResourceId FROM '.$this->Application->getUnitOption('p', 'TableName').'
	WHERE ProductId = '.$product_id
	);

	$sql = 'SELECT DISTINCT(TargetId) FROM '.TABLE_PREFIX.'Relationship
	WHERE SourceId = '.$resource_id.' AND TargetType = 1';
	$related_cats = $this->Conn->GetCol($sql);
	$related_cats = is_array($related_cats) ? $related_cats : Array();
	$sql = 'SELECT DISTINCT(SourceId) FROM '.TABLE_PREFIX.'Relationship
	WHERE TargetId = '.$resource_id.' AND SourceType = 1 AND Type = 1';
	$related_cats2 = $this->Conn->GetCol($sql);
	$related_cats2 = is_array($related_cats2) ? $related_cats2 : Array();
	$related_cats = array_unique( array_merge( $related_cats2, $related_cats ) );

	if($related_cats)
	{
	$type_clauses['product_related']['include'] = '%1$s.ResourceId IN ('.implode(',', $related_cats).')';
	$type_clauses['product_related']['except'] = '%1$s.ResourceId NOT IN ('.implode(',', $related_cats).')';
	}
	else
	{
	$type_clauses['product_related']['include'] = '0';
	$type_clauses['product_related']['except'] = '1';
	}
	$type_clauses['product_related']['having_filter'] = false;
	}

	/********************************************/

	$includes_or_filter =& $this->Application->makeClass('kMultipleFilter');
	$includes_or_filter->setType(FLT_TYPE_OR);

	$excepts_and_filter =& $this->Application->makeClass('kMultipleFilter');
	$excepts_and_filter->setType(FLT_TYPE_AND);

	$includes_or_filter_h =& $this->Application->makeClass('kMultipleFilter');
	$includes_or_filter_h->setType(FLT_TYPE_OR);

	$excepts_and_filter_h =& $this->Application->makeClass('kMultipleFilter');
	$excepts_and_filter_h->setType(FLT_TYPE_AND);

	$except_types_array=explode(',', $types);

	if ($types){
	$types_array=explode(',', $types);
	for ($i=0; $i<sizeof($types_array); $i++){
	$type=trim($types_array[$i]);
	if (isset($type_clauses[$type])){
	if ($type_clauses[$type]['having_filter']){
	$includes_or_filter_h->removeFilter('filter_'.$type);
	$includes_or_filter_h->addFilter('filter_'.$type, $type_clauses[$type]['include']);
	}else{
	$includes_or_filter->removeFilter('filter_'.$type);
	$includes_or_filter->addFilter('filter_'.$type, $type_clauses[$type]['include']);
	}
	}
	}
	}

	if ($except_types){
	$except_types_array=explode(',', $except_types);
	for ($i=0; $i<sizeof($except_types_array); $i++){
	$type=trim($except_types_array[$i]);
	if (isset($type_clauses[$type])){
	if ($type_clauses[$type]['having_filter']){
	$excepts_and_filter_h->removeFilter('filter_'.$type);
	$excepts_and_filter_h->addFilter('filter_'.$type, $type_clauses[$type]['except']);
	}else{
	$excepts_and_filter->removeFilter('filter_'.$type);
	$excepts_and_filter->addFilter('filter_'.$type, $type_clauses[$type]['except']);
	}
	}
	}
	}

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

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

	/**
	* Enter description here...
	*
	* @param kEvent $event
	* @return int
	*/
	function GetPassedId(&$event)
	{
	if ( $this->Application->IsAdmin()) {
	return parent::getPassedID($event);
	}

	return $this->Application->GetVar('m_cat_id');
	}

	function ParentGetPassedId(&$event)
	{
	return parent::GetPassedId($event);
	}

	/**
	* Adds calculates fields for item statuses
	*
	* @param kCatDBItem $object
	* @param kEvent $event
	*/
	function prepareObject(&$object, &$event)
	{
	$object =& $event->getObject( Array('skip_autoload' => true) );

	$object->addCalculatedField('IsNew', ' IF(%1$s.NewItem = 2,
	IF(%1$s.CreatedOn >= (UNIX_TIMESTAMP() - '.
	$this->Application->ConfigValue('Category_DaysNew').
	'360024), 1, 0),
	%1$s.NewItem
	)');
	}

	/**
	* Set correct parent path for newly created categories
	*
	* @param kEvent $event
	*/
	function OnAfterCopyToLive(&$event)
	{
	$parent_path = false;
	$object =& $this->Application->recallObject($event->Prefix.'.-item', null, Array('skip_autoload' => true, 'live_table' => true));
	$object->Load($event->getEventParam('id'));
	if ($event->getEventParam('temp_id') == 0) {
	if ($object->isLoaded()) {
	// update path only for real categories (not including "Home" root category)
	$fields_hash = Array('ParentPath' => $object->buildParentPath());
	$this->Conn->doUpdate($fields_hash, $object->TableName, 'CategoryId = '.$object->GetID());
	$parent_path = $fields_hash['ParentPath'];
	}
	}
	else {
	$parent_path = $object->GetDBField('ParentPath');
	}
	if ($parent_path) {
	$cache_updater =& $this->Application->recallObject('kPermCacheUpdater', null, array('strict_path' => $parent_path));
	$cache_updater->OneStepRun();
	+ $cache_updater->StrictPath = false;
	}
	}

	/**
	* Set cache modification mark if needed
	*
	* @param kEvent $event
	*/
	function OnBeforeDeleteFromLive(&$event)
	{
	$id = $event->getEventParam('id');

	// loding anyway, because this object is needed by "c-perm:OnBeforeDeleteFromLive" event
	$temp_object =& $event->getObject( Array('skip_autoload' => true) );
	$temp_object->Load($id);

	if ($id == 0) {
	if ($temp_object->isLoaded()) {
	// new category -> update chache (not loaded when "Home" category)
	$this->Application->StoreVar('PermCache_UpdateRequired', 1);
	}
	return ;
	}

	// existing category was edited, check if in-cache fields are modified
	$live_object =& $this->Application->recallObject($event->Prefix.'.-item', null, Array('live_table' => true, 'skip_autoload' => true));
	$live_object->Load($id);

	$cached_fields = Array('Name', 'Filename', 'CategoryTemplate', 'ParentId');

	foreach ($cached_fields as $cached_field) {
	if ($live_object->GetDBField($cached_field) != $temp_object->GetDBField($cached_field)) {
	// use session instead of REQUEST because of permission editing in category can contain
	// multiple submits, that changes data before OnSave event occurs
	$this->Application->StoreVar('PermCache_UpdateRequired', 1);
	break;
	}
	}
	}

	/**
	* Calls kDBEventHandler::OnSave original event
	* Used in proj-cms:StructureEventHandler->OnSave
	*
	* @param kEvent $event
	*/
	function parentOnSave(&$event)
	{
	parent::OnSave($event);
	}

	/**
	* Checks cache update mark and redirect to cache if needed
	*
	* @param kEvent $event
	*/
	function OnSave(&$event)
	{
	$object =& $event->getObject();
	if ($object->IsRoot()) {
	$event->setEventParam('master_ids', Array(0));
	}

	parent::OnSave($event);
	if ($event->status == erSUCCESS && $this->Application->RecallVar('PermCache_UpdateRequired')) {
	// "catalog" should be in opener stack by now
	$wid = $this->Application->GetVar('m_wid');
	$stack_name = rtrim('opener_stack_'.$wid, '_');

	$opener_stack = unserialize($this->Application->RecallVar($stack_name));
	$opener_stack[0] = str_replace('catalog', 'categories/cache_updater', $opener_stack[0]);
	$this->Application->StoreVar($stack_name, serialize($opener_stack));
	$this->Application->RemoveVar('PermCache_UpdateRequired');
	}
	}

	/**
	* Deletes all selected items.
	* Automatically recurse into sub-items using temp handler, and deletes sub-items
	* by calling its Delete method if sub-item has AutoDelete set to true in its config file
	*
	* @param kEvent $event
	*/
	function OnMassDelete(&$event)
	{
	if ($this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1)) {
	return;
	}

	// $event->status = erSUCCESS;

	$ids = $this->StoreSelectedIDs($event);
	if ($ids) {
	$recursive_helper =& $this->Application->recallObject('RecursiveHelper');
	/* @var $recursive_helper kRecursiveHelper */

	foreach ($ids as $id) {
	$recursive_helper->DeleteCategory($id, $event->Prefix);
	}
	}
	$this->clearSelectedIDs($event);
	}

	/**
	* Add selected items to clipboard with mode = COPY (CLONE)
	*
	* @param kEvent $event
	*/
	function OnCopy(&$event)
	{
	$this->Application->RemoveVar('clipboard');
	$clipboard_helper =& $this->Application->recallObject('ClipboardHelper');
	$clipboard_helper->setClipboard($event, 'copy', $this->StoreSelectedIDs($event));
	}

	/**
	* Add selected items to clipboard with mode = CUT
	*
	* @param kEvent $event
	*/
	function OnCut(&$event)
	{
	$this->Application->RemoveVar('clipboard');
	$clipboard_helper =& $this->Application->recallObject('ClipboardHelper');
	$clipboard_helper->setClipboard($event, 'cut', $this->StoreSelectedIDs($event));
	}

	/**
	* Controls all item paste operations. Can occur only with filled clipbord.
	*
	* @param kEvent $event
	*/
	function OnPasteClipboard(&$event)
	{
	$clipboard = unserialize( $this->Application->RecallVar('clipboard') );
	foreach ($clipboard as $prefix => $clipboard_data) {
	$paste_event = new kEvent($prefix.':OnPaste', Array('clipboard_data' => $clipboard_data));
	$this->Application->HandleEvent($paste_event);

	$event->redirect = $paste_event->redirect;
	$event->redirect_params = $paste_event->redirect_params;
	$event->status = $paste_event->status;
	}
	}

	/**
	* Paste categories with subitems from clipboard
	*
	* @param kEvent $event
	*/
	function OnPaste(&$event)
	{
	if ($this->Application->CheckPermission('SYSTEM_ACCESS.READONLY', 1)) {
	return;
	}

	$clipboard_data = $event->getEventParam('clipboard_data');

	if (!$clipboard_data['cut'] && !$clipboard_data['copy']) {
	return false;
	}

	$recursive_helper =& $this->Application->recallObject('RecursiveHelper');
	/* @var $recursive_helper kRecursiveHelper */

	if ($clipboard_data['cut']) {
	$recursive_helper->MoveCategories($clipboard_data['cut'], $this->Application->GetVar('m_cat_id'));
	}

	if ($clipboard_data['copy']) {
	foreach ($clipboard_data['copy'] as $id) {
	$recursive_helper->PasteCategory($id, $event->Prefix);
	}
	}

	if ($clipboard_data['cut'] \|\| $clipboard_data['copy']) {
	$event->redirect = 'categories/cache_updater';
	}
	}

	/**
	* Occurs when pasting category
	*
	* @param kEvent $event
	*/
	/*function OnCatPaste(&$event)
	{
	$inp_clipboard = $this->Application->RecallVar('ClipBoard');
	$inp_clipboard = explode('-', $inp_clipboard, 2);

	if($inp_clipboard[0] == 'COPY')
	{
	$saved_cat_id = $this->Application->GetVar('m_cat_id');
	$cat_ids = $event->getEventParam('cat_ids');

	$id_field = $this->Application->getUnitOption($event->Prefix, 'IDField');
	$table = $this->Application->getUnitOption($event->Prefix, 'TableName');
	$ids_sql = 'SELECT '.$id_field.' FROM '.$table.' WHERE ResourceId IN (%s)';
	$resource_ids_sql = 'SELECT ItemResourceId FROM '.TABLE_PREFIX.'CategoryItems WHERE CategoryId = %s AND PrimaryCat = 1';

	$object =& $this->Application->recallObject($event->Prefix.'.item', $event->Prefix, Array('skip_autoload' => true));

	foreach($cat_ids as $source_cat => $dest_cat)
	{
	$item_resource_ids = $this->Conn->GetCol( sprintf($resource_ids_sql, $source_cat) );
	if(!$item_resource_ids) continue;

	$this->Application->SetVar('m_cat_id', $dest_cat);
	$item_ids = $this->Conn->GetCol( sprintf($ids_sql, implode(',', $item_resource_ids) ) );

	$temp =& $this->Application->recallObject($event->getPrefixSpecial().'_TempHandler', 'kTempTablesHandler');
	if($item_ids) $temp->CloneItems($event->Prefix, $event->Special, $item_ids);
	}

	$this->Application->SetVar('m_cat_id', $saved_cat_id);
	}
	}*/

	/**
	* Cleares clipboard content
	*
	* @param kEvent $event
	*/
	function OnClearClipboard(&$event)
	{
	$this->Application->RemoveVar('clipboard');
	}
	}

	?>
	\ No newline at end of file

	Property changes on: branches/unlabeled/unlabeled-1.25.2/core/units/categories/categories_event_handler.php
	___________________________________________________________________
	Modified: cvs2svn:cvs-rev
	## -1 +1 ##
	-1.25.2.12
	\ No newline at end of property
	+1.25.2.13
	\ 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