/**
* Test that new instance does not inherit events
* (when not reading from ini settings)
*/
public function testNewInstance()
{
$event = new ezpEvent(false);
// test filter
$this->assertEquals(null, $event->filter('test/filter', null));
// test notify
$this->assertFalse($event->notify('test/notify'));
}
/**
* @deprecated Since 5.0
* @param string|null $templateResult
*/
function eZDisplayResult($templateResult)
{
ob_start();
if ($templateResult !== null) {
$classname = eZINI::instance()->variable("OutputSettings", "OutputFilterName");
//deprecated
if (!empty($classname) && class_exists($classname)) {
$templateResult = call_user_func(array($classname, 'filter'), $templateResult);
}
$templateResult = ezpEvent::getInstance()->filter('response/preoutput', $templateResult);
$debugMarker = '<!--DEBUG_REPORT-->';
$pos = strpos($templateResult, $debugMarker);
if ($pos !== false) {
$debugMarkerLength = strlen($debugMarker);
echo substr($templateResult, 0, $pos);
eZDisplayDebug();
echo substr($templateResult, $pos + $debugMarkerLength);
} else {
echo $templateResult, eZDisplayDebug();
}
} else {
eZDisplayDebug();
}
echo ezpEvent::getInstance()->filter('response/output', ob_get_clean());
}
public function gc($maxLifeTime)
{
ezpEvent::getInstance()->notify('session/gc', array($maxLifeTime));
$db = eZDB::instance();
eZSession::triggerCallback('gc_pre', array($db, $maxLifeTime));
$sfHandler = $this->storage->getSaveHandler();
if (method_exists($sfHandler, 'gc')) {
$sfHandler->gc($maxLifeTime);
}
eZSession::triggerCallback('gc_post', array($db, $maxLifeTime));
return false;
}
function trashStoredObjectAttribute($contentObjectAttribute, $version = null)
{
$imageHandler = $contentObjectAttribute->attribute("content");
$originalAlias = $imageHandler->imageAlias("original");
// check if there is an actual image, 'is_valid' says if there is an image or not
if ($originalAlias['is_valid'] != '1' && empty($originalAlias['filename'])) {
return;
}
$basenameHashed = md5($originalAlias["basename"]);
$trashedFolder = "{$originalAlias["dirpath"]}/trashed";
$imageHandler->updateAliasPath($trashedFolder, $basenameHashed);
if ($imageHandler->isStorageRequired()) {
$imageHandler->store($contentObjectAttribute);
$contentObjectAttribute->store();
}
// Now clean all other aliases, not cleanly registered within the attribute content
// First get all remaining aliases full path to then safely move them to the trashed folder
ezpEvent::getInstance()->notify('image/trashAliases', array($originalAlias['url']));
$aliasNames = array_keys($imageHandler->aliasList());
$aliasesPath = array();
foreach ($aliasNames as $aliasName) {
if ($aliasName === "original") {
continue;
}
$aliasesPath[] = "{$originalAlias["dirpath"]}/{$originalAlias["basename"]}_{$aliasName}.{$originalAlias["suffix"]}";
}
if (empty($aliasesPath)) {
return;
}
$conds = array("contentobject_attribute_id" => $contentObjectAttribute->attribute("id"), "filepath" => array($aliasesPath));
$remainingAliases = eZPersistentObject::fetchObjectList(eZImageFile::definition(), null, $conds);
unset($conds, $remainingAliasesPath);
if (!empty($remainingAliases)) {
foreach ($remainingAliases as $remainingAlias) {
$filename = basename($remainingAlias->attribute("filepath"));
$newFilePath = $trashedFolder . "/" . $basenameHashed . substr($filename, strrpos($filename, '_'));
eZClusterFileHandler::instance($remainingAlias->attribute("filepath"))->move($newFilePath);
// $newFilePath might have already been processed in eZImageFile
// If so, $remainingAlias is a duplicate. We can then remove it safely
$imageFile = eZImageFile::fetchByFilepath(false, $newFilePath, false);
if (empty($imageFile)) {
$remainingAlias->setAttribute("filepath", $newFilePath);
$remainingAlias->store();
} else {
$remainingAlias->remove();
}
}
}
}
public function __construct()
{
$this->eventHandler = ezpEvent::getInstance();
$fileINI = eZINI::instance('file.ini');
$this->maxCopyTries = (int) $fileINI->variable('eZDFSClusteringSettings', 'MaxCopyRetries');
if (defined('CLUSTER_METADATA_TABLE_CACHE')) {
$this->metaDataTableCache = CLUSTER_METADATA_TABLE_CACHE;
} else {
if ($fileINI->hasVariable('eZDFSClusteringSettings', 'MetaDataTableNameCache')) {
$this->metaDataTableCache = $fileINI->variable('eZDFSClusteringSettings', 'MetaDataTableNameCache');
}
}
$this->cacheDir = eZINI::instance('site.ini')->variable('FileSettings', 'CacheDir');
$this->storageDir = eZINI::instance('site.ini')->variable('FileSettings', 'StorageDir');
}
/**
* @deprecated Since 5.0
* @param string|null $templateResult
*/
function eZDisplayResult($templateResult)
{
ob_start();
if ($templateResult !== null) {
$templateResult = ezpEvent::getInstance()->filter('response/preoutput', $templateResult);
$debugMarker = '<!--DEBUG_REPORT-->';
$pos = strpos($templateResult, $debugMarker);
if ($pos !== false) {
$debugMarkerLength = strlen($debugMarker);
echo substr($templateResult, 0, $pos);
eZDisplayDebug();
echo substr($templateResult, $pos + $debugMarkerLength);
} else {
echo $templateResult, eZDisplayDebug();
}
} else {
eZDisplayDebug();
}
echo ezpEvent::getInstance()->filter('response/output', ob_get_clean());
}
/**
* Creates the image alias $aliasName if it's not already part of the
* existing aliases
*
* @param string $aliasName Name of the alias to create
* @param array $existingAliasList
* Reference to the current alias list. The created alias will be
* added to the list.
* @param array $parameters
* Optional array that can be used to specify the image's basename
* @return bool true if the alias was created, false if it wasn't
*/
function createImageAlias( $aliasName, &$existingAliasList, $parameters = array() )
{
$fname = "createImageAlias( $aliasName )";
// check for $aliasName validity
$aliasList = $this->aliasList();
if ( !isset( $aliasList[$aliasName] ) )
{
eZDebug::writeWarning( "Alias name $aliasName does not exist, cannot create it" );
return false;
}
// check if the reference alias is defined, and if no, use original as ref
$currentAliasInfo = $aliasList[$aliasName];
$referenceAlias = $currentAliasInfo['reference'];
if ( $referenceAlias and !$this->hasAlias( $referenceAlias ) )
{
eZDebug::writeError( "The referenced alias '$referenceAlias' for image alias '$aliasName' does not exist, cannot use it for reference.\n" .
"Will use 'original' alias instead.",
__METHOD__ );
$referenceAlias = false;
}
if ( !$referenceAlias )
$referenceAlias = 'original';
// generate the reference alias if it hasn't been generated yet
$hasReference = false;
if ( array_key_exists( $referenceAlias, $existingAliasList ) )
{
$fileHandler = eZClusterFileHandler::instance();
if ( $fileHandler->fileExists( $existingAliasList[$referenceAlias]['url'] ) )
{
$hasReference = true;
}
else
{
eZDebug::writeError( "The reference alias $referenceAlias file {$existingAliasList[$referenceAlias]['url']} does not exist", __METHOD__ );
}
}
if ( !$hasReference )
{
if ( $referenceAlias == 'original' )
{
eZDebug::writeError( "Original alias does not exist, cannot create other aliases without it" );
return false;
}
if ( !$this->createImageAlias( $referenceAlias, $existingAliasList, $parameters ) )
{
eZDebug::writeError( "Failed creating the referenced alias $referenceAlias, cannot create alias $aliasName", __METHOD__ );
return false;
}
}
// from now on, our reference image (either reference or original)
// exists
$aliasInfo = $existingAliasList[$referenceAlias];
$aliasFilePath = $aliasInfo['url'];
$aliasKey = $currentAliasInfo['alias_key'];
$sourceMimeData = eZMimeType::findByFileContents( $aliasFilePath );
/**
* at first, destinationMimeData (mimedata for the alias we're
* generating) is the same as sourceMimeData. It will evolve as
* alias generation goes on
*/
$destinationMimeData = $sourceMimeData;
if ( isset( $parameters['basename'] ) )
{
$sourceMimeData['basename'] = $parameters['basename'];
eZMimeType::changeBasename( $destinationMimeData, $parameters['basename'] );
}
/**
* Concurrency protection
* startCacheGeneration will return true if the file is not
* already being generated by another process. If it is, it will
* return the maximum time before the generating process enters
* generation timeout
*/
while ( true )
{
$convertHandler = eZClusterFileHandler::instance( $sourceMimeData['url'] );
$startGeneration = $convertHandler->startCacheGeneration();
if ( $startGeneration === true )
{
$destinationMimeData['is_valid'] = false;
if ( $this->convert( $sourceMimeData, $destinationMimeData, $aliasName, $parameters ) )
{
/**
* At this point, we consider that the image exists and destinationMimeData
* has been filled with the proper information
*
* If we were locked during alias generation, we need to recreate
* this structure so that the image can actually be used, but ONLY
* if it was the same alias... sounds like a HUGE mess.
*
* Can we reload the alias list somehow ?
*/
$currentAliasData = array( 'url' => $destinationMimeData['url'],
'dirpath' => $destinationMimeData['dirpath'],
'filename' => $destinationMimeData['filename'],
'suffix' => $destinationMimeData['suffix'],
'basename' => $destinationMimeData['basename'],
'alternative_text' => $aliasInfo['alternative_text'],
'name' => $aliasName,
'sub_type' => false,
'timestamp' => time(),
'alias_key' => $aliasKey,
'mime_type' => $destinationMimeData['name'],
'override_mime_type' => false,
'info' => false,
'width' => false,
'height' => false,
'is_valid' => true,
'is_new' => true );
if ( isset( $destinationMimeData['override_mime_type'] ) )
$currentAliasData['override_mime_type'] = $destinationMimeData['override_mime_type'];
if ( isset( $destinationMimeData['info'] ) )
$currentAliasData['info'] = $destinationMimeData['info'];
$currentAliasData['full_path'] = $currentAliasData['url'];
if ( function_exists( 'getimagesize' ) )
{
/**
* we may want to fetch a unique name here, since we won't use
* the data for anything else
*/
$fileHandler = eZClusterFileHandler::instance( $destinationMimeData['url'] );
if ( $tempPath = $fileHandler->fetchUnique() )
{
$info = getimagesize( $tempPath );
if ( $info )
{
list( $currentAliasData['width'], $currentAliasData['height'] ) = $info;
}
else
{
eZDebug::writeError("The size of the generated image {$destinationMimeData['url']} could not be read by getimagesize()", __METHOD__ );
}
$fileHandler->fileDeleteLocal( $tempPath );
}
else
{
eZDebug::writeError( "The destination image {$destinationMimeData['url']} does not exist, cannot figure out image size", __METHOD__ );
}
}
else
{
eZDebug::writeError( "Unknown function 'getimagesize', cannot get image size", __METHOD__ );
}
$existingAliasList[$aliasName] = $currentAliasData;
$convertHandler->endCacheGeneration( false );
// Notify about image alias generation. Parameters are alias
// url and alias name.
ezpEvent::getInstance()->notify( 'image/alias', array( $currentAliasData['url'],
$currentAliasData['name'] ) );
return true;
}
// conversion failed, we abort generation
else
{
$sourceFile = $sourceMimeData['url'];
$destinationDir = $destinationMimeData['dirpath'];
eZDebug::writeError( "Failed converting $sourceFile to alias '$aliasName' in directory '$destinationDir'", __METHOD__ );
$convertHandler->abortCacheGeneration();
return false;
}
}
// we were not granted file generation (someone else is doing it)
// we wait for max. $remainingGenerationTime and check if the
// file has been generated in between
// Actually, we have no clue if the generated file was the one we were
// looking for, and it doesn't seem possible to RELOAD the alias list.
// We don't even know what attribute we're using... CRAP
else
{
eZDebug::writeDebug( "An alias is already being generated for this image, let's wait", __METHOD__ );
while ( true )
{
$startGeneration = $convertHandler->startCacheGeneration();
// generation lock granted: we can start again by breaking to
// the beggining of the while loop
if ( $startGeneration === true )
{
eZDebug::writeDebug( "Got granted generation permission, restarting !", __METHOD__ );
$convertHandler->abortCacheGeneration();
continue 2;
}
else
{
sleep( 1 );
}
}
}
}
return false;
}
public function __construct()
{
$this->eventHandler = ezpEvent::getInstance();
}
/**
* Remove all session data (Truncate table)
*
* @return bool
*/
public function cleanup()
{
ezpEvent::getInstance()->notify( 'session/cleanup', array() );
$db = eZDB::instance();
eZSession::triggerCallback( 'cleanup_pre', array( $db ) );
$db->query( 'TRUNCATE TABLE ezsession' );
eZSession::triggerCallback( 'cleanup_post', array( $db ) );
return true;
}
$tag->setAttribute('parent_id', $newParentID);
$tag->store();
if (!$newParentTag instanceof eZTagsObject) {
$newParentTag = false;
}
if ($updatePathString) {
$tag->updatePathString($newParentTag);
}
if ($updateDepth) {
$tag->updateDepth($newParentTag);
}
$tag->updateModified();
$tag->registerSearchObjects();
/* Extended Hook */
if (class_exists('ezpEvent', false)) {
$tag = ezpEvent::getInstance()->filter('tag/edit', $tag);
}
$db->commit();
return $Module->redirectToView('id', array($tagID));
}
}
$tpl = eZTemplate::factory();
$tpl->setVariable('tag', $tag);
$tpl->setVariable('warning', $warning);
$tpl->setVariable('error', $error);
$Result = array();
$Result['content'] = $tpl->fetch('design:tags/edit.tpl');
$Result['ui_context'] = 'edit';
$Result['path'] = array();
$tempTag = $tag;
while ($tempTag->hasParent()) {
/**
* Clears all state limitation cache files.
*/
static function clearStateLimitations($cacheItem)
{
$cachePath = eZSys::cacheDirectory();
$fileHandler = eZClusterFileHandler::instance();
$fileHandler->fileDelete($cachePath, 'statelimitations_');
ezpEvent::getInstance()->notify('content/state/cache/all');
}
if ( $Month )
$Month = (int) $Month;
if ( $Day )
$Day = (int) $Day;
$NodeID = (int) $NodeID;
if ( $NodeID < 2 )
{
return $Module->handleError( eZError::KERNEL_NOT_FOUND, 'kernel' );
}
$ini = eZINI::instance();
// Be able to filter node id for general use
$NodeID = ezpEvent::getInstance()->filter( 'content/view', $NodeID, $ini );
$testingHandler = new ezpMultivariateTest( ezpMultivariateTest::getHandler() );
if ( $testingHandler->isEnabled() )
$NodeID = $testingHandler->execute( $NodeID );
$viewCacheEnabled = ( $ini->variable( 'ContentSettings', 'ViewCaching' ) == 'enabled' );
if ( isset( $Params['ViewCache'] ) )
{
$viewCacheEnabled = $Params['ViewCache'];
}
elseif ( $viewCacheEnabled && !in_array( $ViewMode, $ini->variableArray( 'ContentSettings', 'CachedViewModes' ) ) )
{
$viewCacheEnabled = false;
return $Module->redirectToView('dashboard', array());
} else {
if ($http->hasPostVariable('YesButton')) {
$db = eZDB::instance();
foreach ($tagsList as $tag) {
if ($tag->getSubTreeLimitationsCount() > 0 || $tag->attribute('main_tag_id') != 0) {
continue;
}
$db->begin();
$parentTag = $tag->getParent(true);
if ($parentTag instanceof eZTagsObject) {
$parentTag->updateModified();
}
/* Extended Hook */
if (class_exists('ezpEvent', false)) {
ezpEvent::getInstance()->filter('tag/delete', $tag);
}
$tag->recursivelyDeleteTag();
$db->commit();
}
$http->removeSessionVariable('eZTagsDeleteIDArray');
if ($parentTagID > 0) {
return $Module->redirectToView('id', array($parentTagID));
}
return $Module->redirectToView('dashboard', array());
}
}
$tpl = eZTemplate::factory();
$tpl->setVariable('tags', $tagsList);
$Result = array();
$Result['content'] = $tpl->fetch('design:tags/deletetags.tpl');
static function clearObjectViewCache($objectID, $versionNum = true, $additionalNodeList = false)
{
eZDebug::accumulatorStart('node_cleanup_list', '', 'Node cleanup list');
$nodeList = eZContentCacheManager::nodeList($objectID, $versionNum);
if ($nodeList === false and !is_array($additionalNodeList)) {
return false;
}
if ($nodeList === false) {
$nodeList = array();
}
if (is_array($additionalNodeList)) {
array_splice($nodeList, count($nodeList), 0, $additionalNodeList);
}
if (count($nodeList) == 0) {
return false;
}
$nodeList = array_unique($nodeList);
eZDebug::accumulatorStop('node_cleanup_list');
eZDebugSetting::writeDebug('kernel-content-edit', count($nodeList), "count in nodeList");
$ini = eZINI::instance();
if ($ini->variable('ContentSettings', 'StaticCache') == 'enabled') {
$optionArray = array('iniFile' => 'site.ini', 'iniSection' => 'ContentSettings', 'iniVariable' => 'StaticCacheHandler');
$options = new ezpExtensionOptions($optionArray);
$staticCacheHandler = eZExtension::getHandlerClass($options);
$staticCacheHandler->generateAlwaysUpdatedCache();
$staticCacheHandler->generateNodeListCache($nodeList);
}
eZDebug::accumulatorStart('node_cleanup', '', 'Node cleanup');
$nodeList = ezpEvent::getInstance()->filter('content/cache', $nodeList);
eZContentObject::expireComplexViewModeCache();
$cleanupValue = eZContentCache::calculateCleanupValue(count($nodeList));
if (eZContentCache::inCleanupThresholdRange($cleanupValue)) {
eZContentCache::cleanup($nodeList);
} else {
eZDebug::writeDebug("Expiring all view cache since list of nodes({$cleanupValue}) related to object({$objectID}) exeeds site.ini\\[ContentSettings]\\CacheThreshold", __METHOD__);
eZContentObject::expireAllViewCache();
}
eZDebug::accumulatorStop('node_cleanup');
return true;
}
}
if ($http->hasPostVariable("ConfirmButton")) {
foreach ($deleteIDArray as $deleteID) {
eZContentClassGroup::removeSelected($deleteID);
eZContentClassClassGroup::removeGroupMembers($deleteID);
foreach ($deleteClassIDList as $deleteClassID) {
$deleteClass = eZContentClass::fetch($deleteClassID);
if ($deleteClass) {
$deleteClass->remove(true);
}
$deleteClass = eZContentClass::fetch($deleteClassID, true, eZContentClass::VERSION_STATUS_TEMPORARY);
if ($deleteClass) {
$deleteClass->remove(true);
}
ezpEvent::getInstance()->notify('content/class/cache', array($deleteClassID));
}
ezpEvent::getInstance()->notify('content/class/group/cache', array($deleteID));
}
$Module->redirectTo('/class/grouplist/');
}
if ($http->hasPostVariable("CancelButton")) {
$Module->redirectTo('/class/grouplist/');
}
$Module->setTitle(ezpI18n::tr('kernel/class', 'Remove class groups') . ' ' . $GroupName);
$tpl = eZTemplate::factory();
$tpl->setVariable("DeleteResult", $deleteResult);
$tpl->setVariable("module", $Module);
$tpl->setVariable("groups_info", $groupsInfo);
$Result = array();
$Result['content'] = $tpl->fetch("design:class/removegroup.tpl");
$Result['path'] = array(array('url' => '/class/grouplist/', 'text' => ezpI18n::tr('kernel/class', 'Class groups')), array('url' => false, 'text' => ezpI18n::tr('kernel/class', 'Remove class groups')));
if (!$mainTag instanceof eZTagsObject) {
$error = ezpI18n::tr('extension/eztags/errors', 'Selected target tag is invalid.');
}
if (empty($error)) {
$db = eZDB::instance();
$db->begin();
$oldParentTag = false;
if ($tag->attribute('parent_id') != $mainTag->attribute('parent_id')) {
$oldParentTag = $tag->getParent(true);
if ($oldParentTag instanceof eZTagsObject) {
$oldParentTag->updateModified();
}
}
/* Extended Hook */
if (class_exists('ezpEvent', false)) {
ezpEvent::getInstance()->filter('tag/merge', array('tag' => $tag, 'newParentTag' => $mainTag, 'oldParentTag' => $oldParentTag));
}
$tag->moveChildrenBelowAnotherTag($mainTag);
foreach ($tag->getSynonyms(true) as $synonym) {
$synonym->registerSearchObjects();
$synonym->transferObjectsToAnotherTag($mainTag);
$synonym->remove();
}
$tag->registerSearchObjects();
$tag->transferObjectsToAnotherTag($mainTag);
$tag->remove();
$mainTag->updateModified();
$db->commit();
return $Module->redirectToView('id', array($mainTag->attribute('id')));
}
}
/**
* Clears view caches of nodes, parent nodes and relating nodes
* of content objects with ids contained in $objectIDList.
* It will use 'viewcache.ini' to determine additional nodes.
*
* @see clearObjectViewCache
*
* @param array $objectIDList List of object ID
*/
public static function clearObjectViewCacheArray(array $objectIDList)
{
eZDebug::accumulatorStart('node_cleanup_list', '', 'Node cleanup list');
$nodeList = array();
foreach ($objectIDList as $objectID) {
$tempNodeList = self::nodeList($objectID, true);
if ($tempNodeList !== false) {
$nodeList = array_merge($nodeList, $tempNodeList);
}
}
$nodeList = array_unique($nodeList);
eZDebug::accumulatorStop('node_cleanup_list');
eZDebugSetting::writeDebug('kernel-content-edit', count($nodeList), "count in nodeList");
if (eZINI::instance()->variable('ContentSettings', 'StaticCache') === 'enabled') {
$staticCacheHandler = eZExtension::getHandlerClass(new ezpExtensionOptions(array('iniFile' => 'site.ini', 'iniSection' => 'ContentSettings', 'iniVariable' => 'StaticCacheHandler')));
$staticCacheHandler->generateAlwaysUpdatedCache();
$staticCacheHandler->generateNodeListCache($nodeList);
}
eZDebug::accumulatorStart('node_cleanup', '', 'Node cleanup');
$nodeList = ezpEvent::getInstance()->filter('content/cache', $nodeList);
eZContentObject::expireComplexViewModeCache();
$cleanupValue = eZContentCache::calculateCleanupValue(count($nodeList));
if (eZContentCache::inCleanupThresholdRange($cleanupValue)) {
eZContentCache::cleanup($nodeList);
} else {
eZDebug::writeDebug("Expiring all view cache since list of nodes({$cleanupValue}) exceeds site.ini\\[ContentSettings]\\CacheThreshold", __METHOD__);
eZContentObject::expireAllViewCache();
}
eZDebug::accumulatorStop('node_cleanup');
return true;
}
/**
* Stores the tags to database
*
* @param eZContentObjectAttribute $attribute
*/
function store($attribute)
{
if (!($attribute instanceof eZContentObjectAttribute && is_numeric($attribute->attribute('id')))) {
return;
}
$attributeID = $attribute->attribute('id');
$attributeVersion = $attribute->attribute('version');
$objectID = $attribute->attribute('contentobject_id');
$db = eZDB::instance();
$currentTime = time();
//get existing tags for object attribute
$existingTagIDs = array();
$existingTags = $db->arrayQuery("SELECT DISTINCT keyword_id FROM eztags_attribute_link WHERE objectattribute_id = {$attributeID} AND objectattribute_version = {$attributeVersion}");
if (is_array($existingTags)) {
foreach ($existingTags as $t) {
$existingTagIDs[] = (int) $t['keyword_id'];
}
}
//get tags to delete from object attribute
$tagsToDelete = array();
$tempIDArray = array();
// if for some reason already existing tags are added with ID = 0 with fromString
// check to see if they really exist, so we don't delete them by mistake
foreach (array_keys($this->IDArray) as $key) {
if ($this->IDArray[$key] == 0) {
$existing = eZTagsObject::fetchList(array('keyword' => array('like', trim($this->KeywordArray[$key])), 'parent_id' => $this->ParentArray[$key]));
if (is_array($existing) && !empty($existing)) {
$tempIDArray[] = $existing[0]->attribute('id');
}
} else {
$tempIDArray[] = $this->IDArray[$key];
}
}
foreach ($existingTagIDs as $tid) {
if (!in_array($tid, $tempIDArray)) {
$tagsToDelete[] = $tid;
}
}
//and delete them
if (!empty($tagsToDelete)) {
$dbString = $db->generateSQLINStatement($tagsToDelete, 'keyword_id', false, true, 'int');
$db->query("DELETE FROM eztags_attribute_link WHERE {$dbString} AND eztags_attribute_link.objectattribute_id = {$attributeID} AND eztags_attribute_link.objectattribute_version = {$attributeVersion}");
}
//get tags that are new to the object attribute
$newTags = array();
$tagsToLink = array();
foreach (array_keys($this->IDArray) as $key) {
if (!in_array($this->IDArray[$key], $existingTagIDs)) {
if ($this->IDArray[$key] == 0) {
// We won't allow adding tags to the database that already exist, but instead, we link to the existing tags
$existing = eZTagsObject::fetchList(array('keyword' => array('like', trim($this->KeywordArray[$key])), 'parent_id' => $this->ParentArray[$key]));
if (is_array($existing) && !empty($existing)) {
if (!in_array($existing[0]->attribute('id'), $existingTagIDs)) {
$tagsToLink[] = $existing[0]->attribute('id');
}
} else {
$newTags[] = array('id' => $this->IDArray[$key], 'keyword' => $this->KeywordArray[$key], 'parent_id' => $this->ParentArray[$key]);
}
} else {
$tagsToLink[] = $this->IDArray[$key];
}
}
}
//we need to check if user really has access to tags/add, taking into account policy and subtree limits
$attributeSubTreeLimit = $attribute->contentClassAttribute()->attribute(eZTagsType::SUBTREE_LIMIT_FIELD);
$userLimitations = eZTagsTemplateFunctions::getSimplifiedUserAccess('tags', 'add');
if ($userLimitations['accessWord'] != 'no' && !empty($newTags)) {
//first we need to fetch all locations user has access to
$userLimitations = isset($userLimitations['simplifiedLimitations']['Tag']) ? $userLimitations['simplifiedLimitations']['Tag'] : array();
$allowedLocations = self::getAllowedLocations($attributeSubTreeLimit, $userLimitations);
foreach ($newTags as $t) {
//and then for each tag check if user can save in one of the allowed locations
$parentTag = eZTagsObject::fetch($t['parent_id']);
$pathString = $parentTag instanceof eZTagsObject ? $parentTag->attribute('path_string') : '/';
$depth = $parentTag instanceof eZTagsObject ? (int) $parentTag->attribute('depth') + 1 : 1;
if (self::canSave($pathString, $allowedLocations)) {
$db->query("INSERT INTO eztags ( parent_id, main_tag_id, keyword, depth, path_string, modified, remote_id ) VALUES ( " . $t['parent_id'] . ", 0, '" . $db->escapeString(trim($t['keyword'])) . "', {$depth}, '{$pathString}', 0, '" . eZTagsObject::generateRemoteID() . "' )");
$tagID = (int) $db->lastSerialID('eztags', 'id');
$db->query("UPDATE eztags SET path_string = CONCAT(path_string, CAST({$tagID} AS CHAR), '/') WHERE id = {$tagID}");
$pathArray = explode('/', trim($pathString, '/'));
array_push($pathArray, $tagID);
$db->query("UPDATE eztags SET modified = {$currentTime} WHERE " . $db->generateSQLINStatement($pathArray, 'id', false, true, 'int'));
$tagsToLink[] = $tagID;
if (class_exists('ezpEvent', false)) {
ezpEvent::getInstance()->filter('tag/add', array('tag' => eZTagsObject::fetch($tagID), 'parentTag' => $parentTag));
}
}
}
}
//link tags to objects taking into account subtree limit
if (!empty($tagsToLink)) {
$dbString = $db->generateSQLINStatement($tagsToLink, 'id', false, true, 'int');
$tagsToLink = $db->arrayQuery("SELECT id, path_string FROM eztags WHERE {$dbString}");
if (is_array($tagsToLink) && !empty($tagsToLink)) {
foreach ($tagsToLink as $t) {
if ($attributeSubTreeLimit == 0 || $attributeSubTreeLimit > 0 && strpos($t['path_string'], '/' . $attributeSubTreeLimit . '/') !== false) {
$db->query("INSERT INTO eztags_attribute_link ( keyword_id, objectattribute_id, objectattribute_version, object_id ) VALUES ( " . $t['id'] . ", {$attributeID}, {$attributeVersion}, {$objectID} )");
}
}
}
}
}
$GroupID = $Params["GroupID"];
}
$class = eZContentClass::fetch($ClassID);
$ClassName = $class->attribute('name');
$classObjects = eZContentObject::fetchSameClassList($ClassID);
$ClassObjectsCount = count($classObjects);
if ($ClassObjectsCount == 0) {
$ClassObjectsCount .= " object";
} else {
$ClassObjectsCount .= " objects";
}
$http = eZHTTPTool::instance();
if ($http->hasPostVariable("ConfirmButton")) {
$class->remove(true);
eZContentClassClassGroup::removeClassMembers($ClassID, 0);
ezpEvent::getInstance()->notify('content/class/cache', array($ClassID));
$Module->redirectTo('/class/classlist/' . $GroupID);
}
if ($http->hasPostVariable("CancelButton")) {
$Module->redirectTo('/class/classlist/' . $GroupID);
}
$Module->setTitle("Deletion of class " . $ClassID);
$tpl = eZTemplate::factory();
$tpl->setVariable("module", $Module);
$tpl->setVariable("GroupID", $GroupID);
$tpl->setVariable("ClassID", $ClassID);
$tpl->setVariable("ClassName", $ClassName);
$tpl->setVariable("ClassObjectsCount", $ClassObjectsCount);
$Result = array();
$Result['content'] = $tpl->fetch("design:class/delete.tpl");
$Result['path'] = array(array('url' => '/class/delete/', 'text' => ezpI18n::tr('kernel/class', 'Remove class')));
static function clearAllContentCache($ignoreINISettings = false)
{
if (!$ignoreINISettings) {
$ini = eZINI::instance();
$viewCacheEnabled = $ini->variable('ContentSettings', 'ViewCaching') === 'enabled';
$templateCacheEnabled = $ini->variable('TemplateSettings', 'TemplateCache') === 'enabled';
} else {
$viewCacheEnabled = true;
$templateCacheEnabled = true;
}
if ($viewCacheEnabled || $templateCacheEnabled) {
// view cache and/or ordinary template block cache
eZContentObject::expireAllCache();
ezpEvent::getInstance()->notify('content/cache/all');
// subtree template block caches
if ($templateCacheEnabled) {
eZSubtreeCache::cleanupAll();
}
}
}
/**
* Generate result data for a node view
*
* @param eZTemplate $tpl
* @param eZContentObjectTreeNode $node
* @param eZContentObject $object
* @param bool|string $languageCode
* @param string $viewMode
* @param int $offset
* @param array $viewParameters
* @param bool|array $collectionAttributes
* @param bool $validation
* @return array Result array for view
*/
static function generateNodeViewData(eZTemplate $tpl, eZContentObjectTreeNode $node, eZContentObject $object, $languageCode, $viewMode, $offset, array $viewParameters = array('offset' => 0, 'year' => false, 'month' => false, 'day' => false), $collectionAttributes = false, $validation = false)
{
$section = eZSection::fetch($object->attribute('section_id'));
if ($section) {
$navigationPartIdentifier = $section->attribute('navigation_part_identifier');
$sectionIdentifier = $section->attribute('identifier');
} else {
$navigationPartIdentifier = null;
$sectionIdentifier = null;
}
$keyArray = array(array('object', $object->attribute('id')), array('node', $node->attribute('node_id')), array('parent_node', $node->attribute('parent_node_id')), array('class', $object->attribute('contentclass_id')), array('class_identifier', $node->attribute('class_identifier')), array('view_offset', $offset), array('viewmode', $viewMode), array('remote_id', $object->attribute('remote_id')), array('node_remote_id', $node->attribute('remote_id')), array('navigation_part_identifier', $navigationPartIdentifier), array('depth', $node->attribute('depth')), array('url_alias', $node->attribute('url_alias')), array('class_group', $object->attribute('match_ingroup_id_list')), array('state', $object->attribute('state_id_array')), array('state_identifier', $object->attribute('state_identifier_array')), array('section', $object->attribute('section_id')), array('section_identifier', $sectionIdentifier));
$parentClassID = false;
$parentClassIdentifier = false;
$parentNodeRemoteID = false;
$parentObjectRemoteID = false;
$parentNode = $node->attribute('parent');
if (is_object($parentNode)) {
$parentNodeRemoteID = $parentNode->attribute('remote_id');
$keyArray[] = array('parent_node_remote_id', $parentNodeRemoteID);
$parentObject = $parentNode->attribute('object');
if (is_object($parentObject)) {
$parentObjectRemoteID = $parentObject->attribute('remote_id');
$keyArray[] = array('parent_object_remote_id', $parentObjectRemoteID);
$parentClass = $parentObject->contentClass();
if (is_object($parentClass)) {
$parentClassID = $parentClass->attribute('id');
$parentClassIdentifier = $parentClass->attribute('identifier');
$keyArray[] = array('parent_class', $parentClassID);
$keyArray[] = array('parent_class_identifier', $parentClassIdentifier);
}
}
}
$res = eZTemplateDesignResource::instance();
$res->setKeys($keyArray);
if ($languageCode) {
$oldLanguageCode = $node->currentLanguage();
$node->setCurrentLanguage($languageCode);
}
$tpl->setVariable('node', $node);
$tpl->setVariable('viewmode', $viewMode);
$tpl->setVariable('language_code', $languageCode);
if (isset($viewParameters['_custom'])) {
foreach ($viewParameters['_custom'] as $customVarName => $customValue) {
$tpl->setVariable($customVarName, $customValue);
}
unset($viewParameters['_custom']);
}
$tpl->setVariable('view_parameters', $viewParameters);
$tpl->setVariable('collection_attributes', $collectionAttributes);
$tpl->setVariable('validation', $validation);
$tpl->setVariable('persistent_variable', false);
$parents = $node->attribute('path');
$path = array();
$titlePath = array();
foreach ($parents as $parent) {
$path[] = array('text' => $parent->attribute('name'), 'url' => '/content/view/full/' . $parent->attribute('node_id'), 'url_alias' => $parent->attribute('url_alias'), 'node_id' => $parent->attribute('node_id'));
}
$titlePath = $path;
$path[] = array('text' => $object->attribute('name'), 'url' => false, 'url_alias' => false, 'node_id' => $node->attribute('node_id'));
$titlePath[] = array('text' => $object->attribute('name'), 'url' => false, 'url_alias' => false);
$tpl->setVariable('node_path', $path);
$event = ezpEvent::getInstance();
$event->notify('content/pre_rendering', array($node, $tpl, $viewMode));
$Result = array();
$Result['content'] = $tpl->fetch('design:node/view/' . $viewMode . '.tpl');
$Result['view_parameters'] = $viewParameters;
$Result['path'] = $path;
$Result['title_path'] = $titlePath;
$Result['section_id'] = $object->attribute('section_id');
$Result['node_id'] = $node->attribute('node_id');
$Result['navigation_part'] = $navigationPartIdentifier;
$contentInfoArray = array();
$contentInfoArray['object_id'] = $object->attribute('id');
$contentInfoArray['node_id'] = $node->attribute('node_id');
$contentInfoArray['parent_node_id'] = $node->attribute('parent_node_id');
$contentInfoArray['class_id'] = $object->attribute('contentclass_id');
$contentInfoArray['class_identifier'] = $node->attribute('class_identifier');
$contentInfoArray['remote_id'] = $object->attribute('remote_id');
$contentInfoArray['node_remote_id'] = $node->attribute('remote_id');
$contentInfoArray['offset'] = $offset;
$contentInfoArray['viewmode'] = $viewMode;
$contentInfoArray['navigation_part_identifier'] = $navigationPartIdentifier;
$contentInfoArray['node_depth'] = $node->attribute('depth');
$contentInfoArray['url_alias'] = $node->attribute('url_alias');
$contentInfoArray['current_language'] = $object->attribute('current_language');
$contentInfoArray['language_mask'] = $object->attribute('language_mask');
$contentInfoArray['main_node_id'] = $node->attribute('main_node_id');
$contentInfoArray['main_node_url_alias'] = false;
// Add url alias for main node if it is not current node and user has access to it
if (!$node->isMain()) {
$mainNode = $object->mainNode();
if ($mainNode->canRead()) {
$contentInfoArray['main_node_url_alias'] = $mainNode->attribute('url_alias');
}
}
$contentInfoArray['persistent_variable'] = false;
if ($tpl->variable('persistent_variable') !== false) {
$contentInfoArray['persistent_variable'] = $tpl->variable('persistent_variable');
$keyArray[] = array('persistent_variable', $contentInfoArray['persistent_variable']);
$res->setKeys($keyArray);
}
$contentInfoArray['class_group'] = $object->attribute('match_ingroup_id_list');
$contentInfoArray['state'] = $object->attribute('state_id_array');
$contentInfoArray['state_identifier'] = $object->attribute('state_identifier_array');
$contentInfoArray['parent_class_id'] = $parentClassID;
$contentInfoArray['parent_class_identifier'] = $parentClassIdentifier;
$contentInfoArray['parent_node_remote_id'] = $parentNodeRemoteID;
$contentInfoArray['parent_object_remote_id'] = $parentObjectRemoteID;
$Result['content_info'] = $contentInfoArray;
// Store which templates were used to make this cache.
$Result['template_list'] = $tpl->templateFetchList();
// Check if time to live is set in template
if ($tpl->hasVariable('cache_ttl')) {
$cacheTTL = $tpl->variable('cache_ttl');
}
if (!isset($cacheTTL)) {
$cacheTTL = -1;
}
$Result['cache_ttl'] = $cacheTTL;
// if cache_ttl is set to 0 from the template, we need to add a no-cache advice
// to the node's data. That way, the retrieve callback on the next calls
// will be able to determine earlier that no cache generation should be started
// for this node
if ($cacheTTL == 0) {
$Result['no_cache'] = true;
}
if ($languageCode) {
$node->setCurrentLanguage($oldLanguageCode);
}
return $Result;
}
}
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();
ezpEvent::getInstance()->notify('content/section/cache', array($sectionID));
}
}
$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);
$tpl->setVariable('section_array', $sectionArray);
/**
* Resets instance
*/
public static function resetInstance()
{
self::$instance = null;
}
}
} else {
if ($result['status'] === true) {
$aliasText = $result['path'];
if (strcmp($aliasText, $origAliasText) != 0) {
$infoCode = "feedback-alias-cleanup";
$infoData['orig_alias'] = $origAliasText;
$infoData['new_alias'] = $aliasText;
} else {
$infoData['new_alias'] = $aliasText;
}
if ($infoCode == 'no-errors') {
$infoCode = "feedback-alias-created";
}
$aliasText = false;
ezpEvent::getInstance()->notify('content/cache', array($NodeID));
}
}
}
}
}
}
}
// Fetch generated names of node
$filter = new eZURLAliasQuery();
$filter->actions = array('eznode:' . $node->attribute('node_id'));
$filter->type = 'name';
$filter->limit = false;
$elements = $filter->fetchAll();
// Fetch custom aliases for node
$limit = 25;
$state = $StateIdentifier ? $group->stateByIdentifier($StateIdentifier) : $group->newState();
if (!is_object($state)) {
return $Module->handleError(eZError::KERNEL_NOT_FOUND, 'kernel');
}
$redirectUrl = "state/group/{$GroupIdentifier}";
$tpl = eZTemplate::factory();
$currentAction = $Module->currentAction();
if ($currentAction == 'Cancel') {
return $Module->redirectTo($redirectUrl);
} else {
if ($currentAction == 'Store') {
$state->fetchHTTPPersistentVariables();
$messages = array();
$isValid = $state->isValid($messages);
if ($isValid) {
$state->store();
ezpEvent::getInstance()->notify('content/state/cache', array($state->attribute('id')));
return $Module->redirectTo($redirectUrl);
}
$tpl->setVariable('is_valid', $isValid);
$tpl->setVariable('validation_messages', $messages);
}
}
$tpl->setVariable('state', $state);
$tpl->setVariable('group', $group);
if ($StateIdentifier === null) {
$path = array(array('url' => false, 'text' => ezpI18n::tr('kernel/state', 'State')), array('url' => false, 'text' => ezpI18n::tr('kernel/state', 'New')), array('url' => false, 'text' => $GroupIdentifier));
} else {
$path = array(array('url' => false, 'text' => ezpI18n::tr('kernel/state', 'State')), array('url' => false, 'text' => ezpI18n::tr('kernel/state', 'Edit')), array('url' => false, 'text' => $GroupIdentifier), array('url' => false, 'text' => $StateIdentifier));
}
$Result = array('path' => $path, 'content' => $tpl->fetch('design:state/edit.tpl'));
protected function requestInit()
{
if ($this->isInitialized) {
return;
}
eZExecution::setCleanExit(false);
$scriptStartTime = microtime(true);
$GLOBALS['eZRedirection'] = false;
$this->access = eZSiteAccess::current();
eZDebug::setScriptStart($scriptStartTime);
eZDebug::addTimingPoint("Script start");
$this->uri = eZURI::instance(eZSys::requestURI());
$GLOBALS['eZRequestedURI'] = $this->uri;
// Be able to do general events early in process
ezpEvent::getInstance()->notify('request/preinput', array($this->uri));
// Initialize module loading
$this->siteBasics['module-repositories'] = eZModule::activeModuleRepositories();
eZModule::setGlobalPathList($this->siteBasics['module-repositories']);
// make sure we get a new $ini instance now that it has been reset
$ini = eZINI::instance();
// start: eZCheckValidity
// pre check, setup wizard related so needs to be before session/db init
// TODO: Move validity check in the constructor? Setup is not meant to be launched at each (sub)request is it?
if ($ini->variable('SiteAccessSettings', 'CheckValidity') === 'true') {
$this->check = array('module' => 'setup', 'function' => 'init');
// Turn off some features that won't bee needed yet
$this->siteBasics['policy-check-omit-list'][] = 'setup';
$this->siteBasics['show-page-layout'] = $ini->variable('SetupSettings', 'PageLayout');
$this->siteBasics['validity-check-required'] = true;
$this->siteBasics['session-required'] = $this->siteBasics['user-object-required'] = false;
$this->siteBasics['db-required'] = $this->siteBasics['no-cache-adviced'] = $this->siteBasics['url-translator-allowed'] = false;
$this->siteBasics['site-design-override'] = $ini->variable('SetupSettings', 'OverrideSiteDesign');
$this->access = eZSiteAccess::change(array('name' => 'setup', 'type' => eZSiteAccess::TYPE_URI));
eZTranslatorManager::enableDynamicTranslations();
}
// stop: eZCheckValidity
if ($this->siteBasics['session-required']) {
// Check if this should be run in a cronjob
if ($ini->variable('Session', 'BasketCleanup') !== 'cronjob') {
eZSession::addCallback('destroy_pre', function (eZDBInterface $db, $key, $escapedKey) {
$basket = eZBasket::fetch($key);
if ($basket instanceof eZBasket) {
$basket->remove();
}
});
eZSession::addCallback('gc_pre', function (eZDBInterface $db, $time) {
eZBasket::cleanupExpired($time);
});
eZSession::addCallback('cleanup_pre', function (eZDBInterface $db) {
eZBasket::cleanup();
});
}
// addCallBack to update session id for shop basket on session regenerate
eZSession::addCallback('regenerate_post', function (eZDBInterface $db, $escNewKey, $escOldKey) {
$db->query("UPDATE ezbasket SET session_id='{$escNewKey}' WHERE session_id='{$escOldKey}'");
});
// TODO: Session starting should be made only once in the constructor
$this->sessionInit();
}
// if $this->siteBasics['db-required'], open a db connection and check that db is connected
if ($this->siteBasics['db-required'] && !eZDB::instance()->isConnected()) {
$this->warningList[] = array('error' => array('type' => 'kernel', 'number' => eZError::KERNEL_NO_DB_CONNECTION), 'text' => 'No database connection could be made, the system might not behave properly.');
}
// eZCheckUser: pre check, RequireUserLogin & FORCE_LOGIN related so needs to be after session init
if (!isset($this->check)) {
$this->check = eZUserLoginHandler::preCheck($this->siteBasics, $this->uri);
}
ezpEvent::getInstance()->notify('request/input', array($this->uri));
// Initialize with locale settings
// TODO: Move to constructor? Is it relevant to init the locale/charset for each (sub)requests?
$this->languageCode = eZLocale::instance()->httpLocaleCode();
$phpLocale = trim($ini->variable('RegionalSettings', 'SystemLocale'));
if ($phpLocale != '') {
setlocale(LC_ALL, explode(',', $phpLocale));
}
$this->httpCharset = eZTextCodec::httpCharset();
// TODO: are these parameters supposed to vary across potential sub-requests?
$this->site = array('title' => $ini->variable('SiteSettings', 'SiteName'), 'design' => $ini->variable('DesignSettings', 'SiteDesign'), 'http_equiv' => array('Content-Type' => 'text/html; charset=' . $this->httpCharset, 'Content-language' => $this->languageCode));
// Read role settings
$this->siteBasics['policy-check-omit-list'] = array_merge($this->siteBasics['policy-check-omit-list'], $ini->variable('RoleSettings', 'PolicyOmitList'));
$this->isInitialized = true;
}
exitWithInternalError("'{$moduleName}' module does not exist, or is not a valid module.");
return;
}
// check existance of view
$viewName = $uri->element(1);
$moduleViews = $module->attribute('views');
if (!isset($moduleViews[$viewName])) {
exitWithInternalError("'{$viewName}' view does not exist on the current module.");
return;
}
// Check if module / view is disabled
$moduleCheck = eZModule::accessAllowed($uri);
if (!$moduleCheck['result']) {
exitWithInternalError('$moduleName/$viewName is disabled.');
}
// check access to view
$ini = eZINI::instance();
$currentUser = eZUser::currentUser();
if (!hasAccessToBySetting($moduleName, $viewName, $ini->variable('RoleSettings', 'PolicyOmitList')) && !$currentUser->hasAccessToView($module, $viewName, $params)) {
exitWithInternalError("User does not have access to the {$moduleName}/{$viewName} policy.");
return;
}
// run module view
$uri->increase();
$uri->increase();
$GLOBALS['eZRequestedModule'] = $module;
$moduleResult = $module->run($viewName, $uri->elements(false), false, $uri->userParameters());
// ouput result and end exit cleanly
eZDB::checkTransactionCounter();
echo ezpEvent::getInstance()->filter('response/output', $moduleResult['content']);
eZExecution::cleanExit();
$tpl->setVariable('is_edit', $Module->isCurrentAction('Edit'));
$Result['content'] = $tpl->fetch('design:content/translationnew.tpl');
$Result['path'] = array(array('text' => ezpI18n::tr('kernel/content', 'Translation'), 'url' => false), array('text' => 'New', 'url' => false));
return;
}
}
}
if ($Module->isCurrentAction('Remove')) {
$seletedIDList = $Module->actionParameter('SelectedTranslationList');
$db = eZDB::instance();
$db->begin();
foreach ($seletedIDList as $translationID) {
eZContentLanguage::removeLanguage($translationID);
}
$db->commit();
ezpEvent::getInstance()->notify('content/translations/cache', array($seletedIDList));
}
if ($Params['TranslationID']) {
$translation = eZContentLanguage::fetch($Params['TranslationID']);
if (!$translation) {
return $Module->handleError(eZError::KERNEL_NOT_AVAILABLE, 'kernel');
}
$tpl->setVariable('translation', $translation);
$Result['content'] = $tpl->fetch('design:content/translationview.tpl');
$Result['path'] = array(array('text' => ezpI18n::tr('kernel/content', 'Content translations'), 'url' => 'content/translations'), array('text' => $translation->attribute('name'), 'url' => false));
return;
}
$availableTranslations = eZContentLanguage::fetchList();
$tpl->setVariable('available_translations', $availableTranslations);
$Result['content'] = $tpl->fetch('design:content/translations.tpl');
$Result['path'] = array(array('text' => ezpI18n::tr('kernel/content', 'Languages'), 'url' => false));
static function printReport($newWindow = false, $as_html = true, $returnReport = false, $allowedDebugLevels = false, $useAccumulators = true, $useTiming = true, $useIncludedFiles = false)
{
if (!self::isDebugEnabled()) {
return null;
}
$debug = self::instance();
$report = $debug->printReportInternal($as_html, $returnReport & $newWindow, $allowedDebugLevels, $useAccumulators, $useTiming, $useIncludedFiles);
if ($newWindow == true) {
$debugFilePath = eZDir::path(array(eZSys::varDirectory(), 'cache', 'debug.html'));
$debugFileURL = $debugFilePath;
eZURI::transformURI($debugFileURL, true);
print "\n<script type='text/javascript'>\n<!--\n\n(function()\n{\n var debugWindow;\n\n if (navigator.appName == \"Microsoft Internet Explorer\")\n {\n //Microsoft Internet Explorer\n debugWindow = window.open( '{$debugFileURL}', 'ezdebug', 'width=500,height=550,status,scrollbars,resizable,screenX=0,screenY=20,left=20,top=40');\n debugWindow.document.close();\n debugWindow.location.reload();\n }\n else if (navigator.appName == \"Opera\")\n {\n //Opera\n debugWindow = window.open( '', 'ezdebug', 'width=500,height=550,status,scrollbars,resizable,screenX=0,screenY=20,left=20,top=40');\n debugWindow.location.href=\"{$debugFileURL}\";\n debugWindow.navigate(\"{$debugFileURL}\");\n }\n else\n {\n //Mozilla, Firefox, etc.\n debugWindow = window.open( '', 'ezdebug', 'width=500,height=550,status,scrollbars,resizable,screenX=0,screenY=20,left=20,top=40');\n debugWindow.document.location.href=\"{$debugFileURL}\";\n };\n})();\n\n// -->\n</script>\n";
$header = "<!DOCTYPE html><html><head><title>eZ debug</title></head><body>";
$footer = "</body></html>";
$fullPage = ezpEvent::getInstance()->filter('response/output', $header . $report . $footer);
file_put_contents($debugFilePath, $fullPage);
} else {
if ($returnReport) {
return $report;
}
}
return null;
}
$nodeAssignments = array_merge($nodeAssignments, $ownerNodeAssignments);
}
}
}
// If exists location that current user has access to and location is visible.
$canAccess = false;
$isContentDraft = $contentObject->attribute('status') == eZContentObject::STATUS_DRAFT;
foreach ($nodeAssignments as $nodeAssignment) {
if (eZContentObjectTreeNode::showInvisibleNodes() || !$nodeAssignment->attribute('is_invisible') and $nodeAssignment->canRead()) {
$canAccess = true;
break;
}
}
if (!$canAccess && !$isContentDraft) {
return $Module->handleError(eZError::KERNEL_NOT_AVAILABLE, 'kernel');
}
// If $version is not current version (published)
// we should check permission versionRead for the $version.
if ($version != $currentVersion || $isContentDraft) {
$versionObj = eZContentObjectVersion::fetchVersion($version, $contentObjectID);
if (is_object($versionObj) and !$versionObj->canVersionRead()) {
return $Module->handleError(eZError::KERNEL_NOT_AVAILABLE, 'kernel');
}
}
ezpEvent::getInstance()->notify('content/download', array('contentObjectID' => $contentObjectID, 'contentObjectAttributeID' => $contentObjectAttributeID));
$fileHandler = eZBinaryFileHandler::instance();
$result = $fileHandler->handleDownload($contentObject, $contentObjectAttribute, eZBinaryFileHandler::TYPE_FILE);
if ($result == eZBinaryFileHandler::RESULT_UNAVAILABLE) {
eZDebug::writeError("The specified file could not be found.");
return $Module->handleError(eZError::KERNEL_NOT_AVAILABLE, 'kernel');
}
