function getClassConstraintListAsArray($class_identifier = false, $contentclass_id = false, $debug = false)
{
//todo debug
if (!$contentclass_id && !$class_identifier) {
return;
}
if ($contentclass_id && $class_identifier) {
return;
}
$ezobjectrelationlist = eZContentClassAttribute::fetchFilteredList(array('data_type_string' => 'ezobjectrelationlist'));
$return = array();
if ($contentclass_id) {
foreach ($ezobjectrelationlist as $attribute) {
if ($attribute->attribute('contentclass_id') == $contentclass_id) {
$attributeContent = $attribute->content();
if (!empty($attributeContent['class_constraint_list'])) {
$return = array_merge($return, $attributeContent['class_constraint_list']);
}
}
}
if (!empty($return)) {
return $return;
} else {
return false;
}
}
if ($class_identifier) {
foreach ($ezobjectrelationlist as $attribute) {
$attributeContent = $attribute->content();
if (!empty($attributeContent['class_constraint_list'])) {
if (in_array($class_identifier, $attributeContent['class_constraint_list'])) {
$class = eZContentClass::fetch($attribute->attribute('contentclass_id'));
$classIdentifier = eZContentClass::classIdentifierByID($attribute->attribute('contentclass_id'));
$return[$classIdentifier][] = array('class_id' => $attribute->attribute('contentclass_id'), 'class_name' => $class->attribute('name'), 'attribute_identifier' => $attribute->attribute('identifier'), 'attribute_name' => $attribute->attribute('name'), 'class_constraint_list' => $attributeContent['class_constraint_list'], 'search_filter' => $classIdentifier . '/' . $attribute->attribute('identifier') . '/main_node_id');
}
}
}
//eZDebug::writeNotice( $return, __METHOD__ );
if (!empty($return)) {
return $return;
} else {
return false;
}
}
return false;
}
/**
* Computes the version history limit for a content class
*
* @param mixed $class
* Content class ID, content class identifier or content class object
* @return int
* @since 4.2
*/
public static function versionHistoryLimit($class)
{
// default version limit
$contentINI = eZINI::instance('content.ini');
$versionLimit = $contentINI->variable('VersionManagement', 'DefaultVersionHistoryLimit');
// version limit can't be < 2
if ($versionLimit < 2) {
eZDebug::writeWarning("Global version history limit must be equal to or higher than 2", __METHOD__);
$versionLimit = 2;
}
// we need to take $class down to a class ID
if (is_numeric($class)) {
if (!eZContentClass::classIdentifierByID($class)) {
eZDebug::writeWarning("class integer parameter doesn't match any content class ID", __METHOD__);
return $versionLimit;
}
$classID = (int) $class;
} elseif (is_string($class)) {
$classID = eZContentClass::classIDByIdentifier($class);
if (!$classID) {
eZDebug::writeWarning("class string parameter doesn't match any content class identifier", __METHOD__);
return $versionLimit;
}
} elseif (is_object($class)) {
if (!$class instanceof eZContentClass) {
eZDebug::writeWarning("class object parameter is not an eZContentClass", __METHOD__);
return $versionLimit;
} else {
$classID = $class->attribute('id');
}
}
$classLimitSetting = $contentINI->variable('VersionManagement', 'VersionHistoryClass');
$classArray = array_keys($classLimitSetting);
$limitsArray = array_values($classLimitSetting);
$classArray = eZContentClass::classIDByIdentifier($classArray);
foreach ($classArray as $index => $id) {
if ($id == $classID) {
$limit = $limitsArray[$index];
// version limit can't be < 2
if ($limit < 2) {
$classIdentifier = eZContentClass::classIdentifierByID($classID);
eZDebug::writeWarning("Version history limit for class {$classIdentifier} must be equal to or higher than 2", __METHOD__);
$limit = 2;
}
$versionLimit = $limit;
}
}
return $versionLimit;
}
// MA 02110-1301, USA.
$http = eZHTTPTool::instance();
$listIni = eZINI::instance('lists.ini');
$Module = $Params["Module"];
$hasPost = false;
$ajax = false;
$classIdentifier = '';
if (isset($Params['classIdentifier'])) {
$classIdentifier = $Params['classIdentifier'];
}
if ($http->hasPostVariable('classIdentifier')) {
$classIdentifier = $http->postVariable('classIdentifier');
$hasPost = true;
}
if (is_numeric($classIdentifier)) {
$classIdentifier = eZContentClass::classIdentifierByID($classIdentifier);
}
$sortMethod = $listIni->variable('ListSettings', 'DefaultSortMethod');
if (isset($Params['sortMethod'])) {
$sortMethod = $Params['sortMethod'];
}
if ($http->hasPostVariable('sortMethod')) {
$sortMethod = $http->postVariable('sortMethod');
$hasPost = true;
}
$sortOrder = $listIni->variable('ListSettings', 'DefaultSortOrder');
if (isset($Params['sortOrder'])) {
$sortOrder = $Params['sortOrder'];
}
if ($http->hasPostVariable('sortOrder')) {
$sortOrder = $http->postVariable('sortOrder');
/**
* Returns the content class identifer for the current content object
*
* The object will cache the class name information so multiple calls will be fast.
*
* @return string|bool|null
*/
function contentClassIdentifier()
{
if ( !is_numeric( $this->ClassID ) )
{
$retValue = null;
return $retValue;
}
if ( $this->ClassIdentifier !== false )
return $this->ClassIdentifier;
$this->ClassIdentifier = eZContentClass::classIdentifierByID( $this->ClassID );
return $this->ClassIdentifier;
}
/**
* Checks for integrity all object attributes of a given datatype. Or for a single attribute of one class.
* The rules applied for each datatype depend on ini settings.
* The datatype to check is set via loadDatatypeChecks()
*
* @param string $type datatype name or classidentifier/attributeidentifier
* @param bool $also_unpublished
* @return array
* @throws Exception
*/
public function check($type, $also_unpublished = false)
{
$classIdentifierFilter = null;
$attributeIdentifierFilter = null;
if ($this->isAttributeDefinition($type)) {
list($classIdentifierFilter, $attributeIdentifierFilter) = $this->parseAttributeDefinition($type);
$type = $this->datatypeByAttributeDefinition($type);
}
if (!isset($this->checkerClasses[$type])) {
$this->loadDatatypeChecksforType($type);
}
$warnings = array();
// Loop over all class attributes using the datatype:
$classAttributes = eZContentClassAttribute::fetchList(true, array('version' => eZContentClass::VERSION_STATUS_DEFINED, 'data_type' => $type));
$db = eZDB::instance();
foreach ($classAttributes as $classAttribute) {
$classIdentifier = eZContentClass::classIdentifierByID($classAttribute->attribute('contentclass_id'));
$attributeIdentifier = $classAttribute->attribute('identifier');
if ($classIdentifierFilter !== null && $classIdentifier !== $classIdentifierFilter || $attributeIdentifierFilter !== null && $attributeIdentifier !== $attributeIdentifierFilter) {
continue;
}
$this->output("Checking attribute '{$attributeIdentifier}' in class '{$classIdentifier}'...");
// the checkers get initialized once per class attribute
$checkers = array();
foreach ($this->checkerClasses[$type] as $key => $checkerClass) {
$checkers[$key] = call_user_func_array(array($checkerClass, 'instance'), array($classAttribute));
}
$offset = 0;
$total = 0;
do {
$tables = 'ezcontentobject_attribute';
$where = 'contentclassattribute_id = ' . $classAttribute->attribute('id');
if (!$also_unpublished) {
$tables .= ', ezcontentobject';
$where .= ' AND ezcontentobject.id = ezcontentobject_attribute.contentobject_id' . ' AND ezcontentobject.current_version = ezcontentobject_attribute.version' . ' AND ezcontentobject.status = 1';
}
$query = "SELECT ezcontentobject_attribute.* " . "FROM {$tables} " . "WHERE {$where}";
$rows = $db->arrayQuery($query, array('offset' => $offset, 'limit' => $this->limit));
if ($rows === false) {
throw new Exception("DB Error, something is deeply wrong here");
}
foreach ($rows as $row) {
foreach ($checkers as $checker) {
$problems = $checker->checkObjectAttribute($row);
if (count($problems)) {
$warnings = array_merge($warnings, $problems);
}
}
}
$offset += $this->limit;
$total += count($rows);
} while (count($rows) > 0);
$this->output("Checked {$total} object attributes");
}
return $warnings;
}
if ($attribute->attribute('data_type_string') === 'ezpage') {
$page = $attribute->content();
$ini = eZINI::instance('zone.ini');
$zoneName = $ini->variable($page->attribute('zone_layout'), 'ZoneName');
break;
}
}
}
if ($http->hasPostVariable('node_id')) {
$nodeToAdd = eZContentObjectTreeNode::fetch($http->postVariable('node_id'));
$objectToAdd = null;
if ($nodeToAdd instanceof eZContentObjectTreeNode) {
$objectToAdd = $nodeToAdd->object();
}
if ($objectToAdd instanceof eZContentObject) {
$classIdentifier = eZContentClass::classIdentifierByID($objectToAdd->attribute('contentclass_id'));
}
}
switch ($http->postVariable('content')) {
case 'frontpage':
if ($page instanceof eZPage) {
foreach ($page->attribute('zones') as $index => $zone) {
$identifier = $zone->attribute('zone_identifier');
$res[] = array('index' => $index, 'id' => $zone->attribute('id'), 'name' => $zoneName[$identifier], 'zone_identifier' => $identifier);
}
}
break;
case 'zone':
$blockINI = eZINI::instance('block.ini');
if ($http->hasPostVariable('zone')) {
$zoneID = $http->postVariable('zone');
