Exponential 6.0.13 Exponential Enterprise Open Source CMS - PHP Class Reference

ezenumtype.php
Go to the documentation of this file.
1 <?php
17 class eZEnumType extends eZDataType
18 {
19 const DATA_TYPE_STRING = 'ezenum';
20 const IS_MULTIPLE_FIELD = 'data_int1';
21 const IS_MULTIPLE_VARIABLE = '_ezenum_ismultiple_value_';
22 const IS_OPTION_FIELD = 'data_int2';
23 const IS_OPTION_VARIABLE = '_ezenum_isoption_value_';
24
25 public function __construct()
26 {
27 parent::__construct( self::DATA_TYPE_STRING, ezpI18n::tr( 'kernel/classes/datatypes', 'Enum', 'Datatype name' ),
28 array( 'serialize_supported' => true ) );
29 }
30
34 function initializeObjectAttribute( $contentObjectAttribute, $currentVersion, $originalContentObjectAttribute )
35 {
36 if ( $currentVersion != false )
37 {
38 $originalContentObjectAttributeID = $originalContentObjectAttribute->attribute( 'id' );
39 $contentObjectAttributeID = $contentObjectAttribute->attribute( 'id' );
40 $contentObjectAttributeVersion = $contentObjectAttribute->attribute( 'version' );
41
42 $db = eZDB::instance();
43 $db->begin();
44
45 // Delete stored object attributes when initialize translated attribute.
46 if ( $originalContentObjectAttributeID != $contentObjectAttributeID )
47 $this->deleteStoredObjectAttribute( $contentObjectAttribute, $currentVersion );
48
49 $newVersionEnumObject = eZEnumObjectValue::fetchAllElements( $originalContentObjectAttributeID, $currentVersion );
50
51 for ( $i = 0; $i < count( $newVersionEnumObject ); ++$i )
52 {
53 $enumobjectvalue = $newVersionEnumObject[$i];
54 $enumobjectvalue->setAttribute( 'contentobject_attribute_id', $contentObjectAttribute->attribute( 'id' ) );
55 $enumobjectvalue->setAttribute( 'contentobject_attribute_version', $contentObjectAttributeVersion );
56 $enumobjectvalue->store();
57 }
58
59 $db->commit();
60 }
61 }
62
63 function cloneClassAttribute( $oldClassAttribute, $newClassAttribute )
64 {
65 $oldContentClassAttributeID = $oldClassAttribute->attribute( 'id' );
66 $oldEnums = eZEnumValue::fetchAllElements( $oldContentClassAttributeID, 0 );
67
68 $db = eZDB::instance();
69 $db->begin();
70
71 foreach ( $oldEnums as $oldEnum )
72 {
73 $enum = clone $oldEnum;
74 $enum->setAttribute( 'contentclass_attribute_id', $newClassAttribute->attribute( 'id' ) );
75 $enum->setAttribute( 'contentclass_attribute_version', $newClassAttribute->attribute( 'version' ) );
76 $enum->store();
77 }
78
79 $db->commit();
80 }
81
85 function initializeClassAttribute( $classAttribute )
86 {
87 $contentClassAttributeID = $classAttribute->attribute( 'id' );
88 $enums = eZEnumValue::fetchAllElements( $contentClassAttributeID, 1 );
89
90 if ( count ( $enums ) == 0 )
91 {
92 $enums = eZEnumValue::fetchAllElements( $contentClassAttributeID, 0 );
93 $db = eZDB::instance();
94 $db->begin();
95 foreach ( $enums as $enum )
96 {
97 $enum->setAttribute( 'contentclass_attribute_version', 1 );
98 $enum->store();
99 }
100 $db->commit();
101 }
102 }
103
107 function deleteStoredObjectAttribute( $contentObjectAttribute, $version = null )
108 {
109 $contentObjectAttributeID = $contentObjectAttribute->attribute( 'id' );
110 eZEnumObjectValue::removeAllElements( $contentObjectAttributeID, $version );
111
112 }
113
117 function deleteStoredClassAttribute( $contentClassAttribute, $version = null )
118 {
119 $contentClassAttributeID = $contentClassAttribute->attribute( 'id' );
120 eZEnumValue::removeAllElements( $contentClassAttributeID, $version );
121
122 }
123
127 function fetchObjectAttributeHTTPInput( $http, $base, $contentObjectAttribute )
128 {
129 $contentObjectAttributeID = $contentObjectAttribute->attribute( 'id' );
130 $contentObjectAttributeVersion = $contentObjectAttribute->attribute( 'version' );
131 $enumID = $base . '_data_enumid_' . $contentObjectAttributeID;
132 $enumElement = $base . '_data_enumelement_' . $contentObjectAttributeID;
133 $enumValue = $base . '_data_enumvalue_' . $contentObjectAttributeID;
134 $selectedEnumElement = $base . '_select_data_enumelement_' . $contentObjectAttributeID;
135 if ( $http->hasPostVariable( $enumID ) &&
136 $http->hasPostVariable( $enumElement ) &&
137 $http->hasPostVariable( $enumValue ) )
138 {
139 $array_enumID = $http->postVariable( $enumID );
140 $array_enumElement = $http->postVariable( $enumElement );
141 $array_enumValue = $http->postVariable( $enumValue );
142
143 if ( $http->hasPostVariable( $selectedEnumElement ) )
144 $array_selectedEnumElement = $http->postVariable( $selectedEnumElement );
145 else
146 $array_selectedEnumElement = null;
147
148 $db = eZDB::instance();
149 $db->begin();
150
151 // Remove stored enumerations before we store new enumerations
152 eZEnum::removeObjectEnumerations( $contentObjectAttributeID, $contentObjectAttributeVersion );
153
154 if ( is_countable( $array_enumElement ) && is_countable( $array_selectedEnumElement ) )
155 {
156 for ( $i=0;$i<count( $array_enumElement );$i++ )
157 {
158 for ( $j=0;$j<count( $array_selectedEnumElement );$j++ )
159 {
160 if ( $array_enumElement[$i] === $array_selectedEnumElement[$j] )
161 {
162 $eID = $array_enumID[$i];
163 $eElement = $array_enumElement[$i];
164 $eValue = $array_enumValue[$i];
165 eZEnum::storeObjectEnumeration( $contentObjectAttributeID,
166 $contentObjectAttributeVersion,
167 $eID,
168 $eElement,
169 $eValue );
170 }
171 }
172 }
173 }
174 $db->commit();
175 return true;
176 }
177 return false;
178 }
179
184 function validateObjectAttributeHTTPInput( $http, $base, $contentObjectAttribute )
185 {
186 if ( $http->hasPostVariable( $base . '_data_enumid_' . $contentObjectAttribute->attribute( 'id' ) ) )
187 {
188 $array_enumID = $http->postVariable( $base . '_data_enumid_' . $contentObjectAttribute->attribute( 'id' ) );
189 $classAttribute = $contentObjectAttribute->contentClassAttribute();
190
191 if ( $contentObjectAttribute->validateIsRequired() )
192 {
193 if ( !$http->hasPostVariable( $base . '_select_data_enumelement_' . $contentObjectAttribute->attribute( 'id' ) ) )
194 {
195 $contentObjectAttribute->setValidationError( ezpI18n::tr( 'kernel/classes/datatypes',
196 'At least one field should be chosen.' ) );
197 return eZInputValidator::STATE_INVALID;
198 }
199 }
200 }
201 return eZInputValidator::STATE_ACCEPTED;
202 }
203
208 function storeObjectAttribute( $contentObjectAttribute )
209 {
210 }
211
215 function objectAttributeContent( $contentObjectAttribute )
216 {
217 $contentObjectAttributeID = $contentObjectAttribute->attribute( 'id' );
218 $contentObjectAttributeVersion = $contentObjectAttribute->attribute( 'version' );
219 $contentClassAttribute = $contentObjectAttribute->contentClassAttribute();
220 $id = $contentClassAttribute->attribute( 'id' );
221 $version = $contentClassAttribute->attribute( 'version' );
222 $ismultiple = $contentClassAttribute->attribute( 'data_int1' );
223 $isoption = $contentClassAttribute->attribute( 'data_int2' );
224 $enum = new eZEnum( $id, $version );
225 $enum->setIsmultipleValue( $ismultiple );
226 $enum->setIsoptionValue( $isoption );
227 $enum->setObjectEnumValue( $contentObjectAttributeID, $contentObjectAttributeVersion );
228 return $enum;
229 }
230
235 function validateClassAttributeHTTPInput( $http, $base, $contentClassAttribute )
236 {
237 return eZInputValidator::STATE_ACCEPTED;
238 }
239
243 function fetchClassAttributeHTTPInput( $http, $base, $contentClassAttribute )
244 {
245 $ismultiple = $base . self::IS_MULTIPLE_VARIABLE . $contentClassAttribute->attribute( 'id' );
246 $isoption = $base . self::IS_OPTION_VARIABLE . $contentClassAttribute->attribute( 'id' );
247 $enumID = $base . '_data_enumid_' . $contentClassAttribute->attribute( 'id' );
248 $enumElement = $base . '_data_enumelement_' . $contentClassAttribute->attribute( 'id' );
249 $enumValue = $base . '_data_enumvalue_' . $contentClassAttribute->attribute( 'id' );
250 $enumRemove = $base . '_data_enumremove_' . $contentClassAttribute->attribute( 'id' );
251 $version = $contentClassAttribute->attribute( 'version' );
252
253 if ( $http->hasPostVariable( $isoption ) )
254 {
255 $ismultipleValue = $http->hasPostVariable( $ismultiple ) ? 1 : 0;
256 $contentClassAttribute->setAttribute( self::IS_MULTIPLE_FIELD, $ismultipleValue );
257 $optionValue = $http->postVariable( $isoption );
258 $optionValueSet = $optionValue == 1 ? '1' : '0';
259 $contentClassAttribute->setAttribute( self::IS_OPTION_FIELD, $optionValueSet );
260 }
261
262 if ( $http->hasPostVariable( $enumID ) &&
263 $http->hasPostVariable( $enumElement ) &&
264 $http->hasPostVariable( $enumValue ) &&
265 !($http->hasPostVariable( $enumRemove ) ) )
266 {
267 $array_enumID = $http->postVariable( $enumID );
268 $array_enumElement = $http->postVariable( $enumElement );
269 $array_enumValue = $http->postVariable( $enumValue );
270 $enum = $contentClassAttribute->content();
271 $enum->setValue( $array_enumID, $array_enumElement, $array_enumValue, $version );
272 $contentClassAttribute->setContent( $enum );
273 }
274 }
275
276 function storeClassAttribute( $contentClassAttribute, $version )
277 {
278 $contentClassAttribute->content()->setVersion( $version );
279 }
280
281 function storeDefinedClassAttribute( $contentClassAttribute )
282 {
283 $contentClassAttribute->content()->setVersion( eZContentClass::VERSION_STATUS_DEFINED );
284 }
285
286 function storeModifiedClassAttribute( $contentClassAttribute )
287 {
288 $contentClassAttribute->content()->setVersion( eZContentClass::VERSION_STATUS_MODIFIED );
289 }
290
294 function classAttributeContent( $contentClassAttribute )
295 {
296 $id = $contentClassAttribute->attribute( 'id' );
297 $version = $contentClassAttribute->attribute( 'version' );
298 $enum = new eZEnum( $id, $version );
299 return $enum;
300 }
301
302 function customClassAttributeHTTPAction( $http, $action, $contentClassAttribute )
303 {
304 $id = $contentClassAttribute->attribute( 'id' );
305 switch ( $action )
306 {
307 case 'new_enumelement' :
308 {
309 $enum = $contentClassAttribute->content( );
310 $enum->addEnumeration('');
311 $contentClassAttribute->setContent( $enum );
312 }break;
313 case 'remove_selected' :
314 {
315 $enum = $contentClassAttribute->content( );
316 $version = $contentClassAttribute->attribute( 'version' );
317 $postvarname = 'ContentClass' . '_data_enumremove_' . $contentClassAttribute->attribute( 'id' );
318 $array_remove = $http->hasPostVariable( $postvarname ) ? $http->postVariable( $postvarname ) : array();
319 foreach( $array_remove as $enumid )
320 {
321 $enum->removeEnumeration( $id, $enumid, $version );
322 }
323 }break;
324 default :
325 {
326 eZDebug::writeError( 'Unknown custom HTTP action: ' . $action, 'eZEnumType' );
327 }break;
328 }
329 }
330
334 function title( $contentObjectAttribute, $name = null )
335 {
336 $enum = $this->objectAttributeContent( $contentObjectAttribute );
337
338 $enumObjectList = $enum->attribute( 'enumobject_list' );
339
340 $value = '';
341
342 foreach ( $enumObjectList as $count => $enumObjectValue )
343 {
344 if ( $count != 0 )
345 $value .= ', ';
346 $value .= $enumObjectValue->attribute( 'enumelement' );
347 }
348
349 return $value;
350 }
351
355 function metaData( $contentObjectAttribute )
356 {
357 $contentObjectAttributeID = $contentObjectAttribute->attribute( 'id' );
358 $contentObjectAttributeVersion = $contentObjectAttribute->attribute( 'version' );
359 $contentClassAttribute = $contentObjectAttribute->contentClassAttribute();
360 $id = $contentClassAttribute->attribute( 'id' );
361 $version = $contentClassAttribute->attribute( 'version' );
362 $ismultiple = $contentClassAttribute->attribute( 'data_int1' );
363 $isoption = $contentClassAttribute->attribute( 'data_int2' );
364
365 $enum = new eZEnum( $id, $version );
366 $enum->setIsmultipleValue( $ismultiple );
367 $enum->setIsoptionValue( $isoption );
368 $enum->setObjectEnumValue( $contentObjectAttributeID, $contentObjectAttributeVersion );
369
370 $return = '';
371 foreach ( $enum->attribute( 'enumobject_list' ) as $enumElement )
372 {
373 $return .= $enumElement->attribute( 'enumvalue' ) . ' ';
374 $return .= $enumElement->attribute( 'enumelement' ) . ' ';
375 }
376 return $return;
377 }
378
382 function objectDisplayInformation( $objectAttribute, $mergeInfo = false )
383 {
384 $classAttribute = $objectAttribute->contentClassAttribute();
385 $isOption = $classAttribute->attribute( 'data_int2' );
386
387 $editGrouped = ( $isOption == false );
388 $info = array( 'edit' => array( 'grouped_input' => $editGrouped ),
389 'collection' => array( 'grouped_input' => $editGrouped ) );
390 return eZDataType::objectDisplayInformation( $objectAttribute, $info );
391 }
392
393 function isIndexable()
394 {
395 return true;
396 }
397
402 function serializeContentObjectAttribute( $package, $contentObjectAttribute )
403 {
404 $contentObjectAttributeID = $contentObjectAttribute->attribute( 'id' );
405 $contentObjectAttributeVersion = $contentObjectAttribute->attribute( 'version' );
406
407 $node = $this->createContentObjectAttributeDOMNode( $contentObjectAttribute );
408
409 $enumElements = eZEnumObjectValue::fetchAllElements( $contentObjectAttributeID, $contentObjectAttributeVersion );
410
411 foreach ( $enumElements as $enumElement )
412 {
413 $elementNode = $node->ownerDocument->createElement( 'enum-element' );
414
415 $elementNode->setAttribute( 'id', $enumElement->attribute( 'enumid' ) );
416 $elementNode->setAttribute( 'value', $enumElement->attribute( 'enumvalue' ) );
417 $elementNode->setAttribute( 'element', $enumElement->attribute( 'enumelement' ) );
418 $node->appendChild( $elementNode );
419 }
420
421 return $node;
422 }
423
424
432 function unserializeContentObjectAttribute( $package, $objectAttribute, $attributeNode )
433 {
434 if ( $attributeNode->hasChildNodes() )
435 {
436 $contentObjectAttributeID = $objectAttribute->attribute( 'id' );
437 $contentObjectAttributeVersion = $objectAttribute->attribute( 'version' );
438
439 $enumNodes = $attributeNode->childNodes;
440 foreach ( $enumNodes as $enumNode )
441 {
442 $eID = $enumNode->getAttribute( 'id' );
443 $eValue = $enumNode->getAttribute( 'value' );
444 $eElement = $enumNode->getAttribute( 'element' );
445
446 eZEnum::storeObjectEnumeration( $contentObjectAttributeID,
447 $contentObjectAttributeVersion,
448 $eID,
449 $eElement,
450 $eValue );
451 }
452 }
453 else
454 {
455 eZDebug::writeError( "Can't find attributes for enumeration", __METHOD__ );
456 }
457 }
458
459
460 function hasObjectAttributeContent( $contentObjectAttribute )
461 {
462 return true;
463 }
464
465 function serializeContentClassAttribute( $classAttribute, $attributeNode, $attributeParametersNode )
466 {
467 $isOption = $classAttribute->attribute( self::IS_OPTION_FIELD );
468 $isMultiple = $classAttribute->attribute( self::IS_MULTIPLE_FIELD );
469 $content = $classAttribute->attribute( 'content' );
470 $enumList = $content->attribute( 'enum_list' );
471 $attributeParametersNode->setAttribute( 'is-option', $isOption ? 'true' : 'false' );
472 $attributeParametersNode->setAttribute( 'is-multiple', $isMultiple ? 'true' : 'false' );
473
474 $elementListNode = $attributeParametersNode->ownerDocument->createElement( 'elements' );
475 $attributeParametersNode->appendChild( $elementListNode );
476 foreach( $enumList as $enumElement )
477 {
478 $elementNode = $attributeParametersNode->ownerDocument->createElement( 'element' );
479 $elementNode->setAttribute( 'id', $enumElement->attribute( 'id' ) );
480 $elementNode->setAttribute( 'name', $enumElement->attribute( 'enumelement' ) );
481 $elementNode->setAttribute( 'value', $enumElement->attribute( 'enumvalue' ) );
482 $elementListNode->appendChild( $elementNode );
483 }
484 }
485
486 function unserializeContentClassAttribute( $classAttribute, $attributeNode, $attributeParametersNode )
487 {
488 $isOption = strtolower( $attributeParametersNode->getAttribute( 'is-option' ) ) == 'true';
489 $isMultiple = strtolower( $attributeParametersNode->getAttribute( 'is-multiple' ) ) == 'true';
490 $classAttribute->setAttribute( self::IS_OPTION_FIELD, $isOption );
491 $classAttribute->setAttribute( self::IS_MULTIPLE_FIELD, $isMultiple );
492
493 $enum = new eZEnum( $classAttribute->attribute( 'id' ), $classAttribute->attribute( 'version' ) );
494 $elementListNode = $attributeParametersNode->getElementsByTagName( 'elements' )->item( 0 );
495 if ( $elementListNode )
496 {
497 $elementList = $elementListNode->getElementsByTagName( 'element' );
498 foreach ( $elementList as $element )
499 {
500 $elementID = $element->getAttribute( 'id' );
501 $elementName = $element->getAttribute( 'name' );
502 $elementValue = $element->getAttribute( 'value' );
503 $value = eZEnumValue::create( $classAttribute->attribute( 'id' ),
504 $classAttribute->attribute( 'version' ),
505 $elementName );
506 $value->setAttribute( 'enumvalue', $elementValue );
507 $value->store();
508 $enum->addEnumerationValue( $value );
509 }
510 }
511 }
512
513 function diff( $old, $new, $options = false )
514 {
515 return null;
516 }
517 }
518 eZDataType::register( eZEnumType::DATA_TYPE_STRING, 'eZEnumType' );
519
520 ?>
eZContentClass\VERSION_STATUS_MODIFIED
const VERSION_STATUS_MODIFIED
Definition: ezcontentclass.php:24
eZContentClass\VERSION_STATUS_DEFINED
const VERSION_STATUS_DEFINED
Definition: ezcontentclass.php:22
eZDB\instance
static instance( $databaseImplementation=false, $databaseParameters=false, $forceNewInstance=false)
Definition: ezdb.php:117
eZDataType
Base class for content datatypes.
Definition: ezdatatype.php:46
eZDataType\objectDisplayInformation
objectDisplayInformation( $objectAttribute, $mergeInfo=false)
Definition: ezdatatype.php:496
eZDataType\register
static register( $dataTypeString, $className)
Definition: ezdatatype.php:203
eZDataType\createContentObjectAttributeDOMNode
createContentObjectAttributeDOMNode( $objectAttribute)
Definition: ezdatatype.php:1371
eZDebug\writeError
static writeError( $string, $label="", $backgroundClass="")
Definition: ezdebug.php:545
eZEnumObjectValue\fetchAllElements
static fetchAllElements( $contentObjectAttributeID, $contentObjectAttributeVersion, $asObject=true)
Definition: ezenumobjectvalue.php:94
eZEnumObjectValue\removeAllElements
static removeAllElements( $contentObjectAttributeID, $contentObjectAttributeVersion)
Definition: ezenumobjectvalue.php:61
eZEnumType
Definition: ezenumtype.php:18
eZEnumType\unserializeContentObjectAttribute
unserializeContentObjectAttribute( $package, $objectAttribute, $attributeNode)
Definition: ezenumtype.php:432
eZEnumType\IS_OPTION_FIELD
const IS_OPTION_FIELD
Definition: ezenumtype.php:22
eZEnumType\__construct
__construct()
Definition: ezenumtype.php:25
eZEnumType\serializeContentClassAttribute
serializeContentClassAttribute( $classAttribute, $attributeNode, $attributeParametersNode)
Definition: ezenumtype.php:465
eZEnumType\validateClassAttributeHTTPInput
validateClassAttributeHTTPInput( $http, $base, $contentClassAttribute)
Definition: ezenumtype.php:235
eZEnumType\hasObjectAttributeContent
hasObjectAttributeContent( $contentObjectAttribute)
Definition: ezenumtype.php:460
eZEnumType\storeClassAttribute
storeClassAttribute( $contentClassAttribute, $version)
Definition: ezenumtype.php:276
eZEnumType\fetchObjectAttributeHTTPInput
fetchObjectAttributeHTTPInput( $http, $base, $contentObjectAttribute)
Definition: ezenumtype.php:127
eZEnumType\storeDefinedClassAttribute
storeDefinedClassAttribute( $contentClassAttribute)
Definition: ezenumtype.php:281
eZEnumType\validateObjectAttributeHTTPInput
validateObjectAttributeHTTPInput( $http, $base, $contentObjectAttribute)
Definition: ezenumtype.php:184
eZEnumType\IS_MULTIPLE_FIELD
const IS_MULTIPLE_FIELD
Definition: ezenumtype.php:20
eZEnumType\objectAttributeContent
objectAttributeContent( $contentObjectAttribute)
Definition: ezenumtype.php:215
eZEnumType\customClassAttributeHTTPAction
customClassAttributeHTTPAction( $http, $action, $contentClassAttribute)
Definition: ezenumtype.php:302
eZEnumType\diff
diff( $old, $new, $options=false)
Definition: ezenumtype.php:513
eZEnumType\unserializeContentClassAttribute
unserializeContentClassAttribute( $classAttribute, $attributeNode, $attributeParametersNode)
Definition: ezenumtype.php:486
eZEnumType\storeObjectAttribute
storeObjectAttribute( $contentObjectAttribute)
Definition: ezenumtype.php:208
eZEnumType\serializeContentObjectAttribute
serializeContentObjectAttribute( $package, $contentObjectAttribute)
Definition: ezenumtype.php:402
eZEnumType\IS_OPTION_VARIABLE
const IS_OPTION_VARIABLE
Definition: ezenumtype.php:23
eZEnumType\deleteStoredObjectAttribute
deleteStoredObjectAttribute( $contentObjectAttribute, $version=null)
Definition: ezenumtype.php:107
eZEnumType\metaData
metaData( $contentObjectAttribute)
Definition: ezenumtype.php:355
eZEnumType\deleteStoredClassAttribute
deleteStoredClassAttribute( $contentClassAttribute, $version=null)
Definition: ezenumtype.php:117
eZEnumType\title
title( $contentObjectAttribute, $name=null)
Definition: ezenumtype.php:334
eZEnumType\isIndexable
isIndexable()
Definition: ezenumtype.php:393
eZEnumType\storeModifiedClassAttribute
storeModifiedClassAttribute( $contentClassAttribute)
Definition: ezenumtype.php:286
eZEnumType\fetchClassAttributeHTTPInput
fetchClassAttributeHTTPInput( $http, $base, $contentClassAttribute)
Definition: ezenumtype.php:243
eZEnumType\initializeClassAttribute
initializeClassAttribute( $classAttribute)
Definition: ezenumtype.php:85
eZEnumType\classAttributeContent
classAttributeContent( $contentClassAttribute)
Definition: ezenumtype.php:294
eZEnumType\DATA_TYPE_STRING
const DATA_TYPE_STRING
Definition: ezenumtype.php:19
eZEnumType\cloneClassAttribute
cloneClassAttribute( $oldClassAttribute, $newClassAttribute)
Definition: ezenumtype.php:63
eZEnumType\IS_MULTIPLE_VARIABLE
const IS_MULTIPLE_VARIABLE
Definition: ezenumtype.php:21
eZEnumType\objectDisplayInformation
objectDisplayInformation( $objectAttribute, $mergeInfo=false)
Definition: ezenumtype.php:382
eZEnumType\initializeObjectAttribute
initializeObjectAttribute( $contentObjectAttribute, $currentVersion, $originalContentObjectAttribute)
Definition: ezenumtype.php:34
eZEnumValue\removeAllElements
static removeAllElements( $contentClassAttributeID, $version)
Definition: ezenumvalue.php:86
eZEnumValue\fetchAllElements
static fetchAllElements( $classAttributeID, $version, $asObject=true)
Definition: ezenumvalue.php:109
eZEnumValue\create
static create( $contentClassAttributeID, $contentClassAttributeVersion, $element)
Definition: ezenumvalue.php:61
eZEnum
The class eZEnum does.
Definition: ezenum.php:19
eZEnum\removeObjectEnumerations
static removeObjectEnumerations( $contentObjectAttributeID, $contentObjectAttributeVersion)
Definition: ezenum.php:91
eZEnum\storeObjectEnumeration
static storeObjectEnumeration( $contentObjectAttributeID, $contentObjectAttributeVersion, $enumID, $enumElement, $enumValue)
Definition: ezenum.php:96
eZInputValidator\STATE_ACCEPTED
const STATE_ACCEPTED
Definition: ezinputvalidator.php:79
eZInputValidator\STATE_INVALID
const STATE_INVALID
Definition: ezinputvalidator.php:81
ezpI18n\tr
static tr( $context, $source, $comment=null, $arguments=null)
Definition: ezpi18n.php:86
Copyright © 1998 – 2026 7x. All rights reserved. Licensed under the GNU GPLv2+.