in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Wed, Jul 23, 10:29 PM

in-portal
View Options

	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 7056)
	+++ branches/unlabeled/unlabeled-1.8.2/core/units/categories/cache_updater.php (revision 7057)
	@@ -1,386 +1,401 @@
	<?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
	{
	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'] = '';
	$this->Stack->Push($data);
	}

	if (!isset($data['queried'])) {
	$this->QueryTitle($data);
	$this->QueryChildren($data);
	$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);
	$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
	return $this->Stack->Count() > 0;
	}
	}

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

	$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()
	+ function OneStepRun($path='')
	{
	$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.1
	\ No newline at end of property
	+1.8.2.2
	\ 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 7056)
	+++ branches/unlabeled/unlabeled-1.25.2/core/units/categories/categories_event_handler.php (revision 7057)
	@@ -1,549 +1,558 @@
	<?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) {
	- $object =& $this->Application->recallObject($event->Prefix.'.-item', null, Array('skip_autoload' => true, 'live_table' => true));
	- $object->Load($event->getEventParam('id'));
	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();
	+ }
	}

	/**
	* 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');

	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.10
	\ No newline at end of property
	+1.25.2.11
	\ 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