fixed copyright
[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/home/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, "Integer" );
69         $this->IntegerValidator = new eZIntegerValidator();
70     }
71
72     /*!
73      Validates the input and returns true if the input was
74      valid for this datatype.
75     */
76     function validateObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
77     {
78         if ( $http->hasPostVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) ) )
79         {
80             $data =& $http->postVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) );
81             $data = str_replace(" ", "", $data );
82             $classAttribute =& $contentObjectAttribute->contentClassAttribute();
83             $min = $classAttribute->attribute( EZ_DATATYPESTRING_MIN_VALUE_FIELD );
84             $max = $classAttribute->attribute( EZ_DATATYPESTRING_MAX_VALUE_FIELD );
85             $input_state = $classAttribute->attribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD );
86             if( ( $classAttribute->attribute( "is_required" ) == false ) &&  ( $data == "" ) )
87             {
88                 return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
89             }
90             switch( $input_state )
91             {
92                 case EZ_INTEGER_NO_MIN_MAX_VALUE:
93                 {
94                     $state = $this->IntegerValidator->validate( $data );
95                     if( $state===1 )
96                         return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
97                     else
98                         $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
99                                                                              'Input is not integer.',
100                                                                              'eZIntegerType' ) );
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                                                                              'eZIntegerType' ),
112                                                                      $min );
113                 } break;
114                 case EZ_INTEGER_HAS_MAX_VALUE:
115                 {
116                     $this->IntegerValidator->setRange( false, $max );
117                     $state = $this->IntegerValidator->validate( $data );
118                     if( $state===1 )
119                         return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
120                     else
121                         $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
122                                                                              'Input must be less than %1',
123                                                                              'eZIntegerType' ),
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                                                                              'Input is not in defined range %1 - %2',
135                                                                              'eZIntegerType' ),
136                                                                      $min, $max );
137                 } break;
138             }
139         }
140         else
141         {
142             return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
143         }
144         return EZ_INPUT_VALIDATOR_STATE_INVALID;
145     }
146
147     function fixupObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
148     {
149     }
150
151     /*!
152      Sets the default value.
153     */
154     function initializeObjectAttribute( &$contentObjectAttribute, $currentVersion )
155     {
156         if ( $currentVersion != false )
157         {
158             $contentObjectAttributeID = $contentObjectAttribute->attribute( "id" );
159             $currentObjectAttribute =& eZContentObjectAttribute::fetch( $contentObjectAttributeID,
160                                                                         $currentVersion );
161             $dataInt = $currentObjectAttribute ->attribute( "data_int" );
162             $contentObjectAttribute->setAttribute( "data_int", $dataInt );
163         }
164         else
165         {
166             $contentClassAttribute =& $contentObjectAttribute->contentClassAttribute();
167             $default = $contentClassAttribute->attribute( "data_int3" );
168             if ( $default !== 0 )
169             {
170                 $contentObjectAttribute->setAttribute( "data_int", $default );
171             }
172         }
173     }
174
175     /*!
176      Fetches the http post var integer input and stores it in the data instance.
177     */
178     function fetchObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
179     {
180         if ( $http->hasPostVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) ) )
181         {
182             $data =& $http->postVariable( $base . "_data_integer_" . $contentObjectAttribute->attribute( "id" ) );
183             $contentObjectAttribute->setAttribute( "data_int", $data );
184             return true;
185         }else
186         {
187             return false;
188         }
189     }
190
191     /*!
192      Does nothing, the data is already present in the attribute.
193     */
194     function storeObjectAttribute( &$object_attribute )
195     {
196     }
197
198     function storeClassAttribute( &$attribute, $version )
199     {
200         eZDebug::writeWarning( "Storing ezinteger with version $version" );
201     }
202
203     /*!
204          \reimp
205         */
206         function validateClassAttributeHTTPInput( &$http, $base, &$classAttribute )
207         {
208                 $minValueName = $base . EZ_DATATYPESTRING_MIN_VALUE_VARIABLE . $classAttribute->attribute( "id" );
209                 $maxValueName = $base . EZ_DATATYPESTRING_MAX_VALUE_VARIABLE . $classAttribute->attribute( "id" );
210         $defaultValueName = $base . EZ_DATATYPESTRING_DEFAULT_VALUE_VARIABLE . $classAttribute->attribute( "id" );
211
212         if ( $http->hasPostVariable( $minValueName ) and
213              $http->hasPostVariable( $maxValueName ) and
214              $http->hasPostVariable( $defaultValueName ) )
215                 {
216                         $minValueValue = $http->postVariable( $minValueName );
217             $minValueValue = str_replace(" ", "", $minValueValue );
218                         $maxValueValue = $http->postVariable( $maxValueName );
219             $maxValueValue = str_replace(" ", "", $maxValueValue );
220             $defaultValueValue = $http->postVariable( $defaultValueName );
221             $defaultValueValue = str_replace(" ", "", $defaultValueValue );
222
223             if ( ( $minValueValue == "" ) && ( $maxValueValue == "") ){
224                 return  EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
225             }
226             else if ( ( $minValueValue == "" ) && ( $maxValueValue !== "") )
227             {
228                 $max_state = $this->IntegerValidator->validate( $maxValueValue );
229                 return  $max_state;
230             }
231             else if ( ( $minValueValue !== "" ) && ( $maxValueValue == "") )
232             {
233                 $min_state = $this->IntegerValidator->validate( $minValueValue );
234                 return  $min_state;
235             }
236             else
237             {
238                 $min_state = $this->IntegerValidator->validate( $minValueValue );
239                 $max_state = $this->IntegerValidator->validate( $maxValueValue );
240                 if ( ( $min_state == EZ_INPUT_VALIDATOR_STATE_ACCEPTED ) and
241                      ( $max_state == EZ_INPUT_VALIDATOR_STATE_ACCEPTED ) )
242                 {
243                     if ($minValueValue <= $maxValueValue)
244                         return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
245                     else
246                     {
247                         $state = EZ_INPUT_VALIDATOR_STATE_INTERMEDIATE;
248                         eZDebug::writeNotice( "Integer minimum value great than maximum value." );
249                         return $state;
250                     }
251                 }
252             }
253
254             if ($defaultValueValue == ""){
255                 $default_state =  EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
256             }
257             else
258                 $default_state = $this->IntegerValidator->validate( $defaultValueValue );
259                 }
260
261         return EZ_INPUT_VALIDATOR_STATE_INVALID;
262         }
263
264         /*!
265          \reimp
266         */
267         function fixupClassAttributeHTTPInput( &$http, $base, &$classAttribute )
268         {
269                 $minValueName = $base . EZ_DATATYPESTRING_MIN_VALUE_VARIABLE . $classAttribute->attribute( "id" );
270                 $maxValueName = $base . EZ_DATATYPESTRING_MAX_VALUE_VARIABLE . $classAttribute->attribute( "id" );
271                 if ( $http->hasPostVariable( $minValueName ) and $http->hasPostVariable( $maxValueName ) )
272                 {
273                         $minValueValue = $http->postVariable( $minValueName );
274             $minValueValue = $this->IntegerValidator->fixup( $minValueValue );
275             $http->setPostVariable( $minValueName, $minValueValue );
276
277             $maxValueValue = $http->postVariable( $maxValueName );
278             $maxValueValue = $this->IntegerValidator->fixup( $maxValueValue );
279             $http->setPostVariable( $maxValueName, $maxValueValue );
280
281             if ($minValueValue > $maxValueValue)
282                         {
283                 $this->IntegerValidator->setRange( $minValueValue, false );
284                 $maxValueValue = $this->IntegerValidator->fixup( $maxValueValue );
285                                 $http->setPostVariable( $maxValueName, $maxValueValue );
286                         }
287                 }
288         }
289
290         /*!
291          \reimp
292         */
293         function fetchClassAttributeHTTPInput( &$http, $base, &$classAttribute )
294         {
295                 $minValueName = $base . EZ_DATATYPESTRING_MIN_VALUE_VARIABLE . $classAttribute->attribute( "id" );
296                 $maxValueName = $base . EZ_DATATYPESTRING_MAX_VALUE_VARIABLE . $classAttribute->attribute( "id" );
297         $defaultValueName = $base . EZ_DATATYPESTRING_DEFAULT_VALUE_VARIABLE . $classAttribute->attribute( "id" );
298
299         if ( $http->hasPostVariable( $minValueName ) and
300              $http->hasPostVariable( $maxValueName ) and
301              $http->hasPostVariable( $defaultValueName ) )
302                 {
303             $minValueValue = $http->postVariable( $minValueName );
304             $minValueValue = str_replace(" ", "", $minValueValue );
305             $maxValueValue = $http->postVariable( $maxValueName );
306             $maxValueValue = str_replace(" ", "", $maxValueValue );
307             $defaultValueValue = $http->postVariable( $defaultValueName );
308             $defaultValueValue = str_replace(" ", "", $defaultValueValue );
309
310             $classAttribute->setAttribute( EZ_DATATYPESTRING_MIN_VALUE_FIELD, $minValueValue );
311             $classAttribute->setAttribute( EZ_DATATYPESTRING_MAX_VALUE_FIELD, $maxValueValue );
312             $classAttribute->setAttribute( EZ_DATATYPESTRING_DEFAULT_VALUE_FIELD, $defaultValueValue );
313
314             if ( ( $minValueValue == "" ) && ( $maxValueValue == "") ){
315                 $input_state =  EZ_INTEGER_NO_MIN_MAX_VALUE;
316                 $classAttribute->setAttribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD, $input_state );
317             }
318             else if ( ( $minValueValue == "" ) && ( $maxValueValue !== "") )
319             {
320                 $input_state = EZ_INTEGER_HAS_MAX_VALUE;
321                 $classAttribute->setAttribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD, $input_state );
322             }
323             else if ( ( $minValueValue !== "" ) && ( $maxValueValue == "") )
324             {
325                 $input_state = EZ_INTEGER_HAS_MIN_VALUE;
326                 $classAttribute->setAttribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD, $input_state );
327             }
328             else
329             {
330                 $input_state = EZ_INTEGER_HAS_MIN_MAX_VALUE;
331                 $classAttribute->setAttribute( EZ_DATATYPESTRING_INTEGER_INPUT_STATE_FIELD, $input_state );
332             }
333                 }
334         }
335
336     /*!
337      Returns the content.
338     */
339     function &objectAttributeContent( &$contentObjectAttribute )
340     {
341         return $contentObjectAttribute->attribute( "data_int" );
342     }
343
344
345     /*!
346      Returns the meta data used for storing search indeces.
347     */
348     function metaData( $contentObjectAttribute )
349     {
350         return $contentObjectAttribute->attribute( "data_int" );
351     }
352
353     /*!
354      Returns the integer value.
355     */
356     function title( &$contentObjectAttribute )
357     {
358         return $contentObjectAttribute->attribute( "data_int" );
359     }
360
361     /*!
362      \return a DOM representation of the content object attribute
363     */
364     function &serializeContentObjectAttribute( $objectAttribute )
365     {
366         include_once( 'lib/ezxml/classes/ezdomdocument.php' );
367         include_once( 'lib/ezxml/classes/ezdomnode.php' );
368
369         $node = new eZDOMNode();
370         $node->setName( 'attribute' );
371         $node->appendAttribute( eZDOMDocument::createAttributeNode( 'name', $objectAttribute->contentClassAttributeName() ) );
372         $node->appendAttribute( eZDOMDocument::createAttributeNode( 'type', 'ezinteger' ) );
373         $node->appendAttribute( eZDOMDocument::createAttributeNode( 'value', $objectAttribute->attribute( "data_int" ) ) );
374
375         return $node;
376     }
377
378     /// \privatesection
379     /// The integer value validator
380     var $IntegerValidator;
381 }
382
383 eZDataType::register( EZ_DATATYPESTRING_INTEGER, "ezintegertype" );
384
385 ?>