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