- Fixed #16160: Call to undefined function ezi18n()
[tinyz:tinyz.git] / kernel / classes / datatypes / ezkeyword / ezkeywordtype.php
1 <?php
2 //
3 // Definition of eZKeywordType class
4 //
5 // Created on: <29-Apr-2003 14:59:12 bf>
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 /*!
32   \class eZKeywordType ezkeywordtype.php
33   \ingroup eZDatatype
34   \brief A content datatype which handles keyword indexes
35
36 */
37
38
39
40 class eZKeywordType extends eZDataType
41 {
42     const DATA_TYPE_STRING = 'ezkeyword';
43
44     /*!
45      Initializes with a keyword id and a description.
46     */
47     function eZKeywordType()
48     {
49         $this->eZDataType( self::DATA_TYPE_STRING, ezpI18n::translate( 'kernel/classes/datatypes', 'Keywords', 'Datatype name' ),
50                            array( 'serialize_supported' => true ) );
51     }
52
53     /*!
54      Sets the default value.
55     */
56     function initializeObjectAttribute( $contentObjectAttribute, $currentVersion, $originalContentObjectAttribute )
57     {
58         if ( $currentVersion != false )
59         {
60             $originalContentObjectAttributeID = $originalContentObjectAttribute->attribute( 'id' );
61             $contentObjectAttributeID = $contentObjectAttribute->attribute( 'id' );
62
63             // if translating or copying an object
64             if ( $originalContentObjectAttributeID != $contentObjectAttributeID )
65             {
66                 // copy keywords links as well
67                 $keyword = $originalContentObjectAttribute->content();
68                 if ( is_object( $keyword ) )
69                 {
70                     $keyword->store( $contentObjectAttribute );
71                 }
72             }
73         }
74     }
75
76     /*!
77      Validates the input and returns true if the input was
78      valid for this datatype.
79     */
80     function validateObjectAttributeHTTPInput( $http, $base, $contentObjectAttribute )
81     {
82         $classAttribute = $contentObjectAttribute->contentClassAttribute();
83
84         if ( $http->hasPostVariable( $base . '_ezkeyword_data_text_' . $contentObjectAttribute->attribute( 'id' ) ) )
85         {
86             $data = $http->postVariable( $base . '_ezkeyword_data_text_' . $contentObjectAttribute->attribute( 'id' ) );
87
88             if ( $data == "" )
89             {
90                 if ( !$classAttribute->attribute( 'is_information_collector' ) and $contentObjectAttribute->validateIsRequired() )
91                 {
92                     $contentObjectAttribute->setValidationError( ezpI18n::translate( 'kernel/classes/datatypes',
93                                                                          'Input required.' ) );
94                     return eZInputValidator::STATE_INVALID;
95                 }
96             }
97         }
98         else if ( !$classAttribute->attribute( 'is_information_collector' ) and $contentObjectAttribute->validateIsRequired() )
99         {
100             $contentObjectAttribute->setValidationError( ezpI18n::translate( 'kernel/classes/datatypes', 'Input required.' ) );
101             return eZInputValidator::STATE_INVALID;
102         }
103         return eZInputValidator::STATE_ACCEPTED;
104     }
105
106     /*!
107      Fetches the http post var keyword input and stores it in the data instance.
108     */
109     function fetchObjectAttributeHTTPInput( $http, $base, $contentObjectAttribute )
110     {
111         if ( $http->hasPostVariable( $base . '_ezkeyword_data_text_' . $contentObjectAttribute->attribute( 'id' ) ) )
112         {
113             $data = $http->postVariable( $base . '_ezkeyword_data_text_' . $contentObjectAttribute->attribute( 'id' ) );
114             $keyword = new eZKeyword();
115             $keyword->initializeKeyword( $data );
116             $contentObjectAttribute->setContent( $keyword );
117             return true;
118         }
119         return false;
120     }
121
122     /*!
123      Does nothing since it uses the data_text field in the content object attribute.
124      See fetchObjectAttributeHTTPInput for the actual storing.
125     */
126     function storeObjectAttribute( $attribute )
127     {
128         // create keyword index
129         $keyword = $attribute->content();
130         if ( is_object( $keyword ) )
131         {
132             $keyword->store( $attribute );
133         }
134     }
135
136     function storeClassAttribute( $attribute, $version )
137     {
138     }
139
140     function storeDefinedClassAttribute( $attribute )
141     {
142     }
143
144     function validateClassAttributeHTTPInput( $http, $base, $attribute )
145     {
146         return eZInputValidator::STATE_ACCEPTED;
147     }
148
149     function fixupClassAttributeHTTPInput( $http, $base, $attribute )
150     {
151     }
152
153     function fetchClassAttributeHTTPInput( $http, $base, $attribute )
154     {
155         return true;
156     }
157
158     /*!
159      Returns the content.
160     */
161     function objectAttributeContent( $attribute )
162     {
163         $keyword = new eZKeyword();
164         $keyword->fetch( $attribute );
165
166         return $keyword;
167     }
168
169     /*!
170      Returns the meta data used for storing search indeces.
171     */
172     function metaData( $attribute )
173     {
174         $keyword = new eZKeyword();
175         $keyword->fetch( $attribute );
176         $return = $keyword->keywordString();
177
178         return $return;
179     }
180
181     /*!
182      \return the collect information action if enabled
183     */
184     function contentActionList( $classAttribute )
185     {
186         return array();
187     }
188
189     /*!
190      Delete stored object attribute
191     */
192     function deleteStoredObjectAttribute( $contentObjectAttribute, $version = null )
193     {
194         if ( $version != null ) // Do not delete if discarding draft
195         {
196             return;
197         }
198
199         $contentObjectAttributeID = $contentObjectAttribute->attribute( "id" );
200
201         $db = eZDB::instance();
202
203         /* First we retrieve all the keyword ID related to this object attribute */
204         $res = $db->arrayQuery( "SELECT keyword_id
205                                  FROM ezkeyword_attribute_link
206                                  WHERE objectattribute_id='$contentObjectAttributeID'" );
207         if ( !count ( $res ) )
208         {
209             /* If there are no keywords at all, we abort the function as there
210              * is nothing more to do */
211             return;
212         }
213         $keywordIDs = array();
214         foreach ( $res as $record )
215             $keywordIDs[] = $record['keyword_id'];
216         $keywordIDString = implode( ', ', $keywordIDs );
217
218         /* Then we see which ones only have a count of 1 */
219         $res = $db->arrayQuery( "SELECT keyword_id
220                                  FROM ezkeyword, ezkeyword_attribute_link
221                                  WHERE ezkeyword.id = ezkeyword_attribute_link.keyword_id
222                                      AND ezkeyword.id IN ($keywordIDString)
223                                  GROUP BY keyword_id
224                                  HAVING COUNT(*) = 1" );
225         $unusedKeywordIDs = array();
226         foreach ( $res as $record )
227             $unusedKeywordIDs[] = $record['keyword_id'];
228         $unusedKeywordIDString = implode( ', ', $unusedKeywordIDs );
229
230         /* Then we delete those unused keywords */
231         if ( $unusedKeywordIDString )
232             $db->query( "DELETE FROM ezkeyword WHERE id IN ($unusedKeywordIDString)" );
233
234         /* And as last we remove the link between the keyword and the object
235          * attribute to be removed */
236         $db->query( "DELETE FROM ezkeyword_attribute_link
237                      WHERE objectattribute_id='$contentObjectAttributeID'" );
238     }
239
240     /*!
241      Returns the content of the keyword for use as a title
242     */
243     function title( $attribute, $name = null )
244     {
245         $keyword = new eZKeyword();
246         $keyword->fetch( $attribute );
247         $return = $keyword->keywordString();
248
249         return $return;
250     }
251
252     function hasObjectAttributeContent( $contentObjectAttribute )
253     {
254         $keyword = new eZKeyword();
255         $keyword->fetch( $contentObjectAttribute );
256         $array = $keyword->keywordArray();
257
258         return count( $array ) > 0;
259     }
260
261     function isIndexable()
262     {
263         return true;
264     }
265
266     /*!
267      \return string representation of an contentobjectattribute data for simplified export
268
269     */
270     function toString( $contentObjectAttribute )
271     {
272         $keyword = new eZKeyword();
273         $keyword->fetch( $contentObjectAttribute  );
274         return  $keyword->keywordString();
275     }
276
277     function fromString( $contentObjectAttribute, $string )
278     {
279         if ( $string != '' )
280         {
281             $keyword = new eZKeyword();
282             $keyword->initializeKeyword( $string );
283             $contentObjectAttribute ->setContent( $keyword );
284         }
285         return true;
286     }
287
288     function serializeContentObjectAttribute( $package, $objectAttribute )
289     {
290         $node = $this->createContentObjectAttributeDOMNode( $objectAttribute );
291
292         $keyword = new eZKeyword();
293         $keyword->fetch( $objectAttribute );
294         $keyWordString = $keyword->keywordString();
295         $dom = $node->ownerDocument;
296         $keywordStringNode = $dom->createElement( 'keyword-string' );
297         $keywordStringNode->appendChild( $dom->createTextNode( $keyWordString ) );
298         $node->appendChild( $keywordStringNode );
299
300         return $node;
301     }
302
303     function unserializeContentObjectAttribute( $package, $objectAttribute, $attributeNode )
304     {
305         $keyWordString = $attributeNode->getElementsByTagName( 'keyword-string' )->item( 0 )->textContent;
306         $keyword = new eZKeyword();
307         $keyword->initializeKeyword( $keyWordString );
308         $objectAttribute->setContent( $keyword );
309     }
310
311     function supportsBatchInitializeObjectAttribute()
312     {
313         return true;
314     }
315 }
316
317 eZDataType::register( eZKeywordType::DATA_TYPE_STRING, 'eZKeywordType' );
318
319 ?>