- Fixed #16160: Call to undefined function ezi18n()
[tinyz:tinyz.git] / kernel / classes / ezdatatype.php
1 <?php
2 //
3 // Definition of eZDataType class
4 //
5 // Created on: <16-Apr-2002 11:08:14 amos>
6 //
7 // ## BEGIN COPYRIGHT, LICENSE AND WARRANTY NOTICE ##
8 // SOFTWARE NAME: eZ Publish
9 // SOFTWARE RELEASE: 4.1.x
10 // COPYRIGHT NOTICE: Copyright (C) 1999-2010 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 // ## END COPYRIGHT, LICENSE AND WARRANTY NOTICE ##
29 //
30
31 /*! \defgroup eZDataType Content datatypes */
32
33 /*!
34   \class eZDataType ezdatatype.php
35   \ingroup eZKernel
36   \brief Base class for content datatypes
37
38   Defines both the interface for datatypes as well as functions
39   for registering, quering and fetching datatypes.
40
41   Each new datatype will inherit this class and define some functions
42   as well as three templates. A datatype has three roles, it handles
43   definition of content class attributes, editing of a content object
44   attribute and viewing of a content object attribute. The content class
45   attribute definition part is optional while object attribute edit and
46   view must be implemented for the datatype to be usable.
47
48   If the datatype handles class attribute definition it must define one
49   or more of these functions: storeClassAttribute, validateClassAttributeHTTPInput,
50   fixupClassAttributeHTTPInput, fetchClassAttributeHTTPInput. See each function
51   for more details. The class attribute definition usually defines the
52   default data and/or the validation rules for an object attribute.
53
54   Object attribute editing must define these functions: storeObjectAttribute,
55   validateObjectAttributeHTTPInput, fixupObjectAttributeHTTPInput,
56   fetchObjectAttributeHTTPInput, initializeObjectAttribute. If the attribute
57   wants to have a custom action it must implement the customObjectAttributeHTTPAction
58   function. See each function for more details.
59
60   Each datatype initializes itself with a datatype string id (ezstring, ezinteger)
61   and a descriptive name. The datatype string id must be unique for the whole
62   system and should have a prefix, for instance we in eZ Systems use ez as our prefix.
63 */
64
65 class eZDataType
66 {
67     /*!
68      Initializes the datatype with the string id \a $dataTypeString and
69      the name \a $name.
70     */
71     function eZDataType( $dataTypeString, $name, $properties = array() )
72     {
73         $this->DataTypeString = $dataTypeString;
74         $this->Name = $name;
75
76         $translationAllowed = true;
77         $serializeSupported = false;
78         $objectSerializeMap = false;
79         if ( isset( $properties['translation_allowed'] ) )
80             $translationAllowed = $properties['translation_allowed'];
81         if ( isset( $properties['serialize_supported'] ) )
82             $serializeSupported = $properties['serialize_supported'];
83         if ( isset( $properties['object_serialize_map'] ) )
84             $objectSerializeMap = $properties['object_serialize_map'];
85
86         $this->Attributes = array();
87         $this->Attributes["is_indexable"] = $this->isIndexable();
88         $this->Attributes["is_information_collector"] = $this->isInformationCollector();
89
90         $this->Attributes["information"] = array( "string" => $this->DataTypeString,
91                                                   "name" => $this->Name );
92         $this->Attributes["properties"] = array( "translation_allowed" => $translationAllowed,
93                                                  'serialize_supported' => $serializeSupported,
94                                                  'object_serialize_map' => $objectSerializeMap );
95     }
96
97     /*!
98      \return the template name to use for viewing the attribute.
99      \note Default is to return the datatype string which is OK
100            for most datatypes, if you want dynamic templates
101            reimplement this function and return a template name.
102      \note The returned template name does not include the .tpl extension.
103      \sa editTemplate, informationTemplate
104     */
105     function viewTemplate( $contentobjectAttribute )
106     {
107         return $this->DataTypeString;
108     }
109
110     /*!
111      \return the template name to use for editing the attribute.
112      \note Default is to return the datatype string which is OK
113            for most datatypes, if you want dynamic templates
114            reimplement this function and return a template name.
115      \note The returned template name does not include the .tpl extension.
116      \sa viewTemplate, informationTemplate
117     */
118     function editTemplate( $contentobjectAttribute )
119     {
120         return $this->DataTypeString;
121     }
122
123     /*!
124      \return the template name to use for information collection for the attribute.
125      \note Default is to return the datatype string which is OK
126            for most datatypes, if you want dynamic templates
127            reimplement this function and return a template name.
128      \note The returned template name does not include the .tpl extension.
129      \sa viewTemplate, editTemplate
130     */
131     function informationTemplate( $contentobjectAttribute )
132     {
133         return $this->DataTypeString;
134     }
135
136     /*!
137      \return the template name to use for result view of an information collection attribute.
138      \note Default is to return the datatype string which is OK
139            for most datatypes, if you want dynamic templates
140            reimplement this function and return a template name.
141      \note The returned template name does not include the .tpl extension.
142      \note \a $collectionAttribute can in some cases be a eZContentObjectAttribute, so any
143            datatype that overrides this must be able to handle both types.
144     */
145     function resultTemplate( &$collectionAttribute )
146     {
147         return $this->DataTypeString;
148     }
149
150     /*!
151      \static
152      Crates a datatype instance of the datatype string id \a $dataTypeString.
153      \note It only creates one instance for each datatype.
154     */
155     static function create( $dataTypeString )
156     {
157         $def = null;
158         if ( !isset( $GLOBALS["eZDataTypes"][$dataTypeString] ) )
159         {
160             eZDataType::loadAndRegisterType( $dataTypeString );
161         }
162
163         if ( isset( $GLOBALS['eZDataTypes'][$dataTypeString] ) )
164         {
165             $className = $GLOBALS['eZDataTypes'][$dataTypeString];
166
167             if ( !isset( $GLOBALS["eZDataTypeObjects"][$dataTypeString] ) ||
168                  get_class( $GLOBALS["eZDataTypeObjects"][$dataTypeString] ) != $className )
169             {
170                 $GLOBALS["eZDataTypeObjects"][$dataTypeString] = new $className();
171             }
172             return $GLOBALS["eZDataTypeObjects"][$dataTypeString];
173         }
174
175         return null;
176     }
177
178     /*!
179      \static
180      \return a list of datatypes which has been registered.
181      \note This will instantiate all datatypes.
182     */
183     static function registeredDataTypes()
184     {
185         $types = isset( $GLOBALS["eZDataTypes"] ) ? $GLOBALS["eZDataTypes"] : null;
186         if ( isset( $types ) )
187         {
188             foreach ( $types as $dataTypeString => $className )
189             {
190                 if ( !isset( $GLOBALS["eZDataTypeObjects"][$dataTypeString] ) )
191                 {
192                     $GLOBALS["eZDataTypeObjects"][$dataTypeString] = new $className();
193                 }
194             }
195             uasort( $GLOBALS["eZDataTypeObjects"],
196                     create_function( '$a, $b',
197                                      'return strcmp( $a->Name, $b->Name);' ) );
198         return $GLOBALS["eZDataTypeObjects"];
199         }
200         return null;
201     }
202
203     /*!
204      \static
205      Registers the datatype with string id \a $dataTypeString and
206      class name \a $className. The class name is used for instantiating
207      the class and should be in lowercase letters.
208     */
209     static function register( $dataTypeString, $className )
210     {
211         $types =& $GLOBALS["eZDataTypes"];
212         if ( !is_array( $types ) )
213             $types = array();
214         $types[$dataTypeString] = $className;
215     }
216
217     /*!
218      \return the data type identification string.
219     */
220     function isA()
221     {
222         return $this->Attributes["information"]["string"];
223     }
224
225     /*!
226      \return the attributes for this datatype.
227     */
228     function attributes()
229     {
230         return array_keys( $this->Attributes );
231     }
232
233     /*!
234      \return true if the attribute \a $attr exists in this object.
235     */
236     function hasAttribute( $attr )
237     {
238         return isset( $this->Attributes[$attr] );
239     }
240
241     /*!
242      \return the data for the attribute \a $attr or null if it does not exist.
243     */
244     function attribute( $attr )
245     {
246         if ( isset( $this->Attributes[$attr] ) )
247         {
248             return $this->Attributes[$attr];
249         }
250
251         eZDebug::writeError( "Attribute '$attr' does not exist", 'eZDataType::attribute' );
252         $attributeData = null;
253         return $attributeData;
254     }
255
256     /*!
257      \return \c true if the datatype support insertion of HTTP files or \c false (default) otherwise.
258
259      \sa insertHTTPFile()
260     */
261     function isHTTPFileInsertionSupported()
262     {
263         return false;
264     }
265
266     /*!
267      \return \c true if the datatype support insertion of files or \c false (default) otherwise.
268
269      \sa insertRegularFile()
270     */
271     function isRegularFileInsertionSupported()
272     {
273         return false;
274     }
275
276     /*!
277      \return \c true if the datatype support insertion of simple strings or \c false (default) otherwise.
278
279      \sa insertSimpleString()
280     */
281     function isSimpleStringInsertionSupported()
282     {
283         return false;
284     }
285
286     /*!
287      \virtual
288      Inserts the HTTP file \a $httpFile to the content object attribute \a $objectAttribute.
289
290      \param $object The contentobject in which the attribute is contained
291      \param $objectVersion The current version of the object it is being worked on
292      \param $objectLanguage The current language being worked on
293      \param $objectAttribute The attribute which will get the file
294      \param $httpFile Object of type eZHTTPFile which contains information on the uploaded file
295      \param $mimeData MIME-Type information on the file, can be used to figure out a storage name
296      \param[out] $result Array which will be filled with information on the process, it will contain:
297                  - errors - Array with error elements, each element is an array with \c 'description' containing the text
298                  - require_storage - \c true if the attribute must be stored after this call, or \c false if not required at all
299
300      \return \c true if the file was stored correctly in the attribute or \c false if something failed.
301      \note The datatype will return \c null (the default) if does not support HTTP files.
302      \note \a $result will not be defined if the return value is \c null
303      \note The \a $httpFile must not be stored prior to calling this, the datatype will handle this internally
304
305      \sa isHTTPFileInsertionSupported()
306     */
307     function insertHTTPFile( $object, $objectVersion, $objectLanguage,
308                              $objectAttribute, $httpFile, $mimeData,
309                              &$result )
310     {
311         eZDebug::writeWarning( "The datatype " . get_class( $this ) . " for attribute ID " . $objectAttribute->attribute( 'id' ) . " does not support insertion of HTTP files",
312                                'eZDataType::insertHTTPFile' );
313         return null;
314     }
315
316     /*!
317      \virtual
318      Inserts the file named \a $filePath to the content object attribute \a $objectAttribute.
319
320      \param $object The contentobject in which the attribute is contained
321      \param $objectVersion The current version of the object it is being worked on
322      \param $objectLanguage The current language being worked on
323      \param $objectAttribute The attribute which will get the file
324      \param $filePath Full path including the filename
325      \param[out] $result Array which will be filled with information on the process, it will contain:
326                  - errors - Array with error elements, each element is an array with \c 'description' containing the text
327                  - require_storage - \c true if the attribute must be stored after this call, or \c false if not required at all
328
329      \return \c true if the file was stored correctly in the attribute or \c false if something failed.
330      \note The datatype will return \c null (the default) if does not support HTTP files.
331      \note \a $result will not be defined if the return value is \c null
332
333      \sa isRegularFileInsertionSupported()
334     */
335     function insertRegularFile( $object, $objectVersion, $objectLanguage,
336                                 $objectAttribute, $filePath,
337                                 &$result )
338     {
339         eZDebug::writeWarning( "The datatype " . get_class( $this ) . " for attribute ID " . $objectAttribute->attribute( 'id' ) . " does not support insertion of regular files",
340                                'eZDataType::insertRegularFile' );
341         return null;
342     }
343
344     /*!
345      \virtual
346      Inserts the string \a $string to the content object attribute \a $objectAttribute.
347
348      \param $object The contentobject in which the attribute is contained
349      \param $objectVersion The current version of the object it is being worked on
350      \param $objectLanguage The current language being worked on
351      \param $objectAttribute The attribute which will get the file
352      \param $filePath Full path including the filename
353      \param[out] $result Array which will be filled with information on the process, it will contain:
354                  - errors - Array with error elements, each element is an array with \c 'description' containing the text
355                  - require_storage - \c true if the attribute must be stored after this call, or \c false if not required at all
356
357      \return \c true if the file was stored correctly in the attribute or \c false if something failed.
358      \note The datatype will return \c null (the default) if does not support HTTP files.
359      \note \a $result will not be defined if the return value is \c null
360
361      \sa isSimpleStringInsertionSupported()
362     */
363     function insertSimpleString( $object, $objectVersion, $objectLanguage,
364                                  $objectAttribute, $string,
365                                  &$result )
366     {
367         eZDebug::writeWarning( "The datatype " . get_class( $this ) . " for attribute ID " . $objectAttribute->attribute( 'id' ) . " does not support insertion of simple strings",
368                                'eZDataType::insertSimplestring' );
369         return null;
370     }
371
372     /*!
373      \virtual
374      Checks if the datatype supports returning file information.
375
376      \param $object The contentobject in which the attribute is contained
377      \param $objectVersion The current version of the object it is being worked on
378      \param $objectLanguage The current language being worked on
379      \param $objectAttribute The attribute which stored the file
380
381      \return \c true if file information is supported or \c false if it doesn't.
382     */
383     function hasStoredFileInformation( $object, $objectVersion, $objectLanguage,
384                                        $objectAttribute )
385     {
386         return false;
387     }
388
389     /*!
390      \virtual
391      This function is called when someone tries to download the file.
392
393      \param $object The contentobject in which the attribute is contained
394      \param $objectVersion The current version of the object it is being worked on
395      \param $objectLanguage The current language being worked on
396      \param $objectAttribute The attribute which stored the file
397
398      \return \c true if any action has been don or \c false if hasn't.
399     */
400     function handleDownload( $object, $objectVersion, $objectLanguage,
401                              $objectAttribute )
402     {
403         return false;
404     }
405
406     /*!
407      \virtual
408      Returns file information for the filed stored by the attribute.
409
410      \param $object The contentobject in which the attribute is contained
411      \param $objectVersion The current version of the object it is being worked on
412      \param $objectLanguage The current language being worked on
413      \param $objectAttribute The attribute which stored the file
414
415      \return An array structure with information or \c false (default) if no
416              information could be found.
417              The structure must contain:
418              - filepath - The full path to the file
419
420              The structure can contain:
421              - filename - The name of the file, if not supplied it will
422                            be figured out from the filepath
423              - filesize - The size of the file, if not supplied it will
424                            be figured out from the filepath
425              - mime_type - The MIME type for the file, if not supplied it will
426                            be figured out from the filepath
427     */
428     function storedFileInformation( $object, $objectVersion, $objectLanguage,
429                                     $objectAttribute )
430     {
431         return false;
432     }
433
434     /*!
435      Fetches the product option information for option with ID \a $optionID and returns this information.
436      This will be called from the basket when a new product with an option is added, it is then up to the
437      specific datatype to return proper data. It will also be used to recalcuate prices.
438
439      \param $objectAttribute The attribute that the datatype controls.
440      \param $optionID The ID of the option which information should be returned from.
441      \param $productItem The product item object which contains the option, is available for reading only.
442      \return An array structure which contains:
443              - id - The unique ID of the selected option, this must be unique in the attribute and will later on
444                     be used to recalculate prices.
445              - name - The name of the option list
446              - value - The display string of the selected option
447              - additional_price - A value which is added to the total product price, set to 0 or \c false if no price is used.
448              If the option could not be found it should return \c false, if not supported it should return \c null.
449      \sa handleProductOption
450     */
451     function productOptionInformation( $objectAttribute, $optionID, $productItem )
452     {
453         eZDebug::writeWarning( "The datatype " . get_class( $this ) . " for attribute ID " . $objectAttribute->attribute( 'id' ) . " does not support product options",
454                                'eZDataType::productOptionInformation' );
455         return null;
456     }
457
458     /*!
459       \virtual
460       Will return information on how the datatype should be represented in
461       the various display modes when used by an object.
462
463       If this method is reimplemented the implementor must call this method
464       with the new info array as second parameter.
465
466       \param $objectAttribute The content object attribute to return info for.
467       \param $mergeInfo A structure that must match the returned array, or \c false to ignore.
468                         Any entries here will override the default.
469       \return An array structure which contains:
470               - \c edit
471                 - \c grouped_input - If \c true then the datatype has lots of input elements
472                                      that should be grouped. (e.g. in a fieldset)
473                                      EditSettings/GroupedInput in datatype.ini is used to
474                                      automatically determine this field
475                 .
476               - \c view
477               - \c collection
478                 - \c grouped_input - If \c true then the datatype has lots of input elements
479                                      that should be grouped. (e.g. in a fieldset)
480                                      CollectionSettings/GroupedInput in datatype.ini is used to
481                                      automatically determine this field and will override
482                                      the default and datatype setting if used.
483                 .
484               - \c result
485     */
486     function objectDisplayInformation( $objectAttribute, $mergeInfo = false )
487     {
488         $datatype = $objectAttribute->attribute( 'data_type_string' );
489         $ini = eZINI::instance( 'datatype.ini' );
490         $editGrouped = in_array( $datatype, $ini->variable( 'EditSettings', 'GroupedInput' ) );
491         $viewGrouped = in_array( $datatype, $ini->variable( 'ViewSettings', 'GroupedInput' ) );
492         $resultGrouped = in_array( $datatype, $ini->variable( 'ResultSettings', 'GroupedInput' ) );
493         $collectionGrouped = in_array( $datatype, $ini->variable( 'CollectionSettings', 'GroupedInput' ) );
494
495         $info = array( 'edit' => array( 'grouped_input' => false ),
496                        'view' => array( 'grouped_input' => false),
497                        'collection' => array( 'grouped_input' => false ),
498                        'result' => array( 'grouped_input' => false ) );
499         $override = array();
500         if ( $editGrouped )
501             $override['edit']['grouped_input'] = true;
502         if ( $collectionGrouped )
503             $override['collection']['grouped_input'] = true;
504         if ( $viewGrouped )
505             $override['view']['grouped_input'] = true;
506         if ( $resultGrouped )
507             $override['result']['grouped_input'] = true;
508
509         if ( $mergeInfo )
510         {
511             // All entries in $mergeInfo will override the defaults
512             foreach ( array( 'edit', 'view', 'collection', 'result' ) as $view )
513             {
514                 if ( isset( $mergeInfo[$view] ) )
515                     $info[$view] = array_merge( $info[$view], $mergeInfo[$view] );
516                 if ( isset( $override[$view] ) )
517                     $info[$view] = array_merge( $info[$view], $override[$view] );
518             }
519         }
520         else
521         {
522             // All entries in $override will override the defaults
523             foreach ( array( 'edit', 'view', 'collection', 'result' ) as $view )
524             {
525                 if ( isset( $override[$view] ) )
526                     $info[$view] = array_merge( $info[$view], $override[$view] );
527             }
528         }
529         return $info;
530     }
531
532     /*!
533       \virtual
534       Will return information on how the datatype should be represented in
535       the various display modes when used by a class.
536
537       If this method is reimplemented the implementor must call this method
538       with the new info array as second parameter.
539
540       \param $classAttribute The content class attribute to return info for.
541       \param $mergeInfo A structure that must match the returned array, or \c false to ignore.
542                         Any entries here will override the default.
543       \return An array structure which contains:
544               - \c edit
545                 - \c grouped_input - If \c true then the datatype has lots of input elements
546                                      that should be grouped. (e.g. in a fieldset)
547                                      ClassEditSettings/GroupedInput in datatype.ini is used to
548                                      automatically determine this field and will override
549                                      the default and datatype setting if used.
550                 .
551               - \c view
552     */
553     function classDisplayInformation( $classAttribute, $mergeInfo = false )
554     {
555         $datatype = $classAttribute->attribute( 'data_type_string' );
556         $ini = eZINI::instance( 'datatype.ini' );
557         $editGrouped = in_array( $datatype, $ini->variable( 'ClassEditSettings', 'GroupedInput' ) );
558
559         $info = array( 'edit' => array( 'grouped_input' => false ),
560                        'view' => array() );
561         $override = array();
562         if ( $editGrouped )
563             $override['edit']['grouped_input'] = true;
564
565         if ( $mergeInfo )
566         {
567             // All entries in $mergeInfo will override the defaults
568             foreach ( array( 'edit', 'view' ) as $view )
569             {
570                 if ( isset( $mergeInfo[$view] ) )
571                     $info[$view] = array_merge( $info[$view], $mergeInfo[$view] );
572                 if ( isset( $override[$view] ) )
573                     $info[$view] = array_merge( $info[$view], $override[$view] );
574             }
575         }
576         else
577         {
578             // All entries in $override will override the defaults
579             foreach ( array( 'edit', 'view' ) as $view )
580             {
581                 if ( isset( $override[$view] ) )
582                     $info[$view] = array_merge( $info[$view], $override[$view] );
583             }
584         }
585         return $info;
586     }
587
588     /*!
589      Returns the content data for the given content object attribute.
590     */
591     function objectAttributeContent( $objectAttribute )
592     {
593         $retValue = '';
594         return $retValue;
595     }
596
597     /*!
598      \return \c true if the datatype finds any content in the attribute \a $contentObjectAttribute.
599     */
600     function hasObjectAttributeContent( $contentObjectAttribute )
601     {
602         return false;
603     }
604
605     /*!
606      Returns the content data for the given content class attribute.
607     */
608     function classAttributeContent( $classAttribute )
609     {
610         return '';
611     }
612
613     /*!
614      Stores the datatype data to the database which is related to the
615      object attribute.
616      \return True if the value was stored correctly.
617      \note The method is entirely up to the datatype, for instance
618            it could reuse the available types in the the attribute or
619            store in a separate object.
620      \sa fetchObjectAttributeHTTPInput
621     */
622     function storeObjectAttribute( $objectAttribute )
623     {
624     }
625
626     /*!
627      Performs necessary actions with attribute data after object is published,
628      it means that you have access to published nodes.
629      \return True if the value was stored correctly.
630      \note The method is entirely up to the datatype, for instance
631            it could reuse the available types in the the attribute or
632            store in a separate object.
633
634      \note Might be transaction unsafe.
635     */
636     function onPublish( $contentObjectAttribute, $contentObject, $publishedNodes )
637     {
638     }
639
640     /*!
641      Similar to the storeClassAttribute but is called before the
642      attribute itself is stored and can be used to set values in the
643      class attribute.
644      \return True if the value was stored correctly.
645      \sa fetchClassAttributeHTTPInput
646     */
647     function preStoreClassAttribute( $classAttribute, $version )
648     {
649     }
650
651     /*!
652      Stores the datatype data to the database which is related to the
653      class attribute. The \a $version parameter determines which version
654      is currently being stored, 0 is the real version while 1 is the
655      temporary version.
656      \return True if the value was stored correctly.
657      \note The method is entirely up to the datatype, for instance
658            it could reuse the available types in the the attribute or
659            store in a separate object.
660      \note This function is called after the attribute data has been stored.
661            If you need to alter attribute data use preStoreClassAttribute instead.
662      \sa fetchClassAttributeHTTPInput
663     */
664     function storeClassAttribute( $classAttribute, $version )
665     {
666     }
667
668
669     /**
670      * @note Transaction unsafe. If you call several transaction unsafe methods you must enclose
671      *       the calls within a db transaction; thus within db->begin and db->commit.
672      *
673      * @param eZContentClassAttribute $classAttribute Content class attribute of the datatype
674      */
675     function storeDefinedClassAttribute( $classAttribute )
676     {
677     }
678
679     /**
680      * @note Transaction unsafe. If you call several transaction unsafe methods you must enclose
681      *       the calls within a db transaction; thus within db->begin and db->commit.
682      * @param eZContentClassAttribute $classAttribute Content class attribute of the datatype
683      */
684     function storeModifiedClassAttribute( $classAttribute )
685     {
686     }
687
688     /**
689      * @note Transaction unsafe. If you call several transaction unsafe methods you must enclose
690      *       the calls within a db transaction; thus within db->begin and db->commit.
691      * @param eZContentClassAttribute $classAttribute Content class attribute of the datatype
692      * @param int $version Version of the attribute to be stored
693      */
694     function storeVersionedClassAttribute( $classAttribute, $version )
695     {
696         switch ( $version )
697         {
698             case eZContentClass::VERSION_STATUS_DEFINED:
699                 $this->storeDefinedClassAttribute( $classAttribute );
700                 break;
701
702             case eZContentClass::VERSION_STATUS_MODIFIED:
703                 $this->storeModifiedClassAttribute( $classAttribute );
704                 break;
705         }
706     }
707
708     /**
709      * @param eZContentClassAttribute $classAttribute Content class attribute of the datatype
710      */
711     function preStoreDefinedClassAttribute( $classAttribute )
712     {
713         $this->preStoreClassAttribute( $classAttribute, $classAttribute->attribute( 'version' ) );
714     }
715
716     /**
717      * @param eZContentClassAttribute $classAttribute Content class attribute of the datatype
718      */
719     function preStoreModifiedClassAttribute( $classAttribute )
720     {
721         $this->preStoreClassAttribute( $classAttribute, $classAttribute->attribute( 'version' ) );
722     }
723
724     /**
725      * Hook function which is called before an content class attribute is stored
726      *
727      * @see eZContentClassAttribute::storeVersioned()
728      * @param eZContentClassAttribute $classAttribute Content class attribute of the datatype
729      * @param int $version Version of the attribute to be stored
730      */
731     function preStoreVersionedClassAttribute( $classAttribute, $version )
732     {
733         switch ( $version )
734         {
735             case eZContentClass::VERSION_STATUS_DEFINED:
736                 $this->preStoreDefinedClassAttribute( $classAttribute );
737                 break;
738
739             case eZContentClass::VERSION_STATUS_MODIFIED:
740                 $this->preStoreModifiedClassAttribute( $classAttribute );
741                 break;
742         }
743     }
744
745     /*!
746      Validates the input for a class attribute and returns a validation
747      state as defined in eZInputValidator.
748      \note Default implementation does nothing and returns accepted.
749     */
750     function validateClassAttributeHTTPInput( $http, $base, $classAttribute )
751     {
752         return eZInputValidator::STATE_ACCEPTED;
753     }
754
755     /*!
756      Tries to do a fixup on the input text so that it's acceptable as
757      class attribute input.
758      \note Default implementation does nothing and returns accepted.
759     */
760     function fixupClassAttributeHTTPInput( $http, $base, $classAttribute )
761     {
762         return eZInputValidator::STATE_ACCEPTED;
763     }
764
765     /*!
766      Fetches the HTTP input for the content class attribute.
767      \note Default implementation does nothing.
768     */
769     function fetchClassAttributeHTTPInput( $http, $base, $classAttribute )
770     {
771     }
772
773     /*!
774      Executes a custom action for a class attribute which was defined on the web page.
775      \note Default implementation does nothing.
776     */
777     function customClassAttributeHTTPAction( $http, $action, $classAttribute )
778     {
779     }
780
781     /*!
782      Matches the action against the action name \a $actionName
783      and extracts the value from the action puts it into \a $value.
784      \return \c true if the action matched and a value was found,
785              \c false otherwise.
786      \node If no match is made or no value found the \a $value parameter is not modified.
787     */
788     function fetchActionValue( $action, $actionName, &$value )
789     {
790         if ( preg_match( "#^" . $actionName . "_(.+)$#", $action, $matches ) )
791         {
792             $value = $matches[1];
793             return true;
794         }
795         return false;
796     }
797
798     /*!
799      Validates the input for an object attribute and returns a validation
800      state as defined in eZInputValidator.
801      \note Default implementation does nothing and returns accepted.
802     */
803     function validateObjectAttributeHTTPInput( $http, $base, $objectAttribute )
804     {
805         return eZInputValidator::STATE_ACCEPTED;
806     }
807
808     /*!
809      Tries to do a fixup on the input text so that it's acceptable as
810      object attribute input.
811      \note Default implementation does nothing.
812     */
813     function fixupObjectAttributeHTTPInput( $http, $base, $objectAttribute )
814     {
815     }
816
817     /*!
818      Fetches the HTTP input for the content object attribute.
819      \note Default implementation does nothing.
820     */
821     function fetchObjectAttributeHTTPInput( $http, $base, $objectAttribute )
822     {
823     }
824
825     /*!
826      Validates the input for an object attribute and returns a validation
827      state as defined in eZInputValidator.
828      \note Default implementation does nothing and returns accepted.
829     */
830     function validateCollectionAttributeHTTPInput( $http, $base, $objectAttribute )
831     {
832         return eZInputValidator::STATE_ACCEPTED;
833     }
834
835     /*!
836      Tries to do a fixup on the input text so that it's acceptable as
837      object attribute input.
838      \note Default implementation does nothing.
839     */
840     function fixupCollectionAttributeHTTPInput( $http, $base, $objectAttribute )
841     {
842     }
843
844     /*!
845      Fetches the HTTP collected information for the content object attribute.
846      \note Default implementation does nothing.
847
848      \return true if variable was successfully fetched.
849     */
850     function fetchCollectionAttributeHTTPInput( $collection, $collectionAttribute, $http, $base, $objectAttribute )
851     {
852     }
853
854     /*!
855      Executes a custom action for an object attribute which was defined on the web page.
856      \note Default implementation does nothing.
857     */
858     function customObjectAttributeHTTPAction( $http, $action, $objectAttribute, $parameters )
859     {
860     }
861
862     /*!
863      Takes care of custom action handling, this means checking if a custom action request
864      must be sent to a contentobject attribute. This function is only useful for
865      datatypes that must do custom action handling for sub objects and attributes.
866      \note Default implementation does nothing.
867     */
868     function handleCustomObjectHTTPActions( $http, $attributeDataBaseName,
869                                             $customActionAttributeArray, $customActionParameters )
870     {
871     }
872
873     /*!
874      Initializes the class attribute with some data.
875      \note Default implementation does nothing.
876     */
877     function initializeClassAttribute( $classAttribute )
878     {
879     }
880
881     /*!
882      Clones the date from the old class attribute to the new one.
883      \note Default implementation does nothing which is good enough for datatypes which does not use external tables.
884     */
885     function cloneClassAttribute( $oldClassAttribute, $newClassAttribute )
886     {
887     }
888
889     /*!
890      Initializes the object attribute with some data.
891      \note Default implementation does nothing.
892     */
893     function initializeObjectAttribute( $objectAttribute, $currentVersion, $originalContentObjectAttribute )
894     {
895     }
896
897     /*!
898      Tries to do a repair on the content object attribute \a $contentObjectAttribute and returns \c true if it succeeds.
899      \return \c false if it fails or \c null if it is not supported to do a repair.
900     */
901     function repairContentObjectAttribute( $contentObjectAttribute )
902     {
903         return null;
904     }
905
906     /*!
907      Initializes the object attribute with some data after object attribute is already stored. It means that for initial version you allready have an attribute_id and you can store data somewhere using this id.
908      \note Default implementation does nothing.
909     */
910     function postInitializeObjectAttribute( $objectAttribute, $currentVersion, $originalContentObjectAttribute )
911     {
912     }
913
914     /*
915      Makes some post-store operations. Called by framework after store of eZContentObjectAttribute object.
916     */
917     function postStore( $objectAttribute )
918     {
919     }
920
921     /*!
922      Do any necessary changes to stored object attribute when moving an object to trash.
923      \note Default implementation does nothing.
924     */
925     function trashStoredObjectAttribute( $objectAttribute, $version = null )
926     {
927     }
928
929     /*!
930      Clean up stored object attribute
931      \note Default implementation does nothing.
932     */
933     function deleteStoredObjectAttribute( $objectAttribute, $version = null )
934     {
935     }
936
937     /*!
938      Clean up stored class attribute
939      \note Default implementation does nothing.
940     */
941     function deleteStoredClassAttribute( $classAttribute, $version = null )
942     {
943     }
944
945     /*!
946      \return the content action(s) which can be performed on object containing
947      the current datatype.
948     */
949     function contentActionList( $classAttribute )
950     {
951         $actionList = array();
952         if ( is_object( $classAttribute ) )
953         {
954             if ( $classAttribute->attribute( 'is_information_collector' ) == true )
955             {
956                 $actionList[] = array( 'name' => ezpI18n::translate( 'kernel/classes/datatypes', 'Send', 'Datatype information collector action' ),
957                                        'action' => 'ActionCollectInformation' );
958             }
959         }
960         else
961         {
962             eZDebug::writeError( '$classAttribute isn\'t an object.', 'eZDataType::contentActionList' );
963         }
964         return $actionList;
965     }
966
967     /*!
968      \return true if the data type can do information collection
969     */
970     function hasInformationCollection()
971     {
972         return false;
973     }
974
975     /*!
976      Returns the title of the current type, this is to form
977      the title of the object.
978     */
979     function title( $objectAttribute, $name = null )
980     {
981         return "";
982     }
983
984     /*!
985      \return true if the datatype can be indexed
986     */
987     function isIndexable()
988     {
989         return false;
990     }
991
992     /*!
993      \return true if the datatype requires validation during add to basket procedure
994     */
995     function isAddToBasketValidationRequired()
996     {
997         return false;
998     }
999     /*!
1000      Validates the input for an object attribute during add to basket process
1001      and returns a validation state as defined in eZInputValidator.
1002      \note Default implementation does nothing and returns accepted.
1003     */
1004     function validateAddToBasket( $objectAttribute, $data, &$errors )
1005     {
1006         return eZInputValidator::STATE_ACCEPTED;
1007     }
1008
1009     /*!
1010      Queries the datatype if the attribute containing this datatype can be
1011      removed from the class. This can be used by datatypes to ensure
1012      that very important datatypes that could cause system malfunction is
1013      not removed.
1014      The datatype will only need to reimplemented this if it wants to
1015      do some checking, the default returns \c true.
1016
1017      \return \c true if the class attribute can be removed or \c false.
1018      \sa classAttributeRemovableInformation()
1019      \note The default code will call classAttributeRemovableInformation with
1020           $includeAll set to \c false, if it returns false or an empty \c 'list'
1021           it will return \c true.
1022     */
1023     function isClassAttributeRemovable( $classAttribute )
1024     {
1025         $info = $this->classAttributeRemovableInformation( $classAttribute, false );
1026         return ( $info === false or count( $info['list'] ) == 0 );
1027     }
1028
1029     /*!
1030      If the call to isClassAttributeRemovable() returns \c false then this
1031      can be called to figure out why it cannot be removed, e.g to give
1032      information to the user.
1033      \return An array structure with information, or \c false if no info is available
1034              - text - Plain text explaining why it can't be removed
1035              - list - A list of reasons with details on why it can be removed
1036                       - identifier - The identifier of the reason (optional)
1037                       - text - Plain text explaning the reason
1038      \param $includeAll Controls whether the returned information will contain all
1039                         sources for not being to remove or just the first that it finds.
1040     */
1041     function classAttributeRemovableInformation( $classAttribute, $includeAll = true )
1042     {
1043         return false;
1044     }
1045
1046     /*!
1047      \return true if the datatype can be used as an information collector
1048     */
1049     function isInformationCollector()
1050     {
1051         return false;
1052     }
1053
1054     /*!
1055      \return the sort key for the datatype. This is used for sorting on attribute level.
1056     */
1057     function sortKey( $objectAttribute )
1058     {
1059         return "";
1060     }
1061
1062     /*!
1063      \returns the type of the sort key int|string
1064       False is returned if sorting is not supported
1065     */
1066     function sortKeyType()
1067     {
1068         return false;
1069     }
1070
1071     function customSorting()
1072     {
1073         return false;
1074     }
1075
1076     function customSortingSQL( $params )
1077     {
1078         return false;
1079     }
1080
1081     /*!
1082      \return the text which should be indexed in the search engine. An associative array can
1083       be returned to enable searching in specific parts of the data. E.g. array( 'first_column' => "foo",
1084      'second_column' => "bar" );
1085     */
1086     function metaData( $contentObjectAttribute )
1087     {
1088         return '';
1089     }
1090     /*!
1091      \return string representation of an contentobjectattribute data for simplified export
1092      */
1093     function toString( $objectAttribute )
1094     {
1095         return '';
1096     }
1097     function fromString( $objectAttribute, $string )
1098     {
1099     }
1100
1101     /*!
1102      Can be called to figure out if a datatype has certain special templates that it relies on.
1103      This can for instance be used to figure out which override templates to include in a package.
1104      \return An array with template files that this datatype relies on.
1105              Each element can be one of the following types:
1106              - string - The filepath of the template
1107              - array - Advanced matching criteria, element 0 determines the type:
1108                - 'regexp' - A regular expression, element 1 is the regexp string (PREG)
1109              If \c false is returned it means there are no relations to any templates.
1110      \note All matching is done relative from templates directory in the given design.
1111      \note The templates that are found in content/datatype/* should not be included.
1112     */
1113     function templateList()
1114     {
1115         return false;
1116     }
1117
1118     /*!
1119      Adds the necessary dom structure to the attribute parameters.
1120      \note The default is to add unsupported='true' to the attribute node,
1121            meaning that the datatype does not support serializing.
1122     */
1123     function serializeContentClassAttribute( $classAttribute, $attributeNode, $attributeParametersNode )
1124     {
1125         if ( !$this->Attributes['properties']['serialize_supported'] )
1126             $attributeNode->setAttribute( 'unsupported', 'true' );
1127     }
1128
1129     /*!
1130      Extracts values from the attribute parameters and sets it in the class attribute.
1131      \note This function is called after the attribute has been stored and a second store is
1132            called after this function is done.
1133     */
1134     function unserializeContentClassAttribute( $classAttribute, $attributeNode, $attributeParametersNode )
1135     {
1136     }
1137
1138     /*!
1139      \param package
1140      \param objectAttribute content attribute
1141
1142      \return a DOM representation of the content object attribute
1143     */
1144     function serializeContentObjectAttribute( $package, $objectAttribute )
1145     {
1146         $dom = new DOMDocument( '1.0', 'utf-8' );
1147
1148         $node = $dom->createElementNS( 'http://ez.no/object/', 'ezobject:attribute' );
1149
1150         $node->setAttributeNS( 'http://ez.no/ezobject', 'ezremote:id', $objectAttribute->attribute( 'id' ) );
1151         $node->setAttributeNS( 'http://ez.no/ezobject', 'ezremote:identifier', $objectAttribute->contentClassAttributeIdentifier() );
1152         $node->setAttribute( 'name', $objectAttribute->contentClassAttributeName() );
1153         $node->setAttribute( 'type', $this->isA() );
1154
1155         if ( $this->Attributes["properties"]['object_serialize_map'] )
1156         {
1157             $map = $this->Attributes["properties"]['object_serialize_map'];
1158             foreach ( $map as $attributeName => $xmlName )
1159             {
1160                 if ( $objectAttribute->hasAttribute( $attributeName ) )
1161                 {
1162                     $value = $objectAttribute->attribute( $attributeName );
1163                     unset( $attributeNode );
1164                     $attributeNode = $dom->createElement( $xmlName );
1165                     $attributeNode->appendChild( $dom->createTextNode( (string)$value ) );
1166                     $node->appendChild( $attributeNode );
1167                 }
1168                 else
1169                 {
1170                     eZDebug::writeError( "The attribute '$attributeName' does not exist for contentobject attribute " . $objectAttribute->attribute( 'id' ),
1171                                          'eZDataType::serializeContentObjectAttribute' );
1172                 }
1173             }
1174         }
1175         else
1176         {
1177             $dataIntNode = $dom->createElement( 'data-int' );
1178             $dataIntNode->appendChild( $dom->createTextNode( (string)$objectAttribute->attribute( 'data_int' ) ) );
1179             $node->appendChild( $dataIntNode );
1180             $dataFloatNode = $dom->createElement( 'data-float' );
1181             $dataFloatNode->appendChild( $dom->createTextNode( (string)$objectAttribute->attribute( 'data_float' ) ) );
1182             $node->appendChild( $dataFloatNode );
1183             $dataTextNode = $dom->createElement( 'data-text' );
1184             $dataTextNode->appendChild( $dom->createTextNode( $objectAttribute->attribute( 'data_text' ) ) );
1185             $node->appendChild( $dataTextNode );
1186         }
1187         return $node;
1188     }
1189
1190     /*!
1191      Unserialize contentobject attribute
1192
1193      \param package
1194      \param objectAttribute contentobject attribute object
1195      \param attributeNode ezdomnode object
1196     */
1197     function unserializeContentObjectAttribute( $package, $objectAttribute, $attributeNode )
1198     {
1199         if ( $this->Attributes["properties"]['object_serialize_map'] )
1200         {
1201             $map = $this->Attributes["properties"]['object_serialize_map'];
1202             foreach ( $map as $attributeName => $xmlName )
1203             {
1204                 if ( $objectAttribute->hasAttribute( $attributeName ) )
1205                 {
1206                     $elements = $attributeNode->getElementsByTagName( $xmlName );
1207                     if ( $elements->length !== 0 )
1208                     {
1209                         $value = $elements->item( 0 )->textContent;
1210                         $objectAttribute->setAttribute( $attributeName, $value );
1211                     }
1212                     else
1213                     {
1214                         eZDebug::writeError( "The xml element '$xmlName' does not exist for contentobject attribute " . $objectAttribute->attribute( 'id' ),
1215                                              'eZDataType::unserializeContentObjectAttribute' );
1216                     }
1217                 }
1218                 else
1219                 {
1220                     eZDebug::writeError( "The attribute '$attributeName' does not exist for contentobject attribute " . $objectAttribute->attribute( 'id' ),
1221                                          'eZDataType::unserializeContentObjectAttribute' );
1222                 }
1223             }
1224         }
1225         else
1226         {
1227             $objectAttribute->setAttribute( 'data_int', (int)$attributeNode->getElementsByTagName( 'data-int' )->item( 0 )->textContent );
1228             $objectAttribute->setAttribute( 'data_float', (float)$attributeNode->getElementsByTagName( 'data-float' )->item( 0 )->textContent );
1229             $objectAttribute->setAttribute( 'data_text', $attributeNode->getElementsByTagName( 'data-text' )->item( 0 )->textContent );
1230         }
1231     }
1232
1233     /*
1234         Post unserialize. Called after all related objects are created.
1235         \return true means that attribute has been modified and should be stored
1236     */
1237     function postUnserializeContentObjectAttribute( $package, $objectAttribute )
1238     {
1239         return false;
1240     }
1241
1242     static function allowedTypes()
1243     {
1244         $allowedTypes =& $GLOBALS["eZDataTypeAllowedTypes"];
1245         if ( !is_array( $allowedTypes ) )
1246         {
1247             $contentINI = eZINI::instance( 'content.ini' );
1248             $dataTypes = $contentINI->variable( 'DataTypeSettings', 'AvailableDataTypes' );
1249             $allowedTypes = array_unique( $dataTypes );
1250         }
1251         return $allowedTypes;
1252     }
1253
1254     static function loadAndRegisterAllTypes()
1255     {
1256         $allowedTypes = eZDataType::allowedTypes();
1257         foreach( $allowedTypes as $type )
1258         {
1259             eZDataType::loadAndRegisterType( $type );
1260         }
1261     }
1262
1263     static function loadAndRegisterType( $type )
1264     {
1265         $types =& $GLOBALS["eZDataTypes"];
1266         if ( isset( $types[$type] ) )
1267         {
1268             return false;
1269         }
1270
1271         $baseDirectory = eZExtension::baseDirectory();
1272         $contentINI = eZINI::instance( 'content.ini' );
1273
1274         $extensionDirectories = $contentINI->variable( 'DataTypeSettings', 'ExtensionDirectories' );
1275         $extensionDirectories = array_unique( $extensionDirectories );
1276         $repositoryDirectories = $contentINI->variable( 'DataTypeSettings', 'RepositoryDirectories' );
1277         $triedDirectories = $repositoryDirectories;
1278
1279         foreach ( $extensionDirectories as $extensionDirectory )
1280         {
1281             $extensionPath = $baseDirectory . '/' . $extensionDirectory . '/datatypes';
1282             $triedDirectories[] = $extensionPath;
1283             if ( file_exists( $extensionPath ) )
1284             {
1285                 $repositoryDirectories[] = $extensionPath;
1286             }
1287             else
1288             {
1289                 eZDebug::writeWarning( "Extension '$extensionDirectory' does not have the subdirectory 'datatypes'\n" .
1290                                        "Looked for directory '" . $extensionPath . "'\n" .
1291                                        "Cannot look for datatype '$type' in this extension." );
1292             }
1293         }
1294         $foundEventType = false;
1295         $repositoryDirectories = array_unique( $repositoryDirectories );
1296         foreach ( $repositoryDirectories as $repositoryDirectory )
1297         {
1298             $includeFile = "$repositoryDirectory/$type/" . $type . "type.php";
1299             if ( file_exists( $includeFile ) )
1300             {
1301                 $foundEventType = true;
1302                 break;
1303             }
1304         }
1305         if ( !$foundEventType )
1306         {
1307             eZDebug::writeError( "Datatype not found: '$type', searched in these directories: " . implode( ', ', $triedDirectories ), "eZDataType::loadAndRegisterType" );
1308             return false;
1309         }
1310         include_once( $includeFile );
1311         return true;
1312     }
1313
1314     /*!
1315      Removes objects with given ID from the relations list
1316      \note Default implementation does nothing.
1317     */
1318     function removeRelatedObjectItem( $contentObjectAttribute, $objectID )
1319     {
1320     }
1321
1322     /*!
1323     Fixes objects with given ID in the relations list according to what is done with object
1324      \note Default implementation does nothing.
1325     */
1326     function fixRelatedObjectItem( $contentObjectAttribute, $objectID, $mode )
1327     {
1328     }
1329     /**
1330      * Create empty content object attribute DOM node.
1331      *
1332      * The result is intended to be used in a datatype's
1333      * serializeContentObjectAttribute() method.
1334      *
1335      * \return "Empty" DOM node
1336      */
1337     function createContentObjectAttributeDOMNode( $objectAttribute )
1338     {
1339         $dom = new DOMDocument( '1.0', 'utf-8' );
1340
1341         $node = $dom->createElementNS( 'http://ez.no/object/', 'ezobject:attribute' );
1342
1343         $node->setAttributeNS( 'http://ez.no/ezobject', 'ezremote:id', $objectAttribute->attribute( 'id' ) );
1344         $node->setAttributeNS( 'http://ez.no/ezobject', 'ezremote:identifier', $objectAttribute->contentClassAttributeIdentifier() );
1345         $node->setAttribute( 'name', $objectAttribute->contentClassAttributeName() );
1346         $node->setAttribute( 'type', $this->isA() );
1347
1348         return $node;
1349     }
1350
1351     /*!
1352       Method used by content diff system to retrieve changes in attributes.
1353       This method implements the default behaviour, which is to show old and
1354       new version values of the object.
1355     */
1356     function diff( $old, $new, $options = false )
1357     {
1358         $diff = new eZDiff();
1359         $diff->setDiffEngineType( $diff->engineType( 'container' ) );
1360         $diff->initDiffEngine();
1361         $diffObject = $diff->diff( $old, $new );
1362         return $diffObject;
1363     }
1364
1365     /*!
1366       Returns dba-data file name of the specific datatype.
1367       This one is the default dba-data file name for all datatypes
1368     */
1369     function getDBAFileName()
1370     {
1371         return 'share/db_data.dba';
1372     }
1373
1374     /*!
1375       Returns dba-data file path (relative to the system root folder) for the specific datatype.
1376     */
1377     function getDBAFilePath( $checkExtensions = true )
1378     {
1379          $fileName = 'kernel/classes/datatypes/' . $this->DataTypeString . '/' . $this->getDBAFileName();
1380          if ( $checkExtensions === true && !file_exists( $fileName ) )
1381          {
1382              $fileName = $this->getDBAExtensionFilePath();
1383          }
1384          return $fileName;
1385     }
1386
1387     /*!
1388       Returns dba-data file extension path (relative to the system root folder) for the specific datatype.
1389       \return the first path that is found for the datatype. If not found, it will return false.
1390     */
1391     function getDBAExtensionFilePath()
1392     {
1393         $activeExtensions = eZExtension::activeExtensions();
1394         $dataTypeString = $this->DataTypeString;
1395         $dbaFileName = $this->getDBAFileName();
1396         $fileName = false;
1397         foreach ( $activeExtensions as $activeExtension )
1398         {
1399             $extesionFileName = eZExtension::baseDirectory() . '/' . $activeExtension .
1400                                 '/datatypes/' . $dataTypeString . '/' . $dbaFileName;
1401             if ( file_exists( $extesionFileName ) )
1402             {
1403                 $fileName = $extesionFileName;
1404                 break;
1405             }
1406         }
1407         return $fileName;
1408     }
1409
1410     /*!
1411       Used by setup-wizard to update database data using per datatype dba file
1412       which is usually placed in share subfolder of the datatype and (share/db_data.dba)
1413       Any reimplementation of this method must return true if import is succesfully done,
1414       otherwise false.
1415     */
1416     function importDBDataFromDBAFile( $dbaFilePath = false )
1417     {
1418         // If no file path is passed then get the common dba-data file name for the datatype
1419         if ( $dbaFilePath === false )
1420             $dbaFilePath = $this->getDBAFilePath();
1421
1422         $fileExist = true;
1423         if ( !file_exists( $dbaFilePath ) )
1424         {
1425             $fileExist = false;
1426         }
1427         $result = true;
1428         if ( $fileExist === true )
1429         {
1430             $dataArray = eZDbSchema::read( $dbaFilePath, true );
1431             if ( is_array( $dataArray ) and count( $dataArray ) > 0 )
1432             {
1433                 $db = eZDB::instance();
1434                 $dataArray['type'] = strtolower( $db->databaseName() );
1435                 $dataArray['instance'] =& $db;
1436                 $dbSchema = eZDbSchema::instance( $dataArray );
1437
1438                 $result = false;
1439                 if ( $dbSchema )
1440                 {
1441                     // Before adding the schema, make sure that the tables are empty.
1442                     if ( $this->cleanDBDataBeforeImport() )
1443                     {
1444                         // This will insert the data and
1445                         // run any sequence value correction SQL if required
1446                         $result = $dbSchema->insertSchema( array( 'schema' => false,
1447                                                                   'data' => true ) );
1448                     }
1449                 }
1450             }
1451         }
1452         else
1453         {
1454             $result = false;
1455         }
1456         return $result;
1457     }
1458
1459     /*!
1460       \private
1461       Used by updateDBDataByDBAFile() method
1462       Must return true if successfull, or false otherwise.
1463     */
1464     function cleanDBDataBeforeImport()
1465     {
1466         return true;
1467     }
1468
1469     function batchInitializeObjectAttributeData( $classAttribute )
1470     {
1471         return array();
1472     }
1473
1474     function supportsBatchInitializeObjectAttribute()
1475     {
1476         return false;
1477     }
1478
1479     /// \privatesection
1480     /// The datatype string ID, used for uniquely identifying a datatype
1481     public $DataTypeString;
1482     /// The descriptive name of the datatype, usually used for displaying to the user
1483     public $Name;
1484 }
1485
1486 ?>