- Merged in translation changes from stable 3.2 (Rev: 3247, 3250).
[tinyz:tinyz.git] / kernel / classes / datatypes / ezinteger / ezintegertype.php
1 <?php
2 //
3 // Definition of eZIntegerType class
4 //
5 // Copyright (C) 1999-2003 eZ systems as. All rights reserved.
6 //
7 // This source file is part of the eZ publish (tm) Open Source Content
8 // Management System.
9 //
10 // This file may be distributed and/or modified under the terms of the
11 // "GNU General Public License" version 2 as published by the Free
12 // Software Foundation and appearing in the file LICENSE.GPL included in
13 // the packaging of this file.
14 //
15 // Licencees holding valid "eZ publish professional licences" may use this
16 // file in accordance with the "eZ publish professional licence" Agreement
17 // provided with the Software.
18 //
19 // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING
20 // THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21 // PURPOSE.
22 //
23 // The "eZ publish professional licence" is available at
24 // http://ez.no/products/licences/professional/. For pricing of this licence
25 // please contact us via e-mail to licence@ez.no. Further contact
26 // information is available at http://ez.no/home/contact/.
27 //
28 // The "GNU General Public License" (GPL) is available at
29 // http://www.gnu.org/copyleft/gpl.html.
30 //
31 // Contact licence@ez.no if any conditions of this licencing isn't clear to
32 // you.
33 //
34
35 /*!
36   \class eZIntegerType ezintegertype.php
37   \ingroup eZKernel
38   \brief A content datatype which handles integers
39
40   It provides the functionality to work as an integer and handles
41   class definition input, object definition input and object viewing.
42
43   It uses the spare field data_int in a content object attribute for storing
44   the attribute data.
45 */
46
47 include_once( "kernel/classes/ezdatatype.php" );
48 include_once( "lib/ezutils/classes/ezintegervalidator.php" );
49
50 define( "EZ_DATATYPESTRING_INTEGER", "ezinteger" );
51 define( "EZ_DATATYPESTRING_MIN_VALUE_FIELD", "data_int1" );
52 define( "EZ_DATATYPESTRING_MIN_VALUE_VARIABLE", "_ezinteger_min_integer_value_" );
53 define( "EZ_DATATYPESTRING_MAX_VALUE_FIELD", "data_int2" );
54 define( "EZ_DATATYPESTRING_MAX_VALUE_VARIABLE", "_ezinteger_max_integer_value_" );
55 define( "EZ_DATATYPESTRING_DEFAULT_VALUE_FIELD", "data_int3" );
56 define( "EZ_DATATYPESTRING_DEFAULT_VALUE_VARIABLE", "_ezinteger_default_value_" );
57 define( "EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD", "data_int4" );
58 define( "EZ_INTEGER_NO_MIN_MAX_VALUE", 0 );
59 define( "EZ_INTEGER_HAS_MIN_VALUE", 1 );
60 define( "EZ_INTEGER_HAS_MAX_VALUE", 2 );
61 define( "EZ_INTEGER_HAS_MIN_MAX_VALUE", 3 );
62
63
64 class eZIntegerType extends eZDataType
65 {
66     function eZIntegerType()
67     {
68         $this->eZDataType( EZ_DATATYPESTRING_INTEGER, ezi18n( 'kernel/classes/datatypes', "Integer", 'Datatype name' ),
69                            array( 'serialize_supported' => true ) );
70         $this->IntegerValidator = new eZIntegerValidator();
71     }
72
73     /*!
74      Validates the input and returns true if the input was
75      valid for this datatype.
76     */
77     function validateObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
78     {
79         if ( $http->hasPostVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) ) )
80         {
81             $data =& $http->postVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) );
82             $data = str_replace(" ", "", $data );
83             $classAttribute =& $contentObjectAttribute->contentClassAttribute();
84             $min = $classAttribute->attribute( EZ_DATATYPESTRING_MIN_VALUE_FIELD );
85             $max = $classAttribute->attribute( EZ_DATATYPESTRING_MAX_VALUE_FIELD );
86             $input_state = $classAttribute->attribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD );
87             if( ( $classAttribute->attribute( "is_required" ) == false ) &&  ( $data == "" ) )
88             {
89                 return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
90             }
91             switch( $input_state )
92             {
93                 case EZ_INTEGER_NO_MIN_MAX_VALUE:
94                 {
95                     $state = $this->IntegerValidator->validate( $data );
96                     if( $state===1 )
97                         return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
98                     else
99                         $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
100                                                                              'Input is not integer.' ) );
101                 } break;
102                 case EZ_INTEGER_HAS_MIN_VALUE:
103                 {
104                     $this->IntegerValidator->setRange( $min, false );
105                     $state = $this->IntegerValidator->validate( $data );
106                     if( $state===1 )
107                         return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
108                     else
109                         $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
110                                                                              'Input must be greater than %1' ),
111                                                                      $min );
112                 } break;
113                 case EZ_INTEGER_HAS_MAX_VALUE:
114                 {
115                     $this->IntegerValidator->setRange( false, $max );
116                     $state = $this->IntegerValidator->validate( $data );
117                     if( $state===1 )
118                         return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
119                     else
120                         $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
121                                                                              'Input must be less than %1' ),
122                                                                      $max );
123                 } break;
124                 case EZ_INTEGER_HAS_MIN_MAX_VALUE:
125                 {
126                     $this->IntegerValidator->setRange( $min, $max );
127                     $state = $this->IntegerValidator->validate( $data );
128                     if( $state===1 )
129                         return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
130                     else
131                         $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
132                                                                              'Input is not in defined range %1 - %2' ),
133                                                                      $min, $max );
134                 } break;
135             }
136         }
137         else
138         {
139             return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
140         }
141         return EZ_INPUT_VALIDATOR_STATE_INVALID;
142     }
143
144     function fixupObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
145     {
146     }
147
148     /*!
149      Sets the default value.
150     */
151     function initializeObjectAttribute( &$contentObjectAttribute, $currentVersion, &$originalContentObjectAttribute )
152     {
153         if ( $currentVersion != false )
154         {
155 //             $contentObjectAttributeID = $contentObjectAttribute->attribute( "id" );
156 //             $currentObjectAttribute =& eZContentObjectAttribute::fetch( $contentObjectAttributeID,
157 //                                                                         $currentVersion );
158             $dataInt = $originalContentObjectAttribute->attribute( "data_int" );
159             $contentObjectAttribute->setAttribute( "data_int", $dataInt );
160         }
161         else
162         {
163             $contentClassAttribute =& $contentObjectAttribute->contentClassAttribute();
164             $default = $contentClassAttribute->attribute( "data_int3" );
165             if ( $default !== 0 )
166             {
167                 $contentObjectAttribute->setAttribute( "data_int", $default );
168             }
169         }
170     }
171
172     /*!
173      Fetches the http post var integer input and stores it in the data instance.
174     */
175     function fetchObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
176     {
177         if ( $http->hasPostVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) ) )
178         {
179             $data =& $http->postVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) );
180             $contentObjectAttribute->setAttribute( "data_int", $data );
181             return true;
182         }
183         return false;
184     }
185
186     /*!
187      Does nothing, the data is already present in the attribute.
188     */
189     function storeObjectAttribute( &$object_attribute )
190     {
191     }
192
193     function storeClassAttribute( &$attribute, $version )
194     {
195     }
196
197     /*!
198          \reimp
199         */
200         function validateClassAttributeHTTPInput( &$http, $base, &$classAttribute )
201         {
202                 $minValueName = $base . EZ_DATATYPESTRING_MIN_VALUE_VARIABLE . $classAttribute->attribute( "id" );
203                 $maxValueName = $base . EZ_DATATYPESTRING_MAX_VALUE_VARIABLE . $classAttribute->attribute( "id" );
204         $defaultValueName = $base . EZ_DATATYPESTRING_DEFAULT_VALUE_VARIABLE . $classAttribute->attribute( "id" );
205
206         if ( $http->hasPostVariable( $minValueName ) and
207              $http->hasPostVariable( $maxValueName ) and
208              $http->hasPostVariable( $defaultValueName ) )
209                 {
210                         $minValueValue = $http->postVariable( $minValueName );
211             $minValueValue = str_replace(" ", "", $minValueValue );
212                         $maxValueValue = $http->postVariable( $maxValueName );
213             $maxValueValue = str_replace(" ", "", $maxValueValue );
214             $defaultValueValue = $http->postVariable( $defaultValueName );
215             $defaultValueValue = str_replace(" ", "", $defaultValueValue );
216
217             if ( ( $minValueValue == "" ) && ( $maxValueValue == "") ){
218                 return  EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
219             }
220             else if ( ( $minValueValue == "" ) && ( $maxValueValue !== "") )
221             {
222                 $max_state = $this->IntegerValidator->validate( $maxValueValue );
223                 return  $max_state;
224             }
225             else if ( ( $minValueValue !== "" ) && ( $maxValueValue == "") )
226             {
227                 $min_state = $this->IntegerValidator->validate( $minValueValue );
228                 return  $min_state;
229             }
230             else
231             {
232                 $min_state = $this->IntegerValidator->validate( $minValueValue );
233                 $max_state = $this->IntegerValidator->validate( $maxValueValue );
234                 if ( ( $min_state == EZ_INPUT_VALIDATOR_STATE_ACCEPTED ) and
235                      ( $max_state == EZ_INPUT_VALIDATOR_STATE_ACCEPTED ) )
236                 {
237                     if ($minValueValue <= $maxValueValue)
238                         return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
239                     else
240                     {
241                         $state = EZ_INPUT_VALIDATOR_STATE_INTERMEDIATE;
242                         eZDebug::writeNotice( "Integer minimum value great than maximum value." );
243                         return $state;
244                     }
245                 }
246             }
247
248             if ($defaultValueValue == ""){
249                 $default_state =  EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
250             }
251             else
252                 $default_state = $this->IntegerValidator->validate( $defaultValueValue );
253                 }
254
255         return EZ_INPUT_VALIDATOR_STATE_INVALID;
256         }
257
258         /*!
259          \reimp
260         */
261         function fixupClassAttributeHTTPInput( &$http, $base, &$classAttribute )
262         {
263                 $minValueName = $base . EZ_DATATYPESTRING_MIN_VALUE_VARIABLE . $classAttribute->attribute( "id" );
264                 $maxValueName = $base . EZ_DATATYPESTRING_MAX_VALUE_VARIABLE . $classAttribute->attribute( "id" );
265                 if ( $http->hasPostVariable( $minValueName ) and $http->hasPostVariable( $maxValueName ) )
266                 {
267                         $minValueValue = $http->postVariable( $minValueName );
268             $minValueValue = $this->IntegerValidator->fixup( $minValueValue );
269             $http->setPostVariable( $minValueName, $minValueValue );
270
271             $maxValueValue = $http->postVariable( $maxValueName );
272             $maxValueValue = $this->IntegerValidator->fixup( $maxValueValue );
273             $http->setPostVariable( $maxValueName, $maxValueValue );
274
275             if ($minValueValue > $maxValueValue)
276                         {
277                 $this->IntegerValidator->setRange( $minValueValue, false );
278                 $maxValueValue = $this->IntegerValidator->fixup( $maxValueValue );
279                                 $http->setPostVariable( $maxValueName, $maxValueValue );
280                         }
281                 }
282         }
283
284         /*!
285          \reimp
286         */
287         function fetchClassAttributeHTTPInput( &$http, $base, &$classAttribute )
288         {
289                 $minValueName = $base . EZ_DATATYPESTRING_MIN_VALUE_VARIABLE . $classAttribute->attribute( "id" );
290                 $maxValueName = $base . EZ_DATATYPESTRING_MAX_VALUE_VARIABLE . $classAttribute->attribute( "id" );
291         $defaultValueName = $base . EZ_DATATYPESTRING_DEFAULT_VALUE_VARIABLE . $classAttribute->attribute( "id" );
292
293         if ( $http->hasPostVariable( $minValueName ) and
294              $http->hasPostVariable( $maxValueName ) and
295              $http->hasPostVariable( $defaultValueName ) )
296                 {
297             $minValueValue = $http->postVariable( $minValueName );
298             $minValueValue = str_replace(" ", "", $minValueValue );
299             $maxValueValue = $http->postVariable( $maxValueName );
300             $maxValueValue = str_replace(" ", "", $maxValueValue );
301             $defaultValueValue = $http->postVariable( $defaultValueName );
302             $defaultValueValue = str_replace(" ", "", $defaultValueValue );
303
304             $classAttribute->setAttribute( EZ_DATATYPESTRING_MIN_VALUE_FIELD, $minValueValue );
305             $classAttribute->setAttribute( EZ_DATATYPESTRING_MAX_VALUE_FIELD, $maxValueValue );
306             $classAttribute->setAttribute( EZ_DATATYPESTRING_DEFAULT_VALUE_FIELD, $defaultValueValue );
307
308             if ( ( $minValueValue == "" ) && ( $maxValueValue == "") ){
309                 $input_state =  EZ_INTEGER_NO_MIN_MAX_VALUE;
310                 $classAttribute->setAttribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD, $input_state );
311             }
312             else if ( ( $minValueValue == "" ) && ( $maxValueValue !== "") )
313             {
314                 $input_state = EZ_INTEGER_HAS_MAX_VALUE;
315                 $classAttribute->setAttribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD, $input_state );
316             }
317             else if ( ( $minValueValue !== "" ) && ( $maxValueValue == "") )
318             {
319                 $input_state = EZ_INTEGER_HAS_MIN_VALUE;
320                 $classAttribute->setAttribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD, $input_state );
321             }
322             else
323             {
324                 $input_state = EZ_INTEGER_HAS_MIN_MAX_VALUE;
325                 $classAttribute->setAttribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD, $input_state );
326             }
327             return true;
328                 }
329         return false;
330         }
331
332     /*!
333      Returns the content.
334     */
335     function &objectAttributeContent( &$contentObjectAttribute )
336     {
337         return $contentObjectAttribute->attribute( "data_int" );
338     }
339
340
341     /*!
342      Returns the meta data used for storing search indeces.
343     */
344     function metaData( $contentObjectAttribute )
345     {
346         return $contentObjectAttribute->attribute( "data_int" );
347     }
348
349     /*!
350      Returns the integer value.
351     */
352     function title( &$contentObjectAttribute )
353     {
354         return $contentObjectAttribute->attribute( "data_int" );
355     }
356
357     /*!
358      \return true if the datatype can be indexed
359     */
360     function isIndexable()
361     {
362         return true;
363     }
364
365     /*!
366      \reimp
367     */
368     function &sortKey( &$contentObjectAttribute )
369     {
370         return $contentObjectAttribute->attribute( 'data_int' );
371     }
372
373     /*!
374      \reimp
375     */
376     function &sortKeyType()
377     {
378         return 'int';
379     }
380
381     /*!
382      \return a DOM representation of the content object attribute
383     */
384     function &serializeContentObjectAttribute( $objectAttribute )
385     {
386         include_once( 'lib/ezxml/classes/ezdomdocument.php' );
387         include_once( 'lib/ezxml/classes/ezdomnode.php' );
388
389         $node = new eZDOMNode();
390         $node->setName( 'attribute' );
391         $node->appendAttribute( eZDOMDocument::createAttributeNode( 'name', $objectAttribute->contentClassAttributeName() ) );
392         $node->appendAttribute( eZDOMDocument::createAttributeNode( 'type', 'ezinteger' ) );
393         $node->appendAttribute( eZDOMDocument::createAttributeNode( 'value', $objectAttribute->attribute( "data_int" ) ) );
394
395         return $node;
396     }
397
398     /*!
399      \reimp
400     */
401     function &serializeContentClassAttribute( &$classAttribute, &$attributeNode, &$attributeParametersNode )
402     {
403         $defaultValue = $classAttribute->attribute( EZ_DATATYPESTRING_DEFAULT_VALUE_FIELD );
404         $minValue = $classAttribute->attribute( EZ_DATATYPESTRING_MIN_VALUE_FIELD );
405         $maxValue = $classAttribute->attribute( EZ_DATATYPESTRING_MAX_VALUE_FIELD );
406         $minMaxState = $classAttribute->attribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD );
407         $attributeParametersNode->appendChild( eZDOMDocument::createElementTextNode( 'default-value', $defaultValue ) );
408         if ( $minMaxState == EZ_INTEGER_HAS_MIN_VALUE or $minMaxState == EZ_INTEGER_HAS_MIN_MAX_VALUE )
409             $attributeParametersNode->appendChild( eZDOMDocument::createElementTextNode( 'min-value', $minValue ) );
410         if ( $minMaxState == EZ_INTEGER_HAS_MAX_VALUE or $minMaxState == EZ_INTEGER_HAS_MIN_MAX_VALUE )
411             $attributeParametersNode->appendChild( eZDOMDocument::createElementTextNode( 'max-value', $maxValue ) );
412     }
413
414     /*!
415      \reimp
416     */
417     function &unserializeContentClassAttribute( &$classAttribute, &$attributeNode, &$attributeParametersNode )
418     {
419         $defaultValue = $attributeParametersNode->elementTextContentByName( 'default-value' );
420         $minValue = $attributeParametersNode->elementTextContentByName( 'min-value' );
421         $maxValue = $attributeParametersNode->elementTextContentByName( 'max-value' );
422
423         if ( $minValue and $maxValue )
424             $minMaxState = EZ_INTEGER_HAS_MIN_MAX_VALUE;
425         else if ( $minValue )
426             $minMaxState = EZ_INTEGER_HAS_MIN_VALUE;
427         else if ( $maxValue )
428             $minMaxState = EZ_INTEGER_HAS_MAX_VALUE;
429         else
430             $minMaxState = EZ_INTEGER_NO_MIN_MAX_VALUE;
431
432         $classAttribute->setAttribute( EZ_DATATYPESTRING_DEFAULT_VALUE_FIELD, $defaultValue );
433         $classAttribute->setAttribute( EZ_DATATYPESTRING_MIN_VALUE_FIELD, $minValue );
434         $classAttribute->setAttribute( EZ_DATATYPESTRING_MAX_VALUE_FIELD, $maxValue );
435         $classAttribute->setAttribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD, $minMaxState );
436     }
437
438     /// \privatesection
439     /// The integer value validator
440     var $IntegerValidator;
441 }
442
443 eZDataType::register( EZ_DATATYPESTRING_INTEGER, "ezintegertype" );
444
445 ?>