- Configured trunk for the 3.9.0alpha1 subrelease.
[tinyz:tinyz.git] / kernel / classes / datatypes / ezinteger / ezintegertype.php
1 <?php
2 //
3 // Definition of eZIntegerType class
4 //
5 // ## BEGIN COPYRIGHT, LICENSE AND WARRANTY NOTICE ##
6 // SOFTWARE NAME: eZ publish
7 // SOFTWARE RELEASE: 3.9.x
8 // COPYRIGHT NOTICE: Copyright (C) 1999-2006 eZ systems AS
9 // SOFTWARE LICENSE: GNU General Public License v2.0
10 // NOTICE: >
11 //   This program is free software; you can redistribute it and/or
12 //   modify it under the terms of version 2.0  of the GNU General
13 //   Public License as published by the Free Software Foundation.
14 // 
15 //   This program is distributed in the hope that it will be useful,
16 //   but WITHOUT ANY WARRANTY; without even the implied warranty of
17 //   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 //   GNU General Public License for more details.
19 // 
20 //   You should have received a copy of version 2.0 of the GNU General
21 //   Public License along with this program; if not, write to the Free
22 //   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
23 //   MA 02110-1301, USA.
24 // 
25 // 
26 // ## END COPYRIGHT, LICENSE AND WARRANTY NOTICE ##
27 //
28
29 /*!
30   \class eZIntegerType ezintegertype.php
31   \ingroup eZDatatype
32   \brief A content datatype which handles integers
33
34   It provides the functionality to work as an integer and handles
35   class definition input, object definition input and object viewing.
36
37   It uses the spare field data_int in a content object attribute for storing
38   the attribute data.
39 */
40
41 include_once( "kernel/classes/ezdatatype.php" );
42 include_once( "lib/ezutils/classes/ezintegervalidator.php" );
43
44 define( "EZ_DATATYPESTRING_INTEGER", "ezinteger" );
45 define( "EZ_DATATYPESTRING_MIN_VALUE_FIELD", "data_int1" );
46 define( "EZ_DATATYPESTRING_MIN_VALUE_VARIABLE", "_ezinteger_min_integer_value_" );
47 define( "EZ_DATATYPESTRING_MAX_VALUE_FIELD", "data_int2" );
48 define( "EZ_DATATYPESTRING_MAX_VALUE_VARIABLE", "_ezinteger_max_integer_value_" );
49 define( "EZ_DATATYPESTRING_DEFAULT_VALUE_FIELD", "data_int3" );
50 define( "EZ_DATATYPESTRING_DEFAULT_VALUE_VARIABLE", "_ezinteger_default_value_" );
51 define( "EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD", "data_int4" );
52 define( "EZ_INTEGER_NO_MIN_MAX_VALUE", 0 );
53 define( "EZ_INTEGER_HAS_MIN_VALUE", 1 );
54 define( "EZ_INTEGER_HAS_MAX_VALUE", 2 );
55 define( "EZ_INTEGER_HAS_MIN_MAX_VALUE", 3 );
56
57
58 class eZIntegerType extends eZDataType
59 {
60     function eZIntegerType()
61     {
62         $this->eZDataType( EZ_DATATYPESTRING_INTEGER, ezi18n( 'kernel/classes/datatypes', "Integer", 'Datatype name' ),
63                            array( 'serialize_supported' => true,
64                                   'object_serialize_map' => array( 'data_int' => 'value' ) ) );
65         $this->IntegerValidator = new eZIntegerValidator();
66     }
67
68     /*!
69      Private method, only for using inside this class.
70     */
71     function validateIntegerHTTPInput( $data, &$contentObjectAttribute, &$classAttribute )
72     {
73         $min = $classAttribute->attribute( EZ_DATATYPESTRING_MIN_VALUE_FIELD );
74         $max = $classAttribute->attribute( EZ_DATATYPESTRING_MAX_VALUE_FIELD );
75         $input_state = $classAttribute->attribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD );
76
77         switch( $input_state )
78         {
79             case EZ_INTEGER_NO_MIN_MAX_VALUE:
80             {
81                 $this->IntegerValidator->setRange( false, false );
82                 $state = $this->IntegerValidator->validate( $data );
83                 if( $state === EZ_INPUT_VALIDATOR_STATE_INVALID || $state === EZ_INPUT_VALIDATOR_STATE_INTERMEDIATE )
84                     $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
85                                                                          'The input is not a valid integer.' ) );
86                 else
87                     return $state;
88             } break;
89             case EZ_INTEGER_HAS_MIN_VALUE:
90             {
91                 $this->IntegerValidator->setRange( $min, false );
92                 $state = $this->IntegerValidator->validate( $data );
93                 if( $state === EZ_INPUT_VALIDATOR_STATE_ACCEPTED )
94                     return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
95                 else
96                     $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
97                                                                          'The number must be greater than %1' ),
98                                                                  $min );
99             } break;
100             case EZ_INTEGER_HAS_MAX_VALUE:
101             {
102                 $this->IntegerValidator->setRange( false, $max );
103                 $state = $this->IntegerValidator->validate( $data );
104                 if( $state===1 )
105                     return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
106                 else
107                     $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
108                                                                          'The number must be less than %1' ),
109                                                                  $max );
110             } break;
111             case EZ_INTEGER_HAS_MIN_MAX_VALUE:
112             {
113                 $this->IntegerValidator->setRange( $min, $max );
114                 $state = $this->IntegerValidator->validate( $data );
115                 if( $state===1 )
116                     return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
117                 else
118                     $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
119                                                                          'The number is not within the required range %1 - %2' ),
120                                                                  $min, $max );
121             } break;
122         }
123
124         return EZ_INPUT_VALIDATOR_STATE_INVALID;
125
126     }
127
128     /*!
129      Validates the input and returns true if the input was
130      valid for this datatype.
131     */
132     function validateObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
133     {
134         if ( $http->hasPostVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) ) )
135         {
136             $data = $http->postVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) );
137             $data = str_replace(" ", "", $data );
138             $classAttribute =& $contentObjectAttribute->contentClassAttribute();
139
140             if ( $data == "" )
141             {
142                 if ( !$classAttribute->attribute( 'is_information_collector' ) and
143                      $contentObjectAttribute->validateIsRequired() )
144                 {
145                     $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
146                                                                          'Input required.' ) );
147                     return EZ_INPUT_VALIDATOR_STATE_INVALID;
148                 }
149                 else
150                     return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
151             }
152             else
153             {
154                 return $this->validateIntegerHTTPInput( $data, $contentObjectAttribute, $classAttribute );
155             }
156         }
157         else
158             return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
159     }
160
161     function fixupObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
162     {
163     }
164
165     /*!
166      Sets the default value.
167     */
168     function initializeObjectAttribute( &$contentObjectAttribute, $currentVersion, &$originalContentObjectAttribute )
169     {
170         if ( $currentVersion != false )
171         {
172 //             $contentObjectAttributeID = $contentObjectAttribute->attribute( "id" );
173 //             $currentObjectAttribute = eZContentObjectAttribute::fetch( $contentObjectAttributeID,
174 //                                                                         $currentVersion );
175             $dataInt = $originalContentObjectAttribute->attribute( "data_int" );
176             $contentObjectAttribute->setAttribute( "data_int", $dataInt );
177         }
178         else
179         {
180             $contentClassAttribute =& $contentObjectAttribute->contentClassAttribute();
181             $default = $contentClassAttribute->attribute( "data_int3" );
182             if ( $default !== 0 )
183             {
184                 $contentObjectAttribute->setAttribute( "data_int", $default );
185             }
186         }
187     }
188
189     /*!
190      Fetches the http post var integer input and stores it in the data instance.
191     */
192     function fetchObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
193     {
194         if ( $http->hasPostVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) ) )
195         {
196             $data = $http->postVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) );
197             $data = trim( $data ) != '' ? $data : null;
198             $contentObjectAttribute->setAttribute( "data_int", $data );
199             return true;
200         }
201         return false;
202     }
203
204     /*!
205      \reimp
206     */
207     function validateCollectionAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
208     {
209         if ( $http->hasPostVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) ) )
210         {
211             $data = $http->postVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) );
212             $data = str_replace(" ", "", $data );
213             $classAttribute =& $contentObjectAttribute->contentClassAttribute();
214
215             if ( $data == "" )
216             {
217                 if ( $contentObjectAttribute->validateIsRequired() )
218                 {
219                     $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
220                                                                          'Input required.' ) );
221                     return EZ_INPUT_VALIDATOR_STATE_INVALID;
222                 }
223                 else
224                     return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
225             }
226             else
227             {
228                 return $this->validateIntegerHTTPInput( $data, $contentObjectAttribute, $classAttribute );
229             }
230         }
231         else
232             return EZ_INPUT_VALIDATOR_STATE_INVALID;
233     }
234
235     /*!
236      Fetches the http post variables for collected information
237     */
238     function fetchCollectionAttributeHTTPInput( &$collection, &$collectionAttribute, &$http, $base, &$contentObjectAttribute )
239     {
240         if ( $http->hasPostVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) ) )
241         {
242             $data = $http->postVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) );
243             $collectionAttribute->setAttribute( "data_int", $data );
244             return true;
245         }
246         return false;
247     }
248
249     /*!
250      Does nothing, the data is already present in the attribute.
251     */
252     function storeObjectAttribute( &$object_attribute )
253     {
254     }
255
256     function storeClassAttribute( &$attribute, $version )
257     {
258     }
259
260     /*!
261          \reimp
262         */
263         function validateClassAttributeHTTPInput( &$http, $base, &$classAttribute )
264         {
265                 $minValueName = $base . EZ_DATATYPESTRING_MIN_VALUE_VARIABLE . $classAttribute->attribute( "id" );
266                 $maxValueName = $base . EZ_DATATYPESTRING_MAX_VALUE_VARIABLE . $classAttribute->attribute( "id" );
267         $defaultValueName = $base . EZ_DATATYPESTRING_DEFAULT_VALUE_VARIABLE . $classAttribute->attribute( "id" );
268
269         if ( $http->hasPostVariable( $minValueName ) and
270              $http->hasPostVariable( $maxValueName ) and
271              $http->hasPostVariable( $defaultValueName ) )
272                 {
273                         $minValueValue = $http->postVariable( $minValueName );
274             $minValueValue = str_replace(" ", "", $minValueValue );
275                         $maxValueValue = $http->postVariable( $maxValueName );
276             $maxValueValue = str_replace(" ", "", $maxValueValue );
277             $defaultValueValue = $http->postVariable( $defaultValueName );
278             $defaultValueValue = str_replace(" ", "", $defaultValueValue );
279
280             if ( ( $minValueValue == "" ) && ( $maxValueValue == "") ){
281                 return  EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
282             }
283             else if ( ( $minValueValue == "" ) && ( $maxValueValue !== "") )
284             {
285                 $max_state = $this->IntegerValidator->validate( $maxValueValue );
286                 return  $max_state;
287             }
288             else if ( ( $minValueValue !== "" ) && ( $maxValueValue == "") )
289             {
290                 $min_state = $this->IntegerValidator->validate( $minValueValue );
291                 return  $min_state;
292             }
293             else
294             {
295                 $min_state = $this->IntegerValidator->validate( $minValueValue );
296                 $max_state = $this->IntegerValidator->validate( $maxValueValue );
297                 if ( ( $min_state == EZ_INPUT_VALIDATOR_STATE_ACCEPTED ) and
298                      ( $max_state == EZ_INPUT_VALIDATOR_STATE_ACCEPTED ) )
299                 {
300                     if ($minValueValue <= $maxValueValue)
301                         return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
302                     else
303                     {
304                         $state = EZ_INPUT_VALIDATOR_STATE_INTERMEDIATE;
305                         eZDebug::writeNotice( "Integer minimum value great than maximum value." );
306                         return $state;
307                     }
308                 }
309             }
310
311             if ($defaultValueValue == ""){
312                 $default_state =  EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
313             }
314             else
315                 $default_state = $this->IntegerValidator->validate( $defaultValueValue );
316                 }
317
318         return EZ_INPUT_VALIDATOR_STATE_INVALID;
319         }
320
321         /*!
322          \reimp
323         */
324         function fixupClassAttributeHTTPInput( &$http, $base, &$classAttribute )
325         {
326                 $minValueName = $base . EZ_DATATYPESTRING_MIN_VALUE_VARIABLE . $classAttribute->attribute( "id" );
327                 $maxValueName = $base . EZ_DATATYPESTRING_MAX_VALUE_VARIABLE . $classAttribute->attribute( "id" );
328                 if ( $http->hasPostVariable( $minValueName ) and $http->hasPostVariable( $maxValueName ) )
329                 {
330                         $minValueValue = $http->postVariable( $minValueName );
331             $minValueValue = $this->IntegerValidator->fixup( $minValueValue );
332             $http->setPostVariable( $minValueName, $minValueValue );
333
334             $maxValueValue = $http->postVariable( $maxValueName );
335             $maxValueValue = $this->IntegerValidator->fixup( $maxValueValue );
336             $http->setPostVariable( $maxValueName, $maxValueValue );
337
338             if ($minValueValue > $maxValueValue)
339                         {
340                 $this->IntegerValidator->setRange( $minValueValue, false );
341                 $maxValueValue = $this->IntegerValidator->fixup( $maxValueValue );
342                                 $http->setPostVariable( $maxValueName, $maxValueValue );
343                         }
344                 }
345         }
346
347         /*!
348          \reimp
349         */
350         function fetchClassAttributeHTTPInput( &$http, $base, &$classAttribute )
351         {
352                 $minValueName = $base . EZ_DATATYPESTRING_MIN_VALUE_VARIABLE . $classAttribute->attribute( "id" );
353                 $maxValueName = $base . EZ_DATATYPESTRING_MAX_VALUE_VARIABLE . $classAttribute->attribute( "id" );
354         $defaultValueName = $base . EZ_DATATYPESTRING_DEFAULT_VALUE_VARIABLE . $classAttribute->attribute( "id" );
355
356         if ( $http->hasPostVariable( $minValueName ) and
357              $http->hasPostVariable( $maxValueName ) and
358              $http->hasPostVariable( $defaultValueName ) )
359                 {
360             $minValueValue = $http->postVariable( $minValueName );
361             $minValueValue = str_replace(" ", "", $minValueValue );
362             $maxValueValue = $http->postVariable( $maxValueName );
363             $maxValueValue = str_replace(" ", "", $maxValueValue );
364             $defaultValueValue = $http->postVariable( $defaultValueName );
365             $defaultValueValue = str_replace(" ", "", $defaultValueValue );
366
367             $classAttribute->setAttribute( EZ_DATATYPESTRING_MIN_VALUE_FIELD, $minValueValue );
368             $classAttribute->setAttribute( EZ_DATATYPESTRING_MAX_VALUE_FIELD, $maxValueValue );
369             $classAttribute->setAttribute( EZ_DATATYPESTRING_DEFAULT_VALUE_FIELD, $defaultValueValue );
370
371             if ( ( $minValueValue == "" ) && ( $maxValueValue == "") ){
372                 $input_state =  EZ_INTEGER_NO_MIN_MAX_VALUE;
373                 $classAttribute->setAttribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD, $input_state );
374             }
375             else if ( ( $minValueValue == "" ) && ( $maxValueValue !== "") )
376             {
377                 $input_state = EZ_INTEGER_HAS_MAX_VALUE;
378                 $classAttribute->setAttribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD, $input_state );
379             }
380             else if ( ( $minValueValue !== "" ) && ( $maxValueValue == "") )
381             {
382                 $input_state = EZ_INTEGER_HAS_MIN_VALUE;
383                 $classAttribute->setAttribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD, $input_state );
384             }
385             else
386             {
387                 $input_state = EZ_INTEGER_HAS_MIN_MAX_VALUE;
388                 $classAttribute->setAttribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD, $input_state );
389             }
390             return true;
391                 }
392         return false;
393         }
394
395     /*!
396      Returns the content.
397     */
398     function &objectAttributeContent( &$contentObjectAttribute )
399     {
400         return $contentObjectAttribute->attribute( "data_int" );
401     }
402
403
404     /*!
405      Returns the meta data used for storing search indeces.
406     */
407     function metaData( $contentObjectAttribute )
408     {
409         return $contentObjectAttribute->attribute( "data_int" );
410     }
411     /*!
412      \return string representation of an contentobjectattribute data for simplified export
413
414     */
415     function toString( $contentObjectAttribute )
416     {
417         return $contentObjectAttribute->attribute( 'data_int' );
418     }
419
420     function fromString( &$contentObjectAttribute, $string )
421     {
422         return $contentObjectAttribute->setAttribute( 'data_int', $string );
423     }
424
425     /*!
426      Returns the integer value.
427     */
428     function title( &$contentObjectAttribute )
429     {
430         return $contentObjectAttribute->attribute( "data_int" );
431     }
432
433     function hasObjectAttributeContent( &$contentObjectAttribute )
434     {
435         return true;
436     }
437
438     /*!
439      \reimp
440     */
441     function isInformationCollector()
442     {
443         return true;
444     }
445
446     /*!
447      \return true if the datatype can be indexed
448     */
449     function isIndexable()
450     {
451         return true;
452     }
453
454     /*!
455      \reimp
456     */
457     function sortKey( &$contentObjectAttribute )
458     {
459         return $contentObjectAttribute->attribute( 'data_int' );
460     }
461
462     /*!
463      \reimp
464     */
465     function sortKeyType()
466     {
467         return 'int';
468     }
469
470     /*!
471      \reimp
472     */
473     function serializeContentClassAttribute( &$classAttribute, &$attributeNode, &$attributeParametersNode )
474     {
475         $defaultValue = $classAttribute->attribute( EZ_DATATYPESTRING_DEFAULT_VALUE_FIELD );
476         $minValue = $classAttribute->attribute( EZ_DATATYPESTRING_MIN_VALUE_FIELD );
477         $maxValue = $classAttribute->attribute( EZ_DATATYPESTRING_MAX_VALUE_FIELD );
478         $minMaxState = $classAttribute->attribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD );
479         $attributeParametersNode->appendChild( eZDOMDocument::createElementTextNode( 'default-value', $defaultValue ) );
480         if ( $minMaxState == EZ_INTEGER_HAS_MIN_VALUE or $minMaxState == EZ_INTEGER_HAS_MIN_MAX_VALUE )
481             $attributeParametersNode->appendChild( eZDOMDocument::createElementTextNode( 'min-value', $minValue ) );
482         if ( $minMaxState == EZ_INTEGER_HAS_MAX_VALUE or $minMaxState == EZ_INTEGER_HAS_MIN_MAX_VALUE )
483             $attributeParametersNode->appendChild( eZDOMDocument::createElementTextNode( 'max-value', $maxValue ) );
484     }
485
486     /*!
487      \reimp
488     */
489     function unserializeContentClassAttribute( &$classAttribute, &$attributeNode, &$attributeParametersNode )
490     {
491         $defaultValue = $attributeParametersNode->elementTextContentByName( 'default-value' );
492         $minValue = $attributeParametersNode->elementTextContentByName( 'min-value' );
493         $maxValue = $attributeParametersNode->elementTextContentByName( 'max-value' );
494
495         if ( strlen( $minValue ) > 0 and strlen( $maxValue ) > 0 )
496             $minMaxState = EZ_INTEGER_HAS_MIN_MAX_VALUE;
497         else if ( strlen( $minValue ) > 0 )
498             $minMaxState = EZ_INTEGER_HAS_MIN_VALUE;
499         else if ( strlen( $maxValue ) > 0 )
500             $minMaxState = EZ_INTEGER_HAS_MAX_VALUE;
501         else
502             $minMaxState = EZ_INTEGER_NO_MIN_MAX_VALUE;
503
504         $classAttribute->setAttribute( EZ_DATATYPESTRING_DEFAULT_VALUE_FIELD, $defaultValue );
505         $classAttribute->setAttribute( EZ_DATATYPESTRING_MIN_VALUE_FIELD, $minValue );
506         $classAttribute->setAttribute( EZ_DATATYPESTRING_MAX_VALUE_FIELD, $maxValue );
507         $classAttribute->setAttribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD, $minMaxState );
508     }
509
510     /// \privatesection
511     /// The integer value validator
512     var $IntegerValidator;
513 }
514
515 eZDataType::register( EZ_DATATYPESTRING_INTEGER, "ezintegertype" );
516
517 ?>