static function remove($objectID, $removeSubtrees = true)
{
eZContentCacheManager::clearContentCacheIfNeeded($objectID);
$object = eZContentObject::fetch($objectID);
if (!is_object($object)) {
return false;
}
// TODO: Is content cache cleared for all objects in subtree ??
if ($removeSubtrees) {
$assignedNodes = $object->attribute('assigned_nodes');
if (count($assignedNodes) == 0) {
$object->purge();
eZContentObject::expireAllViewCache();
return true;
}
$assignedNodeIDArray = array();
foreach ($assignedNodes as $node) {
$assignedNodeIDArray[] = $node->attribute('node_id');
}
eZContentObjectTreeNode::removeSubtrees($assignedNodeIDArray, false);
} else {
$object->purge();
}
return true;
}
function feZMetaData_ContentActionHandler( &$module, &$http, &$objectID )
{
// Action when user clicks on the Add Button
if( $http->hasPostVariable( 'AddMetaDataButton' ) )
{
$link = 'fezmetadata/edit/0/(contentObjectID)/'.$objectID;
$link .= '/(metaDataName)/'.$_POST['metaDataName'];
$link .= '/(language)/'.$_POST['language'];
eZURI::transformURI( $link );
$http->redirect( $link );
}
// Action when user clicks on the Remove Button
if( $http->hasPostVariable( 'RemoveMetaDataButton' ) and $http->hasPostVariable( 'MetaDataIDSelection' ) )
{
$metaDataSelection = $http->postVariable( 'MetaDataIDSelection' );
foreach( $metaDataSelection as $metaData )
{
$metaDataObject = feZMetaData::fetch( $metaData );
$metaDataObject->remove();
}
eZContentCacheManager::clearContentCache( $objectID );
$ContentObject = eZContentObject::fetch( $objectID );
$ContentNodeID = $ContentObject->mainNodeID();
return $module->redirect( 'content', 'view', array( 'full', $ContentNodeID ) );
}
}
function sectionEditActionCheck($module, $class, $object, $version, $contentObjectAttributes, $editVersion, $editLanguage, $fromLanguage)
{
if (!$module->isCurrentAction('SectionEdit')) {
return;
}
$http = eZHTTPTool::instance();
if (!$http->hasPostVariable('SelectedSectionId')) {
return;
}
$selectedSection = eZSection::fetch((int) $http->postVariable('SelectedSectionId'));
if (!$selectedSection instanceof eZSection) {
return;
}
$selectedSection->applyTo($object);
eZContentCacheManager::clearContentCacheIfNeeded($object->attribute('id'));
$module->redirectToView('edit', array($object->attribute('id'), $editVersion, $editLanguage, $fromLanguage));
}
function execute($process, $event)
{
// get object being published
$parameters = $process->attribute('parameter_list');
$objectId = $parameters['object_id'];
eZDebug::writeDebug('Expire remote cache event begins execution for object ' . $objectId);
$ini = eZINI::instance('ezworkflowcollection.ini');
$object = eZContentObject::fetch($objectId);
if ($object != null) {
if ($ini->variable('ExpireRemoteCacheFlowSettings', 'ExpireOnlyObjectNodes') == 'enabled') {
// basic version
// get list of nodes this object is published with
$assigned_nodes = $object->attribute('assigned_nodes');
} else {
// smart-cache enabled version
// get list of nodes whose view-cache is expired
$assigned_nodes = array();
eZContentCacheManager::nodeListForObject($object, true, eZContentCacheManager::CLEAR_DEFAULT, $assigned_nodes, $handledObjectList);
foreach ($assigned_nodes as $i => $nodeID) {
$assigned_nodes[$i] = eZContentObjectTreeNode::fetch($nodeID);
}
}
$domains = $ini->variable('ExpireRemoteCacheFlowSettings', 'ExpireDomains');
foreach ($assigned_nodes as $assigned_node) {
// for every node, call eZHTTPCacheManager to clean the remote cache
$url = $assigned_node->urlAlias();
if (is_array($domains) && (count($domains) > 1 || count($domains) > 0 && $domains[0] != '')) {
eZURI::transformURI($url);
foreach ($domains as $domain) {
eZHTTPCacheManager::execute($domain . $url);
}
} else {
eZURI::transformURI($url, false, 'full');
eZHTTPCacheManager::execute($url);
}
}
} else {
eZDebug::writeError('Expire remote cache event triggered for inexisting object: ' . $objectId);
return eZWorkflowType::STATUS_WORKFLOW_CANCELLED;
}
return eZWorkflowType::STATUS_ACCEPTED;
}
/**
* Updating priority sorting for given node
*
* @param mixed $args
* @return array
*/
public static function updatePriority( $args )
{
$http = eZHTTPTool::instance();
if ( !$http->hasPostVariable('ContentNodeID')
|| !$http->hasPostVariable('PriorityID')
|| !$http->hasPostVariable('Priority') )
{
return array();
}
$contentNodeID = $http->postVariable('ContentNodeID');
$priorityArray = $http->postVariable('Priority');
$priorityIDArray = $http->postVariable('PriorityID');
$contentNode = eZContentObjectTreeNode::fetch( $contentNodeID );
if ( !$contentNode->attribute( 'can_edit' ) )
{
eZDebug::writeError( 'Current user can not update the priorities because he has no permissions to edit the node' );
return array();
}
if ( eZOperationHandler::operationIsAvailable( 'content_updatepriority' ) )
{
$operationResult = eZOperationHandler::execute( 'content', 'updatepriority',
array( 'node_id' => $contentNodeID,
'priority' => $priorityArray,
'priority_id' => $priorityIDArray ), null, true );
}
else
{
eZContentOperationCollection::updatePriority( $contentNodeID, $priorityArray, $priorityIDArray );
}
if ( $http->hasPostVariable( 'ContentObjectID' ) )
{
$objectID = $http->postVariable( 'ContentObjectID' );
eZContentCacheManager::clearContentCache( $objectID );
}
}
/**
* @param eZWorkflowProcess $process
* @param eZWorkflowEvent $event
* @return int
*/
function execute( $process, $event )
{
// Get some information about the object being passed
$parameters = $process->attribute( 'parameter_list' );
$object = eZContentObject::fetch( $parameters['object_id'] );
if($object->ClassIdentifier != 'article')
return self::STATUS_ACCEPTED;
/* @type $dataMap eZContentObjectAttribute[] */
$dataMap = $object->dataMap();
if(isset($dataMap['source']))
{
$sourceString = MMNewsSource::getSourceString($object);
if($sourceString)
{
$dataMap['source']->setAttribute('data_text', $sourceString);
$dataMap['source']->store();
}
eZContentCacheManager::clearContentCache($object->attribute('id'));
}
return self::STATUS_ACCEPTED;
}
function removeRelatedCache($siteAccess)
{
// Delete compiled template
$ini = eZINI::instance();
$iniPath = eZSiteAccess::findPathToSiteAccess($siteAccess);
$siteINI = eZINI::instance('site.ini.append', $iniPath);
if ($siteINI->hasVariable('FileSettings', 'CacheDir')) {
$cacheDir = $siteINI->variable('FileSettings', 'CacheDir');
if ($cacheDir[0] == "/") {
$cacheDir = eZDir::path(array($cacheDir));
} else {
if ($siteINI->hasVariable('FileSettings', 'VarDir')) {
$varDir = $siteINI->variable('FileSettings', 'VarDir');
$cacheDir = eZDir::path(array($varDir, $cacheDir));
}
}
} else {
if ($siteINI->hasVariable('FileSettings', 'VarDir')) {
$varDir = $siteINI->variable('FileSettings', 'VarDir');
$cacheDir = $ini->variable('FileSettings', 'CacheDir');
$cacheDir = eZDir::path(array($varDir, $cacheDir));
} else {
$cacheDir = eZSys::cacheDirectory();
}
}
$compiledTemplateDir = $cacheDir . "/template/compiled";
eZDir::unlinkWildcard($compiledTemplateDir . "/", "*pagelayout*.*");
eZCache::clearByTag('template-block');
// Expire content view cache
eZContentCacheManager::clearAllContentCache();
}
static function setFailedLoginAttempts($userID, $value = false, $setByForce = false)
{
$trustedUser = eZUser::isTrusted();
// If user is trusted we should stop processing
if ($trustedUser and !$setByForce) {
return true;
}
$maxNumberOfFailedLogin = eZUser::maxNumberOfFailedLogin();
if ($maxNumberOfFailedLogin == '0' and !$setByForce) {
return true;
}
$userID = (int) $userID;
$userObject = eZUser::fetch($userID);
if (!$userObject) {
return true;
}
$isEnabled = $userObject->isEnabled();
// If current user is disabled we should not continue
if (!$isEnabled and !$setByForce) {
return true;
}
$db = eZDB::instance();
$db->begin();
$userVisitArray = $db->arrayQuery("SELECT 1 FROM ezuservisit WHERE user_id={$userID}");
if (isset($userVisitArray[0])) {
if ($value === false) {
$failedLoginAttempts = $userObject->failedLoginAttempts();
$failedLoginAttempts += 1;
} else {
$failedLoginAttempts = (int) $value;
}
$db->query("UPDATE ezuservisit SET failed_login_attempts={$failedLoginAttempts} WHERE user_id={$userID}");
} else {
if ($value === false) {
$failedLoginAttempts = 1;
} else {
$failedLoginAttempts = (int) $value;
}
$db->query("INSERT INTO ezuservisit ( failed_login_attempts, user_id ) VALUES ( {$failedLoginAttempts}, {$userID} )");
}
$db->commit();
eZContentCacheManager::clearContentCacheIfNeeded($userID);
eZContentCacheManager::generateObjectViewCache($userID);
}
function storeObjectAttribute($attribute)
{
$ini = eZINI::instance();
// Delete compiled template
$siteINI = eZINI::instance();
if ($siteINI->hasVariable('FileSettings', 'CacheDir')) {
$cacheDir = $siteINI->variable('FileSettings', 'CacheDir');
if ($cacheDir[0] == "/") {
$cacheDir = eZDir::path(array($cacheDir));
} else {
if ($siteINI->hasVariable('FileSettings', 'VarDir')) {
$varDir = $siteINI->variable('FileSettings', 'VarDir');
$cacheDir = eZDir::path(array($varDir, $cacheDir));
}
}
} else {
if ($siteINI->hasVariable('FileSettings', 'VarDir')) {
$varDir = $siteINI->variable('FileSettings', 'VarDir');
$cacheDir = $ini->variable('FileSettings', 'CacheDir');
$cacheDir = eZDir::path(array($varDir, $cacheDir));
} else {
$cacheDir = eZSys::cacheDirectory();
}
}
$compiledTemplateDir = $cacheDir . "/template/compiled";
eZDir::unlinkWildcard($compiledTemplateDir . "/", "*pagelayout*.*");
// Expire template block cache
eZContentCacheManager::clearTemplateBlockCacheIfNeeded(false);
}
// Sort objectDepthList by depth to apply updatechildren in the right order
if (!array_multisort($objectDepthList[0], SORT_ASC, $objectDepthList[1], SORT_ASC)) {
eZDebug::writeError('Error in array_multisort', 'ezmbpaex_updatechildren.php');
} else {
// Generate array of paex objects to update
$paexObjectArray = array();
foreach ($objectDepthList[1] as $contentobjectId) {
if (isset($pendingList[$contentobjectId])) {
// Generate update children data for every pending object in pendingIDList
$paexObjectArray = $pendingList[$contentobjectId]->generateUpdateChildren($paexObjectArray);
} else {
eZDebug::writeError('Found contentobject_id [' . $contentobjectId . '] not present in the pendingIDList', 'ezmbpaex_updatechildren.php');
}
}
// Reset pending object updatechildren attribute in pendingIDList objects and add to the array of paex objects to update
foreach ($pendingList as $pendingObject) {
$pendingObject->setAttribute('updatechildren', 0);
$paexObjectArray[$pendingObject->attribute('contentobject_id')] = $pendingObject;
}
// Store updated paex objects in the DB
$db = eZDB::instance();
$db->begin();
foreach ($paexObjectArray as $paexObject) {
$paexObject->store();
eZContentCacheManager::clearContentCacheIfNeeded($paexObject->attribute('contentobject_id'));
}
$db->commit();
}
}
$cli->output("eZPaEx: Update children process end");
}
/**
* Clears the view cache for a subtree
*
* @param eZContentObjectTreeNode $node
* @param bool $clearForRootNode
* @return bool
*/
static function clearViewCacheForSubtree(eZContentObjectTreeNode $node, $clearForRootNode = true)
{
// Max nodes to fetch at a time
static $limit = 200;
if ($clearForRootNode) {
$objectID = $node->attribute('contentobject_id');
eZContentCacheManager::clearContentCacheIfNeeded($objectID);
}
$offset = 0;
$params = array('AsObject' => false, 'Depth' => false, 'Limitation' => array());
// Empty array means no permission checking
$subtreeCount = $node->subTreeCount($params);
while ($offset < $subtreeCount) {
$params['Offset'] = $offset;
$params['Limit'] = $limit;
$subtreeChunk = $node->subTree($params);
$nNodesInChunk = count($subtreeChunk);
$offset += $nNodesInChunk;
if ($nNodesInChunk == 0) {
break;
}
$objectIDList = array();
foreach ($subtreeChunk as $curNode) {
$objectIDList[] = $curNode['id'];
}
unset($subtreeChunk);
eZContentCacheManager::clearContentCacheIfNeeded(array_unique($objectIDList));
}
return true;
}
static function generateObjectViewCache($objectID)
{
// Generate the view cache
$ini = eZINI::instance();
$object = eZContentObject::fetch($objectID);
$user = eZUser::currentUser();
eZDebug::accumulatorStart('generate_cache', '', 'Generating view cache');
if ($ini->variable('ContentSettings', 'PreViewCache') == 'enabled') {
$preCacheSiteaccessArray = $ini->variable('ContentSettings', 'PreCacheSiteaccessArray');
$currentSiteAccess = $GLOBALS['eZCurrentAccess'];
// This is the default view parameters for content/view
$viewParameters = array('offset' => false, 'year' => false, 'month' => false, 'day' => false, 'namefilter' => false);
if (is_array($preCacheSiteaccessArray) && count($preCacheSiteaccessArray) > 0) {
foreach ($preCacheSiteaccessArray as $changeToSiteAccess) {
$newSiteAccess = $currentSiteAccess;
$newSiteAccess['name'] = $changeToSiteAccess;
unset($newSiteAccess['uri_part']);
//eZSiteAccess::load() will take care of setting correct one
eZSiteAccess::load($newSiteAccess);
$tpl = eZTemplate::factory();
// Get the sitedesign and cached view preferences for this siteaccess
$siteini = eZINI::instance('site.ini');
$cachedViewPreferences = $siteini->variable('ContentSettings', 'CachedViewPreferences');
$language = false;
// Needs to be specified if you want to generate the cache for a specific language
$viewMode = 'full';
$assignedNodes = $object->assignedNodes();
foreach ($assignedNodes as $node) {
// We want to generate the cache for the specified user
$previewCacheUsers = $ini->variable('ContentSettings', 'PreviewCacheUsers');
foreach ($previewCacheUsers as $previewCacheUserID) {
// If the text is 'anon' we need to fetch the Anonymous user ID.
if ($previewCacheUserID === 'anonymous') {
$previewCacheUserID = $siteini->variable("UserSettings", "AnonymousUserID");
$previewCacheUser = eZUser::fetch($previewCacheUserID);
} else {
if ($previewCacheUserID === 'current') {
$previewCacheUser = $user;
} else {
$previewCacheUser = eZUser::fetch($previewCacheUserID);
}
}
if (!$previewCacheUser) {
continue;
}
// Before we generate the view cache we must change the currently logged in user to $previewCacheUser
// If not the templates might read in wrong personalized data (preferences etc.)
eZUser::setCurrentlyLoggedInUser($previewCacheUser, $previewCacheUser->attribute('contentobject_id'), eZUser::NO_SESSION_REGENERATE);
// Cache the current node
$cacheFileArray = eZNodeviewfunctions::generateViewCacheFile($previewCacheUser, $node->attribute('node_id'), false, false, $language, $viewMode, $viewParameters, $cachedViewPreferences);
$tmpRes = eZNodeviewfunctions::generateNodeView($tpl, $node, $node->attribute('object'), $language, $viewMode, false, $cacheFileArray['cache_dir'], $cacheFileArray['cache_path'], true, $viewParameters);
// Cache the parent node
$parentNode = $node->attribute('parent');
$objectID = $parentNode->attribute('contentobject_id');
// if parent objectID is null or is 0 we should not create cache.
if ($objectID) {
$cacheFileArray = eZNodeviewfunctions::generateViewCacheFile($previewCacheUser, $parentNode->attribute('node_id'), 0, false, $language, $viewMode, $viewParameters, $cachedViewPreferences);
$tmpRes = eZNodeviewfunctions::generateNodeView($tpl, $parentNode, $parentNode->attribute('object'), $language, $viewMode, 0, $cacheFileArray['cache_dir'], $cacheFileArray['cache_path'], true, $viewParameters);
}
}
}
}
// Restore the old user as the current one
eZUser::setCurrentlyLoggedInUser($user, $user->attribute('contentobject_id'), eZUser::NO_SESSION_REGENERATE);
// restore siteaccess
eZSiteAccess::load($currentSiteAccess);
}
}
if ($ini->variable('ContentSettings', 'StaticCache') == 'enabled') {
$nodes = array();
$ini = eZINI::instance();
$useURLAlias =& $GLOBALS['eZContentObjectTreeNodeUseURLAlias'];
$pathPrefix = $ini->variable('SiteAccessSettings', 'PathPrefix');
// get staticCacheHandler instance
$optionArray = array('iniFile' => 'site.ini', 'iniSection' => 'ContentSettings', 'iniVariable' => 'StaticCacheHandler');
$options = new ezpExtensionOptions($optionArray);
$staticCacheHandler = eZExtension::getHandlerClass($options);
if (!isset($useURLAlias)) {
$useURLAlias = $ini->variable('URLTranslator', 'Translation') == 'enabled';
}
eZContentCacheManager::nodeListForObject($object, true, self::CLEAR_DEFAULT, $nodes, $handledObjectList);
// If no nodes returns it means that ClearCacheMethod = self::CLEAR_NO_CACHE
if (count($nodes)) {
foreach ($nodes as $nodeID) {
if ($useURLAlias) {
$oNode = eZContentObjectTreeNode::fetch($nodeID, false, true);
if (!isset($oNode)) {
continue;
}
$urlAlias = $oNode->urlAlias();
if ($pathPrefix != '') {
$tempAlias = substr($pathPrefix, strlen($pathPrefix) - 1) == '/' ? $urlAlias . '/' : $urlAlias;
if (strncmp($tempAlias, $pathPrefix, strlen($tempAlias)) == 0) {
$urlAlias = substr($tempAlias, strlen($pathPrefix));
}
}
} else {
$urlAlias = 'content/view/full/' . $nodeID;
}
$staticCacheHandler->cacheURL('/' . $urlAlias, $nodeID);
}
$staticCacheHandler->generateAlwaysUpdatedCache();
}
}
eZDebug::accumulatorStop('generate_cache');
}
if ($existingNotification) {
$tpl->setVariable('success_message', ezpI18n::tr('ezcomments/comment/add', 'You have already subscribed to comment updates on this content.'));
} else {
$tpl->setVariable('success_message', ezpI18n::tr('ezcomments/comment/add', 'You will receive comment updates on the content.'));
}
} else {
$tpl->setVariable('success_message', ezpI18n::tr('ezcomments/comment/add', 'A confirmation email has been sent to your email address. You will receive comment updates after confirmation.'));
}
}
//remember cookies
$cookieManager = ezcomCookieManager::instance();
if ($http->postVariable('CommentRememberme', false) !== false || !$user->isAnonymous()) {
$cookieManager->storeCookie($comment);
} else {
$cookieManager->clearCookie();
}
eZContentCacheManager::clearContentCacheIfNeeded($contentObjectId);
if (!$changeNotification) {
$commentINI = eZINI::instance('ezcomments.ini');
if ($commentINI->variable('GlobalSettings', 'RedirectAfterCommenting') === 'true') {
$module->redirectTo($redirectURI);
}
} else {
$tpl->setVariable('redirect_uri', $redirectURI);
}
}
} else {
$tpl->setVariable('error_message', ezpI18n::tr('ezcomments/comment/add', 'You should not access this view directly.'));
}
$Result['content'] = $tpl->fetch('design:comment/add.tpl');
return $Result;
function swapNodes( $params )
{
$nodeInfo1 = $params['src_node'];
$nodeInfo2 = $params['dst_node'];
//init vars
$node1 = $this->nodeIdByName( $nodeInfo1 );
$node2 = $this->nodeIdByName( $nodeInfo2 );
$nodeID = $node1;
$node = eZContentObjectTreeNode::fetch( $nodeID );
if( !is_object( $node ) )
{
$this->reportError( "Can't fetch node '$nodeID'", 'eZSiteInstaller::swapNodes' );
return false;
}
if( !$node->canSwap() )
{
$this->reportError( "Cannot swap node '$nodeID' (no edit permission)", 'eZSiteInstaller::swapNodes' );
return false;
}
$nodeParentNodeID = $node->attribute( 'parent_node_id' );
$object = $node->object();
if( !is_object( $object ) )
{
$this->reportError( "Cannot fetch object for node '$nodeID'", 'eZSiteInstaller::swapNodes' );
return false;
}
$objectID = $object->attribute( 'id' );
$objectVersion = $object->attribute( 'current_version' );
$class = $object->contentClass();
$classID = $class->attribute( 'id' );
$selectedNodeID = $node2;
$selectedNode = eZContentObjectTreeNode::fetch( $selectedNodeID );
if( !is_object( $selectedNode ) )
{
$this->reportError( "Cannot fetch node '$selectedNodeID'", 'eZSiteInstaller::swapNodes' );
return false;
}
if( !$selectedNode->canSwap() )
{
$this->reportError( "Cannot use node $selectedNodeID as the exchanging node for $nodeID, the current user does not have edit permission for it",
'eZSiteInstaller::swapNodes' );
return false;
}
// clear cache.
eZContentCacheManager::clearContentCacheIfNeeded( $objectID );
$selectedObject = $selectedNode->object();
$selectedObjectID = $selectedObject->attribute( 'id' );
$selectedObjectVersion = $selectedObject->attribute( 'current_version' );
$selectedNodeParentNodeID = $selectedNode->attribute( 'parent_node_id' );
/* In order to swap node1 and node2 a user should have the following permissions:
* 1. move_from: move node1
* 2. move_from: move node2
* 3. move_to: move an object of the same class as node2 under parent of node1
* 4. move_to: move an object of the same class as node1 under parent of node2
*
* The First two has already been checked. Let's check the rest.
*/
$nodeParent = $node->attribute( 'parent' );
$selectedNodeParent = $selectedNode->attribute( 'parent' );
$objectClassID = $object->attribute( 'contentclass_id' );
$selectedObjectClassID = $selectedObject->attribute( 'contentclass_id' );
if( !$nodeParent || !$selectedNodeParent )
{
$this->reportError( "No $nodeParent or no !$selectedNodeParent received.",
'eZSiteInstaller::swapNodes' );
return false;
}
if( !$nodeParent->canMoveTo( $selectedObjectClassID ) )
{
$this->reportError( "Cannot move an object of class $selectedObjectClassID to node $nodeParentNodeID (no create permission)",
'eZSiteInstaller::swapNodes' );
return false;
}
if( !$selectedNodeParent->canMoveTo( $objectClassID ) )
{
$this->reportError( "Cannot move an object of class $objectClassID to node $selectedNodeParentNodeID (no create permission)",
'eZSiteInstaller::swapNodes' );
return false;
}
// exchange contentobject ids and versions.
$node->setAttribute( 'contentobject_id', $selectedObjectID );
$node->setAttribute( 'contentobject_version', $selectedObjectVersion );
$db = eZDB::instance();
$db->begin();
$node->store();
$selectedNode->setAttribute( 'contentobject_id', $objectID );
$selectedNode->setAttribute( 'contentobject_version', $objectVersion );
$selectedNode->store();
// modify path string
$changedOriginalNode = eZContentObjectTreeNode::fetch( $nodeID );
$changedOriginalNode->updateSubTreePath();
$changedTargetNode = eZContentObjectTreeNode::fetch( $selectedNodeID );
$changedTargetNode->updateSubTreePath();
// modify section
if( $changedOriginalNode->attribute( 'main_node_id' ) == $changedOriginalNode->attribute( 'node_id' ) )
{
$changedOriginalObject = $changedOriginalNode->object();
$parentObject = $nodeParent->object();
if( $changedOriginalObject->attribute( 'section_id' ) != $parentObject->attribute( 'section_id' ) )
{
eZContentObjectTreeNode::assignSectionToSubTree( $changedOriginalNode->attribute( 'main_node_id' ),
$parentObject->attribute( 'section_id' ),
$changedOriginalObject->attribute( 'section_id' ) );
}
}
if( $changedTargetNode->attribute( 'main_node_id' ) == $changedTargetNode->attribute( 'node_id' ) )
{
$changedTargetObject = $changedTargetNode->object();
$selectedParentObject = $selectedNodeParent->object();
if( $changedTargetObject->attribute( 'section_id' ) != $selectedParentObject->attribute( 'section_id' ) )
{
eZContentObjectTreeNode::assignSectionToSubTree( $changedTargetNode->attribute( 'main_node_id' ),
$selectedParentObject->attribute( 'section_id' ),
$changedTargetObject->attribute( 'section_id' ) );
}
}
$db->commit();
// clear cache for new placement.
eZContentCacheManager::clearContentCacheIfNeeded( $objectID );
return true;
}
/**
* Create a ezsrRatingDataObject and store it.
* Note: No access checks or input validation is done other then on rating
*
* @param int $contentobjectId
* @param int $contentobjectAttributeId
* @param int $rate (above 0 and bellow or equal 5)
* @param bool $onlyStoreIfUserNotAlreadyRated
* @return null|ezsrRatingDataObject
*/
static function rate($contentobjectId, $contentobjectAttributeId, $rate)
{
$rating = null;
if (is_numeric($contentobjectId) && is_numeric($contentobjectAttributeId) && is_numeric($rate) && $rate <= 5 && $rate > 0) {
$row = array('contentobject_attribute_id' => $contentobjectAttributeId, 'contentobject_id' => $contentobjectId, 'rating' => $rate);
$rating = self::create($row);
if (!$rating->userHasRated()) {
$rating->store();
$avgRating = $rating->getAverageRating();
$avgRating->updateFromRatingData();
$avgRating->store();
// clear the cache for all nodes associated with this object
eZContentCacheManager::clearContentCacheIfNeeded($contentobjectId, true, false);
}
}
return $rating;
}
/**
* Forza l'impostazione del colore di base di un site
*
* Ritorna true se il colore è stato modificato
*
* @param int $currentColor
* @return boolean
*/
public static function forceSiteColor($currentColor)
{
//
// lettura variabili per individuare file scss
$designINIinstance = eZINI::instance('design.ini', 'settings', null, FALSE);
$_stylesheetBaseFile = $designINIinstance->variable('StylesheetSettings', 'StylesheetBaseFile');
$_stylesheetDestFile = $designINIinstance->variable('StylesheetSettings', 'StylesheetDestinationFile');
$_stylesheetCluster = $designINIinstance->variable('StylesheetSettings', 'StylesheetCluster');
// Cicla sui file di origine
for ($i = 0; $i < count($_stylesheetBaseFile); $i++) {
foreach ($_stylesheetCluster as $itemCluster) {
// File da sostituire.
$curFile = $itemCluster . $_stylesheetBaseFile[$i];
$curDestinationFile = $itemCluster . $_stylesheetDestFile[$i];
//print_r('File :<br><b>');
//print_r($curFile);
//print_r('<br>in:<br><b>');
//print_r($curDestinationFile);
//die();
// recupera i valori del eZPersistentObject sinet_site_colors
$colorList = Sinetsitecolors_PstObject::fetchHandlerList();
$fh = fopen($curFile, 'r');
$newRow = '';
// Legge ogni singola riga del file origine
$arrayOriginalColor = explode("-", $currentColor);
while (!feof($fh)) {
$tmpRow = fgets($fh);
$indiceColore = 0;
foreach ($colorList as $objColor) {
// per ogni riga del pesisten object sostituisce il name_tag con il colore letto
$curname_tag = $objColor['name_tag'];
if (count($arrayOriginalColor) > $indiceColore) {
$tmpRow = PatBaseColorFunctions::replaceCssInLine($tmpRow, $arrayOriginalColor[$indiceColore], $curname_tag);
}
$indiceColore++;
}
$newRow .= $tmpRow;
}
// set del colore nel persistent object
$indiceColore = 0;
foreach ($colorList as $objColor) {
$curname_tag = $objColor['name_tag'];
$curId = $objColor['id'];
if (count($arrayOriginalColor) > $indiceColore) {
$simpleObj = Sinetsitecolors_PstObject::fetchById($curId);
$simpleObj->setAttribute('color', $arrayOriginalColor[$indiceColore]);
$simpleObj->store();
}
$indiceColore++;
}
// Scrive il file di destinazione
$fw = fopen($curDestinationFile, 'w');
if (!$fw) {
echo '</b><font color=red>Errore Open W</font></pre>';
} else {
$bytes = fwrite($fw, $newRow);
fclose($fw);
}
fclose($fh);
// echo('</b><font color=red>OK</font></pre>');
}
}
// Prova la pulizia della cache dei template
eZContentCacheManager::clearAllContentCache();
eZContentCacheManager::clearContentCache(2);
//die();
return true;
}
if (preg_match('/(^[^A-Za-z])|\\W/', $sectionIdentifier)) {
$errorMessage = ezpI18n::tr('design/admin/section/edit', 'Identifier should consist of letters, numbers or \'_\' with letter prefix.');
} else {
$conditions = array('identifier' => $sectionIdentifier, 'id' => array('!=', $SectionID));
$existingSection = eZSection::fetchFilteredList($conditions);
if (count($existingSection) > 0) {
$errorMessage = ezpI18n::tr('design/admin/section/edit', 'The identifier has been used in another section.');
}
}
}
$section->setAttribute('identifier', $sectionIdentifier);
$section->setAttribute('navigation_part_identifier', $http->postVariable('NavigationPartIdentifier'));
if ($http->hasPostVariable('Locale')) {
$section->setAttribute('locale', $http->postVariable('Locale'));
}
if ($errorMessage === '') {
$section->store();
eZContentCacheManager::clearContentCacheIfNeededBySectionID($section->attribute('id'));
$Module->redirectTo($Module->functionURI('list'));
return;
} else {
$tpl->setVariable('error_message', $errorMessage);
}
}
if ($http->hasPostVariable('CancelButton')) {
$Module->redirectTo($Module->functionURI('list'));
}
$tpl->setVariable("section", $section);
$Result = array();
$Result['content'] = $tpl->fetch("design:section/edit.tpl");
$Result['path'] = array(array('url' => 'section/list', 'text' => ezpI18n::tr('kernel/section', 'Sections')), array('url' => false, 'text' => $section instanceof eZSection ? $section->attribute('name') : $section['name']));
/**
* Do all time based operations on block pool such as rotation, updating
* the queue, overflow as well as executes fetch interfaces.
*
* @static
*/
public static function update($nodeArray = array())
{
// log in user as anonymous if another user is logged in
$currentUser = eZUser::currentUser();
if ($currentUser->isLoggedIn()) {
$loggedInUser = $currentUser;
$anonymousUserId = eZUser::anonymousId();
$anonymousUser = eZUser::instance($anonymousUserId);
eZUser::setCurrentlyLoggedInUser($anonymousUser, $anonymousUserId);
unset($currentUser, $anonymousUser, $anonymousUserId);
}
include_once 'kernel/classes/ezcontentcache.php';
$ini = eZINI::instance('block.ini');
$db = eZDB::instance();
// Remove the blocks and items for the block if marked for removal
$res = $db->arrayQuery("SELECT id\n FROM ezm_block\n WHERE is_removed=1");
foreach ($res as $row) {
$blockID = $row['id'];
$db->begin();
$db->query("DELETE FROM ezm_pool\n WHERE block_id='{$blockID}'");
$db->query("DELETE FROM ezm_block\n WHERE id='{$blockID}'");
$db->commit();
}
if (!$nodeArray) {
// Update pool and pages for all nodes
$res = $db->arrayQuery("SELECT DISTINCT node_id FROM ezm_block");
foreach ($res as $row) {
$nodeArray[] = $row['node_id'];
}
}
foreach ($nodeArray as $nodeID) {
$time = time() - 5;
// a safety margin
$nodeChanged = false;
$blocks = $db->arrayQuery("SELECT *\n FROM ezm_block\n WHERE node_id={$nodeID}");
$blockByID = array();
// Determine the order of updating
$correctOrder = array();
$next = array();
foreach ($blocks as $block) {
$next[$block['id']] = trim($block['overflow_id']);
// Make sure that block ID does not any have spaces
$blockByID[$block['id']] = $block;
}
$nextIDs = array_keys($next);
foreach ($nextIDs as $id) {
if (in_array($id, $correctOrder, true)) {
continue;
}
if (!$next[$id]) {
$correctOrder[] = $id;
continue;
}
$subCorrectOrder = array($id);
$currentID = $id;
while ($nextID = $next[$currentID]) {
if (!in_array($nextID, $nextIDs, true)) {
eZDebug::writeWarning("Overflow for {$currentID} is {$nextID}, but no such block was found for the given node", __METHOD__);
break;
}
if (in_array($nextID, $subCorrectOrder, true)) {
eZDebug::writeWarning("Loop detected, ignoring ({$nextID} should be after {$currentID} and vice versa)", __METHOD__);
break;
}
if (in_array($nextID, $correctOrder, true)) {
break;
}
$subCorrectOrder[] = $nextID;
$currentID = $nextID;
}
if (!$nextID || !in_array($nextID, $correctOrder, true)) {
foreach ($subCorrectOrder as $element) {
$correctOrder[] = $element;
}
} else {
$newCorrectOrder = array();
foreach ($correctOrder as $element) {
if ($element === $nextID) {
foreach ($subCorrectOrder as $element2) {
$newCorrectOrder[] = $element2;
}
}
$newCorrectOrder[] = $element;
}
$correctOrder = $newCorrectOrder;
}
}
// Loop through all block in determined order
foreach ($correctOrder as $blockID) {
if ($blockByID[$blockID]) {
$block = $blockByID[$blockID];
} else {
continue;
}
// Do we need to update block? No, continue to process next block
$ttl = 0;
if ($ini->hasVariable($block['block_type'], 'TTL')) {
$ttl = $ini->variable($block['block_type'], 'TTL');
}
if ($ttl + $block['last_update'] >= $time) {
continue;
}
// For "rotating blocks", does the rotation_interval has passed from the last update?
if ($block['rotation_type'] != self::ROTATION_NONE && $block['last_update'] + $block['rotation_interval'] >= $time) {
continue;
}
$blockChanged = false;
// Fetch new objects and add them to the queue of the current block
eZFlowOperations::updateBlockPoolByBlockID($block, $time);
$db->begin();
// We need to find out if there are any items to move from the queue
$movingFromQueue = $db->arrayQuery("SELECT object_id\n FROM ezm_pool\n WHERE block_id='{$blockID}'\n AND ts_visible=0\n AND ts_hidden=0\n AND ts_publication<={$time}\n ORDER BY ts_publication ASC, priority ASC");
if ($movingFromQueue) {
$blockChanged = true;
// Find out a number of items in "valid" state and the max. priority used
$countMaxPriorityValid = $db->arrayQuery("SELECT count(*) AS count, max(priority) AS priority\n FROM ezm_pool\n WHERE block_id='{$blockID}'\n AND ts_visible>0\n AND ts_hidden=0");
$countValid = $countMaxPriorityValid[0]['count'];
$maxPriorityValid = $countMaxPriorityValid[0]['priority'];
if ($countValid == 0) {
$maxPriorityValid = 0;
}
$priority = $maxPriorityValid + 1;
// Move objects waiting in queue to the "valid ones"
foreach ($movingFromQueue as $itemToMove) {
$objectID = $itemToMove['object_id'];
$db->query("UPDATE ezm_pool\n SET ts_visible={$time}, priority={$priority}\n WHERE block_id='{$blockID}'\n AND object_id={$objectID}");
$priority++;
}
$countValid += count($movingFromQueue);
// Compare this number to the given and archive the oldest (order by ts_visible)
$numberOfValidItems = $ini->variable($block['block_type'], 'NumberOfValidItems');
if (!$numberOfValidItems) {
$numberOfValidItems = 20;
eZDebug::writeWarning('Number of valid items for ' . $block['block_type'] . ' is not set; using the default value (' . $numberOfValidItems . ')', __METHOD__);
}
$countToRemove = $countValid - $numberOfValidItems;
if ($countToRemove > 0) {
$overflowID = $block['overflow_id'];
$items = $db->arrayQuery("SELECT node_id, object_id, rotation_until\n FROM ezm_pool\n WHERE block_id='{$blockID}'\n AND ts_visible>0\n AND ts_hidden=0\n ORDER BY priority ASC", array('limit' => $countToRemove));
if ($items) {
$itemArray = array();
$priority = 0;
foreach ($items as $item) {
$objectID = $item['object_id'];
if ($block['rotation_type'] != self::ROTATION_NONE && ($item['rotation_until'] > $time || $item['rotation_until'] == 0)) {
if ($block['rotation_type'] == self::ROTATION_SIMPLE) {
// Simple rotation
$newPublicationTS = -$time;
$priority++;
} else {
// Random rotation/Shuffle
$newPublicationTS = 0;
$priority = mt_rand();
}
// Move item back to queue
$db->query("UPDATE ezm_pool\n SET ts_visible=0,\n ts_publication=-{$time},\n priority={$priority}\n WHERE block_id='{$blockID}'\n AND object_id={$objectID}");
} else {
$itemArray[] = $objectID;
}
}
if ($itemArray) {
if ($overflowID) {
// Put $itemArray items into pool of different block
$priority = 0;
foreach ($items as $item) {
$itemObjectID = $item['object_id'];
$itemNodeID = $item['node_id'];
// Check if the object_id is not already in the new block
$duplicityCheck = $db->arrayQuery("SELECT object_id\n FROM ezm_pool\n WHERE block_id='{$overflowID}'\n AND object_id={$itemObjectID}", array('limit' => 1));
if ($duplicityCheck) {
eZDebug::writeNotice("Object {$itemObjectID} is already available in the block {$overflowID}.", __METHOD__);
} else {
$db->query("INSERT INTO ezm_pool(block_id,object_id,node_id,ts_publication,priority)\n VALUES ('{$overflowID}',{$itemObjectID},{$itemNodeID},{$time},{$priority})");
$priority++;
}
}
$db->query("UPDATE ezm_pool\n SET ts_hidden={$time},\n moved_to='{$overflowID}',\n priority=0\n WHERE block_id='{$blockID}'\n AND " . $db->generateSQLINStatement($itemArray, 'object_id'));
} else {
$db->query("UPDATE ezm_pool\n SET ts_hidden={$time},\n priority=0\n WHERE block_id='{$blockID}'\n AND " . $db->generateSQLINStatement($itemArray, 'object_id'));
}
}
}
}
// Cleanup in archived items
$countArchived = $db->arrayQuery("SELECT count(*) AS count\n FROM ezm_pool\n WHERE block_id='{$blockID}'\n AND ts_hidden>0");
$countArchived = $countArchived[0]['count'];
// Compare this number to the given and remove the oldest ones
$numberOfArchivedItems = $ini->variable($block['block_type'], 'NumberOfArchivedItems');
if ($numberOfArchivedItems < 0) {
$numberOfArchivedItems = 50;
eZDebug::writeWarning('Number of archived items for ' . $block['block_type'] . ' is not set; using the default value (' . $numberOfArchivedItems . ')', __METHOD__);
}
$countToRemove = $countArchived - $numberOfArchivedItems;
if ($countToRemove > 0) {
$items = $db->arrayQuery("SELECT object_id\n FROM ezm_pool\n WHERE block_id='{$blockID}'\n AND ts_hidden>0\n ORDER BY ts_hidden ASC", array('limit' => $countToRemove));
if ($items) {
$itemArray = array();
foreach ($items as $item) {
$itemArray[] = $item['object_id'];
}
$db->query("DELETE FROM ezm_pool\n WHERE block_id='{$blockID}'\n AND " . $db->generateSQLINStatement($itemArray, 'object_id'));
}
}
}
// If the block changed, we need to update whole node
if ($blockChanged) {
$nodeChanged = true;
}
$db->commit();
}
if ($nodeChanged) {
$contentObject = eZContentObject::fetchByNodeID($nodeID);
if ($contentObject) {
eZContentCacheManager::clearContentCache($contentObject->attribute('id'));
}
}
}
// log the previously logged in user if it was changed to anonymous earlier
if (isset($loggedInUser)) {
eZUser::setCurrentlyLoggedInUser($loggedInUser, $loggedInUser->attribute('contentobject_id'));
}
}
/**
* Removes the language if there is no object having translation in it.
*
* \return True if the language was removed from the site, false otherwise.
*/
function removeThis()
{
if ($this->objectCount() > 0 or $this->classCount() > 0) {
return false;
}
$this->remove();
eZContentCacheManager::clearAllContentCache();
eZContentLanguage::fetchList(true);
return true;
}
if ($siteINI->hasVariable('FileSettings', 'VarDir')) {
$varDir = $siteINI->variable('FileSettings', 'VarDir');
$cacheDir = eZDir::path(array($varDir, $cacheDir));
}
}
} else {
if ($siteINI->hasVariable('FileSettings', 'VarDir')) {
$varDir = $siteINI->variable('FileSettings', 'VarDir');
$cacheDir = $ini->variable('FileSettings', 'CacheDir');
$cacheDir = eZDir::path(array($varDir, $cacheDir));
} else {
$cacheDir = eZSys::cacheDirectory();
}
}
$compiledTemplateDir = $cacheDir . "/template/compiled";
eZDir::unlinkWildcard($compiledTemplateDir . "/", "*pagelayout*.*");
// Expire template block cache
eZContentCacheManager::clearTemplateBlockCacheIfNeeded(false);
}
$availableMenuArray = $menuINI->variable('MenuSettings', 'AvailableMenuArray');
$menuArray = array();
foreach ($availableMenuArray as $menuType) {
$menuArray[] = array('type' => $menuType, 'settings' => $menuINI->group($menuType));
}
$tpl->setVariable('available_menu_array', $menuArray);
$tpl->setVariable('current_menu', $menuINI->variable('SelectedMenu', 'CurrentMenu'));
$tpl->setVariable('siteaccess_list', $siteAccessList);
$tpl->setVariable('current_siteaccess', $siteAccess);
$Result = array();
$Result['content'] = $tpl->fetch("design:visual/menuconfig.tpl");
$Result['path'] = array(array('url' => false, 'text' => ezpI18n::tr('design/standard/menuconfig', 'Menu management')));
/**
* Activate user with user or deactivate and create new eZUserAccountKey with user hash
* depending on $enableUser being true or not.
*
* @param int $userID
* @param string $userHash
* @param bool $enableUser
*
* @return array An array with operation status, always true if userID is ok
*/
public static function activation($userID, $userHash, $enableUser = false)
{
$user = eZUser::fetch($userID);
$userSetting = eZUserSetting::fetch($userID);
if ($user && $userSetting) {
$userChange = $userSetting->attribute('is_enabled') != $enableUser;
if ($enableUser) {
$userSetting->setAttribute('is_enabled', 1);
$userSetting->store();
eZUserAccountKey::removeByUserID($userID);
} else {
$userSetting->setAttribute('is_enabled', 0);
$userSetting->store();
$accountKey = eZUserAccountKey::createNew($userID, $userHash, time());
$accountKey->store();
}
if ($userChange) {
if (!$enableUser) {
eZUser::removeSessionData($userID);
}
eZContentCacheManager::clearContentCacheIfNeeded($userID);
}
return array('status' => true);
} else {
eZDebug::writeError("Failed to activate user {$userID} (could not fetch)", __METHOD__);
return array('status' => false);
}
}
/**
* Fixes reverse relations
*
* @see eZObjectRelationListType::fixRelatedObjectItem()
*
* @param int $objectID
* @param string|bool $mode See eZObjectRelationListType::fixRelatedObjectItem() for valid modes
*/
static function fixReverseRelations( $objectID, $mode = false )
{
$db = eZDB::instance();
$objectID = (int) $objectID;
// Finds all the attributes that store relations to the given object.
$result = $db->arrayQuery( "SELECT attr.*
FROM ezcontentobject_link link,
ezcontentobject_attribute attr
WHERE link.from_contentobject_id=attr.contentobject_id AND
link.from_contentobject_version=attr.version AND
link.contentclassattribute_id=attr.contentclassattribute_id AND
link.to_contentobject_id=$objectID" );
if ( count( $result ) > 0 )
{
$objectIDList = array();
foreach( $result as $row )
{
$attr = new eZContentObjectAttribute( $row );
$dataType = $attr->dataType();
$dataType->fixRelatedObjectItem( $attr, $objectID, $mode );
$objectIDList[] = $attr->attribute( 'contentobject_id' );
}
if ( eZINI::instance()->variable( 'ContentSettings', 'ViewCaching' ) === 'enabled' )
eZContentCacheManager::clearObjectViewCacheArray( $objectIDList );
}
}
/**
* Stores the current class as a modified version, updates the contentobject_name
* attribute and recreates the class group entries.
*
* @note It will remove classes in the previous and specified version before storing.
*
* @param array $attributes array of attributes
* @param int $version version status
* @since Version 4.3
*/
public function storeVersioned($attributes, $version)
{
$previousVersion = $this->attribute('version');
$db = eZDB::instance();
$db->begin();
// Before removing anything from the attributes, load attribute information
// which might otherwise not accessible when recreating them below.
// See issue #18164
foreach ($attributes as $attribute) {
$attribute->content();
}
$this->removeAttributes(false, $version);
$this->removeAttributes(false, $previousVersion);
$this->remove(false);
$this->setVersion($version, $attributes);
$this->setAttribute("modifier_id", eZUser::currentUser()->attribute("contentobject_id"));
$this->setAttribute("modified", time());
$this->adjustAttributePlacements($attributes);
foreach ($attributes as $attribute) {
$attribute->storeVersioned($version);
}
// Set contentobject_name to something sensible if it is missing
if (count($attributes) > 0 && trim($this->attribute('contentobject_name')) == '') {
$this->setAttribute('contentobject_name', '<' . $attributes[0]->attribute('identifier') . '>');
}
// Recreate class member entries
eZContentClassClassGroup::removeClassMembers($this->ID, $version);
foreach (eZContentClassClassGroup::fetchGroupList($this->ID, $previousVersion) as $classgroup) {
$classgroup->setAttribute('contentclass_version', $version);
$classgroup->store();
}
eZContentClassClassGroup::removeClassMembers($this->ID, $previousVersion);
eZExpiryHandler::registerShutdownFunction();
$handler = eZExpiryHandler::instance();
$time = time();
$handler->setTimestamp('user-class-cache', $time);
$handler->setTimestamp('class-identifier-cache', $time);
$handler->setTimestamp('sort-key-cache', $time);
$handler->store();
eZContentCacheManager::clearAllContentCache();
$this->setAttribute('serialized_name_list', $this->NameList->serializeNames());
$this->setAttribute('serialized_description_list', $this->DescriptionList->serializeNames());
eZPersistentObject::store();
$this->NameList->store($this);
$db->commit();
}
return $Module->handleError(eZError::KERNEL_ACCESS_DENIED, 'kernel');
}
}
if ($http->hasPostVariable('ConfirmRemoveSectionButton')) {
$currentUser = eZUser::currentUser();
$accessResult = $currentUser->hasAccessTo('section', 'edit');
if ($accessResult['accessWord'] == 'yes') {
if ($http->hasSessionVariable('SectionIDArray')) {
$sectionIDArray = $http->sessionVariable('SectionIDArray');
$db = eZDB::instance();
$db->begin();
foreach ($sectionIDArray as $sectionID) {
$section = eZSection::fetch($sectionID);
if (is_object($section) and $section->canBeRemoved()) {
// Clear content cache if needed
eZContentCacheManager::clearContentCacheIfNeededBySectionID($sectionID);
$section->remove();
}
}
$db->commit();
}
} else {
return $Module->handleError(eZError::KERNEL_ACCESS_DENIED, 'kernel');
}
}
$viewParameters = array('offset' => $offset);
$sectionArray = eZSection::fetchByOffset($offset, $limit);
$sectionCount = eZSection::sectionCount();
$currentUser = eZUser::currentUser();
$allowedAssignSectionList = $currentUser->canAssignSectionList();
$tpl->setVariable("limit", $limit);
eZDebug::writeError("Missing NodeID parameter for action " . $module->currentAction(), 'content/action');
return $module->redirectToView('view', array('full', 2));
}
$objectID = $module->actionParameter('ObjectID');
$nodeID = $module->actionParameter('NodeID');
$object = eZContentObject::fetch($objectID);
if (!$object) {
return $module->handleError(eZError::KERNEL_NOT_AVAILABLE, 'kernel');
}
$user = eZUser::currentUser();
$result = $user->hasAccessTo('setup', 'managecache');
if ($result['accessWord'] != 'yes') {
return $module->handleError(eZError::KERNEL_ACCESS_DENIED, 'kernel');
}
if ($module->isCurrentAction('ClearViewCache')) {
eZContentCacheManager::clearContentCacheIfNeeded($objectID);
} else {
$node = eZContentObjectTreeNode::fetch($nodeID);
if (!$node) {
return $module->handleError(eZError::KERNEL_NOT_AVAILABLE, 'kernel');
}
eZContentObjectTreeNode::clearViewCacheForSubtree($node);
}
if ($module->hasActionParameter('CurrentURL')) {
$currentURL = $module->actionParameter('CurrentURL');
return $module->redirectTo($currentURL);
}
return $module->redirectToView('view', array($viewMode, $nodeID, $languageCode));
} else {
if ($module->isCurrentAction('UploadFile')) {
if (!$module->hasActionParameter('UploadActionName')) {
* @license http://www.gnu.org/licenses/gpl-2.0.txt GNU General Public License v2
* @version 2012.8
* @package kernel
*/
// Check for extension
require_once 'kernel/common/ezincludefunctions.php';
eZExtension::activateExtensions();
// Extension check end
$ini = eZINI::instance('content.ini');
$unpublishClasses = $ini->variable('UnpublishSettings', 'ClassList');
$rootNodeIDList = $ini->variable('UnpublishSettings', 'RootNodeList');
$currentDate = time();
foreach ($rootNodeIDList as $nodeID) {
$rootNode = eZContentObjectTreeNode::fetch($nodeID);
$articleNodeArray = $rootNode->subTree(array('ClassFilterType' => 'include', 'ClassFilterArray' => $unpublishClasses));
foreach ($articleNodeArray as $articleNode) {
$article = $articleNode->attribute('object');
$dataMap = $article->attribute('data_map');
$dateAttribute = $dataMap['unpublish_date'];
if ($dateAttribute === null) {
continue;
}
$date = $dateAttribute->content();
$articleRetractDate = $date->attribute('timestamp');
if ($articleRetractDate > 0 && $articleRetractDate < $currentDate) {
// Clean up content cache
eZContentCacheManager::clearContentCacheIfNeeded($article->attribute('id'));
$article->removeThis($articleNode->attribute('node_id'));
}
}
}
/**
* Removes a RSS/ATOM Feed export for a node
*
* @param int $nodeID Node ID
*
* @since 4.3
*/
public static function removeFeedForNode($nodeID)
{
$rssExport = eZPersistentObject::fetchObject(eZRSSExport::definition(), null, array('node_id' => $nodeID, 'status' => eZRSSExport::STATUS_VALID), true);
if (!$rssExport instanceof eZRSSExport) {
eZDebug::writeError('DisableRSS: There is no rss/atom feeds left to delete for this node: ' . $nodeID, __METHOD__);
return array('status' => false);
}
$node = eZContentObjectTreeNode::fetch($nodeID);
if (!$node instanceof eZContentObjectTreeNode) {
eZDebug::writeError('DisableRSS: Could not fetch node: ' . $nodeID, __METHOD__);
return array('status' => false);
}
$objectID = $node->attribute('contentobject_id');
$rssExport->removeThis();
eZContentCacheManager::clearContentCacheIfNeeded($objectID);
return array('status' => true);
}
/**
* Rate content object attribute id
*
* @param array $args ( 0 => contentobjectattribute_id, 1 => contentobject_version, 2 => rating )
* @return array
*/
public static function rate( $args )
{
$ret = array( 'id' => 0, 'rated' => false, 'already_rated' => false, 'stats' => false );
if ( !isset( $args[2] ) )
throw new LengthException( 'Rating expects 3 arguments: attr_id, version, rating' );
else if ( !is_numeric( $args[0] ) )
throw new InvalidArgumentException( 'Rating argument[0] attr_id must be a number' );
else if ( !is_numeric( $args[1] ) )
throw new InvalidArgumentException( 'Rating argument[1] version must be a number' );
else if ( !is_numeric( $args[2] ) )
throw new InvalidArgumentException( 'Rating argument[2] rating must be a number' );
else if ( $args[2] > 5 || $args[2] < 1 )
throw new UnexpectedValueException( 'Rating argument[2] rating must be between 1 and 5' );
$ret['id'] = (int) $args[0];
// Provide extra session protection on 4.1 (not possible on 4.0) by expecting user
// to have an existing session (new session = mostlikely a spammer / hacker trying to manipulate rating)
if (
eZSession::userHasSessionCookie() !== true
&& eZINI::instance()->variable( 'eZStarRating', 'AllowAnonymousRating' ) === 'disabled'
)
return $ret;
// Return if parameters are not valid attribute id + version numbers
$contentobjectAttribute = eZContentObjectAttribute::fetch( $ret['id'], $args[1] );
if ( !$contentobjectAttribute instanceof eZContentObjectAttribute )
return $ret;
// Return if attribute is not a rating attribute
if ( $contentobjectAttribute->attribute('data_type_string') !== ezsrRatingType::DATA_TYPE_STRING )
return $ret;
// Return if rating has been disabled on current attribute
if ( $contentobjectAttribute->attribute('data_int') )
return $ret;
// Return if user does not have access to object
$contentobject = $contentobjectAttribute->attribute('object');
if ( !$contentobject instanceof eZContentObject || !$contentobject->attribute('can_read') )
return $ret;
$rateDataObj = ezsrRatingDataObject::create( array( 'contentobject_id' => $contentobjectAttribute->attribute('contentobject_id'),
'contentobject_attribute_id' => $ret['id'],
'rating' => $args[2]
));
$proiorRating = $rateDataObj->userHasRated( true );
if ( $proiorRating === true )
{
$ret['already_rated'] = true;
}
else if ( $proiorRating instanceof ezsrRatingDataObject )
{
$rateDataObj = $proiorRating;
$rateDataObj->setAttribute( 'rating', $args[2] );
$ret['already_rated'] = true;
$proiorRating = false;// just to reuse code bellow
}
if ( !$proiorRating )
{
$rateDataObj->store();
$avgRateObj = $rateDataObj->getAverageRating();
$avgRateObj->updateFromRatingData();
$avgRateObj->store();
eZContentCacheManager::clearContentCacheIfNeeded( $rateDataObj->attribute('contentobject_id') );
$ret['rated'] = true;
$ret['stats'] = array(
'rating_count' => $avgRateObj->attribute('rating_count'),
'rating_average' => $avgRateObj->attribute('rating_average'),
'rounded_average' => $avgRateObj->attribute('rounded_average'),
);
}
return $ret;
}
}
$db->commit();
// because we changed users, we have to remove content cache
eZContentCacheManager::clearAllContentCache();
}
if ($http->hasPostVariable("RemoveCustomerButton")) {
if ($http->hasPostVariable("CustomerIDArray")) {
$customerIDArray = $http->postVariable("CustomerIDArray");
$db = eZDB::instance();
$db->begin();
foreach ($customerIDArray as $customerID) {
eZUserDiscountRule::removeUser($customerID);
}
$db->commit();
}
eZContentCacheManager::clearAllContentCache();
}
$membershipList = eZUserDiscountRule::fetchByRuleID($discountGroupID);
$customers = array();
foreach ($membershipList as $membership) {
$customers[] = eZContentObject::fetch($membership->attribute('contentobject_id'));
}
$ruleList = eZDiscountSubRule::fetchByRuleID($discountGroupID);
$ruleArray = array();
foreach ($ruleList as $rule) {
$name = $rule->attribute('name');
$percent = $rule->attribute('discount_percent');
$limitation = $rule->attribute('limitation');
$discountRuleID = $rule->attribute('id');
if ($limitation != '*') {
$ruleValues = eZDiscountSubRuleValue::fetchBySubRuleID($discountRuleID);
function runOperation(&$node)
{
$datamap = $node->dataMap();
$object_attribute = $datamap[$this->attribute];
if (!isset($object_attribute)) {
echo "Attribute '{$this->attribute}' not found. ";
return false;
}
$old_value = $object_attribute->toString();
// Set new value to specified attributes
$arg_array = $this->arguments;
foreach ($datamap as $key => $object_attribute) {
$value = $object_attribute->toString();
$arg_array = str_replace('{' . $key . '}', $value, $arg_array);
}
$new_value = call_user_func_array($this->change_function, $arg_array);
if ($new_value == $old_value) {
// Nothing to change
return true;
}
$db = eZDB::instance();
$db->begin();
// Create new version
$content_object = $node->object();
$content_object_id = $content_object->attribute('id');
$version = $content_object->createNewVersion();
$version->setAttribute('modified', time());
$version->setAttribute('status', 'EZ_VERSION_STATUS_DRAFT');
$version->store();
$datamap = $version->dataMap();
$object_attribute = $datamap[$this->attribute];
$object_attribute->fromString($new_value);
$object_attribute->store();
// Publish new version
$operation_result = eZOperationHandler::execute('content', 'publish', array('object_id' => $content_object_id, 'version' => $version->attribute('version')));
$db->commit();
eZContentCacheManager::clearObjectViewCache($content_object_id);
return $operation_result['status'] == 1;
}
