function __construct($id, $createIfNotExists = false, $options = array(), $remoteUrl = null)
{
$this->notifications = array(self::ERROR => array(), self::WARNING => array(), self::NOTICE => array());
if ($remoteUrl !== NULL) {
self::setRemoteUrl($remoteUrl);
}
$class = eZContentClass::fetch(intval($id));
$this->options = $options;
$this->data = new stdClass();
if (!$class instanceof eZContentClass) {
$class = eZContentClass::fetchByIdentifier($id);
}
if (!$class instanceof eZContentClass) {
if (!$createIfNotExists) {
throw new Exception("Classe {$id} non trovata");
} else {
if (!is_numeric($id)) {
eZDebug::writeWarning("Creazione della classe {$id}");
$class = $this->createNew($id);
if (!$class instanceof eZContentClass) {
throw new Exception("Fallita la creazionde della classe {$id}");
}
} else {
throw new Exception("Per creare automaticamente una nuova classe è necessario fornire l'identificativo e non l'id numerico");
}
}
}
$this->currentClass = $class;
$this->id = $this->currentClass->attribute('id');
$this->identifier = $this->currentClass->attribute('identifier');
}
public function execute($process, $event)
{
$processParameters = $process->attribute('parameter_list');
$object = eZContentObject::fetch($processParameters['object_id']);
$targetClassIdentifier = $object->contentClass()->attribute('identifier');
$iniGroups = eZINI::instance('ngindexer.ini')->groups();
$targets = array();
foreach ($iniGroups as $iniGroupName => $iniGroup) {
$iniGroupNameArray = explode('/', $iniGroupName);
if (is_array($iniGroupNameArray) && count($iniGroupNameArray) == 3) {
$class = eZContentClass::fetchByIdentifier($iniGroupNameArray[0]);
if ($class instanceof eZContentClass) {
$classAttribute = $class->fetchAttributeByIdentifier($iniGroupNameArray[1]);
if ($classAttribute instanceof eZContentClassAttribute) {
$indexTarget = isset($iniGroup['IndexTarget']) ? trim($iniGroup['IndexTarget']) : '';
$referencedClassIdentifiers = isset($iniGroup['ClassIdentifiers']) && is_array($iniGroup['ClassIdentifiers']) ? $iniGroup['ClassIdentifiers'] : null;
if ($referencedClassIdentifiers != null && (empty($referencedClassIdentifiers) || in_array($targetClassIdentifier, $referencedClassIdentifiers))) {
switch ($indexTarget) {
case 'parent':
case 'parent_line':
$children = eZContentObjectTreeNode::subTreeByNodeID(array('ClassFilterType' => 'include', 'ClassFilterArray' => array($iniGroupNameArray[0]), 'Depth' => $indexTarget == 'parent' ? 1 : false), $object->mainNode()->attribute('node_id'));
if (is_array($children)) {
$targets = array_merge($targets, $children);
}
break;
case 'children':
$parentNode = $object->mainNode()->fetchParent();
if ($parentNode->classIdentifier() == $iniGroupNameArray[0]) {
$targets[] = $parentNode;
}
break;
case 'subtree':
$path = $object->mainNode()->fetchPath();
foreach ($path as $pathNode) {
if ($pathNode->classIdentifier() == $iniGroupNameArray[0]) {
$targets[] = $parentNode;
}
}
break;
default:
continue;
}
}
}
}
}
}
$filteredTargets = array();
foreach ($targets as $target) {
$objectID = $target->attribute('contentobject_id');
$version = $target->object()->attribute('current_version');
if (!isset($filteredTargets[$objectID])) {
$filteredTargets[$objectID] = $version;
eZContentOperationCollection::registerSearchObject($objectID, $version);
}
}
return eZWorkflowType::STATUS_ACCEPTED;
}
private function attribute_migrate($classIdentifier, $srcAttribute, $conversion, $destAttribute)
{
$contentClass = eZContentClass::fetchByIdentifier($classIdentifier);
if (!$contentClass) {
throw new Exception("Failed to instantiate content class [" . $classIdentifier . "]");
}
$classDataMap = $contentClass->attribute("data_map");
if (!isset($classDataMap[$srcAttribute])) {
throw new Exception("Content class '" . $classIdentifier . "' does not contain this attribute: [" . $srcAttribute . "]");
}
if (!isset($classDataMap[$destAttribute])) {
throw new Exception("Content class '" . $classIdentifier . "' does not contain this attribute: [" . $destAttribute . "]");
}
$classId = $contentClass->attribute("id");
$objects = eZContentObject::fetchSameClassList($classId, false);
$numObjects = count($objects);
$conversionFunc = null;
switch ($conversion) {
default:
echo "This mapping is not supported: [" . $conversion . "]\n";
return;
break;
case "rot13":
$conversionFunc = "convertStringToRot13";
break;
case "time2integer":
$conversionFunc = "convertTimeToInteger";
break;
case "trim":
$conversionFunc = "convertTrim";
break;
case "date2ts":
$conversionFunc = "dateToTS";
break;
}
foreach ($objects as $n => $object) {
$object = eZContentObject::fetch($object["id"]);
if ($object) {
// copy data with conversion
$dataMap = $object->DataMap();
$src = $dataMap[$srcAttribute];
$dest = $dataMap[$destAttribute];
$dest->fromString(eep::$conversionFunc($src->toString()));
$dest->store();
// publish to get changes recognized, eg object title updated
eep::republishObject($object->attribute("id"));
}
echo "Percent complete: " . sprintf("% 3.3f", ($n + 1.0) / $numObjects * 100.0) . "%\r";
// clear caches
unset($GLOBALS["eZContentObjectContentObjectCache"]);
unset($GLOBALS["eZContentObjectDataMapCache"]);
unset($GLOBALS["eZContentObjectVersionCache"]);
unset($object);
}
echo "\n";
}
/**
* Ritorna l'elengo dei tag disponibili
*
* @return eZTagsObject[]
*/
public static function notificationAvailableTags()
{
$class = eZContentClass::fetchByIdentifier(self::CLASS_IDENTIFIER);
if ($class instanceof eZContentClass) {
$classAttribute = $class->fetchAttributeByIdentifier(self::TAG_ATTRIBUTE_IDENTIFIER);
if ($classAttribute instanceof eZContentClassAttribute) {
$tagRoot = eZTagsObject::fetch(intval($classAttribute->attribute(eZTagsType::SUBTREE_LIMIT_FIELD)));
return $tagRoot->getChildren();
}
}
return array();
}
function initSettings($parameters)
{
$siteINI = eZINI::instance();
$classIdentifier = 'template_look';
//get the class
$class = eZContentClass::fetchByIdentifier($classIdentifier, true, eZContentClass::VERSION_STATUS_TEMPORARY);
if (!$class) {
$class = eZContentClass::fetchByIdentifier($classIdentifier, true, eZContentClass::VERSION_STATUS_DEFINED);
if (!$class) {
eZDebug::writeError("Warning, DEFINED version for class identifier {$classIdentifier} does not exist.");
return;
}
}
$classId = $class->attribute('id');
$this->Settings['template_look_class_id'] = $classId;
$objects = eZContentObject::fetchSameClassList($classId);
if (!count($objects)) {
eZDebug::writeError("Object of class {$classIdentifier} does not exist.");
return;
}
$templateLookObject = $objects[0];
$this->Settings['template_look_object'] = $templateLookObject;
$this->Settings['template_look_object_id'] = $templateLookObject->attribute('id');
if (!is_array($parameters)) {
return;
}
$this->addSetting('admin_account_id', eZSiteInstaller::getParam($parameters, 'object_remote_map/1bb4fe25487f05527efa8bfd394cecc7', ''));
$this->addSetting('guest_accounts_id', eZSiteInstaller::getParam($parameters, 'object_remote_map/5f7f0bdb3381d6a461d8c29ff53d908f', ''));
$this->addSetting('anonymous_accounts_id', eZSiteInstaller::getParam($parameters, 'object_remote_map/15b256dbea2ae72418ff5facc999e8f9', ''));
$this->addSetting('package_object', eZSiteInstaller::getParam($parameters, 'package_object', false));
$this->addSetting('design_list', eZSiteInstaller::getParam($parameters, 'design_list', array()));
$this->addSetting('main_site_design', strtolower($this->solutionName()));
$this->addSetting('extension_list', array('ezwt', 'ezstarrating', 'ezgmaplocation', strtolower($this->solutionName())));
$this->addSetting('version', $this->solutionVersion());
$this->addSetting('locales', eZSiteInstaller::getParam($parameters, 'all_language_codes', array()));
// usual user siteaccess like 'ezwebin_site'
$this->addSetting('user_siteaccess', eZSiteInstaller::getParam($parameters, 'user_siteaccess', ''));
// usual admin siteaccess like 'ezwebin_site_admin'
$this->addSetting('admin_siteaccess', eZSiteInstaller::getParam($parameters, 'admin_siteaccess', ''));
// extra siteaccess based on languages info, like 'eng', 'rus', ...
$this->addSetting('language_based_siteaccess_list', $this->languageNameListFromLocaleList($this->setting('locales')));
$this->addSetting('user_siteaccess_list', array_merge(array($this->setting('user_siteaccess')), $this->setting('language_based_siteaccess_list')));
$this->addSetting('all_siteaccess_list', array_merge($this->setting('user_siteaccess_list'), array($this->setting('admin_siteaccess'))));
$this->addSetting('access_type', eZSiteInstaller::getParam($parameters, 'site_type/access_type', ''));
$this->addSetting('access_type_value', eZSiteInstaller::getParam($parameters, 'site_type/access_type_value', ''));
$this->addSetting('admin_access_type_value', eZSiteInstaller::getParam($parameters, 'site_type/admin_access_type_value', ''));
$this->addSetting('host', eZSiteInstaller::getParam($parameters, 'host', ''));
$siteaccessUrls = array('admin' => $this->createSiteaccessUrls(array('siteaccess_list' => array($this->setting('admin_siteaccess')), 'access_type' => $this->setting('access_type'), 'access_type_value' => $this->setting('admin_access_type_value'), 'host' => $this->setting('host'), 'host_prepend_siteaccess' => false)), 'user' => $this->createSiteaccessUrls(array('siteaccess_list' => array($this->setting('user_siteaccess')), 'access_type' => $this->setting('access_type'), 'access_type_value' => $this->setting('access_type_value'), 'host' => $this->setting('host'), 'host_prepend_siteaccess' => false)), 'translation' => $this->createSiteaccessUrls(array('siteaccess_list' => $this->setting('language_based_siteaccess_list'), 'access_type' => $this->setting('access_type'), 'access_type_value' => $this->setting('access_type_value') + 1, 'host' => $this->setting('host'), 'exclude_port_list' => array($this->setting('admin_access_type_value'), $this->setting('access_type_value')))));
$this->addSetting('siteaccess_urls', $siteaccessUrls);
$this->addSetting('primary_language', eZSiteInstaller::getParam($parameters, 'all_language_codes/0', ''));
$this->addSetting('var_dir', eZSiteInstaller::getParam($parameters, 'var_dir', 'var/' . $this->setting('user_siteaccess')));
}
public function __construct($classIdentifier, $parentNodeID = false, $creatorID = 14, $section = 1, $languageCode = false)
{
$this->class = eZContentClass::fetchByIdentifier($classIdentifier);
if (!$this->class instanceof eZContentClass) {
throw new ezcBaseValueException('class', isset($this->class) ? get_class($this->class) : null, 'eZContentClass ($classIdentifier was: ' . $classIdentifier . ' ) ', 'member');
}
$this->object = $this->class->instantiate($creatorID, $section, false, $languageCode);
// Create main node
if (is_numeric($parentNodeID)) {
$this->mainNode = new ezpNode($this->object, $parentNodeID, true);
}
$this->nodes = array($this->mainNode);
}
/**
* Unit test for eZContentClass::versionHistoryLimit() with object parameters
*
* Replica of testVersionHistoryLimit() but you cannot make calls
* to the eZ API which relies on a database, as this is not present
* in the provider methods.
*/
public function testVersionHistoryLimitWithObjectParameter()
{
// different custom limits (article: 13, image: 6) and object as a parameter
$INISettings = array(array('VersionHistoryClass', array('article' => 13, 'image' => 6)));
$class = eZContentClass::fetchByIdentifier('image');
$expectedLimit = 6;
// change the INI limit settings
foreach ($INISettings as $settings) {
list($INIVariable, $INIValue) = $settings;
ezpINIHelper::setINISetting('content.ini', 'VersionManagement', $INIVariable, $INIValue);
}
$limit = eZContentClass::versionHistoryLimit($class);
self::assertEquals($expectedLimit, $limit);
ezpINIHelper::restoreINISettings();
}
private function updateContentObject(eZContentObject $eZContentObject)
{
$mainNodeID = $eZContentObject->mainNodeID();
$parentNodeID = eZContentObjectTreeNode::getParentNodeId($mainNodeID);
$classIdentifier = $eZContentObject->ClassIdentifier;
$remoteID = $eZContentObject->RemoteID;
if (!eZContentClass::fetchByIdentifier($classIdentifier)) {
throw new Exception("La classe" . $classIdentifier . "non esiste in questa installazione");
}
$params = array();
$params['class_identifier'] = $classIdentifier;
$params['remote_id'] = $remoteID;
$params['parent_node_id'] = $parentNodeID;
$params['attributes'] = $this->getAttributesStringArray($eZContentObject);
$result = eZContentFunctions::updateAndPublishObject($eZContentObject, $params);
return $result;
}
function modify(&$tpl, &$operatorName, &$operatorParameters, &$rootNamespace, &$currentNamespace, &$operatorValue, &$namedParameters)
{
switch ($operatorName) {
case 'class_extra_parameters':
$classIdentifier = $namedParameters['class_identifier'];
$handler = $namedParameters['handler'];
$class = eZContentClass::fetchByIdentifier($classIdentifier);
if ($class instanceof eZContentClass) {
$extraParametersManager = OCClassExtraParametersManager::instance($class);
if (is_string($handler)) {
$operatorValue = $extraParametersManager->getHandler($handler);
} else {
$operatorValue = $extraParametersManager->getHandlers();
}
}
break;
}
}
/**
* Data provider for testGetFieldName
**/
public static function providerTestGetFieldName()
{
$providerArray = array();
$providerArray[] = array(ezfSolrDocumentFieldBase::ATTR_FIELD_PREFIX . 'title_t', 'article/title');
if ($contentClass = eZContentClass::fetchByIdentifier('article')) {
$contentClassId = $contentClass->attribute('id');
$providerArray[] = array(array('fieldName' => ezfSolrDocumentFieldBase::ATTR_FIELD_PREFIX . 'title_t', 'contentClassId' => $contentClassId), 'article/title', true);
}
/*
if ( $contentClass = eZContentClass::fetchByIdentifier( 'article' ) )
{
$providerArray[] = array(
ezfSolrDocumentFieldBase::SUBATTR_FIELD_PREFIX . 'image-alternative_text_t',
'article/image/alternative_text'
);
}
*/
return $providerArray;
}
public function fetch($parameters, $publishedAfter, $publishedBeforeOrAt)
{
$ini = eZINI::instance('block.ini');
$limit = 5;
if ($ini->hasVariable('Keywords', 'NumberOfValidItems')) {
$limit = $ini->variable('Keywords', 'NumberOfValidItems');
}
if (isset($parameters['Source']) && $parameters['Source'] != '') {
$nodeID = $parameters['Source'];
$node = eZContentObjectTreeNode::fetch($nodeID, false, false);
// not as an object
if ($node && $node['modified_subnode'] <= $publishedAfter) {
return array();
}
} else {
$nodeID = false;
}
$sortBy = array('published', false);
$classIDs = array();
if (isset($parameters['Classes']) && $parameters['Classes'] != '') {
$classIdentifiers = explode(',', $parameters['Classes']);
foreach ($classIdentifiers as $classIdentifier) {
$class = eZContentClass::fetchByIdentifier($classIdentifier, false);
// not as an object
if ($class) {
$classIDs[] = $class['id'];
}
}
}
if (isset($parameters['Keywords'])) {
$keywords = $parameters['Keywords'];
}
$result = eZFunctionHandler::execute('content', 'keyword', array('alphabet' => $keywords, 'classid' => $classIDs, 'offset' => 0, 'limit' => $limit, 'parent_node_id' => $nodeID, 'include_duplicates' => false, 'sort_by' => $sortBy, 'strict_matching' => false));
if ($result === null) {
return array();
}
$fetchResult = array();
foreach ($result as $item) {
$fetchResult[] = array('object_id' => $item['link_object']->attribute('contentobject_id'), 'node_id' => $item['link_object']->attribute('node_id'), 'ts_publication' => $item['link_object']->object()->attribute('published'));
}
return $fetchResult;
}
function createObject($classIdentifier, $parentNodeID, $name)
{
$user = eZUser::currentUser();
$Class = eZContentClass::fetchByIdentifier($classIdentifier);
if (!$Class) {
eZDebug::writeError("No class with identifier {$classIdentifier}", "classCreation");
return false;
}
$contentObject = $Class->instantiate($user->attribute('contentobject_id'));
$nodeAssignment = eZNodeAssignment::create(array('contentobject_id' => $contentObject->attribute('id'), 'contentobject_version' => $contentObject->attribute('current_version'), 'parent_node' => $parentNodeID, 'is_main' => 1));
$nodeAssignment->store();
$version = $contentObject->version(1);
$version->setAttribute('modified', eZDateTime::currentTimeStamp());
$version->setAttribute('status', eZContentObjectVersion::STATUS_DRAFT);
$version->store();
$contentObjectID = $contentObject->attribute('id');
$attributes = $contentObject->attribute('contentobject_attributes');
$attributes[0]->fromString($name);
$attributes[0]->store();
$operationResult = eZOperationHandler::execute('content', 'publish', array('object_id' => $contentObjectID, 'version' => 1));
return true;
}
/**
* Unserialize xml structure. Creates an object from xml input.
*
* Transaction unsafe. If you call several transaction unsafe methods you must enclose
* the calls within a db transaction; thus within db->begin and db->commit.
*
* @param mixed $package
* @param DOMElement $domNode
* @param array $options
* @param int|bool $ownerID Override owner ID, null to use XML owner id (optional)
* @param string $handlerType
* @return array|bool|eZContentObject|null created object, false if could not create object/xml invalid
*/
static function unserialize( $package, $domNode, &$options, $ownerID = false, $handlerType = 'ezcontentobject' )
{
if ( $domNode->localName != 'object' )
{
$retValue = false;
return $retValue;
}
$initialLanguage = eZContentObject::mapLanguage( $domNode->getAttribute( 'initial_language' ), $options );
if( $initialLanguage === 'skip' )
{
$retValue = true;
return $retValue;
}
$sectionID = $domNode->getAttributeNS( 'http://ez.no/ezobject', 'section_id' );
if ( $ownerID === false )
{
$ownerID = $domNode->getAttributeNS( 'http://ez.no/ezobject', 'owner_id' );
}
$remoteID = $domNode->getAttribute( 'remote_id' );
$name = $domNode->getAttribute( 'name' );
$classRemoteID = $domNode->getAttribute( 'class_remote_id' );
$classIdentifier = $domNode->getAttributeNS( 'http://ez.no/ezobject', 'class_identifier' );
$alwaysAvailable = ( $domNode->getAttributeNS( 'http://ez.no/ezobject', 'always_available' ) == '1' );
$contentClass = eZContentClass::fetchByRemoteID( $classRemoteID );
if ( !$contentClass )
{
$contentClass = eZContentClass::fetchByIdentifier( $classIdentifier );
}
if ( !$contentClass )
{
$options['error'] = array( 'error_code' => self::PACKAGE_ERROR_NO_CLASS,
'element_id' => $remoteID,
'description' => "Can't install object '$name': Unable to fetch class with remoteID: $classRemoteID." );
$retValue = false;
return $retValue;
}
/** @var DOMElement $versionListNode */
$versionListNode = $domNode->getElementsByTagName( 'version-list' )->item( 0 );
$importedLanguages = array();
foreach( $versionListNode->getElementsByTagName( 'version' ) as $versionDOMNode )
{
/** @var DOMElement $versionDOMNode */
foreach ( $versionDOMNode->getElementsByTagName( 'object-translation' ) as $versionDOMNodeChild )
{
/** @var DOMElement $versionDOMNodeChild */
$importedLanguage = eZContentObject::mapLanguage( $versionDOMNodeChild->getAttribute( 'language' ), $options );
$language = eZContentLanguage::fetchByLocale( $importedLanguage );
// Check if the language is allowed in this setup.
if ( $language )
{
$hasTranslation = true;
}
else
{
if ( $importedLanguage == 'skip' )
continue;
// if there is no needed translation in system then add it
$locale = eZLocale::instance( $importedLanguage );
$translationName = $locale->internationalLanguageName();
$translationLocale = $locale->localeCode();
if ( $locale->isValid() )
{
eZContentLanguage::addLanguage( $locale->localeCode(), $locale->internationalLanguageName() );
$hasTranslation = true;
}
else
$hasTranslation = false;
}
if ( $hasTranslation )
{
$importedLanguages[] = $importedLanguage;
$importedLanguages = array_unique( $importedLanguages );
}
}
}
// If object exists we return a error.
// Minimum install element is an object now.
$contentObject = eZContentObject::fetchByRemoteID( $remoteID );
// Figure out initial language
if ( !$initialLanguage ||
!in_array( $initialLanguage, $importedLanguages ) )
{
$initialLanguage = false;
foreach ( eZContentLanguage::prioritizedLanguages() as $language )
{
if ( in_array( $language->attribute( 'locale' ), $importedLanguages ) )
{
$initialLanguage = $language->attribute( 'locale' );
break;
}
}
}
if ( !$contentObject )
{
$firstVersion = true;
$contentObject = $contentClass->instantiateIn( $initialLanguage, $ownerID, $sectionID );
}
else
{
$firstVersion = false;
$description = "Object '$name' already exists.";
$choosenAction = eZPackageHandler::errorChoosenAction( self::PACKAGE_ERROR_EXISTS,
$options, $description, $handlerType, false );
switch( $choosenAction )
{
case eZPackage::NON_INTERACTIVE:
case self::PACKAGE_UPDATE:
{
// Keep existing contentobject.
} break;
case self::PACKAGE_REPLACE:
{
eZContentObjectOperations::remove( $contentObject->attribute( 'id' ) );
unset( $contentObject );
$contentObject = $contentClass->instantiateIn( $initialLanguage, $ownerID, $sectionID );
$firstVersion = true;
} break;
case self::PACKAGE_SKIP:
{
$retValue = true;
return $retValue;
} break;
case self::PACKAGE_NEW:
{
$contentObject->setAttribute( 'remote_id', eZRemoteIdUtility::generate( 'object' ) );
$contentObject->store();
unset( $contentObject );
$contentObject = $contentClass->instantiateIn( $initialLanguage, $ownerID, $sectionID );
$firstVersion = true;
} break;
default:
{
$options['error'] = array( 'error_code' => self::PACKAGE_ERROR_EXISTS,
'element_id' => $remoteID,
'description' => $description,
'actions' => array( self::PACKAGE_REPLACE => ezpI18n::tr( 'kernel/classes', 'Replace existing object' ),
self::PACKAGE_SKIP => ezpI18n::tr( 'kernel/classes', 'Skip object' ),
self::PACKAGE_NEW => ezpI18n::tr( 'kernel/classes', 'Keep existing and create a new one' ),
self::PACKAGE_UPDATE => ezpI18n::tr( 'kernel/classes', 'Update existing object' ) ) );
$retValue = false;
return $retValue;
} break;
}
}
$db = eZDB::instance();
$db->begin();
if ( $alwaysAvailable )
{
// Make sure always available bit is set.
$contentObject->setAttribute( 'language_mask', (int)$contentObject->attribute( 'language_mask' ) | 1 );
}
$contentObject->setAttribute( 'section_id', $sectionID );
$contentObject->store();
$activeVersion = false;
$lastVersion = false;
$versionListActiveVersion = $versionListNode->getAttribute( 'active_version' );
$contentObject->setAttribute( 'remote_id', $remoteID );
$contentObject->setAttribute( 'contentclass_id', $contentClass->attribute( 'id' ) );
$contentObject->store();
$sectionObject = eZSection::fetch( $sectionID );
if ( $sectionObject instanceof eZSection )
{
$updateWithParentSection = false;
}
else
{
$updateWithParentSection = true;
}
$options['language_array'] = $importedLanguages;
$versionList = array();
foreach( $versionListNode->getElementsByTagName( 'version' ) as $versionDOMNode )
{
unset( $nodeList );
$nodeList = array();
$contentObjectVersion = eZContentObjectVersion::unserialize( $versionDOMNode,
$contentObject,
$ownerID,
$sectionID,
$versionListActiveVersion,
$firstVersion,
$nodeList,
$options,
$package,
'ezcontentobject',
$initialLanguage );
if ( !$contentObjectVersion )
{
$db->commit();
$retValue = false;
return $retValue;
}
$versionStatus = $versionDOMNode->getAttributeNS( 'http://ez.no/ezobject', 'status' );
$versionList[$versionDOMNode->getAttributeNS( 'http://ez.no/ezobject', 'version' )] = array( 'node_list' => $nodeList,
'status' => $versionStatus );
unset( $versionStatus );
$firstVersion = false;
$lastVersion = $contentObjectVersion->attribute( 'version' );
if ( $versionDOMNode->getAttribute( 'version' ) == $versionListActiveVersion )
{
$activeVersion = $contentObjectVersion->attribute( 'version' );
}
eZNodeAssignment::setNewMainAssignment( $contentObject->attribute( 'id' ), $lastVersion );
eZOperationHandler::execute( 'content', 'publish', array( 'object_id' => $contentObject->attribute( 'id' ),
'version' => $lastVersion ) );
$mainNodeInfo = null;
foreach ( $nodeList as $nodeInfo )
{
if ( $nodeInfo['is_main'] )
{
$mainNodeInfo =& $nodeInfo;
break;
}
}
if ( $mainNodeInfo )
{
$existingMainNode = eZContentObjectTreeNode::fetchByRemoteID( $mainNodeInfo['parent_remote_id'], false );
if ( $existingMainNode )
{
eZContentObjectTreeNode::updateMainNodeID( $existingMainNode['node_id'],
$mainNodeInfo['contentobject_id'],
$mainNodeInfo['contentobject_version'],
$mainNodeInfo['parent_node'],
$updateWithParentSection );
}
}
unset( $mainNodeInfo );
// Refresh $contentObject from DB.
$contentObject = eZContentObject::fetch( $contentObject->attribute( 'id' ) );
}
if ( !$activeVersion )
{
$activeVersion = $lastVersion;
}
/*
$contentObject->setAttribute( 'current_version', $activeVersion );
*/
$contentObject->setAttribute( 'name', $name );
if ( isset( $options['use_dates_from_package'] ) && $options['use_dates_from_package'] )
{
$contentObject->setAttribute( 'published', eZDateUtils::textToDate( $domNode->getAttributeNS( 'http://ez.no/ezobject', 'published' ) ) );
$contentObject->setAttribute( 'modified', eZDateUtils::textToDate( $domNode->getAttributeNS( 'http://ez.no/ezobject', 'modified' ) ) );
}
$contentObject->store();
$versions = $contentObject->versions();
$objectName = $contentObject->name();
$objectID = $contentObject->attribute( 'id' );
foreach ( $versions as $version )
{
$versionNum = $version->attribute( 'version' );
$oldVersionStatus = $version->attribute( 'status' );
$newVersionStatus = isset( $versionList[$versionNum] ) ? $versionList[$versionNum]['status'] : null;
// set the correct status for non-published versions
if ( isset( $newVersionStatus ) && $oldVersionStatus != $newVersionStatus && $newVersionStatus != eZContentObjectVersion::STATUS_PUBLISHED )
{
$version->setAttribute( 'status', $newVersionStatus );
$version->store( array( 'status' ) );
}
// when translation does not have object name set then we copy object name from the current object version
$translations = $version->translations( false );
if ( !$translations )
continue;
foreach ( $translations as $translation )
{
if ( ! $contentObject->name( $versionNum, $translation ) )
{
eZDebug::writeNotice( "Setting name '$objectName' for version ($versionNum) of the content object ($objectID) in language($translation)" );
$contentObject->setName( $objectName, $versionNum, $translation );
}
}
}
foreach ( $versionList[$versionListActiveVersion]['node_list'] as $nodeInfo )
{
unset( $parentNode );
$parentNode = eZContentObjectTreeNode::fetchNode( $contentObject->attribute( 'id' ),
$nodeInfo['parent_node'] );
if ( is_object( $parentNode ) )
{
$parentNode->setAttribute( 'priority', $nodeInfo['priority'] );
$parentNode->store( array( 'priority' ) );
}
}
$db->commit();
return $contentObject;
}
/**
* Returns the content class to use when creating the content object from
* the file
*
* @param array $mimeData
* @return eZContentClass
* @throw RuntimeException if the found class identifier does not exists
* @throw DomainException if objects of the found class are not allowed
*/
public function getContentClass(array $mimeData)
{
$upload = new eZContentUpload();
$classIdentifier = $upload->detectClassIdentifier($mimeData['name']);
$class = eZContentClass::fetchByIdentifier($classIdentifier);
if (!$class instanceof eZContentClass) {
throw new RuntimeException(ezpI18n::tr('extension/ezjscore/ajaxuploader', 'Unable to load the class which identifier is "%class",' . ' this is probably a configuration issue in upload.ini.', null, array('%class' => $classIdentifier)));
}
$classContent = $this->attribute->attribute('class_content');
if (!empty($classContent['class_constraint_list']) && !in_array($classIdentifier, $classContent['class_constraint_list'])) {
throw new DomainException(ezpI18n::tr('extension/ezjscore/ajaxuploader', 'The file cannot be processed because' . ' it would result in a \'%class\' object and this relation' . ' does not accept this type of object.', null, array('%class' => $class->attribute('name'))));
}
return $class;
}
}
if ($http->hasPostVariable('NewButton') || $module->isCurrentAction('NewObjectAddNodeAssignment')) {
$hasClassInformation = false;
$contentClassID = false;
$contentClassIdentifier = false;
$languageCode = false;
$class = false;
if ($http->hasPostVariable('ClassID')) {
$contentClassID = $http->postVariable('ClassID');
if ($contentClassID) {
$hasClassInformation = true;
}
} else {
if ($http->hasPostVariable('ClassIdentifier')) {
$contentClassIdentifier = $http->postVariable('ClassIdentifier');
$class = eZContentClass::fetchByIdentifier($contentClassIdentifier);
if (is_object($class)) {
$contentClassID = $class->attribute('id');
if ($contentClassID) {
$hasClassInformation = true;
}
}
}
}
if ($http->hasPostVariable('ContentLanguageCode')) {
$languageCode = $http->postVariable('ContentLanguageCode');
$languageID = eZContentLanguage::idByLocale($languageCode);
if ($languageID === false) {
eZDebug::writeError("The language code [{$languageCode}] specified in ContentLanguageCode does not exist in the system.");
return $module->handleError(eZError::KERNEL_NOT_AVAILABLE, 'kernel');
}
/**
*
* Récupère l'id numérique correspondant à un identifiant de classe
* @param $classIdentifier : un identifiant de classe
* @return l'ID numérique de la classe (0 si la classe n'existe pas)
*
*/
public static function getClassID( $classIdentifier )
{
$classID = 0;
$class = is_numeric( $classIdentifier ) ?
eZContentClass::fetch( $classIdentifier ) :
eZContentClass::fetchByIdentifier( $classIdentifier );
if ( ! empty( $class ) )
{
$classID = (int)$class->ID;
}
return $classID;
}
public static function checkAccess($access, $contentObject, $contentClassID, $parentContentClassID, $languageCode = false)
{
if ($contentObject instanceof eZContentObjectTreeNode) {
$contentObject = $contentObject->attribute('object');
}
if ($contentClassID !== false and !is_numeric($contentClassID)) {
$class = eZContentClass::fetchByIdentifier($contentClassID);
if (!$class) {
return array('error' => array('error_type' => 'kernel', 'error_code' => eZError::KERNEL_NOT_FOUND));
}
$contentClassID = $class->attribute('id');
}
if ($access and $contentObject instanceof eZContentObject) {
$result = $contentObject->checkAccess($access, $contentClassID, $parentContentClassID, false, $languageCode);
return array('result' => $result);
}
}
function createContentObject( $objectInformation )
{
$db = eZDB::instance();
$contentObjectVersion = false;
if ( $objectInformation['ownerID'] )
{
$userID = $objectInformation['ownerID'];
}
else
{
$user = eZUser::currentUser();
$userID = $user->attribute( 'contentobject_id' );
}
if ( $objectInformation['remoteID'] )
{
$contentObject = eZContentObject::fetchByRemoteId( $objectInformation['remoteID'] );
if ( $contentObject )
{
$this->writeMessage( "\t[".$objectInformation['remoteID']."] Object exists: " . $contentObject->attribute("name") . ". Creating new version.", 'notice' );
$contentObjectVersion = $contentObject->createNewVersion();
}
}
elseif ( $objectInformation['objectID'] )
{
$contentObject = eZContentObject::fetch( $objectInformation['objectID'] );
if ( $contentObject )
{
$this->writeMessage( "\t[".$objectInformation['remoteID']."] Object exists: " . $contentObject->attribute("name") . ". Creating new version.", 'notice' );
$contentObjectVersion = $contentObject->createNewVersion();
}
}
if ( !$contentObjectVersion )
{
if ( is_numeric( $objectInformation['classID'] ) )
{
$contentClass = eZContentClass::fetch( $objectInformation['classID'] );
}
elseif ( is_string( $objectInformation['classID'] ) && $objectInformation['classID'] != "" )
{
$contentClass = eZContentClass::fetchByIdentifier( $objectInformation['classID'] );
}
else
{
$this->writeMessage( "\tNo class defined. Using class article.", 'warning' );
$contentClass = eZContentClass::fetchByIdentifier( 'article' );
}
if ( !$contentClass )
{
$this->writeMessage( "\tCannot instantiate class '". $objectInformation['classID'] ."'." , 'error' );
return false;
}
$contentObject = $contentClass->instantiate( $userID );
$contentObject->setAttribute( 'remote_id', $objectInformation['remoteID'] );
if ( $contentObject )
{
$contentObjectVersion = $contentObject->currentVersion();
}
}
if ( $contentObjectVersion )
{
$db->begin();
$versionNumber = $contentObjectVersion->attribute( 'version' );
$sortField = intval( eZContentObjectTreeNode::sortFieldID( $objectInformation['sort_field'] ) );
$sortOrder = strtolower( $objectInformation['sort_order'] ) == 'desc' ? eZContentObjectTreeNode::SORT_ORDER_DESC : eZContentObjectTreeNode::SORT_ORDER_ASC;
$nodeAssignment = eZNodeAssignment::create(
array( 'contentobject_id' => $contentObject->attribute( 'id' ),
'contentobject_version' => $versionNumber,
'parent_node' => $objectInformation['parentNode'],
'is_main' => 1,
'sort_field' => $sortField,
'sort_order' => $sortOrder,
)
);
$nodeAssignment->store();
$dataMap = $contentObjectVersion->dataMap();
foreach ( $objectInformation['attributes'] as $attributeName => $attributesContent )
{
if ( array_key_exists( $attributeName, $dataMap ) )
{
$attribute = $dataMap[$attributeName];
$classAttributeID = $attribute->attribute( 'contentclassattribute_id' );
$dataType = $attribute->attribute( 'data_type_string' );
switch ( $dataType )
{
case 'ezstring':
case 'eztext':
case 'ezselection':
case 'ezemail':
{
if ( array_key_exists( 'parseReferences', $attributesContent ) && $attributesContent['parseReferences'] == "true" )
{
$attribute->setAttribute( 'data_text', $this->parseAndReplaceStringReferences( $attributesContent['content'] ) );
}
else
{
$attribute->setAttribute( 'data_text', $attributesContent['content'] );
}
} break;
case 'ezboolean':
case 'ezinteger':
{
$attribute->setAttribute( 'data_int', (int)$attributesContent['content'] );
} break;
case 'ezxmltext':
{
if ( array_key_exists( 'parseReferences', $attributesContent ) && $attributesContent['parseReferences'] == "true" )
{
$attributesContent['content'] = $this->parseAndReplaceStringReferences( $attributesContent['content'] );
}
if ( array_key_exists( 'htmlDecode', $attributesContent ) && $attributesContent['htmlDecode'] == "true" )
{
$content = html_entity_decode( $attributesContent['content'] );
}
else
{
$content = $attributesContent['content'];
}
if( array_key_exists( 'fullxml', $attributesContent ) && $attributesContent['fullxml'] == "true" )
{
$xml = $content;
}
else
{
$xml = '<?xml version="1.0" encoding="utf-8"?>'."\n".
'<section xmlns:image="http://ez.no/namespaces/ezpublish3/image/"'."\n".
' xmlns:xhtml="http://ez.no/namespaces/ezpublish3/xhtml/"'."\n".
' xmlns:custom="http://ez.no/namespaces/ezpublish3/custom/">'."\n".
' <section>'."\n";
$xml .= ' <paragraph>' . $content . "</paragraph>\n";
$xml .= " </section>\n</section>\n";
}
$attribute->setAttribute( 'data_text', $xml );
} break;
case 'ezprice':
case 'ezfloat':
{
$attribute->setAttribute( 'data_float', (float)$attributesContent['content'] );
} break;
case 'ezimage':
{
$imagePath = $this->setting( 'data_source' ) . '/' . $attributesContent['src'];
$imageName = $attributesContent['title'];
$path = realpath( $imagePath );
if ( file_exists( $path ) )
{
$content = $attribute->content();
$content->initializeFromFile( $path, $imageName, basename( $attributesContent['src'] ) );
$content->store( $attribute );
}
else
{
$this->writeMessage( "\tFile " . $path . " not found.", 'warning' );
}
} break;
case 'ezobjectrelation':
{
$relationContent = trim( $attributesContent['content'] );
if ( $relationContent != '' )
{
$objectID = $this->getReferenceID( $attributesContent['content'] );
if ( $objectID )
{
$attribute->setAttribute( 'data_int', $objectID );
eZContentObject::fetch( $objectID )->addContentObjectRelation( $objectID, $versionNumber, $contentObject->attribute( 'id' ), $attribute->attribute( 'contentclassattribute_id' ), eZContentObject::RELATION_ATTRIBUTE );
}
else
{
$this->writeMessage( "\tReference " . $attributesContent['content'] . " not set.", 'warning' );
}
}
} break;
case 'ezurl':
{
$url = '';
$title = '';
if ( array_key_exists( 'url', $attributesContent ) )
$url = $attributesContent['url'];
if ( array_key_exists( 'title', $attributesContent ) )
$title = $attributesContent['title'];
if ( array_key_exists( 'parseReferences', $attributesContent ) && $attributesContent['parseReferences'] == "true" )
{
$title = $this->parseAndReplaceStringReferences( $title );
$url = $this->parseAndReplaceStringReferences( $url );
}
$attribute->setAttribute( 'data_text', $title );
$attribute->setContent( $url );
} break;
case 'ezuser':
{
$login = '';
$email = '';
$password = '';
if ( array_key_exists( 'login', $attributesContent ) )
$login = $attributesContent['login'];
if ( array_key_exists( 'email', $attributesContent ) )
$email = $attributesContent['email'];
if ( array_key_exists( 'password', $attributesContent ) )
$password = $attributesContent['password'];
$contentObjectID = $attribute->attribute( "contentobject_id" );
$user =& $attribute->content();
if ( $user === null )
{
$user = eZUser::create( $contentObjectID );
}
$ini =& eZINI::instance();
$generatePasswordIfEmpty = $ini->variable( "UserSettings", "GeneratePasswordIfEmpty" );
if ( $password == "" )
{
if ( $generatePasswordIfEmpty == 'true' )
{
$passwordLength = $ini->variable( "UserSettings", "GeneratePasswordLength" );
$password = $user->createPassword( $passwordLength );
}
else
{
$password = null;
}
}
if ( $password == "_ezpassword" )
{
$password = false;
$passwordConfirm = false;
}
$user->setInformation( $contentObjectID, $login, $email, $password, $password );
$attribute->setContent( $user );
} break;
case 'ezkeyword':
{
$keyword = new eZKeyword();
$keyword->initializeKeyword( $attributesContent['content'] );
$attribute->setContent( $keyword );
} break;
case 'ezmatrix':
{
if ( is_array( $attributesContent ) )
{
$matrix = $attribute->attribute( 'content' );
$cells = array();
$matrix->Matrix['rows']['sequential'] = array();
$matrix->NumRows = 0;
foreach( $attributesContent as $key => $value )
{
$cells = array_merge( $cells, $value );
$newRow['columns'] = $value;
$newRow['identifier'] = 'row_' . ( $matrix->NumRows + 1 );
$newRow['name'] = 'Row_' . ( $matrix->NumRows + 1 );
$matrix->NumRows++;
$matrix->Matrix['rows']['sequential'][] = $newRow;
}
$matrix->Cells = $cells;
$attribute->setAttribute( 'data_text', $matrix->xmlString() );
$matrix->decodeXML( $attribute->attribute( 'data_text' ) );
$attribute->setContent( $matrix );
}
} break;
case 'ezobjectrelationlist':
{
$relationContent = explode( ',', $attributesContent['content'] );
if ( count( $relationContent ) )
{
$objectIDs = array();
foreach( $relationContent as $relation )
{
$objectIDs[] = $this->getReferenceID( trim ( $relation ) );
}
$attribute->fromString( implode( '-', $objectIDs ) );
}
else
{
eZDebug::writeWarning( $attributesContent['content'], "No relation declared" );
}
} break;
case 'ezauthor':
case 'ezbinaryfile':
case 'ezcountry':
case 'ezdate':
case 'ezdatetime':
case 'ezenum':
case 'ezidentifier':
case 'ezinisetting':
case 'ezisbn':
case 'ezmedia':
case 'ezmultioption':
case 'ezmultiprice':
case 'ezoption':
case 'ezpackage':
case 'ezproductcategory':
case 'ezrangeoption':
case 'ezsubtreesubscription':
case 'eztime':
default:
{
try
{
$attribute->fromString($attributesContent['content']);
}
catch ( Exception $e )
{
$this->writeMessage( "\tDatatype " . $dataType . " fromString function rejected value " . $attributesContent['content'], 'warning' );
}
} break;
}
$attribute->store();
}
}
if ( isset($objectInformation['sectionID']) && $objectInformation['sectionID'] != '' && $objectInformation['sectionID'] != 0 )
{
$contentObject->setAttribute( 'section_id', $objectInformation['sectionID'] );
}
if ( isset($objectInformation['creatorID']) && $objectInformation['creatorID'] != '' && $objectInformation['creatorID'] != 0 )
{
$contentObjectVersion->setAttribute( 'creator_id', $objectInformation['creatorID'] );
}
if ( isset($objectInformation['ownerID']) && $objectInformation['ownerID'] != '' && $objectInformation['ownerID'] != 0 )
{
$contentObject->setAttribute( 'owner_id', $objectInformation['ownerID'] );
}
if( isset( $objectInformation['relations'] ) && is_array( $objectInformation['relations'] ) )
{
foreach( $objectInformation['relations'] as $toObjectID )
{
$contentObject->addContentObjectRelation( $toObjectID );
}
}
$contentObjectVersion->store();
$contentObject->store();
$db->commit();
eZOperationHandler::execute( 'content', 'publish', array( 'object_id' => $contentObject->attribute( 'id' ), 'version' => $versionNumber ) );
$newNodeArray = eZContentObjectTreeNode::fetchByContentObjectID( $contentObject->attribute( 'id' ) );
$refArray = false;
if ( $newNodeArray && count($newNodeArray) >= 1 )
{
$newNode = $newNodeArray[0];
if ( $newNode )
{
$refArray = array( "node_id" => $newNode->attribute( 'node_id' ),
"name" => $contentObjectVersion->attribute( 'name' ),
"object_id" => $contentObject->attribute( 'id' ) );
if( $objectInformation['priority'] )
{
$this->updateNodePriority( $refArray['node_id'], $objectInformation['priority'] );
}
}
}
unset($contentObjectVersion);
unset($contentObject);
return $refArray;
}
return false;
}
<?php
$Module = $Params['Module'];
$tpl = eZTemplate::factory();
$newsletter_ini = eZINI::instance('jaj_newsletter.ini');
$newsletter_root_node_id = $newsletter_ini->variable('NewsletterSettings', 'RootFolderNodeId');
$node = eZContentObject::fetchByNodeID($newsletter_root_node_id);
if (!$node || !$node->canRead()) {
return $Module->handleError(eZError::KERNEL_NOT_AVAILABLE, 'kernel');
}
switch (eZPreferences::value('admin_jaj_newsletter_newsletters_limit')) {
case '25':
$limit = 25;
break;
case '50':
$limit = 50;
break;
default:
$limit = 10;
break;
}
$newsletter_content_class = eZContentClass::fetchByIdentifier('jaj_newsletter');
if ($newsletter_content_class) {
$tpl->setVariable('newsletter_content_class_id', $newsletter_content_class->ID);
}
$viewParameters = array('offset' => $Params['Offset']);
$tpl->setVariable('node', $node);
$tpl->setVariable('set_limit', $limit);
$tpl->setVariable('view_parameters', $viewParameters);
$Result = array('content' => $tpl->fetch('design:jaj_newsletter/newsletters/index.tpl'), 'path' => array(array('url' => 'jaj_newsletter/index', 'text' => ezpI18n::tr('jaj_newsletter/navigation', 'Newsletter')), array('url' => false, 'text' => ezpI18n::tr('jaj_newsletter/navigation', 'Newsletters'))));
/**
* Content creation
* <code>
* $options = new SQLIContentOptions( array( 'class_identifier' => 'article',
* 'remote_id' => 'myremoteid',
* 'language' => 'fre-FR' ) );
* $article = SQLIContent::create( $options );
* $article->fields->title = 'My Title';
* $article->fields->body = '<tag>myxmlcontent</tag>';
* </code>
* @param SQLIContentOptions $options See {@link SQLIContentOptions::__set()} to see available options.
* Mandatory parameters are :
* - class_identifier
*/
public static function create(SQLIContentOptions $options)
{
if (!isset($options['class_identifier'])) {
throw new SQLIContentException('Cannot create content without "class_identifier" option');
}
$creatorID = $options['creator_id'];
$sectionID = $options['section_id'];
$lang = $options['language'];
$contentObject = null;
// If remote ID is set, first try to fetch content object from it
if (isset($options['remote_id'])) {
$contentObject = eZContentObject::fetchByRemoteID($options['remote_id']);
}
if (!$contentObject instanceof eZContentObject) {
$db = eZDB::instance();
$db->begin();
$contentClass = eZContentClass::fetchByIdentifier($options['class_identifier']);
$contentObject = $contentClass->instantiate($creatorID, $sectionID, false, $lang);
if (isset($options['remote_id'])) {
$contentObject->setAttribute('remote_id', $options['remote_id']);
$contentObject->store();
}
$db->commit();
}
$content = self::fromContentObject($contentObject);
if ($lang) {
$content->setActiveLanguage($lang);
}
return $content;
}
$node = eZContentObjectTreeNode::fetch($nodeID );
if (!$node) {
continue;
}
if ($node->canRemove()) {
$node->removeNodeFromTree($moveToTrash);
$removeCount++;
}
}
$tpl->setVariable('remove_count', $removeCount);
}
}
}
$path = array(array('url' => 'classlists/list', 'text' => ezpI18n::tr('classlists/list', 'Lists by content class')));
if ($classIdentifier != '') {
$classObject = eZContentClass::fetchByIdentifier($classIdentifier);
if (is_object($classObject)) {
$page_uri = trim($Module->redirectionURI('classlists', 'list', array($classIdentifier, $sortMethod, $sortOrder)), '/');
$path[] = array('url' => $page_uri, 'text' => ezpI18n::tr('classlists/list', '%classname objects', false, array('%classname' => $classObject->attribute('name'))));
$tpl->setVariable('class_identifier', $classIdentifier);
$tpl->setVariable('page_uri', $page_uri);
} else {
$page_uri = trim($Module->redirectionURI('classlists', 'list', array('', $sortMethod, $sortOrder)), '/');
$tpl->setVariable('page_uri', $page_uri);
$tpl->setVariable('class_identifier', false);
$tpl->setVariable('error', ezpI18n::tr('classlists/list', '%class_identifier is not a valid content class identifier.', false, array('%class_identifier' => $classIdentifier)));
}
} else {
$tpl->setVariable('page_uri', 'classlists/list//' . $sortMethod . '/' . $sortOrder);
$tpl->setVariable('class_identifier', false);
}
function createSubNode($node, $name)
{
$namedChildrenArray = $node->childrenByName($name);
$subNode = false;
//pk
if (!$node->canCreate()) {
$this->setError(self::ERROR_ACCESSDENIED, ezpI18n::tr('extension/ezodf/import/error', "Folder for images could not be created, access denied."));
return false;
}
if (empty($namedChildrenArray)) {
$class = eZContentClass::fetchByIdentifier("folder");
$creatorID = $this->currentUserID;
//$creatorID = 14; // 14 == admin
$parentNodeID = $placeNodeID;
$contentObject = $class->instantiate($creatorID, 1);
$nodeAssignment = eZNodeAssignment::create(array('contentobject_id' => $contentObject->attribute('id'), 'contentobject_version' => $contentObject->attribute('current_version'), 'parent_node' => $node->attribute('node_id'), 'is_main' => 1));
$nodeAssignment->store();
$version = $contentObject->version(1);
$version->setAttribute('modified', eZDateTime::currentTimeStamp());
$version->setAttribute('status', eZContentObjectVersion::STATUS_DRAFT);
$version->store();
$contentObjectID = $contentObject->attribute('id');
$dataMap = $contentObject->dataMap();
$titleAttribudeIdentifier = 'name';
$dataMap[$titleAttribudeIdentifier]->setAttribute('data_text', $name);
$dataMap[$titleAttribudeIdentifier]->store();
$operationResult = eZOperationHandler::execute('content', 'publish', array('object_id' => $contentObjectID, 'version' => 1));
$subNode = $contentObject->mainNode();
} else {
if (count($namedChildrenArray) == 1) {
$subNode = $namedChildrenArray[0];
}
}
return $subNode;
}
protected function __construct($classIdentifier)
{
$this->contentClass = eZContentClass::fetchByIdentifier($classIdentifier);
if (!$this->contentClass instanceof eZContentClass) {
throw new Exception("Class {$classIdentifier} not found");
}
}
/**
* Returns a valid limitation value to be saved in database
*
* @since 1.2.0
* @param string $limitationType Limitation type
* @param string $limitationValue Human readable input value
* @return string Value to be saved in database
*/
private function getLimitationValue($limitationType, $limitationValue)
{
$limitationValue = $this->getReferenceID($limitationValue);
switch ($limitationType) {
case 'Class':
case 'ParentClass':
if (!is_int($limitationValue)) {
$class = eZContentClass::fetchByIdentifier($limitationValue);
if ($class) {
$limitationValue = $class->ID;
}
}
break;
case 'Subtree':
//Subtree limitations need to store path_string instead of node_id
$val = (int) $limitationValue;
if ($val > 0) {
$node = eZContentObjectTreeNode::fetch($val);
$limitationValue = $node->attribute('path_string');
}
break;
case 'SiteAccess':
//siteaccess name must be crc32'd
if (!is_int($limitationValue)) {
$limitationValue = eZSys::ezcrc32($limitationValue);
}
break;
case 'Section':
if (!is_int($limitationValue)) {
$section = eZSection::fetchByIdentifier($limitationValue);
if ($section) {
$limitationValue = $section->attribute('id');
}
}
break;
}
return $limitationValue;
}
function initializePackage($siteType, &$accessMap, $charset, &$extraLanguageCodes, &$allLanguages, &$primaryLanguage, &$admin, &$resultArray)
{
// Time limit #3:
// We set the time limit to 5 minutes to ensure we have enough time
// to initialize the site. However we only set if the current limit
// is too small
$maxTime = ini_get('max_execution_time');
if ($maxTime != 0 and $maxTime < 5 * 60) {
@set_time_limit(5 * 60);
}
switch ($siteType['access_type']) {
case 'port':
$userSiteaccessName = $siteType['identifier'] . '_' . 'user';
$adminSiteaccessName = $siteType['identifier'] . '_' . 'admin';
$accessMap['port'][$siteType['access_type_value']] = $userSiteaccessName;
$accessMap['port'][$siteType['admin_access_type_value']] = $adminSiteaccessName;
break;
case 'hostname':
$userSiteaccessName = $siteType['identifier'] . '_' . 'user';
$adminSiteaccessName = $siteType['identifier'] . '_' . 'admin';
$accessMap['hostname'][$siteType['access_type_value']] = $userSiteaccessName;
$accessMap['hostname'][$siteType['admin_access_type_value']] = $adminSiteaccessName;
break;
case 'url':
default:
$userSiteaccessName = $siteType['access_type_value'];
$adminSiteaccessName = $siteType['admin_access_type_value'];
$accessMap['url'][$siteType['access_type_value']] = $userSiteaccessName;
$accessMap['url'][$siteType['admin_access_type_value']] = $adminSiteaccessName;
break;
}
$accessMap['accesses'][] = $userSiteaccessName;
$accessMap['accesses'][] = $adminSiteaccessName;
$accessMap['sites'][] = $userSiteaccessName;
$userDesignName = $siteType['identifier'];
$languageObjects = $allLanguages;
$databaseMap = eZSetupDatabaseMap();
$databaseInfo = $this->PersistenceList['database_info'];
$databaseInfo['info'] = $databaseMap[$databaseInfo['type']];
$dbServer = $databaseInfo['server'];
$dbPort = $databaseInfo['port'];
// $dbName = $databaseInfo['dbname'];
$dbSocket = $databaseInfo['socket'];
$dbUser = $databaseInfo['user'];
$dbPwd = $databaseInfo['password'];
$dbCharset = $charset;
$dbDriver = $databaseInfo['info']['driver'];
$dbName = $siteType['database'];
$dbParameters = array('server' => $dbServer, 'port' => $dbPort, 'user' => $dbUser, 'password' => $dbPwd, 'socket' => $dbSocket, 'database' => $dbName, 'charset' => $dbCharset);
$db = eZDB::instance($dbDriver, $dbParameters, true);
if (!$db->isConnected()) {
$resultArray['errors'][] = array('code' => 'EZSW-005', 'text' => "Failed connecting to database {$dbName}\n" . $db->errorMessage());
return false;
}
eZDB::setInstance($db);
$result = true;
// Initialize the database by inserting schema and data
if (!isset($siteType['existing_database'])) {
$siteType['existing_database'] = false;
}
if ($siteType['existing_database'] == eZStepInstaller::DB_DATA_REMOVE) {
eZDBTool::cleanup($db);
}
if ($siteType['existing_database'] != eZStepInstaller::DB_DATA_KEEP) {
$result = true;
$schemaArray = eZDbSchema::read('share/db_schema.dba', true);
if (!$schemaArray) {
$resultArray['errors'][] = array('code' => 'EZSW-001', 'message' => "Failed loading database schema file share/db_schema.dba");
$result = false;
}
if ($result) {
$result = true;
$dataArray = eZDbSchema::read('share/db_data.dba', true);
if (!$dataArray) {
$resultArray['errors'][] = array('code' => 'EZSW-002', 'text' => "Failed loading database data file share/db_data.dba");
$result = false;
}
if ($result) {
$schemaArray = array_merge($schemaArray, $dataArray);
$schemaArray['type'] = strtolower($db->databaseName());
$schemaArray['instance'] = $db;
$result = true;
$dbSchema = eZDbSchema::instance($schemaArray);
if (!$dbSchema) {
$resultArray['errors'][] = array('code' => 'EZSW-003', 'text' => "Failed loading " . $db->databaseName() . " schema handler");
$result = false;
}
if ($result) {
$result = true;
// This will insert the schema, then the data and
// run any sequence value correction SQL if required
$params = array('schema' => true, 'data' => true);
if ($db->databaseName() == 'mysql') {
$engines = $db->arrayQuery('SHOW ENGINES');
foreach ($engines as $engine) {
if ($engine['Engine'] == 'InnoDB' && in_array($engine['Support'], array('YES', 'DEFAULT'))) {
$params['table_type'] = 'innodb';
break;
}
}
}
if (!$dbSchema->insertSchema($params)) {
$resultArray['errors'][] = array('code' => 'EZSW-004', 'text' => "Failed inserting data to " . $db->databaseName() . "\n" . $db->errorMessage());
$result = false;
}
}
}
}
if ($result) {
// Inserting data from the dba-data files of the datatypes
eZDataType::loadAndRegisterAllTypes();
$registeredDataTypes = eZDataType::registeredDataTypes();
foreach ($registeredDataTypes as $dataType) {
if (!$dataType->importDBDataFromDBAFile()) {
$resultArray['errors'][] = array('code' => 'EZSW-002', 'text' => "Failed importing datatype related data into database: \n" . 'datatype - ' . $dataType->DataTypeString . ", \n" . 'dba-data file - ' . $dataType->getDBAFilePath());
}
}
}
}
if (!$result) {
return false;
}
// Database initialization done
// Prepare languages
$primaryLanguageLocaleCode = $primaryLanguage->localeCode();
$primaryLanguageName = $primaryLanguage->languageName();
$prioritizedLanguages = array_merge(array($primaryLanguageLocaleCode), $extraLanguageCodes);
$installParameters = array('path' => '.');
$installParameters['ini'] = array();
$siteINIChanges = array();
$url = $siteType['url'];
if (preg_match("#^[a-zA-Z0-9]+://(.*)\$#", $url, $matches)) {
$url = $matches[1];
}
$siteINIChanges['SiteAccessSettings'] = array('RelatedSiteAccessList' => $accessMap['accesses']);
$siteINIChanges['ContentSettings'] = array('TranslationList' => implode(';', $extraLanguageCodes));
$siteINIChanges['SiteSettings'] = array('SiteName' => $siteType['title'], 'SiteURL' => $url);
$siteINIChanges['DatabaseSettings'] = array('DatabaseImplementation' => $dbDriver, 'Server' => $dbServer, 'Port' => $dbPort, 'Database' => $dbName, 'User' => $dbUser, 'Password' => $dbPwd, 'Charset' => false);
$siteINIChanges['FileSettings'] = array('VarDir' => 'var/' . $siteType['identifier']);
if (trim($dbSocket) != '') {
$siteINIChanges['DatabaseSettings']['Socket'] = $dbSocket;
} else {
$siteINIChanges['DatabaseSettings']['Socket'] = 'disabled';
}
if ($admin['email']) {
$siteINIChanges['InformationCollectionSettings'] = array('EmailReceiver' => false);
$siteINIChanges['UserSettings'] = array('RegistrationEmail' => false);
$siteINIChanges['MailSettings'] = array('AdminEmail' => $admin['email'], 'EmailSender' => false);
}
$siteINIChanges['RegionalSettings'] = array('Locale' => $primaryLanguage->localeFullCode(), 'ContentObjectLocale' => $primaryLanguage->localeCode(), 'SiteLanguageList' => $prioritizedLanguages);
if ($primaryLanguage->localeCode() == 'eng-GB') {
$siteINIChanges['RegionalSettings']['TextTranslation'] = 'disabled';
} else {
$siteINIChanges['RegionalSettings']['TextTranslation'] = 'enabled';
}
$installParameters['ini']['siteaccess'][$adminSiteaccessName]['site.ini.append'] = $siteINIChanges;
$installParameters['ini']['siteaccess'][$userSiteaccessName]['site.ini.append'] = $siteINIChanges;
$installParameters['ini']['siteaccess'][$userSiteaccessName]['site.ini']['DesignSettings'] = array('SiteDesign' => $userDesignName);
$installParameters['variables']['user_siteaccess'] = $userSiteaccessName;
$installParameters['variables']['admin_siteaccess'] = $adminSiteaccessName;
$installParameters['variables']['design'] = $userDesignName;
$tmpSiteINI = eZINI::create('site.ini');
// Set ReadOnlySettingsCheck to false: towards
// Ignore site.ini[eZINISettings].ReadonlySettingList[] settings when saving ini variables.
$tmpSiteINI->setReadOnlySettingsCheck(false);
$tmpSiteINI->setVariable('FileSettings', 'VarDir', $siteINIChanges['FileSettings']['VarDir']);
// Change the current translation variables, before other parts start using them
$tmpSiteINI->setVariable('RegionalSettings', 'Locale', $siteINIChanges['RegionalSettings']['Locale']);
$tmpSiteINI->setVariable('RegionalSettings', 'ContentObjectLocale', $siteINIChanges['RegionalSettings']['ContentObjectLocale']);
$tmpSiteINI->setVariable('RegionalSettings', 'TextTranslation', $siteINIChanges['RegionalSettings']['TextTranslation']);
$tmpSiteINI->save(false, '.append.php', false, true, "settings/siteaccess/{$userSiteaccessName}");
/*
$typeFunctionality = eZSetupFunctionality( $siteType['identifier'] );
$extraFunctionality = array_merge( isset( $this->PersistenceList['additional_packages'] ) ?
$this->PersistenceList['additional_packages'] :
array(),
$typeFunctionality['required'] );
$extraFunctionality = array_unique( $extraFunctionality );
*/
// Add a policy to permit editors using OE
eZPolicy::createNew(3, array('ModuleName' => 'ezoe', 'FunctionName' => '*'));
// Install site package and it's required packages
$sitePackageName = $this->chosenSitePackage();
$sitePackage = eZPackage::fetch($sitePackageName);
if (!is_object($sitePackage)) {
$resultArray['errors'][] = array('code' => 'EZSW-041', 'text' => " Could not fetch site package: '{$sitePackageName}'");
return false;
}
$dependecies = $sitePackage->attribute('dependencies');
$requires = $dependecies['requires'];
$requiredPackages = array();
// Include setting files
$settingsFiles = $sitePackage->attribute('settings-files');
foreach ($settingsFiles as $settingsFileName) {
if (file_exists($sitePackage->path() . '/settings/' . $settingsFileName)) {
include_once $sitePackage->path() . '/settings/' . $settingsFileName;
}
}
// Call user function for additional setup tasks.
if (function_exists('eZSitePreInstall')) {
eZSitePreInstall($siteType);
}
// Make sure objects use the selected main language instead of eng-GB
if ($primaryLanguageLocaleCode != 'eng-GB') {
$engLanguageObj = eZContentLanguage::fetchByLocale('eng-GB');
$engLanguageID = (int) $engLanguageObj->attribute('id');
$updateSql = "UPDATE ezcontent_language\nSET\nlocale='{$primaryLanguageLocaleCode}',\nname='{$primaryLanguageName}'\nWHERE\nid={$engLanguageID}";
$db->query($updateSql);
eZContentLanguage::expireCache();
$primaryLanguageObj = eZContentLanguage::fetchByLocale($primaryLanguageLocaleCode);
// Add it if it is missing (most likely)
if (!$primaryLanguageObj) {
$primaryLanguageObj = eZContentLanguage::addLanguage($primaryLanguageLocaleCode, $primaryLanguageName);
}
$primaryLanguageID = (int) $primaryLanguageObj->attribute('id');
// Find objects which are always available
if ($db->databaseName() == 'oracle') {
$sql = "SELECT id\nFROM\nezcontentobject\nWHERE\nbitand( language_mask, 1 ) = 1";
} else {
$sql = "SELECT id\nFROM\nezcontentobject\nWHERE\nlanguage_mask & 1 = 1";
}
$objectList = array();
$list = $db->arrayQuery($sql);
foreach ($list as $row) {
$objectList[] = (int) $row['id'];
}
$inSql = 'IN ( ' . implode(', ', $objectList) . ')';
// Updates databases that have eng-GB data to the new locale.
$updateSql = "UPDATE ezcontentobject_name\nSET\ncontent_translation='{$primaryLanguageLocaleCode}',\nreal_translation='{$primaryLanguageLocaleCode}',\nlanguage_id={$primaryLanguageID}\nWHERE\ncontent_translation='eng-GB' OR\nreal_translation='eng-GB'";
$db->query($updateSql);
// Fix always available
$updateSql = "UPDATE ezcontentobject_name\nSET\nlanguage_id=language_id+1\nWHERE\ncontentobject_id {$inSql}";
$db->query($updateSql);
// attributes
$updateSql = "UPDATE ezcontentobject_attribute\nSET\nlanguage_code='{$primaryLanguageLocaleCode}',\nlanguage_id={$primaryLanguageID}\nWHERE\nlanguage_code='eng-GB'";
$db->query($updateSql);
// Fix always available
$updateSql = "UPDATE ezcontentobject_attribute\nSET\nlanguage_id=language_id+1\nWHERE\ncontentobject_id {$inSql}";
$db->query($updateSql);
// version
$updateSql = "UPDATE ezcontentobject_version\nSET\ninitial_language_id={$primaryLanguageID},\nlanguage_mask={$primaryLanguageID}\nWHERE\ninitial_language_id={$engLanguageID}";
$db->query($updateSql);
// Fix always available
$updateSql = "UPDATE ezcontentobject_version\nSET\nlanguage_mask=language_mask+1\nWHERE\ncontentobject_id {$inSql}";
$db->query($updateSql);
// object
$updateSql = "UPDATE ezcontentobject\nSET\ninitial_language_id={$primaryLanguageID},\nlanguage_mask={$primaryLanguageID}\nWHERE\ninitial_language_id={$engLanguageID}";
$db->query($updateSql);
// Fix always available
$updateSql = "UPDATE ezcontentobject\nSET\nlanguage_mask=language_mask+1\nWHERE\nid {$inSql}";
$db->query($updateSql);
// content object state groups & states
$mask = $primaryLanguageID | 1;
$db->query("UPDATE ezcobj_state_group\n SET language_mask = {$mask}, default_language_id = {$primaryLanguageID}\n WHERE default_language_id = {$engLanguageID}");
$db->query("UPDATE ezcobj_state\n SET language_mask = {$mask}, default_language_id = {$primaryLanguageID}\n WHERE default_language_id = {$engLanguageID}");
$db->query("UPDATE ezcobj_state_group_language\n SET language_id = {$primaryLanguageID}\n WHERE language_id = {$engLanguageID}");
$db->query("UPDATE ezcobj_state_language\n SET language_id = {$primaryLanguageID}\n WHERE language_id = {$engLanguageID}");
// ezcontentclass_name
$updateSql = "UPDATE ezcontentclass_name\nSET\nlanguage_locale='{$primaryLanguageLocaleCode}'\nWHERE\nlanguage_locale='eng-GB'";
$db->query($updateSql);
// use high-level api, because it's impossible to update serialized names with direct sqls.
// use direct access to 'NameList' to avoid unnecessary sql-requests and because
// we do 'replacement' of existing language(with some 'id') with another language code.
$contentClassList = eZContentClass::fetchList();
foreach ($contentClassList as $contentClass) {
$classAttributes = $contentClass->fetchAttributes();
foreach ($classAttributes as $classAttribute) {
$classAttribute->NameList->setName($classAttribute->NameList->name('eng-GB'), $primaryLanguageLocaleCode);
$classAttribute->NameList->setAlwaysAvailableLanguage($primaryLanguageLocaleCode);
$classAttribute->NameList->removeName('eng-GB');
$classAttribute->store();
}
$contentClass->NameList->setName($contentClass->NameList->name('eng-GB'), $primaryLanguageLocaleCode);
$contentClass->NameList->setAlwaysAvailableLanguage($primaryLanguageLocaleCode);
$contentClass->NameList->removeName('eng-GB');
$contentClass->NameList->setHasDirtyData(false);
// to not update 'ezcontentclass_name', because we've already updated it.
$contentClass->store();
}
}
// Setup all languages
foreach ($allLanguages as $languageObject) {
$primaryLanguageObj = eZContentLanguage::fetchByLocale($languageObject->localeCode());
// Add it if it is missing (most likely)
if (!$primaryLanguageObj) {
$primaryLanguageObj = eZContentLanguage::addLanguage($languageObject->localeCode(), $languageObject->internationalLanguageName());
}
}
eZContentLanguage::expireCache();
// Make sure priority list is changed to the new chosen languages
eZContentLanguage::setPrioritizedLanguages($prioritizedLanguages);
if ($siteType['existing_database'] != eZStepInstaller::DB_DATA_KEEP) {
$user = eZUser::instance(14);
// Must be initialized to make node assignments work correctly
if (!is_object($user)) {
$resultArray['errors'][] = array('code' => 'EZSW-020', 'text' => "Could not fetch administrator user object");
return false;
}
// Make sure Admin is the currently logged in user
// This makes sure all new/changed objects get this as creator
$user->loginCurrent();
// by default(if 'language_map' is not set) create all necessary languages
$languageMap = isset($this->PersistenceList['package_info']) && isset($this->PersistenceList['package_info']['language_map']) ? $this->PersistenceList['package_info']['language_map'] : true;
if (is_array($languageMap) && count($languageMap) > 0) {
//
// Create necessary languages and set them as "prioritized languages" to avoid
// drawbacks in fetch functions, like eZContentObjectTreeNode::fetch().
//
$prioritizedLanguageObjects = eZContentLanguage::prioritizedLanguages();
// returned objects
foreach ($languageMap as $fromLanguage => $toLanguage) {
if ($toLanguage != 'skip') {
$prioritizedLanguageObjects[] = eZContentLanguage::fetchByLocale($toLanguage, true);
}
}
$prioritizedLanguageLocales = array();
foreach ($prioritizedLanguageObjects as $language) {
$locale = $language->attribute('locale');
if (!in_array($locale, $prioritizedLanguageLocales)) {
$prioritizedLanguageLocales[] = $locale;
}
}
eZContentLanguage::setPrioritizedLanguages($prioritizedLanguageLocales);
}
foreach ($requires as $require) {
if ($require['type'] != 'ezpackage') {
continue;
}
$packageName = $require['name'];
$package = eZPackage::fetch($packageName, false, false, false);
if (is_object($package)) {
$requiredPackages[] = $package;
if ($package->attribute('install_type') == 'install') {
$installParameters = array('use_dates_from_package' => true, 'site_access_map' => array('*' => $userSiteaccessName), 'top_nodes_map' => array('*' => 2), 'design_map' => array('*' => $userDesignName), 'language_map' => $languageMap, 'restore_dates' => true, 'user_id' => $user->attribute('contentobject_id'), 'non-interactive' => true);
$status = $package->install($installParameters);
if (!$status) {
$errorText = "Unable to install package '{$packageName}'";
if (isset($installParameters['error']['description'])) {
$errorText .= ": " . $installParameters['error']['description'];
}
$resultArray['errors'][] = array('code' => 'EZSW-051', 'text' => $errorText);
return false;
}
}
} else {
$resultArray['errors'][] = array('code' => 'EZSW-050', 'text' => "Could not fetch required package: '{$packageName}'");
return false;
}
unset($package);
}
}
$GLOBALS['eZContentObjectDefaultLanguage'] = $primaryLanguageLocaleCode;
$nodeRemoteMap = array();
$rows = $db->arrayQuery("SELECT node_id, remote_id FROM ezcontentobject_tree");
foreach ($rows as $row) {
$remoteID = $row['remote_id'];
if (strlen(trim($remoteID)) > 0) {
$nodeRemoteMap[$remoteID] = $row['node_id'];
}
}
$objectRemoteMap = array();
$rows = $db->arrayQuery("SELECT id, remote_id FROM ezcontentobject");
foreach ($rows as $row) {
$remoteID = $row['remote_id'];
if (strlen(trim($remoteID)) > 0) {
$objectRemoteMap[$remoteID] = $row['id'];
}
}
$classRemoteMap = array();
$rows = $db->arrayQuery("SELECT id, identifier, remote_id FROM ezcontentclass");
foreach ($rows as $row) {
$remoteID = $row['remote_id'];
if (strlen(trim($remoteID)) > 0) {
$classRemoteMap[$remoteID] = array('id' => $row['id'], 'identifier' => $row['identifier']);
}
}
$siteCSS = false;
$classesCSS = false;
foreach ($requiredPackages as $package) {
if ($package->attribute('type') == 'sitestyle') {
$fileList = $package->fileList('default');
foreach ($fileList as $file) {
$fileIdentifier = $file["variable-name"];
if ($fileIdentifier == 'sitecssfile') {
$siteCSS = $package->fileItemPath($file, 'default');
} else {
if ($fileIdentifier == 'classescssfile') {
$classesCSS = $package->fileItemPath($file, 'default');
}
}
}
}
}
$parameters = array('node_remote_map' => $nodeRemoteMap, 'object_remote_map' => $objectRemoteMap, 'class_remote_map' => $classRemoteMap, 'preview_design' => $userDesignName, 'design_list' => array($userDesignName, 'admin2', 'admin'), 'user_siteaccess' => $userSiteaccessName, 'admin_siteaccess' => $adminSiteaccessName, 'package_object' => $sitePackage, 'siteaccess_urls' => $this->siteaccessURLs(), 'access_map' => $accessMap, 'site_type' => $siteType, 'all_language_codes' => $prioritizedLanguages);
$siteINIStored = false;
$siteINIAdminStored = false;
$designINIStored = false;
if (function_exists('eZSiteINISettings')) {
$extraSettings = eZSiteINISettings($parameters);
} else {
$extraSettings = array();
}
if (function_exists('eZSiteAdminINISettings')) {
$extraAdminSettings = eZSiteAdminINISettings($parameters);
} else {
$extraAdminSettings = array();
}
if (function_exists('eZSiteCommonINISettings')) {
$extraCommonSettings = eZSiteCommonINISettings($parameters);
} else {
$extraCommonSettings = array();
}
$isUntranslatedSettingAdded = false;
foreach ($extraAdminSettings as $key => $extraAdminSetting) {
if ($extraAdminSetting['name'] == 'site.ini') {
$extraAdminSettings[$key]['settings']['RegionalSettings']['ShowUntranslatedObjects'] = 'enabled';
$isUntranslatedSettingAdded = true;
break;
}
}
if (!$isUntranslatedSettingAdded) {
$extraAdminSettings[] = array('name' => 'site.ini', 'settings' => array('RegionalSettings' => array('ShowUntranslatedObjects' => 'enabled')));
}
// Enable OE and ODF extensions by default
$extensionsToEnable = array();
// Included in "fat" install, needs to override $extraCommonSettings extensions
$extensionsPrepended = array('ezjscore', 'ezoe', 'ezformtoken');
foreach (array('ezie', 'ezodf', 'ezprestapiprovider', 'ezmultiupload', 'eztags', 'ezautosave', 'ez_network', 'ez_network_demo') as $extension) {
if (file_exists("extension/{$extension}")) {
$extensionsToEnable[] = $extension;
}
}
$settingAdded = false;
foreach ($extraCommonSettings as $key => $extraCommonSetting) {
if ($extraCommonSetting['name'] == 'site.ini' && isset($extraCommonSettings[$key]['settings']['ExtensionSettings']['ActiveExtensions'])) {
$settingAdded = true;
$extraCommonSettings[$key]['settings']['ExtensionSettings']['ActiveExtensions'] = array_merge($extensionsPrepended, $extraCommonSettings[$key]['settings']['ExtensionSettings']['ActiveExtensions'], $extensionsToEnable);
break;
}
}
if (!$settingAdded) {
$extraCommonSettings[] = array('name' => 'site.ini', 'settings' => array('ExtensionSettings' => array('ActiveExtensions' => array_merge($extensionsPrepended, $extensionsToEnable))));
}
// Enable dynamic tree menu for the admin interface by default
$enableDynamicTreeMenuAdded = false;
foreach ($extraAdminSettings as $key => $extraSetting) {
if ($extraSetting['name'] == 'contentstructuremenu.ini') {
if (isset($extraSetting['settings']['TreeMenu'])) {
$extraAdminSettings[$key]['settings']['TreeMenu']['Dynamic'] = 'enabled';
} else {
$extraAdminSettings[$key]['settings'] = array('TreeMenu' => array('Dynamic' => 'enabled'));
}
$enableDynamicTreeMenuAdded = true;
break;
}
}
if (!$enableDynamicTreeMenuAdded) {
$extraAdminSettings[] = array('name' => 'contentstructuremenu.ini', 'settings' => array('TreeMenu' => array('Dynamic' => 'enabled')));
}
$resultArray['common_settings'] = $extraCommonSettings;
foreach ($extraSettings as $extraSetting) {
if ($extraSetting === false) {
continue;
}
$iniName = $extraSetting['name'];
$settings = $extraSetting['settings'];
$resetArray = false;
if (isset($extraSetting['reset_arrays'])) {
$resetArray = $extraSetting['reset_arrays'];
}
$tmpINI = eZINI::create($iniName);
// Set ReadOnlySettingsCheck to false: towards
// Ignore site.ini[eZINISettings].ReadonlySettingList[] settings when saving ini variables.
$tmpINI->setReadOnlySettingsCheck(false);
$tmpINI->setVariables($settings);
if ($iniName == 'site.ini') {
$siteINIStored = true;
$tmpINI->setVariables($siteINIChanges);
$tmpINI->setVariable('DesignSettings', 'SiteDesign', $userDesignName);
$tmpINI->setVariable('DesignSettings', 'AdditionalSiteDesignList', array('base'));
} else {
if ($iniName == 'design.ini') {
if ($siteCSS) {
$tmpINI->setVariable('StylesheetSettings', 'SiteCSS', $siteCSS);
}
if ($classesCSS) {
$tmpINI->setVariable('StylesheetSettings', 'ClassesCSS', $classesCSS);
}
$designINIStored = true;
}
}
$tmpINI->save(false, '.append.php', false, true, "settings/siteaccess/{$userSiteaccessName}", $resetArray);
if ($siteType['existing_database'] != eZStepInstaller::DB_DATA_KEEP) {
// setting up appropriate data in look&feel object
$templateLookClass = eZContentClass::fetchByIdentifier('template_look', true);
if ($templateLookClass) {
$objectList = $templateLookClass->objectList();
if ($objectList and count($objectList) > 0) {
$templateLookObject = current($objectList);
$dataMap = $templateLookObject->fetchDataMap();
if (isset($dataMap['title'])) {
$dataMap['title']->setAttribute('data_text', $siteINIChanges['SiteSettings']['SiteName']);
$dataMap['title']->store();
}
if (isset($dataMap['siteurl'])) {
$dataMap['siteurl']->setAttribute('data_text', $siteINIChanges['SiteSettings']['SiteURL']);
$dataMap['siteurl']->store();
}
if (isset($dataMap['email'])) {
$dataMap['email']->setAttribute('data_text', $siteINIChanges['MailSettings']['AdminEmail']);
$dataMap['email']->store();
}
$objectName = $templateLookClass->contentObjectName($templateLookObject);
$templateLookObject->setName($objectName);
$templateLookObject->store();
}
}
}
}
foreach ($extraAdminSettings as $extraSetting) {
if ($extraSetting === false) {
continue;
}
$iniName = $extraSetting['name'];
$settings = $extraSetting['settings'];
$resetArray = false;
if (isset($extraSetting['reset_arrays'])) {
$resetArray = $extraSetting['reset_arrays'];
}
$tmpINI = eZINI::create($iniName);
$tmpINI->setVariables($settings);
if ($iniName == 'site.ini') {
$siteINIAdminStored = true;
$tmpINI->setVariables($siteINIChanges);
$tmpINI->setVariable('SiteAccessSettings', 'RequireUserLogin', 'true');
$tmpINI->setVariable('DesignSettings', 'SiteDesign', 'admin2');
$tmpINI->setVariable('DesignSettings', 'AdditionalSiteDesignList', array('admin'));
$tmpINI->setVariable('SiteSettings', 'LoginPage', 'custom');
$tmpINI->setVariable('SiteSettings', 'DefaultPage', 'content/dashboard');
}
$tmpINI->save(false, '.append.php', false, true, "settings/siteaccess/{$adminSiteaccessName}", $resetArray);
}
if (!$siteINIAdminStored) {
$siteINI = eZINI::create('site.ini');
// Set ReadOnlySettingsCheck to false: towards
// Ignore site.ini[eZINISettings].ReadonlySettingList[] settings when saving ini variables.
$siteINI->setReadOnlySettingsCheck(false);
$siteINI->setVariables($siteINIChanges);
$siteINI->setVariable('SiteAccessSettings', 'RequireUserLogin', 'true');
$siteINI->setVariable('DesignSettings', 'SiteDesign', 'admin2');
$tmpINI->setVariable('DesignSettings', 'AdditionalSiteDesignList', array('admin'));
$siteINI->setVariable('SiteSettings', 'LoginPage', 'custom');
$siteINI->setVariable('SiteSettings', 'DefaultPage', 'content/dashboard');
$siteINI->save(false, '.append.php', false, false, "settings/siteaccess/{$adminSiteaccessName}", true);
}
if (!$siteINIStored) {
$siteINI = eZINI::create('site.ini');
// Set ReadOnlySettingsCheck to false: towards
// Ignore site.ini[eZINISettings].ReadonlySettingList[] settings when saving ini variables.
$siteINI->setReadOnlySettingsCheck(false);
$siteINI->setVariables($siteINIChanges);
$siteINI->setVariable('DesignSettings', 'SiteDesign', $userDesignName);
$siteINI->setVariable('DesignSettings', 'AdditionalSiteDesignList', array('base'));
$siteINI->save(false, '.append.php', false, true, "settings/siteaccess/{$userSiteaccessName}", true);
}
if (!$designINIStored) {
$designINI = eZINI::create('design.ini');
// Set ReadOnlySettingsCheck to false: towards
// Ignore site.ini[eZINISettings].ReadonlySettingList[] settings when saving ini variables.
$designINI->setReadOnlySettingsCheck(false);
if ($siteCSS) {
$designINI->setVariable('StylesheetSettings', 'SiteCSS', $siteCSS);
}
if ($classesCSS) {
$designINI->setVariable('StylesheetSettings', 'ClassesCSS', $classesCSS);
}
$designINI->save(false, '.append.php', false, true, "settings/siteaccess/{$userSiteaccessName}");
}
eZDir::mkdir("design/" . $userDesignName);
eZDir::mkdir("design/" . $userDesignName . "/templates");
eZDir::mkdir("design/" . $userDesignName . "/stylesheets");
eZDir::mkdir("design/" . $userDesignName . "/images");
eZDir::mkdir("design/" . $userDesignName . "/override");
eZDir::mkdir("design/" . $userDesignName . "/override/templates");
if ($siteType['existing_database'] == eZStepInstaller::DB_DATA_KEEP) {
return true;
}
// Try and remove user/login without limitation from the anonymous user
$anonRole = eZRole::fetchByName('Anonymous');
if (is_object($anonRole)) {
$anonPolicies = $anonRole->policyList();
foreach ($anonPolicies as $anonPolicy) {
if ($anonPolicy->attribute('module_name') == 'user' and $anonPolicy->attribute('function_name') == 'login') {
$anonPolicy->removeThis();
break;
}
}
}
// Setup all roles according to site chosen and addons
if (function_exists('eZSiteRoles')) {
$extraRoles = eZSiteRoles($parameters);
foreach ($extraRoles as $extraRole) {
if (!$extraRole) {
continue;
}
$extraRoleName = $extraRole['name'];
$role = eZRole::fetchByName($extraRoleName);
if (!is_object($role)) {
$role = eZRole::create($extraRoleName);
$role->store();
}
$roleID = $role->attribute('id');
if (isset($extraRole['policies'])) {
$extraPolicies = $extraRole['policies'];
foreach ($extraPolicies as $extraPolicy) {
if (isset($extraPolicy['limitation'])) {
$role->appendPolicy($extraPolicy['module'], $extraPolicy['function'], $extraPolicy['limitation']);
} else {
$role->appendPolicy($extraPolicy['module'], $extraPolicy['function']);
}
}
}
if (isset($extraRole['assignments'])) {
$roleAssignments = $extraRole['assignments'];
foreach ($roleAssignments as $roleAssignment) {
$assignmentIdentifier = false;
$assignmentValue = false;
if (isset($roleAssignment['limitation'])) {
$assignmentIdentifier = $roleAssignment['limitation']['identifier'];
$assignmentValue = $roleAssignment['limitation']['value'];
}
$role->assignToUser($roleAssignment['user_id'], $assignmentIdentifier, $assignmentValue);
}
}
}
}
// Setup user preferences based on the site chosen and addons
if (function_exists('eZSitePreferences')) {
$prefs = eZSitePreferences($parameters);
foreach ($prefs as $prefEntry) {
if (!$prefEntry) {
continue;
}
$prefUserID = $prefEntry['user_id'];
foreach ($prefEntry['preferences'] as $pref) {
$prefName = $pref['name'];
$prefValue = $pref['value'];
if (!eZPreferences::setValue($prefName, $prefValue, $prefUserID)) {
$resultArray['errors'][] = array('code' => 'EZSW-070', 'text' => "Could not create ezpreference '{$prefValue}' for {$prefUserID}");
return false;
}
}
}
}
$publishAdmin = false;
$userAccount = eZUser::fetch(14);
if (!is_object($userAccount)) {
$resultArray['errors'][] = array('code' => 'EZSW-020', 'text' => "Could not fetch administrator user object");
return false;
}
$userObject = $userAccount->attribute('contentobject');
if (!is_object($userObject)) {
$resultArray['errors'][] = array('code' => 'EZSW-021', 'text' => "Could not fetch administrator content object");
return false;
}
$newUserObject = $userObject->createNewVersion(false, false);
if (!is_object($newUserObject)) {
$resultArray['errors'][] = array('code' => 'EZSW-022', 'text' => "Could not create new version of administrator content object");
return false;
}
$dataMap = $newUserObject->attribute('data_map');
$error = false;
if (trim($admin['email'])) {
if (!isset($dataMap['user_account'])) {
$resultArray['errors'][] = array('code' => 'EZSW-023', 'text' => "Administrator content object does not have a 'user_account' attribute");
return false;
}
$userAccount->setInformation(14, 'admin', $admin['email'], $admin['password'], $admin['password']);
$dataMap['user_account']->setContent($userAccount);
$dataMap['user_account']->store();
$publishAdmin = true;
$userAccount->store();
}
if (trim($admin['first_name']) or trim($admin['last_name'])) {
if (!isset($dataMap['first_name'])) {
$resultArray['errors'][] = array('code' => 'EZSW-023', 'text' => "Administrator content object does not have a 'first_name' field");
$error = true;
}
if (!isset($dataMap['last_name'])) {
$resultArray['errors'][] = array('code' => 'EZSW-024', 'text' => "Administrator content object does not have a 'last_name' field");
$error = true;
}
if ($error) {
return false;
}
$dataMap['first_name']->setAttribute('data_text', $admin['first_name']);
$dataMap['first_name']->store();
$dataMap['last_name']->setAttribute('data_text', $admin['last_name']);
$dataMap['last_name']->store();
$newUserObject->store();
$publishAdmin = true;
}
if ($publishAdmin) {
$operationResult = eZOperationHandler::execute('content', 'publish', array('object_id' => $newUserObject->attribute('contentobject_id'), 'version' => $newUserObject->attribute('version')));
if ($operationResult['status'] != eZModuleOperationInfo::STATUS_CONTINUE) {
$resultArray['errors'][] = array('code' => 'EZSW-025', 'text' => "Failed to properly publish the administrator object");
return false;
}
}
// Call user function for additional setup tasks.
if (function_exists('eZSitePostInstall')) {
eZSitePostInstall($parameters);
}
// get all siteaccesses. do it via 'RelatedSiteAccessesList' settings.
$adminSiteINI = eZINI::instance('site.ini' . '.append.php', "settings/siteaccess/{$adminSiteaccessName}");
$relatedSiteAccessList = $adminSiteINI->variable('SiteAccessSettings', 'RelatedSiteAccessList');
// Adding override for 'tiny_image' view for 'multi-option2' datatype
foreach ($relatedSiteAccessList as $siteAccess) {
$tmpOverrideINI = new eZINI('override.ini' . '.append.php', "settings/siteaccess/{$siteAccess}", null, null, null, true, true);
$tmpOverrideINI->setVariable('tiny_image', 'Source', 'content/view/tiny.tpl');
$tmpOverrideINI->setVariable('tiny_image', 'MatchFile', 'tiny_image.tpl');
$tmpOverrideINI->setVariable('tiny_image', 'Subdir', 'templates');
$tmpOverrideINI->setVariable('tiny_image', 'Match', array('class_identifier' => 'image'));
$tmpOverrideINI->save();
}
$accessMap = $parameters['access_map'];
// Call user function for some text which will be displayed at 'Finish' screen
if (function_exists('eZSiteFinalText')) {
$text = eZSiteFinalText($parameters);
if (!isset($this->PersistenceList['final_text'])) {
$this->PersistenceList['final_text'] = array();
}
$this->PersistenceList['final_text'][] = $text;
}
// ensure that evaluated policy wildcards in the user info cache
// will be up to date with the currently activated modules
eZCache::clearByID('user_info_cache');
return true;
}
/**
* Fetches the uploaded file, figures out its MIME-type and creates the
* proper content object out of it.
*
* @param array $result
* Result data, will be filled with information which the client can
* examine, contains: errors An array with errors, each element is
* an array with a 'description' entry containing the text
* @param string $httpFileIdentifier
* The HTTP identifier of the uploaded file, this must match the
* name of the input tag.
* @param mixed $location
* The node ID which the new object will be placed or the string
* 'auto' for automatic placement of type.
* @param eZContentObjectTreeNode|false $existingNode
* Pass a contentobjecttreenode object to let the uploading be done
* to an existing object, if not it will create one from scratch.
* @param string $nameString
* The name of the new object/new version
* @param string|false $localeCode
* Locale code (eg eng-GB, fre-FR, ...) to use when creating the
* object or the version.
* @param boolean $publish whether to publish the new created content object
*
* @return boolean
*/
function handleUpload(&$result, $httpFileIdentifier, $location, $existingNode, $nameString = '', $localeCode = false, $publish = true)
{
$result = array('errors' => array(), 'notices' => array(), 'result' => false, 'redirect_url' => false);
$this->fetchHTTPFile($httpFileIdentifier, $result['errors'], $file, $mimeData);
if (!$file) {
$result['errors'][] = array('description' => ezpI18n::tr('kernel/content/upload', 'No HTTP file found, cannot fetch uploaded file.'));
return false;
}
$mime = $mimeData['name'];
if ($mime == '') {
$mime = $file->attribute("mime_type");
}
$handler = $this->findHandler($result, $mimeData);
if ($handler === false) {
$result['errors'][] = array('description' => ezpI18n::tr('kernel/content/upload', 'There was an error trying to instantiate content upload handler.'));
return false;
}
// If this is an object we have a special handler for the file
// The handler will be responsible for the rest of the execution.
if (is_object($handler)) {
$filePath = $file->attribute("filename");
$originalFilename = $file->attribute("original_filename");
$handlerResult = $handler->handleFile($this, $result, $filePath, $originalFilename, $mimeData, $location, $existingNode);
if (is_object($result['contentobject'])) {
return $handlerResult;
}
}
$object = false;
$class = false;
// Figure out class identifier from an existing node
// if not we will have to detect it from the mimetype
if (is_object($existingNode)) {
$object = $existingNode->object();
$class = $object->contentClass();
$classIdentifier = $class->attribute('identifier');
} else {
$classIdentifier = $this->detectClassIdentifier($mime);
}
if (!$classIdentifier) {
$result['errors'][] = array('description' => ezpI18n::tr('kernel/content/upload', 'No matching class identifier found.'));
return false;
}
if (!is_object($class)) {
$class = eZContentClass::fetchByIdentifier($classIdentifier);
}
if (!$class) {
$result['errors'][] = array('description' => ezpI18n::tr('kernel/content/upload', 'The class %class_identifier does not exist.', null, array('%class_identifier' => $classIdentifier)));
return false;
}
$parentNodes = false;
$parentMainNode = false;
// If do not have an existing node we need to figure
// out the locations from $location and $classIdentifier
if (!is_object($existingNode)) {
$locationOK = $this->detectLocations($classIdentifier, $class, $location, $parentNodes, $parentMainNode);
if ($locationOK === false) {
$result['errors'][] = array('description' => ezpI18n::tr('kernel/content/upload', 'Was not able to figure out placement of object.'));
return false;
} elseif ($locationOK === null) {
$result['status'] = eZContentUpload::STATUS_PERMISSION_DENIED;
$result['errors'][] = array('description' => ezpI18n::tr('kernel/content/upload', 'Permission denied'));
return false;
}
}
$uploadINI = eZINI::instance('upload.ini');
$iniGroup = $classIdentifier . '_ClassSettings';
if (!$uploadINI->hasGroup($iniGroup)) {
$result['errors'][] = array('description' => ezpI18n::tr('kernel/content/upload', 'No configuration group in upload.ini for class identifier %class_identifier.', null, array('%class_identifier' => $classIdentifier)));
return false;
}
$fileAttribute = $uploadINI->variable($iniGroup, 'FileAttribute');
$dataMap = $class->dataMap();
if ($classIdentifier == 'image') {
$classAttribute = $dataMap['image'];
$maxSize = 1024 * 1024 * $classAttribute->attribute('data_int1');
if ($maxSize != 0 && $file->attribute('filesize') > $maxSize) {
$result['errors'][] = array('description' => ezpI18n::tr('kernel/content/upload', 'The size of the uploaded file exceeds the limit set for this site: %1 bytes.', null, array($maxSize)));
return false;
}
}
$fileAttribute = $this->findHTTPFileAttribute($dataMap, $fileAttribute);
if (!$fileAttribute) {
$result['errors'][] = array('description' => ezpI18n::tr('kernel/content/upload', 'No matching file attribute found, cannot create content object without this.'));
return false;
}
$nameAttribute = $uploadINI->variable($iniGroup, 'NameAttribute');
if (!$nameAttribute) {
$nameAttribute = $this->findStringAttribute($dataMap, $nameAttribute);
}
if (!$nameAttribute) {
$result['errors'][] = array('description' => ezpI18n::tr('kernel/content/upload', 'No matching name attribute found, cannot create content object without this.'));
return false;
}
$variables = array('original_filename' => $file->attribute('original_filename'), 'mime_type' => $mime);
$variables['original_filename_base'] = $mimeData['basename'];
$variables['original_filename_suffix'] = $mimeData['suffix'];
if (!$nameString) {
$namePattern = $uploadINI->variable($iniGroup, 'NamePattern');
$nameString = $this->processNamePattern($variables, $namePattern);
}
$db = eZDB::instance();
$db->begin();
// If we have an existing node we need to create
// a new version in it.
// If we don't we have to make a new object
if (is_object($existingNode)) {
if ($existingNode->canEdit() != '1') {
$result['status'] = eZContentUpload::STATUS_PERMISSION_DENIED;
$result['errors'][] = array('description' => ezpI18n::tr('kernel/content/upload', 'Permission denied'));
$db->commit();
return false;
}
$version = $object->createNewVersion(false, true, $localeCode);
unset($dataMap);
$dataMap = $version->dataMap();
$publishVersion = $version->attribute('version');
} else {
$object = $class->instantiateIn($localeCode);
unset($dataMap);
$dataMap = $object->dataMap();
$publishVersion = $object->attribute('current_version');
}
unset($dataMap);
$dataMap = $object->dataMap();
if ($localeCode === false) {
$localeCode = eZContentObject::defaultLanguage();
}
$status = $dataMap[$fileAttribute]->insertHTTPFile($object, $publishVersion, $localeCode, $file, $mimeData, $storeResult);
if ($status === null) {
$result['errors'][] = array('description' => ezpI18n::tr('kernel/content/upload', 'The attribute %class_identifier does not support HTTP file storage.', null, array('%class_identifier' => $classIdentifier)));
$db->commit();
return false;
} else {
if (!$status) {
$result['errors'] = array_merge($result['errors'], $storeResult['errors']);
$db->commit();
return false;
}
}
if ($storeResult['require_storage']) {
$dataMap[$fileAttribute]->store();
}
$status = $dataMap[$nameAttribute]->insertSimpleString($object, $publishVersion, $localeCode, $nameString, $storeResult);
if ($status === null) {
$result['errors'][] = array('description' => ezpI18n::tr('kernel/content/upload', 'The attribute %class_identifier does not support simple string storage.', null, array('%class_identifier' => $classIdentifier)));
$db->commit();
return false;
} else {
if (!$status) {
$result['errors'] = array_merge($result['errors'], $storeResult['errors']);
$db->commit();
return false;
}
}
if ($storeResult['require_storage']) {
$dataMap[$nameAttribute]->store();
}
if (is_array($parentNodes)) {
foreach ($parentNodes as $key => $parentNode) {
$object->createNodeAssignment($parentNode, $parentNode == $parentMainNode);
}
}
$object->setName($class->contentObjectName($object));
$object->store();
if ($publish) {
$tmpresult = $this->publishObject($result, $result['errors'], $result['notices'], $object, $publishVersion, $class, $parentNodes, $parentMainNode);
} else {
$tmpresult = $result;
$tmpresult['contentobject'] = $object;
$tmpresult['contentobject_id'] = $object->attribute('id');
$tmpresult['contentobject_version'] = $publishVersion;
$tmpresult['contentobject_main_node'] = false;
$tmpresult['contentobject_main_node_id'] = false;
$this->setResult(array('node_id' => 0, 'object_id' => $object->attribute('id'), 'object_version' => $publishVersion));
}
$db->commit();
return $tmpresult;
}
/**
* Get an array of class attribute identifiers based on either a class attribute
* list, or a content classes list
*
* @param array $classIDArray
* Classes to search in. Either an array of class ID, class identifiers,
* a class ID or a class identifier.
* Using numerical attribute/class identifiers for $classIDArray is more efficient.
* @param array $classAttributeID
* Class attributes to search in. Either an array of class attribute id,
* or a single class attribute. Literal identifiers are not allowed.
* @param array $fieldTypeExcludeList
* filter list. List of field types to exclude. ( set to empty array by default ).
*
* @return array List of solr field names.
*/
protected function getClassAttributes($classIDArray = false, $classAttributeIDArray = false, $fieldTypeExcludeList = null)
{
eZDebug::createAccumulator('Class attribute list', 'eZ Find');
eZDebug::accumulatorStart('Class attribute list');
$fieldArray = array();
$classAttributeArray = array();
// classAttributeIDArray = simple integer (content class attribute ID)
if (is_numeric($classAttributeIDArray) and $classAttributeIDArray > 0) {
$classAttributeArray[] = eZContentClassAttribute::fetch($classAttributeIDArray);
} else {
if (is_array($classAttributeIDArray)) {
foreach ($classAttributeIDArray as $classAttributeID) {
$classAttributeArray[] = eZContentClassAttribute::fetch($classAttributeID);
}
}
}
// no class attribute list given, we need a class list
// this block will create the class attribute array based on $classIDArray
if (empty($classAttributeArray)) {
// Fetch class list.
$condArray = array("is_searchable" => 1, "version" => eZContentClass::VERSION_STATUS_DEFINED);
if (!$classIDArray) {
$classIDArray = array();
} else {
if (!is_array($classIDArray)) {
$classIDArray = array($classIDArray);
}
}
// literal class identifiers are converted to numerical ones
$tmpClassIDArray = $classIDArray;
$classIDArray = array();
foreach ($tmpClassIDArray as $key => $classIdentifier) {
if (!is_numeric($classIdentifier)) {
if (!($contentClass = eZContentClass::fetchByIdentifier($classIdentifier, false))) {
eZDebug::writeWarning("Unknown content class identifier '{$classIdentifier}'", __METHOD__);
} else {
$classIDArray[] = $contentClass['id'];
}
} else {
$classIDArray[] = $classIdentifier;
}
}
if (!empty($classIDArray)) {
$condArray['contentclass_id'] = array($classIDArray);
}
$classAttributeArray = eZContentClassAttribute::fetchFilteredList($condArray);
}
// $classAttributeArray now contains a list of eZContentClassAttribute
// we can use to construct the list of fields solr should search in
// @TODO : retrieve sub attributes here. Mind the types !
foreach ($classAttributeArray as $classAttribute) {
$fieldArray = array_merge(ezfSolrDocumentFieldBase::getFieldNameList($classAttribute, $fieldTypeExcludeList), $fieldArray);
}
// the array is unified + sorted in order to make it consistent
$fieldArray = array_unique($fieldArray);
sort($fieldArray);
eZDebug::accumulatorStop('Class attribute list');
return $fieldArray;
}
function classByIdentifier( $params )
{
$classIdentifier = $params['identifier'];
$contentClass = eZContentClass::fetchByIdentifier( $classIdentifier );
if( !is_object( $contentClass ) )
{
eZDebug::writeWarning( "Content class with identifier '$classIdentifier' doesn't exist.", __METHOD__ );
}
return $contentClass;
}
function install($package, $installType, $parameters, $name, $os, $filename, $subdirectory, $content, &$installParameters, &$installData)
{
$serializedNameListNode = $content->getElementsByTagName('serialized-name-list')->item(0);
$serializedNameList = $serializedNameListNode ? $serializedNameListNode->textContent : false;
$classNameList = new eZContentClassNameList($serializedNameList);
if ($classNameList->isEmpty()) {
$classNameList->initFromString($content->getElementsByTagName('name')->item(0)->textContent);
// for backward compatibility( <= 3.8 )
}
$classNameList->validate();
$serializedDescriptionListNode = $content->getElementsByTagName('serialized-description-list')->item(0);
$serializedDescriptionList = $serializedDescriptionListNode ? $serializedDescriptionListNode->textContent : false;
$classDescriptionList = new eZSerializedObjectNameList($serializedDescriptionList);
$classIdentifier = $content->getElementsByTagName('identifier')->item(0)->textContent;
$classRemoteID = $content->getElementsByTagName('remote-id')->item(0)->textContent;
$classObjectNamePattern = $content->getElementsByTagName('object-name-pattern')->item(0)->textContent;
$classURLAliasPattern = is_object($content->getElementsByTagName('url-alias-pattern')->item(0)) ? $content->getElementsByTagName('url-alias-pattern')->item(0)->textContent : null;
$classIsContainer = $content->getAttribute('is-container');
if ($classIsContainer !== false) {
$classIsContainer = $classIsContainer == 'true' ? 1 : 0;
}
$classRemoteNode = $content->getElementsByTagName('remote')->item(0);
$classID = $classRemoteNode->getElementsByTagName('id')->item(0)->textContent;
$classGroupsNode = $classRemoteNode->getElementsByTagName('groups')->item(0);
$classCreated = $classRemoteNode->getElementsByTagName('created')->item(0)->textContent;
$classModified = $classRemoteNode->getElementsByTagName('modified')->item(0)->textContent;
$classCreatorNode = $classRemoteNode->getElementsByTagName('creator')->item(0);
$classModifierNode = $classRemoteNode->getElementsByTagName('modifier')->item(0);
$classAttributesNode = $content->getElementsByTagName('attributes')->item(0);
$dateTime = time();
$classCreated = $dateTime;
$classModified = $dateTime;
$userID = false;
if (isset($installParameters['user_id'])) {
$userID = $installParameters['user_id'];
}
$class = eZContentClass::fetchByRemoteID($classRemoteID);
if ($class) {
$className = $class->name();
$description = ezpI18n::tr('kernel/package', "Class '%classname' already exists.", false, array('%classname' => $className));
$choosenAction = $this->errorChoosenAction(self::ERROR_EXISTS, $installParameters, $description, $this->HandlerType);
switch ($choosenAction) {
case eZPackage::NON_INTERACTIVE:
case self::ACTION_REPLACE:
if (eZContentClassOperations::remove($class->attribute('id')) == false) {
eZDebug::writeWarning("Unable to remove class '{$className}'.");
return true;
}
eZDebug::writeNotice("Class '{$className}' will be replaced.", 'eZContentClassPackageHandler');
break;
case self::ACTION_SKIP:
return true;
case self::ACTION_NEW:
$class->setAttribute('remote_id', eZRemoteIdUtility::generate('class'));
$class->store();
$classNameList->appendGroupName(" (imported)");
break;
default:
$installParameters['error'] = array('error_code' => self::ERROR_EXISTS, 'element_id' => $classRemoteID, 'description' => $description, 'actions' => array());
if ($class->isRemovable()) {
$errorMsg = ezpI18n::tr('kernel/package', "Replace existing class");
$objectsCount = eZContentObject::fetchSameClassListCount($class->attribute('id'));
if ($objectsCount) {
$errorMsg .= ' ' . ezpI18n::tr('kernel/package', "(Warning! {$objectsCount} content object(s) and their sub-items will be removed)");
}
$installParameters['error']['actions'][self::ACTION_REPLACE] = $errorMsg;
}
$installParameters['error']['actions'][self::ACTION_SKIP] = ezpI18n::tr('kernel/package', 'Skip installing this class');
$installParameters['error']['actions'][self::ACTION_NEW] = ezpI18n::tr('kernel/package', 'Keep existing and create a new one');
return false;
}
}
unset($class);
// Try to create a unique class identifier
$currentClassIdentifier = $classIdentifier;
$unique = false;
while (!$unique) {
$classList = eZContentClass::fetchByIdentifier($currentClassIdentifier);
if ($classList) {
// "increment" class identifier
if (preg_match('/^(.*)_(\\d+)$/', $currentClassIdentifier, $matches)) {
$currentClassIdentifier = $matches[1] . '_' . ($matches[2] + 1);
} else {
$currentClassIdentifier = $currentClassIdentifier . '_1';
}
} else {
$unique = true;
}
unset($classList);
}
$classIdentifier = $currentClassIdentifier;
$values = array('version' => 0, 'serialized_name_list' => $classNameList->serializeNames(), 'serialized_description_list' => $classDescriptionList->serializeNames(), 'create_lang_if_not_exist' => true, 'identifier' => $classIdentifier, 'remote_id' => $classRemoteID, 'contentobject_name' => $classObjectNamePattern, 'url_alias_name' => $classURLAliasPattern, 'is_container' => $classIsContainer, 'created' => $classCreated, 'modified' => $classModified);
if ($content->hasAttribute('sort-field')) {
$values['sort_field'] = eZContentObjectTreeNode::sortFieldID($content->getAttribute('sort-field'));
} else {
eZDebug::writeNotice('The sort field was not specified in the content class package. ' . 'This property is exported and imported since eZ Publish 4.0.2', __METHOD__);
}
if ($content->hasAttribute('sort-order')) {
$values['sort_order'] = $content->getAttribute('sort-order');
} else {
eZDebug::writeNotice('The sort order was not specified in the content class package. ' . 'This property is exported and imported since eZ Publish 4.0.2', __METHOD__);
}
if ($content->hasAttribute('always-available')) {
$values['always_available'] = $content->getAttribute('always-available') === 'true' ? 1 : 0;
} else {
eZDebug::writeNotice('The default object availability was not specified in the content class package. ' . 'This property is exported and imported since eZ Publish 4.0.2', __METHOD__);
}
// create class
$class = eZContentClass::create($userID, $values);
$class->store();
$classID = $class->attribute('id');
if (!isset($installData['classid_list'])) {
$installData['classid_list'] = array();
}
if (!isset($installData['classid_map'])) {
$installData['classid_map'] = array();
}
$installData['classid_list'][] = $class->attribute('id');
$installData['classid_map'][$classID] = $class->attribute('id');
// create class attributes
$classAttributeList = $classAttributesNode->getElementsByTagName('attribute');
foreach ($classAttributeList as $classAttributeNode) {
$isNotSupported = strtolower($classAttributeNode->getAttribute('unsupported')) == 'true';
if ($isNotSupported) {
continue;
}
$attributeDatatype = $classAttributeNode->getAttribute('datatype');
$attributeIsRequired = strtolower($classAttributeNode->getAttribute('required')) == 'true';
$attributeIsSearchable = strtolower($classAttributeNode->getAttribute('searchable')) == 'true';
$attributeIsInformationCollector = strtolower($classAttributeNode->getAttribute('information-collector')) == 'true';
$attributeIsTranslatable = strtolower($classAttributeNode->getAttribute('translatable')) == 'true';
$attributeSerializedNameListNode = $classAttributeNode->getElementsByTagName('serialized-name-list')->item(0);
$attributeSerializedNameListContent = $attributeSerializedNameListNode ? $attributeSerializedNameListNode->textContent : false;
$attributeSerializedNameList = new eZSerializedObjectNameList($attributeSerializedNameListContent);
if ($attributeSerializedNameList->isEmpty()) {
$attributeSerializedNameList->initFromString($classAttributeNode->getElementsByTagName('name')->item(0)->textContent);
}
// for backward compatibility( <= 3.8 )
$attributeSerializedNameList->validate();
$attributeSerializedDescriptionListNode = $classAttributeNode->getElementsByTagName('serialized-description-list')->item(0);
$attributeSerializedDescriptionListContent = $attributeSerializedDescriptionListNode ? $attributeSerializedDescriptionListNode->textContent : false;
$attributeSerializedDescriptionList = new eZSerializedObjectNameList($attributeSerializedDescriptionListContent);
$attributeCategoryNode = $classAttributeNode->getElementsByTagName('category')->item(0);
$attributeCategory = $attributeCategoryNode ? $attributeCategoryNode->textContent : '';
$attributeSerializedDataTextNode = $classAttributeNode->getElementsByTagName('serialized-description-text')->item(0);
$attributeSerializedDataTextContent = $attributeSerializedDataTextNode ? $attributeSerializedDataTextNode->textContent : false;
$attributeSerializedDataText = new eZSerializedObjectNameList($attributeSerializedDataTextContent);
$attributeIdentifier = $classAttributeNode->getElementsByTagName('identifier')->item(0)->textContent;
$attributePlacement = $classAttributeNode->getElementsByTagName('placement')->item(0)->textContent;
$attributeDatatypeParameterNode = $classAttributeNode->getElementsByTagName('datatype-parameters')->item(0);
$classAttribute = $class->fetchAttributeByIdentifier($attributeIdentifier);
if (!$classAttribute) {
$classAttribute = eZContentClassAttribute::create($class->attribute('id'), $attributeDatatype, array('version' => 0, 'identifier' => $attributeIdentifier, 'serialized_name_list' => $attributeSerializedNameList->serializeNames(), 'serialized_description_list' => $attributeSerializedDescriptionList->serializeNames(), 'category' => $attributeCategory, 'serialized_data_text' => $attributeSerializedDataText->serializeNames(), 'is_required' => $attributeIsRequired, 'is_searchable' => $attributeIsSearchable, 'is_information_collector' => $attributeIsInformationCollector, 'can_translate' => $attributeIsTranslatable, 'placement' => $attributePlacement));
$dataType = $classAttribute->dataType();
$classAttribute->store();
$dataType->unserializeContentClassAttribute($classAttribute, $classAttributeNode, $attributeDatatypeParameterNode);
$classAttribute->sync();
}
}
// add class to a class group
$classGroupsList = $classGroupsNode->getElementsByTagName('group');
foreach ($classGroupsList as $classGroupNode) {
$classGroupName = $classGroupNode->getAttribute('name');
$classGroup = eZContentClassGroup::fetchByName($classGroupName);
if (!$classGroup) {
$classGroup = eZContentClassGroup::create();
$classGroup->setAttribute('name', $classGroupName);
$classGroup->store();
}
$classGroup->appendClass($class);
}
return true;
}
/**
* Returns publisher folders related to given cluster
* @param string $clusterIdentifier
* @throws Exception
* @return array:
*/
function fetchPublisherFoldersForCluster( $clusterIdentifier )
{
$remoteID = 'country_' . $clusterIdentifier;
$clusterObject = eZContentObject::fetchByRemoteId($remoteID);
if ( !$clusterObject instanceof eZContentObject )
throw new Exception( 'No node found for cluster ' . $clusterIdentifier );
$clusterNodeID = $clusterObject->mainNode()->attribute('node_id');
$class = eZContentClass::fetchByIdentifier( CLASS_IDENTIFIER_PUBLISHER_FOLDER );
$attributeID = (int) $class->fetchAttributeByIdentifier( ATTRIBUTE_TARGET_CONTENT_SERVICE )->ID;
$limit = 200;
$offset = 0;
$result = array();
while ( true )
{
$params = array(
'Depth' => 1,
'AsObject' => true,
'ClassFilterType' => 'include',
'ClassFilterArray' => array(
CLASS_IDENTIFIER_APPLICATION_FOLDER
),
'Limit' => $limit,
'Offset' => $offset,
);
$fetchedNodes = eZContentObjectTreeNode::subTreeByNodeID( $params, $clusterNodeID );
if ( empty( $fetchedNodes ) )
break;
foreach ( $fetchedNodes as $node )
{
$object = $node->ContentObject;
$publisherFolders = $object->relatedObjects( false, false, $attributeID, false, array(
'AllRelations' => eZContentObject::RELATION_ATTRIBUTE
), true );
foreach ( $publisherFolders as $publisherFolder )
{
$result['objects'][] = $publisherFolder;
$result['questions'][] = str_replace( 'publisher_folder-', '', $publisherFolder->RemoteID );
}
}
$offset += $limit;
}
return $result;
}
