eZ Publish 3.9.0 : /kernel/classes/datatypes/ezfloat/ezfloattype.php source

[Sommaire] [Imprimer]
   1  <?php
   2  //
   3  // Definition of eZFloatType class
   4  //
   5  // Created on: <26-Apr-2002 16:54:35 bf>
   6  //
   7  // SOFTWARE NAME: eZ publish
   8  // SOFTWARE RELEASE: 3.9.0
   9  // BUILD VERSION: 17785
  10  // COPYRIGHT NOTICE: Copyright (C) 1999-2006 eZ systems AS
  11  // SOFTWARE LICENSE: GNU General Public License v2.0
  12  // NOTICE: >
  13  //   This program is free software; you can redistribute it and/or
  14  //   modify it under the terms of version 2.0  of the GNU General
  15  //   Public License as published by the Free Software Foundation.
  16  //
  17  //   This program is distributed in the hope that it will be useful,
  18  //   but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  //   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  //   GNU General Public License for more details.
  21  //
  22  //   You should have received a copy of version 2.0 of the GNU General
  23  //   Public License along with this program; if not, write to the Free
  24  //   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  25  //   MA 02110-1301, USA.
  26  //
  27  //
  28  
  29  /*!
  30    \class eZFloatType ezfloattype.php
  31    \ingroup eZDatatype
  32    \brief Stores a float value
  33  
  34  */
  35  
  36  include_once ( "kernel/classes/ezdatatype.php" );
  37  include_once ( "lib/ezutils/classes/ezfloatvalidator.php" );
  38  
  39  define( "EZ_DATATYPESTRING_FLOAT", "ezfloat" );
  40  define( "EZ_DATATYPESTRING_MIN_FLOAT_FIELD", "data_float1" );
  41  define( "EZ_DATATYPESTRING_MIN_FLOAT_VARIABLE", "_ezfloat_min_float_value_" );
  42  define( "EZ_DATATYPESTRING_MAX_FLOAT_FIELD", "data_float2" );
  43  define( "EZ_DATATYPESTRING_MAX_FLOAT_VARIABLE", "_ezfloat_max_float_value_" );
  44  define( "EZ_DATATYPESTRING_DEFAULT_FLOAT_FIELD", "data_float3" );
  45  define( "EZ_DATATYPESTRING_DEFAULT_FLOAT_VARIABLE", "_ezfloat_default_value_" );
  46  define( "EZ_DATATYPESTRING_FLOAT_INPUT_STATE_FIELD", "data_float4" );
  47  define( "EZ_FLOAT_NO_MIN_MAX_VALUE", 0 );
  48  define( "EZ_FLOAT_HAS_MIN_VALUE", 1 );
  49  define( "EZ_FLOAT_HAS_MAX_VALUE", 2 );
  50  define( "EZ_FLOAT_HAS_MIN_MAX_VALUE", 3 );
  51  
  52  class eZFloatType extends eZDataType
  53  {
  54      function eZFloatType()
  55      {
  56          $this->eZDataType( EZ_DATATYPESTRING_FLOAT, ezi18n( 'kernel/classes/datatypes', "Float", 'Datatype name' ),
  57                             array( 'serialize_supported' => true,
  58                                    'object_serialize_map' => array( 'data_float' => 'value' ) ) );
  59          $this->FloatValidator = new eZFloatValidator();
  60      }
  61  
  62      /*!
  63       Sets the default value.
  64      */
  65      function initializeObjectAttribute( &$contentObjectAttribute, $currentVersion, &$originalContentObjectAttribute )
  66      {
  67          if ( $currentVersion != false )
  68          {
  69  //             $contentObjectAttributeID = $contentObjectAttribute->attribute( "id" );
  70  //             $currentObjectAttribute = eZContentObjectAttribute::fetch( $contentObjectAttributeID,
  71  //                                                                         $currentVersion );
  72              $dataFloat = $originalContentObjectAttribute->attribute( "data_float" );
  73              $contentObjectAttribute->setAttribute( "data_float", $dataFloat );
  74          }
  75          else
  76          {
  77              $contentClassAttribute =& $contentObjectAttribute->contentClassAttribute();
  78              $default = $contentClassAttribute->attribute( "data_float3" );
  79              if ( $default !== 0 )
  80              {
  81                  $contentObjectAttribute->setAttribute( "data_float", $default );
  82              }
  83          }
  84      }
  85  
  86      /*!
  87       Fetches the http post var float input and stores it in the data instance.
  88      */
  89      function fetchObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
  90      {
  91          if ( $http->hasPostVariable( $base . "_data_float_" . $contentObjectAttribute->attribute( "id" ) ) )
  92          {
  93              $data = $http->postVariable( $base . "_data_float_" . $contentObjectAttribute->attribute( "id" ) );
  94              $contentObjectAttribute->setHTTPValue( $data );
  95  
  96              include_once ( 'lib/ezlocale/classes/ezlocale.php' );
  97              $locale =& eZLocale::instance();
  98              $data = $locale->internalNumber( $data );
  99  
 100              $contentObjectAttribute->setAttribute( "data_float", $data );
 101              return true;
 102          }
 103          return false;
 104      }
 105  
 106      /*!
 107       Validates the input and returns true if the input was
 108       valid for this datatype.
 109      */
 110      function validateObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
 111      {
 112          if ( $http->hasPostVariable( $base . "_data_float_" . $contentObjectAttribute->attribute( "id" ) ) )
 113          {
 114              $data = $http->postVariable( $base . "_data_float_" . $contentObjectAttribute->attribute( "id" ) );
 115              $data = str_replace(" ", "", $data );
 116              $classAttribute =& $contentObjectAttribute->contentClassAttribute();
 117              $min = $classAttribute->attribute( EZ_DATATYPESTRING_MIN_FLOAT_FIELD );
 118              $max = $classAttribute->attribute( EZ_DATATYPESTRING_MAX_FLOAT_FIELD );
 119              $input_state = $classAttribute->attribute( EZ_DATATYPESTRING_FLOAT_INPUT_STATE_FIELD );
 120  
 121              if ( !$contentObjectAttribute->validateIsRequired() &&  ( $data == "" ) )
 122              {
 123                  return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
 124              }
 125  
 126              include_once ( 'lib/ezlocale/classes/ezlocale.php' );
 127              $locale =& eZLocale::instance();
 128              $data = $locale->internalNumber( $data );
 129  
 130              switch( $input_state )
 131              {
 132                  case EZ_FLOAT_NO_MIN_MAX_VALUE:
 133                  {
 134                      $state = $this->FloatValidator->validate( $data );
 135                      if( $state===1 )
 136                          return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
 137                      else
 138                          $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
 139                                                                               'The given input is not a floating point number.' ) );
 140                  } break;
 141                  case EZ_FLOAT_HAS_MIN_VALUE:
 142                  {
 143                      $this->FloatValidator->setRange( $min, false );
 144                      $state = $this->FloatValidator->validate( $data );
 145                      if( $state===1 )
 146                          return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
 147                      else
 148                          $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
 149                                                                               'The input must be greater than %1' ),
 150                                                                       $min );
 151                  } break;
 152                  case EZ_FLOAT_HAS_MAX_VALUE:
 153                  {
 154                      $this->FloatValidator->setRange( false, $max );
 155                      $state = $this->FloatValidator->validate( $data );
 156                      if( $state===1 )
 157                          return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
 158                      else
 159                          $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
 160                                                                               'The input must be less than %1' ),
 161                                                                       $max );
 162                  } break;
 163                  case EZ_FLOAT_HAS_MIN_MAX_VALUE:
 164                  {
 165                      $this->FloatValidator->setRange( $min, $max );
 166                      $state = $this->FloatValidator->validate( $data );
 167                      if( $state===1 )
 168                          return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
 169                      else
 170                          $contentObjectAttribute->setValidationError( ezi18n( 'kernel/classes/datatypes',
 171                                                                               'The input is not in defined range %1 - %2' ),
 172                                                                       $min, $max );
 173                  } break;
 174              }
 175          }
 176          return EZ_INPUT_VALIDATOR_STATE_INVALID;
 177      }
 178  
 179      function fixupObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
 180      {
 181      }
 182  
 183      function storeObjectAttribute( &$attribute )
 184      {
 185      }
 186  
 187      function fetchClassAttributeHTTPInput( &$http, $base, &$classAttribute )
 188      {
 189          $minValueName = $base . EZ_DATATYPESTRING_MIN_FLOAT_VARIABLE . $classAttribute->attribute( "id" );
 190          $maxValueName = $base . EZ_DATATYPESTRING_MAX_FLOAT_VARIABLE . $classAttribute->attribute( "id" );
 191          $defaultValueName =  $base . EZ_DATATYPESTRING_DEFAULT_FLOAT_VARIABLE . $classAttribute->attribute( "id" );
 192  
 193          if ( $http->hasPostVariable( $minValueName ) and
 194               $http->hasPostVariable( $maxValueName ) and
 195               $http->hasPostVariable( $defaultValueName ) )
 196          {
 197              include_once ( 'lib/ezlocale/classes/ezlocale.php' );
 198              $locale =& eZLocale::instance();
 199  
 200              $minValueValue = $http->postVariable( $minValueName );
 201              $minValueValue = str_replace(" ", "", $minValueValue );
 202              $minValueValue = $locale->internalNumber( $minValueValue );
 203              $maxValueValue = $http->postVariable( $maxValueName );
 204              $maxValueValue = str_replace(" ", "", $maxValueValue );
 205              $maxValueValue = $locale->internalNumber( $maxValueValue );
 206              $defaultValueValue = $http->postVariable( $defaultValueName );
 207              $defaultValueValue = str_replace(" ", "", $defaultValueValue );
 208              $defaultValueValue = $locale->internalNumber( $defaultValueValue );
 209  
 210              $classAttribute->setAttribute( EZ_DATATYPESTRING_MIN_FLOAT_FIELD, $minValueValue );
 211              $classAttribute->setAttribute( EZ_DATATYPESTRING_MAX_FLOAT_FIELD, $maxValueValue );
 212              $classAttribute->setAttribute( EZ_DATATYPESTRING_DEFAULT_FLOAT_FIELD, $defaultValueValue );
 213  
 214              if ( ( $minValueValue == "" ) && ( $maxValueValue == "") ){
 215                  $input_state =  EZ_FLOAT_NO_MIN_MAX_VALUE;
 216                  $classAttribute->setAttribute( EZ_DATATYPESTRING_FLOAT_INPUT_STATE_FIELD, $input_state );
 217              }
 218              else if ( ( $minValueValue == "" ) && ( $maxValueValue !== "") )
 219              {
 220                  $input_state = EZ_FLOAT_HAS_MAX_VALUE;
 221                  $classAttribute->setAttribute( EZ_DATATYPESTRING_FLOAT_INPUT_STATE_FIELD, $input_state );
 222              }
 223              else if ( ( $minValueValue !== "" ) && ( $maxValueValue == "") )
 224              {
 225                  $input_state = EZ_FLOAT_HAS_MIN_VALUE;
 226                  $classAttribute->setAttribute( EZ_DATATYPESTRING_FLOAT_INPUT_STATE_FIELD, $input_state );
 227              }
 228              else
 229              {
 230                  $input_state = EZ_FLOAT_HAS_MIN_MAX_VALUE;
 231                  $classAttribute->setAttribute( EZ_DATATYPESTRING_FLOAT_INPUT_STATE_FIELD, $input_state );
 232              }
 233              return true;
 234          }
 235          return false;
 236      }
 237  
 238      function validateClassAttributeHTTPInput( &$http, $base, &$classAttribute )
 239      {
 240          $minValueName = $base . EZ_DATATYPESTRING_MIN_FLOAT_VARIABLE . $classAttribute->attribute( "id" );
 241          $maxValueName = $base . EZ_DATATYPESTRING_MAX_FLOAT_VARIABLE . $classAttribute->attribute( "id" );
 242          $defaultValueName =  $base . EZ_DATATYPESTRING_DEFAULT_FLOAT_VARIABLE . $classAttribute->attribute( "id" );
 243  
 244          if ( $http->hasPostVariable( $minValueName ) and
 245               $http->hasPostVariable( $maxValueName ) and
 246               $http->hasPostVariable( $defaultValueName ) )
 247          {
 248              include_once ( 'lib/ezlocale/classes/ezlocale.php' );
 249              $locale =& eZLocale::instance();
 250  
 251              $minValueValue = $http->postVariable( $minValueName );
 252              $minValueValue = str_replace(" ", "", $minValueValue );
 253              $minValueValue = $locale->internalNumber( $minValueValue );
 254              $maxValueValue = $http->postVariable( $maxValueName );
 255              $maxValueValue = str_replace(" ", "", $maxValueValue );
 256              $maxValueValue = $locale->internalNumber( $maxValueValue );
 257              $defaultValueValue = $http->postVariable( $defaultValueName );
 258              $defaultValueValue = str_replace(" ", "", $defaultValueValue );
 259              $defaultValueValue = $locale->internalNumber( $defaultValueValue );
 260  
 261              if ( ( $minValueValue == "" ) && ( $maxValueValue == "") ){
 262                  return  EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
 263              }
 264              else if ( ( $minValueValue == "" ) && ( $maxValueValue !== "") )
 265              {
 266                  $max_state = $this->FloatValidator->validate( $maxValueValue );
 267                  return  $max_state;
 268              }
 269              else if ( ( $minValueValue !== "" ) && ( $maxValueValue == "") )
 270              {
 271                  $min_state = $this->FloatValidator->validate( $minValueValue );
 272                  return  $min_state;
 273              }
 274              else
 275              {
 276                  $min_state = $this->FloatValidator->validate( $minValueValue );
 277                  $max_state = $this->FloatValidator->validate( $maxValueValue );
 278                  if ( ( $min_state == EZ_INPUT_VALIDATOR_STATE_ACCEPTED ) and
 279                       ( $max_state == EZ_INPUT_VALIDATOR_STATE_ACCEPTED ) )
 280                  {
 281                      if ($minValueValue <= $maxValueValue)
 282                          return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
 283                      else
 284                      {
 285                          $state = EZ_INPUT_VALIDATOR_STATE_INTERMEDIATE;
 286                          eZDebug::writeNotice( "Integer minimum value great than maximum value." );
 287                          return $state;
 288                      }
 289                  }
 290              }
 291  
 292              if ($defaultValueValue == ""){
 293                  $default_state =  EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
 294              }
 295              else
 296                  $default_state = $this->FloatValidator->validate( $defaultValueValue );
 297          }
 298          return EZ_INPUT_VALIDATOR_STATE_INVALID;
 299      }
 300  
 301      function fixupClassAttributeHTTPInput( &$http, $base, &$classAttribute )
 302      {
 303          $minValueName = $base . EZ_DATATYPESTRING_MIN_FLOAT_VARIABLE . $classAttribute->attribute( "id" );
 304          $maxValueName = $base . EZ_DATATYPESTRING_MAX_FLOAT_VARIABLE . $classAttribute->attribute( "id" );
 305          if ( $http->hasPostVariable( $minValueName ) and $http->hasPostVariable( $maxValueName ) )
 306          {
 307              include_once ( 'lib/ezlocale/classes/ezlocale.php' );
 308              $locale =& eZLocale::instance();
 309  
 310              $minValueValue = $http->postVariable( $minValueName );
 311              $minValueValue = str_replace(" ", "", $minValueValue );
 312              $minValueValue = $locale->internalNumber( $minValueValue );
 313              $maxValueValue = $http->postVariable( $maxValueName );
 314              $maxValueValue = str_replace(" ", "", $maxValueValue );
 315              $maxValueValue = $locale->internalNumber( $maxValueValue );
 316  
 317              if ($minValueValue > $maxValueValue)
 318              {
 319                  $this->FloatValidator->setRange( $minValueValue, false );
 320                  $maxValueValue = $this->FloatValidator->fixup( $maxValueValue );
 321                  $http->setPostVariable( $maxValueName, $maxValueValue );
 322              }
 323          }
 324      }
 325  
 326      function storeClassAttribute( &$attribute, $version )
 327      {
 328      }
 329  
 330      function metaData( $contentObjectAttribute )
 331      {
 332          return $contentObjectAttribute->attribute( "data_float" );
 333      }
 334  
 335      /*!
 336       Returns the content.
 337      */
 338      function &objectAttributeContent( &$contentObjectAttribute )
 339      {
 340          return $contentObjectAttribute->attribute( 'data_float' );
 341      }
 342  
 343      /*!
 344       Returns the float value.
 345      */
 346  
 347      function title( &$contentObjectAttribute )
 348      {
 349          return $contentObjectAttribute->attribute( "data_float" );
 350      }
 351  
 352      function hasObjectAttributeContent( &$contentObjectAttribute )
 353      {
 354          return true;
 355      }
 356      /*!
 357       \return string representation of an contentobjectattribute data for simplified export
 358  
 359      */
 360      function toString( $contentObjectAttribute )
 361      {
 362          return $contentObjectAttribute->attribute( 'data_float' );
 363      }
 364  
 365      function fromString( &$contentObjectAttribute, $string )
 366      {
 367          return $contentObjectAttribute->setAttribute( 'data_float', $string );
 368      }
 369  
 370      /*!
 371       \reimp
 372      */
 373      function serializeContentClassAttribute( &$classAttribute, &$attributeNode, &$attributeParametersNode )
 374      {
 375          $defaultValue = $classAttribute->attribute( EZ_DATATYPESTRING_DEFAULT_FLOAT_FIELD );
 376          $minValue = $classAttribute->attribute( EZ_DATATYPESTRING_MIN_FLOAT_FIELD );
 377          $maxValue = $classAttribute->attribute( EZ_DATATYPESTRING_MAX_FLOAT_FIELD );
 378          $minMaxState = $classAttribute->attribute( EZ_DATATYPESTRING_FLOAT_INPUT_STATE_FIELD );
 379          $attributeParametersNode->appendChild( eZDOMDocument::createElementTextNode( 'default-value', $defaultValue ) );
 380          if ( $minMaxState == EZ_FLOAT_HAS_MIN_VALUE or $minMaxState == EZ_FLOAT_HAS_MIN_MAX_VALUE )
 381              $attributeParametersNode->appendChild( eZDOMDocument::createElementTextNode( 'min-value', $minValue ) );
 382          if ( $minMaxState == EZ_FLOAT_HAS_MAX_VALUE or $minMaxState == EZ_FLOAT_HAS_MIN_MAX_VALUE )
 383              $attributeParametersNode->appendChild( eZDOMDocument::createElementTextNode( 'max-value', $maxValue ) );
 384      }
 385  
 386      /*!
 387       \reimp
 388      */
 389      function unserializeContentClassAttribute( &$classAttribute, &$attributeNode, &$attributeParametersNode )
 390      {
 391          $defaultValue = $attributeParametersNode->elementTextContentByName( 'default-value' );
 392          $minValue = $attributeParametersNode->elementTextContentByName( 'min-value' );
 393          $maxValue = $attributeParametersNode->elementTextContentByName( 'max-value' );
 394  
 395          if ( strlen( $minValue ) > 0 and strlen( $maxValue ) > 0 )
 396              $minMaxState = EZ_FLOAT_HAS_MIN_MAX_VALUE;
 397          else if ( strlen( $minValue ) > 0 )
 398              $minMaxState = EZ_FLOAT_HAS_MIN_VALUE;
 399          else if ( strlen( $maxValue ) > 0 )
 400              $minMaxState = EZ_FLOAT_HAS_MAX_VALUE;
 401          else
 402              $minMaxState = EZ_FLOAT_NO_MIN_MAX_VALUE;
 403  
 404          $classAttribute->setAttribute( EZ_DATATYPESTRING_DEFAULT_FLOAT_FIELD, $defaultValue );
 405          $classAttribute->setAttribute( EZ_DATATYPESTRING_MIN_FLOAT_FIELD, $minValue );
 406          $classAttribute->setAttribute( EZ_DATATYPESTRING_MAX_FLOAT_FIELD, $maxValue );
 407          $classAttribute->setAttribute( EZ_DATATYPESTRING_FLOAT_INPUT_STATE_FIELD, $minMaxState );
 408      }
 409  
 410      /// \privatesection
 411      /// The float value validator
 412      var $FloatValidator;
 413  }
 414  
 415  eZDataType::register( EZ_DATATYPESTRING_FLOAT, "ezfloattype" );
 416  
 417  ?>
Code source de eZ Publish 3.9.0

/kernel/classes/datatypes/ezfloat/ -> ezfloattype.php (source)
