- Fixed #16160: Call to undefined function ezi18n()
[tinyz:tinyz.git] / kernel / content / ezcontentfunctioncollection.php
1 <?php
2 //
3 // Definition of eZContentFunctionCollection class
4 //
5 // Created on: <06-Oct-2002 16:19:31 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 /*! \file
32 */
33
34 /*!
35   \class eZContentFunctionCollection ezcontentfunctioncollection.php
36   \brief The class eZContentFunctionCollection does
37
38 */
39
40 class eZContentFunctionCollection
41 {
42     /*!
43      Constructor
44     */
45     function eZContentFunctionCollection()
46     {
47     }
48
49     static public function fetchContentObject( $objectID, $remoteID = false )
50     {
51         if ( $objectID === false && $remoteID !== false )
52         {
53             $contentObject = eZContentObject::fetchByRemoteID( $remoteID );
54         }
55         else
56         {
57             $contentObject = eZContentObject::fetch( $objectID );
58         }
59
60         if ( $contentObject === null )
61         {
62             $result = array( 'error' => array( 'error_type' => 'kernel',
63                                                'error_code' => eZError::KERNEL_NOT_FOUND ) );
64         }
65         else
66         {
67             $result = array( 'result' => $contentObject );
68         }
69
70         return $result;
71     }
72
73     static public function fetchContentVersion( $objectID, $versionID )
74     {
75         $contentVersion = eZContentObjectVersion::fetchVersion( $versionID, $objectID );
76         if ( !$contentVersion )
77         {
78             $result = array( 'error' => array( 'error_type' => 'kernel',
79                                                'error_code' => eZError::KERNEL_NOT_FOUND ) );
80         }
81         else
82         {
83             $result = array( 'result' => $contentVersion );
84         }
85
86         return $result;
87     }
88
89     static public function fetchContentNode( $nodeID, $nodePath, $languageCode, $remoteID = false )
90     {
91         $contentNode = null;
92         if ( $nodeID )
93         {
94             if ( !isset( $languageCode ) )
95                 $languageCode = false;
96
97             $contentNode = eZContentObjectTreeNode::fetch( $nodeID, $languageCode );
98         }
99         else if ( $nodePath )
100         {
101             $nodeID = eZURLAliasML::fetchNodeIDByPath( $nodePath );
102
103             if ( $nodeID )
104             {
105                $contentNode = eZContentObjectTreeNode::fetch( $nodeID );
106             }
107         }
108         else if ( $remoteID )
109         {
110             $contentNode = eZContentObjectTreeNode::fetchByRemoteID( $remoteID );
111         }
112         if ( $contentNode === null )
113         {
114             $retVal = array( 'error' => array( 'error_type' => 'kernel',
115                                                'error_code' => eZError::KERNEL_NOT_FOUND ) );
116         }
117         else
118         {
119             $retVal = array( 'result' => $contentNode );
120         }
121
122         return $retVal;
123     }
124
125     static public function fetchNonTranslationList( $objectID, $version )
126     {
127         $version = eZContentObjectVersion::fetchVersion( $version, $objectID );
128         if ( !$version )
129             return array( 'error' => array( 'error_type' => 'kernel',
130                                             'error_code' => eZError::KERNEL_NOT_FOUND ) );
131
132         $nonTranslationList = $version->nonTranslationList();
133         if ( $nonTranslationList === null )
134             return array( 'error' => array( 'error_type' => 'kernel',
135                                             'error_code' => eZError::KERNEL_NOT_FOUND ) );
136         return array( 'result' => $nonTranslationList );
137     }
138
139     static public function fetchTranslationList()
140     {
141         $translationList = eZContentObject::translationList();
142         if ( $translationList === null )
143         {
144             $result =  array( 'error' => array( 'error_type' => 'kernel',
145                                                 'error_code' => eZError::KERNEL_NOT_FOUND ) );
146         }
147         else
148         {
149             $result = array( 'result' => $translationList );
150         }
151
152         return $result;
153     }
154
155     static public function fetchPrioritizedLanguages()
156     {
157         $languages = eZContentLanguage::prioritizedLanguages();
158         if ( $languages === null )
159         {
160             $result =  array( 'error' => array( 'error_type' => 'kernel',
161                                                 'error_code' => eZError::KERNEL_NOT_FOUND ) );
162         }
163         else
164         {
165             $result = array( 'result' => $languages );
166         }
167
168         return $result;
169     }
170
171     static public function fetchPrioritizedLanguageCodes()
172     {
173         $languageCodes = eZContentLanguage::prioritizedLanguageCodes();
174         if ( $languageCodes === null )
175         {
176             $result =  array( 'error' => array( 'error_type' => 'kernel',
177                                                 'error_code' => eZError::KERNEL_NOT_FOUND ) );
178         }
179         else
180         {
181             $result = array( 'result' => $languageCodes );
182         }
183
184         return $result;
185     }
186
187     static public function fetchLocaleList( $withVariations )
188     {
189         $localeList = eZLocale::localeList( true, $withVariations );
190         if ( $localeList === null )
191         {
192             $result = array( 'error' => array( 'error_type' => 'kernel',
193                                                'error_code' => eZError::KERNEL_NOT_FOUND ) );
194         }
195         else
196         {
197             $result = array( 'result' => $localeList );
198         }
199
200         return $result;
201     }
202
203     static public function fetchLocale( $localeCode )
204     {
205         // Fetch locale list
206         $localeList = eZLocale::localeList( false, true );
207         $localeObj = eZLocale::instance( $localeCode );
208         // Check if $localeName exists
209         if ( $localeObj === null or ( is_object( $localeObj ) and !in_array( $localeObj->localeFullCode(), $localeList ) ) )
210         {
211             $result = array( 'error' => array( 'error_type' => 'kernel',
212                                                'error_code' => eZError::KERNEL_NOT_FOUND ) );
213         }
214         else
215         {
216             $result = array( 'result' => $localeObj );
217         }
218
219         return $result;
220     }
221
222     static public function fetchObject( $objectID )
223     {
224         $object = eZContentObject::fetch( $objectID );
225         if ( $object === null )
226         {
227             $result = array( 'error' => array( 'error_type' => 'kernel',
228                                                'error_code' => eZError::KERNEL_NOT_FOUND ) );
229         }
230         else
231         {
232             $result = array( 'result' => $object );
233         }
234
235         return $result;
236     }
237
238     static public function fetchClass( $classID )
239     {
240         if ( !is_numeric( $classID ) )
241             $object = eZContentClass::fetchByIdentifier( $classID );
242         else
243             $object = eZContentClass::fetch( $classID );
244         if ( $object === null )
245         {
246             $result = array( 'error' => array( 'error_type' => 'kernel',
247                                                'error_code' => eZError::KERNEL_NOT_FOUND ) );
248         }
249         else
250         {
251             $result = array( 'result' => $object );
252         }
253
254         return $result;
255     }
256
257     static public function fetchClassAttributeList( $classID, $versionID )
258     {
259         $objectList = eZContentClass::fetch( $classID )->fetchAttributes( false, true, $versionID );
260         if ( $objectList === null )
261         {
262             $result = array( 'error' => array( 'error_type' => 'kernel',
263                                                'error_code' => eZError::KERNEL_NOT_FOUND ) );
264         }
265         else
266         {
267             $result = array( 'result' => $objectList );
268         }
269
270         return $result;
271     }
272
273     static public function fetchClassAttribute( $attributeID, $versionID )
274     {
275         $attribute = eZContentClassAttribute::fetch( $attributeID, true, $versionID );
276         if ( $attribute === null )
277         {
278             $result = array( 'error' => array( 'error_type' => 'kernel',
279                                                'error_code' => eZError::KERNEL_NOT_FOUND ) );
280         }
281         else
282         {
283             $result = array( 'result' => $attribute );
284         }
285
286         return $result;
287     }
288
289     static public function calendar( $parentNodeID, $offset, $limit, $depth, $depthOperator,
290                                $classID, $attribute_filter, $extended_attribute_filter, $class_filter_type, $class_filter_array,
291                                $groupBy, $mainNodeOnly, $ignoreVisibility, $limitation )
292     {
293         $treeParameters = array( 'Offset' => $offset,
294                                  'Limit' => $limit,
295                                  'Limitation' => $limitation,
296                                  'class_id' => $classID,
297                                  'AttributeFilter' => $attribute_filter,
298                                  'ExtendedAttributeFilter' => $extended_attribute_filter,
299                                  'ClassFilterType' => $class_filter_type,
300                                  'ClassFilterArray' => $class_filter_array,
301                                  'IgnoreVisibility' => $ignoreVisibility,
302                                  'MainNodeOnly' => $mainNodeOnly );
303         if ( is_array( $groupBy ) )
304         {
305             $groupByHash = array( 'field' => $groupBy[0],
306                                   'type' => false );
307             if ( isset( $groupBy[1] ) )
308                 $groupByHash['type'] = $groupBy[1];
309             $treeParameters['GroupBy'] = $groupByHash;
310         }
311
312         if ( $depth !== false )
313         {
314             $treeParameters['Depth'] = $depth;
315             $treeParameters['DepthOperator'] = $depthOperator;
316         }
317
318         $children = null;
319         if ( is_numeric( $parentNodeID ) )
320         {
321             $children = eZContentObjectTreeNode::calendar( $treeParameters,
322                                                             $parentNodeID );
323         }
324
325         if ( $children === null )
326         {
327             $result = array( 'error' => array( 'error_type' => 'kernel',
328                                                'error_code' => eZError::KERNEL_NOT_FOUND ) );
329         }
330         else
331         {
332             $result = array( 'result' => $children );
333         }
334         return $result;
335     }
336
337     static public function fetchObjectTree( $parentNodeID, $sortBy, $onlyTranslated, $language, $offset, $limit, $depth, $depthOperator,
338                               $classID, $attribute_filter, $extended_attribute_filter, $class_filter_type, $class_filter_array,
339                               $groupBy, $mainNodeOnly, $ignoreVisibility, $limitation, $asObject, $objectNameFilter, $loadDataMap = null )
340     {
341         $treeParameters = array( 'Offset' => $offset,
342                                  'OnlyTranslated' => $onlyTranslated,
343                                  'Language' => $language,
344                                  'Limit' => $limit,
345                                  'Limitation' => $limitation,
346                                  'SortBy' => $sortBy,
347                                  'class_id' => $classID,
348                                  'AttributeFilter' => $attribute_filter,
349                                  'ExtendedAttributeFilter' => $extended_attribute_filter,
350                                  'ClassFilterType' => $class_filter_type,
351                                  'ClassFilterArray' => $class_filter_array,
352                                  'IgnoreVisibility' => $ignoreVisibility,
353                                  'ObjectNameFilter' => $objectNameFilter,
354                                  'MainNodeOnly' => $mainNodeOnly );
355         if ( is_array( $groupBy ) )
356         {
357             $groupByHash = array( 'field' => $groupBy[0],
358                                   'type' => false );
359             if ( isset( $groupBy[1] ) )
360                 $groupByHash['type'] = $groupBy[1];
361             $treeParameters['GroupBy'] = $groupByHash;
362         }
363         if ( $asObject !== null )
364             $treeParameters['AsObject'] = $asObject;
365         if ( $loadDataMap )
366             $treeParameters['LoadDataMap'] = true;
367         else if ( $loadDataMap === null )
368             $treeParameters['LoadDataMap'] = 15;
369         if ( $depth !== false )
370         {
371             $treeParameters['Depth'] = $depth;
372             $treeParameters['DepthOperator'] = $depthOperator;
373         }
374
375         $children = null;
376         if ( is_numeric( $parentNodeID ) or is_array( $parentNodeID ) )
377         {
378             $children = eZContentObjectTreeNode::subTreeByNodeID( $treeParameters,
379                                                                   $parentNodeID );
380         }
381
382         if ( $children === null )
383         {
384             return array( 'error' => array( 'error_type' => 'kernel',
385                                             'error_code' => eZError::KERNEL_NOT_FOUND ) );
386         }
387         else
388         {
389             return array( 'result' => $children );
390         }
391     }
392
393     static public function fetchObjectTreeCount( $parentNodeID, $onlyTranslated, $language, $class_filter_type, $class_filter_array,
394                                    $attributeFilter, $depth, $depthOperator,
395                                    $ignoreVisibility, $limitation, $mainNodeOnly, $extendedAttributeFilter, $objectNameFilter )
396     {
397         $childrenCount = null;
398
399         if ( is_numeric( $parentNodeID ) or is_array( $parentNodeID ) )
400         {
401             $childrenCount = eZContentObjectTreeNode::subTreeCountByNodeID( array( 'Limitation' => $limitation,
402                                                                            'ClassFilterType' => $class_filter_type,
403                                                                            'ClassFilterArray' => $class_filter_array,
404                                                                            'AttributeFilter' => $attributeFilter,
405                                                                            'DepthOperator' => $depthOperator,
406                                                                            'Depth' => $depth,
407                                                                            'IgnoreVisibility' => $ignoreVisibility,
408                                                                            'OnlyTranslated' => $onlyTranslated,
409                                                                            'Language' => $language,
410                                                                            'ObjectNameFilter' => $objectNameFilter,
411                                                                            'ExtendedAttributeFilter' => $extendedAttributeFilter,
412                                                                            'MainNodeOnly' => $mainNodeOnly ),
413                                                                      $parentNodeID );
414         }
415
416         if ( $childrenCount === null )
417         {
418             $result = array( 'error' => array( 'error_type' => 'kernel',
419                                                'error_code' => eZError::KERNEL_NOT_FOUND ) );
420         }
421         else
422         {
423             $result = array( 'result' => $childrenCount );
424         }
425         return $result;
426     }
427
428     static public function fetchContentSearch( $searchText, $subTreeArray, $offset, $limit, $searchTimestamp, $publishDate, $sectionID,
429                                  $classID, $classAttributeID, $ignoreVisibility, $limitation, $sortArray )
430     {
431         $searchArray = eZSearch::buildSearchArray();
432         $parameters = array();
433         if ( $classID !== false )
434             $parameters['SearchContentClassID'] = $classID;
435         if ( $classAttributeID !== false )
436             $parameters['SearchContentClassAttributeID'] = $classAttributeID;
437         if ( $sectionID !== false )
438             $parameters['SearchSectionID'] = $sectionID;
439         if ( $publishDate !== false )
440             $parameters['SearchDate'] = $publishDate;
441         if ( $sortArray !== false )
442             $parameters['SortArray'] = $sortArray;
443         $parameters['SearchLimit'] = $limit;
444         $parameters['SearchOffset'] = $offset;
445         $parameters['IgnoreVisibility'] = $ignoreVisibility;
446         $parameters['Limitation'] = $limitation;
447
448         if ( $subTreeArray !== false )
449             $parameters['SearchSubTreeArray'] = $subTreeArray;
450         if ( $searchTimestamp )
451             $parameters['SearchTimestamp'] = $searchTimestamp;
452         $searchResult = eZSearch::search( $searchText,
453                                           $parameters,
454                                           $searchArray );
455         return array( 'result' => $searchResult );
456     }
457
458     static public function fetchTrashObjectCount( $objectNameFilter, $attributeFilter = false )
459     {
460         $params = array();
461         if ( $objectNameFilter !== false )
462         {
463             $params['ObjectNameFilter'] = $objectNameFilter;
464         }
465
466         $params[ 'AttributeFilter' ] = $attributeFilter;
467
468         $trashCount = eZContentObjectTrashNode::trashListCount( $params );
469         return array( 'result' => $trashCount );
470     }
471
472     static public function fetchTrashObjectList( $offset, $limit, $objectNameFilter, $attributeFilter = false, $sortBy = false, $asObject = true )
473     {
474         $params = array();
475         if ( $objectNameFilter !== false )
476         {
477             $params['ObjectNameFilter'] = $objectNameFilter;
478         }
479         $params[ 'Limit' ] = $limit;
480         $params[ 'Offset' ] = $offset;
481         $params[ 'AttributeFilter' ] = $attributeFilter;
482         $params[ 'SortBy' ] = $sortBy;
483         $params[ 'AsObject' ] = $asObject;
484
485         $trashNodesList = eZContentObjectTrashNode::trashList( $params, false );
486         return array( 'result' => $trashNodesList );
487     }
488
489     static public function fetchDraftVersionList( $offset, $limit )
490     {
491         $userID = eZUser::currentUserID();
492         $draftVersionList =  eZPersistentObject::fetchObjectList( eZContentObjectVersion::definition(),
493                                                                    null, array(  'creator_id' => $userID,
494                                                                                  'status' => eZContentObjectVersion::STATUS_DRAFT ),
495                                                                    array( 'modified' => true,
496                                                                           'initial_language_id' => true ),
497                                                                    array( 'length' => $limit, 'offset' => $offset ),
498                                                                    true );
499         return array( 'result' => $draftVersionList );
500     }
501
502     static public function fetchDraftVersionCount()
503     {
504         $userID = eZUser::currentUserID();
505         $draftVersionList = eZPersistentObject::fetchObjectList( eZContentObjectVersion::definition(),
506                                                                  array(),
507                                                                  array( 'creator_id' => $userID,
508                                                                         'status' => eZContentObjectVersion::STATUS_DRAFT ),
509                                                                  false,
510                                                                  null,
511                                                                  false,
512                                                                  false,
513                                                                  array( array( 'operation' => 'count( * )',
514                                                                                'name' => 'count' ) ) );
515         return array( 'result' => $draftVersionList[0]['count'] );
516     }
517
518     static public function fetchPendingList( $offset, $limit )
519     {
520         $userID = eZUser::currentUserID();
521         $pendingList =  eZPersistentObject::fetchObjectList( eZContentObjectVersion::definition(),
522                                                              null, array(  'creator_id' => $userID,
523                                                                            'status' => eZContentObjectVersion::STATUS_PENDING ),
524                                                              null, array( 'length' => $limit, 'offset' => $offset ),
525                                                              true );
526         return array( 'result' => $pendingList );
527
528     }
529
530     static public function fetchPendingCount()
531     {
532         $userID = eZUser::currentUserID();
533         $pendingList = eZPersistentObject::fetchObjectList( eZContentObjectVersion::definition(),
534                                                             array(),
535                                                             array( 'creator_id' => $userID,
536                                                                    'status' => eZContentObjectVersion::STATUS_PENDING ),
537                                                             false,
538                                                             null,
539                                                             false,
540                                                             false,
541                                                             array( array( 'operation' => 'count( * )',
542                                                                           'name' => 'count' ) ) );
543         return array( 'result' => $pendingList[0]['count'] );
544     }
545
546
547     static public function fetchVersionList( $contentObject, $offset, $limit, $sorts = null )
548     {
549         if ( !is_object( $contentObject ) )
550             return array( 'result' => null );
551         $versionList =  eZPersistentObject::fetchObjectList( eZContentObjectVersion::definition(),
552                                                               null, array(  'contentobject_id' => $contentObject->attribute("id") ),
553                                                                    $sorts, array( 'length' => $limit, 'offset' => $offset ),
554                                                                    true );
555         return array( 'result' => $versionList );
556
557     }
558
559     static public function fetchVersionCount( $contentObject )
560     {
561         if ( !is_object( $contentObject ) )
562             return array( 'result' => 0 );
563         $versionList = eZPersistentObject::fetchObjectList( eZContentObjectVersion::definition(),
564                                                             array(),
565                                                             array( 'contentobject_id' => $contentObject->attribute( 'id' ) ),
566                                                             false,
567                                                             null,
568                                                             false,
569                                                             false,
570                                                             array( array( 'operation' => 'count( * )',
571                                                                           'name' => 'count' ) ) );
572         return array( 'result' => $versionList[0]['count'] );
573     }
574
575     static public function canInstantiateClassList( $groupID, $parentNode, $filterType = 'include', $fetchID, $asObject )
576     {
577         $ClassGroupIDs = false;
578
579         if ( is_numeric( $groupID ) && ( $groupID > 0 ) )
580         {
581             $ClassGroupIDs = array( $groupID );
582         }
583         else if( is_array( $groupID ) )
584         {
585             $ClassGroupIDs = $groupID;
586         }
587
588         if ( is_numeric( $parentNode ) )
589             $parentNode = eZContentObjectTreeNode::fetch( $parentNode );
590
591         if ( is_object( $parentNode ) )
592         {
593             $classList = $parentNode->canCreateClassList( $asObject, $filterType == 'include', $ClassGroupIDs, $fetchID );
594         }
595         else
596         {
597             $classList = eZContentClass::canInstantiateClassList( $asObject, $filterType == 'include', $ClassGroupIDs, $fetchID );
598         }
599
600         return array( 'result' => $classList );
601     }
602
603     static public function canInstantiateClasses( $parentNode )
604     {
605         if ( is_object( $parentNode ) )
606         {
607             $contentObject = $parentNode->attribute( 'object' );
608             return array( 'result' => $contentObject->attribute( 'can_create' ) );
609         }
610         return array( 'result' => eZContentClass::canInstantiateClasses() );
611     }
612
613     static public function contentobjectAttributes( $version, $languageCode )
614     {
615         if ( $languageCode == '' )
616         {
617             return array( 'result' => $version->contentObjectAttributes( ) );
618         }
619         else
620         {
621             return array( 'result' => $version->contentObjectAttributes( $languageCode ) );
622         }
623     }
624
625     static public function fetchBookmarks( $offset, $limit )
626     {
627         $user = eZUser::currentUser();
628         return array( 'result' => eZContentBrowseBookmark::fetchListForUser( $user->id(), $offset, $limit ) );
629     }
630
631     static public function fetchRecent()
632     {
633         $user = eZUser::currentUser();
634         return array( 'result' => eZContentBrowseRecent::fetchListForUser( $user->id() ) );
635     }
636
637     static public function fetchSectionList()
638     {
639         return array( 'result' => eZSection::fetchList() );
640     }
641
642     static public function fetchTipafriendTopList( $offset, $limit, $start_time, $end_time, $duration, $ascending, $extended )
643     {
644         $currentTime = time();
645         $conds = array();
646
647         if ( is_numeric( $start_time ) and is_numeric( $end_time ) )
648         {
649             $conds = array( 'requested' => array( false, array( $start_time, $end_time ) ) );
650         }
651         else if ( is_numeric( $start_time ) and is_numeric( $duration ) )
652         {
653             $conds = array( 'requested' => array( false, array( $start_time, $start_time + $duration ) ) );
654         }
655         else if ( is_numeric( $end_time ) and is_numeric( $duration ) )
656         {
657             $conds = array( 'requested' => array( false, array( $end_time - $duration, $end_time ) ) );
658         }
659         else if ( is_numeric( $start_time ) )
660         {
661             $conds = array( 'requested' => array( '>', $start_time ) );
662         }
663         else if ( is_numeric( $end_time ) )
664         {
665             $conds = array( 'requested' => array( '<', $end_time ) );
666         }
667         else if ( is_numeric( $duration ) )
668         {
669             // substract passed duration from current time timestamp to get start_time stamp
670             // end_timestamp is equal to current time in this case
671             $conds = array( 'requested' => array( '>', $currentTime - $duration ) );
672         }
673
674         $topList = eZPersistentObject::fetchObjectList( eZTipafriendCounter::definition(),
675                                                         array( 'node_id' ),
676                                                         $conds,
677                                                         array( 'count' => ( $ascending ? 'asc' : 'desc' ) ),
678                                                         array( 'length' => $limit, 'offset' => $offset ),
679                                                         false,
680                                                         array( 'node_id' ),
681                                                         array( array( 'operation' => 'count( * )',
682                                                                       'name' => 'count' ) ) );
683         if ( $extended )
684         {
685             foreach ( array_keys( $topList ) as $key )
686             {
687                 $contentNode = eZContentObjectTreeNode::fetch( $topList[ $key ][ 'node_id' ] );
688                 if ( !is_object( $contentNode ) )
689                     return array( 'error' => array( 'error_type' => 'kernel',
690                                                     'error_code' => eZError::KERNEL_NOT_FOUND ) );
691                 $topList[ $key ][ 'node' ] = $contentNode;
692             }
693             return array( 'result' => $topList );
694         }
695         else
696         {
697             $retList = array();
698             foreach ( $topList as $entry )
699             {
700                 $contentNode = eZContentObjectTreeNode::fetch( $entry[ 'node_id' ] );
701                 if ( !is_object( $contentNode ) )
702                     return array( 'error' => array( 'error_type' => 'kernel',
703                                                     'error_code' => eZError::KERNEL_NOT_FOUND ) );
704                 $retList[] = $contentNode;
705             }
706             return array( 'result' => $retList );
707         }
708
709     }
710
711     static public function fetchMostViewedTopList( $classID, $sectionID, $offset, $limit )
712     {
713         $topList = eZViewCounter::fetchTopList( $classID, $sectionID, $offset, $limit );
714         $contentNodeList = array();
715         foreach ( array_keys ( $topList ) as $key )
716         {
717             $nodeID = $topList[$key]['node_id'];
718             $contentNode = eZContentObjectTreeNode::fetch( $nodeID );
719             if ( $contentNode === null )
720                 return array( 'error' => array( 'error_type' => 'kernel',
721                                             'error_code' => eZError::KERNEL_NOT_FOUND ) );
722             $contentNodeList[] = $contentNode;
723         }
724         return array( 'result' => $contentNodeList );
725     }
726
727     static public function fetchCollectedInfoCount( $objectAttributeID, $objectID, $value, $creatorID = false, $userIdentifier = false )
728     {
729         return eZInfocollectorFunctionCollection::fetchCollectedInfoCount( $objectAttributeID, $objectID, $value, $creatorID, $userIdentifier );
730     }
731
732     static public function fetchCollectedInfoCountList( $objectAttributeID )
733     {
734         return eZInfocollectorFunctionCollection::fetchCollectedInfoCountList( $objectAttributeID );
735     }
736
737     static public function fetchCollectedInfoCollection( $collectionID, $contentObjectID )
738     {
739         return eZInfocollectorFunctionCollection::fetchCollectedInfoCollection( $collectionID, $contentObjectID );
740     }
741
742     static public function fetchCollectionsList( $objectID = false, $creatorID = false, $userIdentifier = false, $limit = false, $offset = false, $sortBy = false )
743     {
744         return eZInfocollectorFunctionCollection::fetchCollectionsList( $objectID,
745                                                                         $creatorID,
746                                                                         $userIdentifier,
747                                                                         $limit,
748                                                                         $offset,
749                                                                         $sortBy );
750      }
751
752     static public function fetchObjectByAttribute( $identifier )
753     {
754         $contentObjectAttribute = eZContentObjectAttribute::fetchByIdentifier( $identifier );
755         if ( $contentObjectAttribute === null )
756         {
757             $result = array( 'error' => array( 'error_type' => 'kernel',
758                                             'error_code' => eZError::KERNEL_NOT_FOUND ) );
759         }
760         else
761         {
762             $result = array( 'result' => $contentObjectAttribute->attribute( 'object' ) );
763         }
764         return $result;
765     }
766
767     static public function fetchObjectCountByUserID( $classID, $userID, $status = false )
768     {
769         $objectCount = eZContentObject::fetchObjectCountByUserID( $classID, $userID, $status );
770         return array( 'result' => $objectCount );
771     }
772
773     static public function fetchKeywordCount( $alphabet,
774                                 $classid,
775                                 $owner = false,
776                                 $parentNodeID = false,
777                                 $includeDuplicates = true,
778                                 $strictMatching = false )
779     {
780         $classIDArray = array();
781         if ( is_numeric( $classid ) )
782         {
783             $classIDArray = array( $classid );
784         }
785         else if ( is_array( $classid ) )
786         {
787             $classIDArray = $classid;
788         }
789
790         $showInvisibleNodesCond = eZContentObjectTreeNode::createShowInvisibleSQLString( true, false );
791         $limitation = false;
792         $limitationList = eZContentObjectTreeNode::getLimitationList( $limitation );
793         $sqlPermissionChecking = eZContentObjectTreeNode::createPermissionCheckingSQL( $limitationList );
794
795         $db = eZDB::instance();
796
797         $alphabet = $db->escapeString( $alphabet );
798
799         $sqlOwnerString = is_numeric( $owner ) ? "AND ezcontentobject.owner_id = '$owner'" : '';
800         $parentNodeIDString = is_numeric( $parentNodeID ) ? "AND ezcontentobject_tree.parent_node_id = '$parentNodeID'" : '';
801
802         $sqlClassIDs = '';
803         if ( $classIDArray != null )
804         {
805             $sqlClassIDs = 'AND ' . $db->generateSQLINStatement( $classIDArray, 'ezkeyword.class_id', false, false, 'int' ) . ' ';
806         }
807
808         $sqlToExcludeDuplicates = '';
809         if ( !$includeDuplicates )
810         {
811           //will use SELECT COUNT( DISTINCT ezcontentobject.id ) to count object only once even if it has
812           //several keywords started with $alphabet.
813           //COUNT( DISTINCT fieldName ) is SQL92 compliant syntax.
814             $sqlToExcludeDuplicates = ' DISTINCT';
815         }
816         // composing sql for matching tag word, it could be strict equiality or LIKE clause dependent of $strictMatching parameter.
817         $sqlMatching = "ezkeyword.keyword LIKE '$alphabet%'";
818         if ( $strictMatching )
819         {
820             $sqlMatching = "ezkeyword.keyword = '$alphabet'";
821         }
822
823         $query = "SELECT COUNT($sqlToExcludeDuplicates ezcontentobject.id) AS count
824                   FROM ezkeyword, ezkeyword_attribute_link,ezcontentobject_tree,ezcontentobject,ezcontentclass, ezcontentobject_attribute
825                        $sqlPermissionChecking[from]
826                   WHERE $sqlMatching
827                   $showInvisibleNodesCond
828                   $sqlPermissionChecking[where]
829                   $sqlClassIDs
830                   $sqlOwnerString
831                   $parentNodeIDString
832                   AND ezcontentclass.version=0
833                   AND ezcontentobject.status=".eZContentObject::STATUS_PUBLISHED."
834                   AND ezcontentobject_attribute.version=ezcontentobject.current_version
835                   AND ezcontentobject_tree.main_node_id=ezcontentobject_tree.node_id
836                   AND ezcontentobject_attribute.contentobject_id=ezcontentobject.id
837                   AND ezcontentobject_tree.contentobject_id = ezcontentobject.id
838                   AND ezcontentclass.id = ezcontentobject.contentclass_id
839                   AND ezcontentobject_attribute.id=ezkeyword_attribute_link.objectattribute_id
840                   AND ezkeyword_attribute_link.keyword_id = ezkeyword.id";
841
842         $keyWords = $db->arrayQuery( $query );
843         // cleanup temp tables
844         $db->dropTempTableList( $sqlPermissionChecking['temp_tables'] );
845
846         return array( 'result' => $keyWords[0]['count'] );
847     }
848
849     //
850     //Returns an array( 'result' => array( 'keyword' => keyword, 'link_object' => node_id );
851     //By default fetchKeyword gets a list of (not necessary unique) nodes and respective keyword strings
852     //Search keyword provided in $alphabet parameter.
853     //By default keyword matching implemented by LIKE so all keywords that starts with $alphabet
854     //will successfully match. This means that if some object have attached keywords:
855     //'Skien', 'Skien forests', 'Skien comunity' than fetchKeyword('Skien') will return tree entries
856     //for this object.
857     //Setting $includeDuplicates parameter to false makes fetchKeyword('Skien') to return just
858     //one entry for such objects.
859     static public function fetchKeyword( $alphabet,
860                            $classid,
861                            $offset,
862                            $limit,
863                            $owner = false,
864                            $sortBy = array(),
865                            $parentNodeID = false,
866                            $includeDuplicates = true,
867                            $strictMatching = false )
868     {
869         $classIDArray = array();
870         if ( is_numeric( $classid ) )
871         {
872             $classIDArray = array( $classid );
873         }
874         else if ( is_array( $classid ) )
875         {
876             $classIDArray = $classid;
877         }
878
879         $showInvisibleNodesCond = eZContentObjectTreeNode::createShowInvisibleSQLString( true, false );
880         $limitation = false;
881         $limitationList = eZContentObjectTreeNode::getLimitationList( $limitation );
882         $sqlPermissionChecking = eZContentObjectTreeNode::createPermissionCheckingSQL( $limitationList );
883
884         $db_params = array();
885         $db_params['offset'] = $offset;
886         $db_params['limit'] = $limit;
887
888         $keywordNodeArray = array();
889         $lastKeyword = '';
890
891         $db = eZDB::instance();
892
893         //in SELECT clause below we will use a full keyword value
894         //or just a part of ezkeyword.keyword matched to $alphabet respective to $includeDuplicates parameter.
895         //In the case $includeDuplicates = ture we need only a part
896         //of ezkeyword.keyword to be fetched in field to allow DISTINCT to remove rows with the same node id's
897         $sqlKeyword = 'ezkeyword.keyword';
898         if ( !$includeDuplicates )
899         {
900             $sqlKeyword = $db->subString('ezkeyword.keyword', 1, strlen( $alphabet ) ) . ' AS keyword ';
901         }
902
903         $alphabet = $db->escapeString( $alphabet );
904
905         $sortingInfo = array();
906         $sortingInfo['attributeFromSQL'] = ', ezcontentobject_attribute a1';
907         $sortingInfo['attributeWhereSQL'] = '';
908         $sqlTarget = $sqlKeyword.',ezcontentobject_tree.node_id';
909
910         if ( is_array( $sortBy ) && count ( $sortBy ) > 0 )
911         {
912             switch ( $sortBy[0] )
913             {
914                 case 'keyword':
915                 case 'name':
916                 {
917                     $sortingString = '';
918                     if ( $sortBy[0] == 'name' )
919                         $sortingString = 'ezcontentobject.name';
920                     elseif ( $sortBy[0] == 'keyword' )
921                         $sortingString = 'ezkeyword.keyword';
922
923                     $sortOrder = true; // true is ascending
924                     if ( isset( $sortBy[1] ) )
925                         $sortOrder = $sortBy[1];
926                     $sortingOrder = $sortOrder ? ' ASC' : ' DESC';
927                     $sortingInfo['sortingFields'] = $sortingString . $sortingOrder;
928                 } break;
929                 default:
930                 {
931                     $sortingInfo = eZContentObjectTreeNode::createSortingSQLStrings( $sortBy );
932
933                     if ( $sortBy[0] == 'attribute' )
934                     {
935                         // if sort_by is 'attribute' we should add ezcontentobject_name to "FromSQL" and link to ezcontentobject
936                         $sortingInfo['attributeFromSQL']  .= ', ezcontentobject_name, ezcontentobject_attribute a1';
937                         $sortingInfo['attributeWhereSQL'] .= ' ezcontentobject.id = ezcontentobject_name.contentobject_id AND';
938                         $sqlTarget = 'DISTINCT ezcontentobject_tree.node_id, '.$sqlKeyword;
939                     }
940                     else // for unique declaration
941                         $sortingInfo['attributeFromSQL']  .= ', ezcontentobject_attribute a1';
942
943                 } break;
944             }
945         }
946         else
947         {
948             $sortingInfo['sortingFields'] = 'ezkeyword.keyword ASC';
949         }
950         $sortingInfo['attributeWhereSQL'] .= " a1.version=ezcontentobject.current_version
951                                              AND a1.contentobject_id=ezcontentobject.id AND";
952
953         //Adding DISTINCT to avoid duplicates,
954         //check if DISTINCT keyword was added before providing clauses for sorting.
955         if ( !$includeDuplicates && substr( $sqlTarget, 0, 9) != 'DISTINCT ' )
956         {
957             $sqlTarget = 'DISTINCT ' . $sqlTarget;
958         }
959
960         $sqlOwnerString = is_numeric( $owner ) ? "AND ezcontentobject.owner_id = '$owner'" : '';
961         $parentNodeIDString = is_numeric( $parentNodeID ) ? "AND ezcontentobject_tree.parent_node_id = '$parentNodeID'" : '';
962
963         $sqlClassIDString = '';
964         if ( is_array( $classIDArray ) and count( $classIDArray ) )
965         {
966             $sqlClassIDString = 'AND ' . $db->generateSQLINStatement( $classIDArray, 'ezkeyword.class_id', false, false, 'int' ) . ' ';
967         }
968
969         // composing sql for matching tag word, it could be strict equiality or LIKE clause
970         // dependent of $strictMatching parameter.
971         $sqlMatching = "ezkeyword.keyword LIKE '$alphabet%'";
972         if ( $strictMatching )
973         {
974             $sqlMatching = "ezkeyword.keyword = '$alphabet'";
975         }
976
977         $query = "SELECT $sqlTarget
978                   FROM ezkeyword, ezkeyword_attribute_link,ezcontentobject_tree,ezcontentobject,ezcontentclass
979                        $sortingInfo[attributeFromSQL]
980                        $sqlPermissionChecking[from]
981                   WHERE
982                   $sortingInfo[attributeWhereSQL]
983                   $sqlMatching
984                   $showInvisibleNodesCond
985                   $sqlPermissionChecking[where]
986                   $sqlClassIDString
987                   $sqlOwnerString
988                   $parentNodeIDString
989                   AND ezcontentclass.version=0
990                   AND ezcontentobject.status=".eZContentObject::STATUS_PUBLISHED."
991                   AND ezcontentobject_tree.main_node_id=ezcontentobject_tree.node_id
992                   AND ezcontentobject_tree.contentobject_id = ezcontentobject.id
993                   AND ezcontentclass.id = ezcontentobject.contentclass_id
994                   AND a1.id=ezkeyword_attribute_link.objectattribute_id
995                   AND ezkeyword_attribute_link.keyword_id = ezkeyword.id ORDER BY {$sortingInfo['sortingFields']}";
996
997         $keyWords = $db->arrayQuery( $query, $db_params );
998
999         $trans = eZCharTransform::instance();
1000
1001         foreach ( $keyWords as $keywordArray )
1002         {
1003             $keyword = $keywordArray['keyword'];
1004             $nodeID = $keywordArray['node_id'];
1005             $nodeObject = eZContentObjectTreeNode::fetch( $nodeID );
1006
1007             if ( $nodeObject != null )
1008             {
1009                 $keywordLC = $trans->transformByGroup( $keyword, 'lowercase' );
1010                 if ( $lastKeyword == $keywordLC )
1011                     $keywordNodeArray[] = array( 'keyword' => '', 'link_object' => $nodeObject );
1012                 else
1013                     $keywordNodeArray[] = array( 'keyword' => $keyword, 'link_object' => $nodeObject );
1014
1015                 $lastKeyword = $keywordLC;
1016             }
1017             else
1018             {
1019                 $lastKeyword = $trans->transformByGroup( $keyword, 'lowercase' );
1020             }
1021         }
1022         return array( 'result' => $keywordNodeArray );
1023     }
1024
1025     static public function fetchSameClassAttributeNodeList( $contentclassattributeID, $value, $datatype )
1026     {
1027         if ( $datatype == "int" )
1028              $type = "data_int";
1029         else if ( $datatype == "float" )
1030              $type = "data_float";
1031         else if ( $datatype == "text" )
1032              $type = "data_text";
1033         else
1034         {
1035             eZDebug::writeError( "DatatypeString not supported in fetch same_classattribute_node, use int, float or text" );
1036             return false;
1037         }
1038         $db = eZDB::instance();
1039         $contentclassattributeID =(int) $contentclassattributeID;
1040         $value = $db->escapeString( $value );
1041         if ( $datatype != "text" )
1042             settype( $value, $datatype );
1043         $resultNodeArray = array();
1044         $nodeList = $db->arrayQuery( "SELECT ezcontentobject_tree.node_id, ezcontentobject.name, ezcontentobject_tree.parent_node_id
1045                                             FROM ezcontentobject_tree, ezcontentobject, ezcontentobject_attribute
1046                                            WHERE ezcontentobject_attribute.$type='$value'
1047                                              AND ezcontentobject_attribute.contentclassattribute_id='$contentclassattributeID'
1048                                              AND ezcontentobject_attribute.contentobject_id=ezcontentobject.id
1049                                              AND ezcontentobject_attribute.version=ezcontentobject.current_version
1050                                              AND ezcontentobject_tree.contentobject_version=ezcontentobject.current_version
1051                                              AND ezcontentobject_tree.contentobject_id=ezcontentobject.id
1052                                         ORDER BY ezcontentobject.name");
1053
1054         foreach ( $nodeList as $nodeObject )
1055         {
1056             $nodeID = $nodeObject['node_id'];
1057             $node = eZContentObjectTreeNode::fetch( $nodeID );
1058             $resultNodeArray[] = $node;
1059         }
1060         return array( 'result' => $resultNodeArray );
1061     }
1062
1063     static public function checkAccess( $access, $contentObject, $contentClassID, $parentContentClassID, $languageCode = false )
1064     {
1065         if ( $contentObject instanceof eZContentObjectTreeNode )
1066         {
1067             $contentObject = $contentObject->attribute( 'object' );
1068         }
1069         if (  $contentClassID !== false and !is_numeric( $contentClassID ) )
1070         {
1071             $class = eZContentClass::fetchByIdentifier( $contentClassID );
1072             if ( !$class )
1073                 return array( 'error' => array( 'error_type' => 'kernel',
1074                                                 'error_code' => eZError::KERNEL_NOT_FOUND ) );
1075             $contentClassID = $class->attribute( 'id' );
1076         }
1077         if ( $access and $contentObject instanceof eZContentObject )
1078         {
1079             $result = $contentObject->checkAccess( $access, $contentClassID, $parentContentClassID, false, $languageCode );
1080             return array( 'result' => $result );
1081         }
1082     }
1083
1084     // Fetches all navigation parts as an array
1085     static public function fetchNavigationParts()
1086     {
1087         return array( 'result' => eZNavigationPart::fetchList() );
1088     }
1089
1090     // Fetches one navigation parts by identifier
1091     static public function fetchNavigationPart( $identifier )
1092     {
1093         return array( 'result' => eZNavigationPart::fetchPartByIdentifier( $identifier ) );
1094     }
1095
1096     static public function contentobjectRelationTypeMask( $contentObjectRelationTypes = false )
1097     {
1098         $relationTypeMask = 0;
1099         if ( is_array( $contentObjectRelationTypes ) )
1100         {
1101             $relationTypeMap = array( 'common'    => eZContentObject::RELATION_COMMON,
1102                                       'xml_embed' => eZContentObject::RELATION_EMBED,
1103                                       'xml_link'  => eZContentObject::RELATION_LINK,
1104                                       'attribute' => eZContentObject::RELATION_ATTRIBUTE );
1105             foreach ( $contentObjectRelationTypes as $relationType )
1106             {
1107                 if ( isset( $relationTypeMap[$relationType] ) )
1108                 {
1109                     $relationTypeMask |= $relationTypeMap[$relationType];
1110                 }
1111                 else
1112                 {
1113                     eZDebug::writeWarning( "Unknown relation type: '$relationType'.", "eZContentFunctionCollection::contentobjectRelationTypeMask()" );
1114                 }
1115             }
1116         }
1117         elseif ( !is_bool( $contentObjectRelationTypes ) )
1118         {
1119             $contentObjectRelationTypes = false;
1120         }
1121
1122         if ( is_bool( $contentObjectRelationTypes ) )
1123         {
1124             $relationTypeMask = eZContentObject::relationTypeMask( $contentObjectRelationTypes );
1125         }
1126
1127         return $relationTypeMask;
1128     }
1129
1130     // Fetches related objects id grouped by relation types
1131     static public function fetchRelatedObjectsID( $objectID, $attributeID, $allRelations)
1132     {
1133         if ( !is_array( $allRelations ) || $allRelations === array() )
1134         {
1135             $allRelations = array( 'common', 'xml_embed', 'attribute' );
1136             if ( eZContentObject::isObjectRelationTyped() )
1137             {
1138                 $allRelations[] = 'xml_link';
1139             }
1140         }
1141
1142         $relatedObjectsTyped = array();
1143         foreach ( $allRelations as $relationType )
1144         {
1145             $relatedObjectsTyped[$relationType] =
1146                 eZContentFunctionCollection::fetchRelatedObjects( $objectID, $attributeID, array( $relationType ), false, array() );
1147         }
1148
1149         $relatedObjectsTypedIDArray = array();
1150         foreach ( $relatedObjectsTyped as $relationTypeName => $relatedObjectsByType )
1151         {
1152             $relatedObjectsTypedIDArray[$relationTypeName] = array();
1153             foreach ( $relatedObjectsByType['result'] as $relatedObjectByType )
1154             {
1155                 $relatedObjectsTypedIDArray[$relationTypeName][] = $relatedObjectByType->ID;
1156             }
1157         }
1158
1159         return array( 'result' => $relatedObjectsTypedIDArray );
1160     }
1161
1162     // Fetches reverse related objects id grouped by relation types
1163     static public function fetchReverseRelatedObjectsID( $objectID, $attributeID, $allRelations )
1164     {
1165         if ( !is_array( $allRelations ) || $allRelations === array() )
1166         {
1167             $allRelations = array( 'common', 'xml_embed', 'attribute' );
1168             if ( eZContentObject::isObjectRelationTyped() )
1169             {
1170                 $allRelations[] = 'xml_link';
1171             }
1172         }
1173
1174         $relatedObjectsTyped = array();
1175         foreach ( $allRelations as $relationType )
1176         {
1177             $relatedObjectsTyped[$relationType] =
1178                 eZContentFunctionCollection::fetchReverseRelatedObjects( $objectID, $attributeID, array( $relationType ), false, array(), null );
1179         }
1180
1181         $relatedObjectsTypedIDArray = array();
1182         foreach ( $relatedObjectsTyped as $relationTypeName => $relatedObjectsByType )
1183         {
1184             $relatedObjectsTypedIDArray[$relationTypeName] = array();
1185             foreach ( $relatedObjectsByType['result'] as $relatedObjectByType )
1186             {
1187                 $relatedObjectsTypedIDArray[$relationTypeName][] = $relatedObjectByType->ID;
1188             }
1189         }
1190
1191         return array( 'result' =>$relatedObjectsTypedIDArray );
1192     }
1193
1194     // Fetches reverse related objects
1195     static public function fetchRelatedObjects( $objectID, $attributeID, $allRelations, $groupByAttribute, $sortBy, $limit = false, $offset = false, $asObject = true, $loadDataMap = false, $ignoreVisibility = null )
1196     {
1197         if ( !is_numeric( $objectID ) )
1198         {
1199             eZDebug::writeError( "ObjectID is missing or invalid", __METHOD__ );
1200             return false;
1201         }
1202
1203         $object = eZContentObject::fetch( $objectID );
1204         if ( !$object instanceof eZContentObject )
1205         {
1206             eZDebug::writeError( "An error occured fetching object #$objectID", __METHOD__ );
1207             return false;
1208         }
1209
1210         $params = array();
1211         $params['Limit'] = $limit;
1212         $params['Offset'] = $offset;
1213         $params['AsObject'] = $asObject;
1214         $params['LoadDataMap'] = $loadDataMap;
1215
1216         if ( $sortBy )
1217         {
1218             if ( is_array( $sortBy ) )
1219             {
1220                 $params['SortBy'] = $sortBy;
1221             }
1222             else
1223             {
1224                 eZDebug::writeError( "Function parameter 'SortBy' should be an array.", 'content/fetchRelatedObjects' );
1225             }
1226         }
1227
1228         if ( $ignoreVisibility !== null )
1229         {
1230             $params['IgnoreVisibility'] = $ignoreVisibility;
1231         }
1232
1233         if ( !$attributeID )
1234         {
1235             $attributeID = 0;
1236         }
1237
1238         if ( isset( $allRelations ) )
1239         {
1240             if ( $attributeID && !$allRelations )
1241             {
1242                 $params['AllRelations'] = eZContentFunctionCollection::contentobjectRelationTypeMask( array( 'attribute' ) );
1243             }
1244             elseif( $allRelations === true )
1245             {
1246                 $attributeID = false;
1247             }
1248             else
1249             {
1250                 $params['AllRelations'] = eZContentFunctionCollection::contentobjectRelationTypeMask( $allRelations );
1251             }
1252         }
1253
1254         if ( $attributeID && !is_numeric( $attributeID ) && !is_bool( $attributeID ) )
1255         {
1256             $attributeID = eZContentObjectTreeNode::classAttributeIDByIdentifier( $attributeID );
1257             if ( !$attributeID )
1258             {
1259                 eZDebug::writeError( "Can't get class attribute ID by identifier" );
1260                 return false;
1261             }
1262         }
1263
1264         return array( 'result' => $object->relatedContentObjectList( false, $objectID, $attributeID, $groupByAttribute, $params ) );
1265     }
1266
1267         // Fetches count of reverse related objects
1268     static public function fetchRelatedObjectsCount( $objectID, $attributeID, $allRelations )
1269     {
1270         if ( !is_numeric( $objectID ) )
1271         {
1272             eZDebug::writeError( "ObjectID is missing", __METHOD__ );
1273             return false;
1274         }
1275
1276         $object = eZContentObject::fetch( $objectID );
1277         if ( !$object instanceof eZContentObject )
1278         {
1279             eZDebug::writeError( "An error occured fetching object #$objectID", __METHOD__ );
1280             return false;
1281         }
1282
1283         $params=array();
1284         if ( !$attributeID )
1285         {
1286             $attributeID = 0;
1287         }
1288
1289         if ( isset( $allRelations ) )
1290         {
1291             if ( $attributeID && !$allRelations )
1292             {
1293                 $params['AllRelations'] = eZContentFunctionCollection::contentobjectRelationTypeMask( array( 'attribute' ) );
1294             }
1295             elseif( $allRelations === true )
1296             {
1297                 $attributeID = false;
1298             }
1299             else
1300             {
1301                 $params['AllRelations'] = eZContentFunctionCollection::contentobjectRelationTypeMask( $allRelations );
1302             }
1303         }
1304
1305         if ( $attributeID && !is_numeric( $attributeID ) && !is_bool( $attributeID ) )
1306         {
1307             $attributeID = eZContentObjectTreeNode::classAttributeIDByIdentifier( $attributeID );
1308             if ( !$attributeID )
1309             {
1310                 eZDebug::writeError( "Can't get class attribute ID by identifier" );
1311                 return false;
1312             }
1313         }
1314
1315         return array( 'result' => $object->relatedContentObjectCount( false, $attributeID, $params ) );
1316     }
1317
1318     static public function fetchReverseRelatedObjects( $objectID, $attributeID, $allRelations, $groupByAttribute, $sortBy, $ignoreVisibility,  $limit = false, $offset = false, $asObject = true, $loadDataMap = false  )
1319     {
1320         if ( !$objectID or !is_numeric( $objectID ) )
1321         {
1322             eZDebug::writeDebug( "Missing or incorrect \$objectID parameter", __METHOD__ );
1323             return false;
1324         }
1325
1326         $object = eZContentObject::fetch( $objectID );
1327         if ( !$object instanceof eZContentObject )
1328         {
1329             eZDebug::writeError( "An error occured fetching object #$objectID", __METHOD__ );
1330             return false;
1331         }
1332
1333         $params = array();
1334         $params['Limit'] = $limit;
1335         $params['Offset'] = $offset;
1336         $params['AsObject'] = $asObject;
1337         $params['LoadDataMap'] = $loadDataMap;
1338
1339         if ( $sortBy )
1340         {
1341             if ( is_array( $sortBy ) )
1342             {
1343                 $params['SortBy'] = $sortBy;
1344             }
1345             else
1346             {
1347                 eZDebug::writeError( "Function parameter 'SortBy' should be an array.", 'content/fetchReverseRelatedObjects' );
1348             }
1349         }
1350         if ( isset( $ignoreVisibility ) )
1351         {
1352             $params['IgnoreVisibility'] = $ignoreVisibility;
1353         }
1354         if ( !$attributeID )
1355         {
1356             $attributeID = 0;
1357         }
1358
1359         if ( isset( $allRelations ) )
1360         {
1361             if ( $attributeID && !$allRelations )
1362             {
1363                 $params['AllRelations'] = eZContentFunctionCollection::contentobjectRelationTypeMask( array( 'attribute' ) );
1364             }
1365             elseif( $allRelations === true )
1366             {
1367                 $attributeID = false;
1368             }
1369             else
1370             {
1371                 $params['AllRelations'] = eZContentFunctionCollection::contentobjectRelationTypeMask( $allRelations );
1372             }
1373         }
1374
1375         if ( $attributeID && !is_numeric( $attributeID ) && !is_bool( $attributeID ) )
1376         {
1377             $attributeID = eZContentObjectTreeNode::classAttributeIDByIdentifier( $attributeID );
1378             if ( !$attributeID )
1379             {
1380                 eZDebug::writeError( "Can't get class attribute ID by identifier" );
1381                 return false;
1382             }
1383         }
1384         return array( 'result' => $object->reverseRelatedObjectList( false, $attributeID, $groupByAttribute, $params ) );
1385     }
1386
1387     // Fetches count of reverse related objects
1388     static public function fetchReverseRelatedObjectsCount( $objectID, $attributeID, $allRelations, $ignoreVisibility  )
1389     {
1390         if ( !is_numeric( $objectID ) )
1391         {
1392             eZDebug::writeError( "\$objectID is missing or invalid", __METHOD__ );
1393             return false;
1394         }
1395
1396         $object = eZContentObject::fetch( $objectID );
1397         if ( !$object instanceof eZContentObject )
1398         {
1399             eZDebug::writeError( "An error occured fetching object #$objectID", __METHOD__ );
1400             return false;
1401         }
1402
1403         $params = array();
1404         if ( isset( $ignoreVisibility ) )
1405         {
1406             $params['IgnoreVisibility'] = $ignoreVisibility;
1407         }
1408
1409         if ( !$attributeID )
1410         {
1411             $attributeID = 0;
1412         }
1413
1414         if ( isset( $allRelations ) )
1415         {
1416             if ( $attributeID && !$allRelations )
1417             {
1418                 $params['AllRelations'] = eZContentFunctionCollection::contentobjectRelationTypeMask( array( 'attribute' ) );
1419             }
1420             elseif( $allRelations === true )
1421             {
1422                 $attributeID = false;
1423             }
1424             else
1425             {
1426                 $params['AllRelations'] = eZContentFunctionCollection::contentobjectRelationTypeMask( $allRelations );
1427             }
1428         }
1429
1430         if ( $attributeID && !is_numeric( $attributeID ) && !is_bool( $attributeID ) )
1431         {
1432             $attributeID = eZContentObjectTreeNode::classAttributeIDByIdentifier( $attributeID );
1433             if ( !$attributeID )
1434             {
1435                 eZDebug::writeError( "Can't get class attribute ID by identifier" );
1436                 return false;
1437             }
1438         }
1439         return array( 'result' => $object->reverseRelatedObjectCount( false, $attributeID, $params ) );
1440     }
1441
1442     static public function fetchAvailableSortFieldList()
1443     {
1444         return array( 'result' => array( '6' => ezpI18n::translate( 'kernel/content', 'Class identifier' ),
1445                                          '7' => ezpI18n::translate( 'kernel/content', 'Class name' ),
1446                                          '5' => ezpI18n::translate( 'kernel/content', 'Depth' ),
1447                                          '3' => ezpI18n::translate( 'kernel/content', 'Modified' ),
1448                                          '9' => ezpI18n::translate( 'kernel/content', 'Name' ),
1449                                          '1' => ezpI18n::translate( 'kernel/content', 'Path String' ),
1450                                          '8' => ezpI18n::translate( 'kernel/content', 'Priority' ),
1451                                          '2' => ezpI18n::translate( 'kernel/content', 'Published' ),
1452                                          '4' => ezpI18n::translate( 'kernel/content', 'Section' ) ) );
1453     }
1454
1455     static public function fetchCountryList( $filter, $value )
1456     {
1457         // Fetch country list
1458         if ( !$filter and !$value )
1459         {
1460             $country = eZCountryType::fetchCountryList();
1461         }
1462         else
1463         {
1464             $country = eZCountryType::fetchCountry( $value, $filter );
1465         }
1466
1467         return array( 'result' => $country );
1468     }
1469
1470     static public function fetchContentTreeMenuExpiry()
1471     {
1472         eZExpiryHandler::registerShutdownFunction();
1473
1474         $expiryHandler = eZExpiryHandler::instance();
1475
1476         if ( !$expiryHandler->hasTimestamp( 'content-tree-menu' ) )
1477         {
1478             $expiryHandler->setTimestamp( 'content-tree-menu', time() );
1479             $expiryHandler->store();
1480         }
1481
1482         return array( 'result' => $expiryHandler->timestamp( 'content-tree-menu' ) );
1483     }
1484 }
1485
1486 ?>