Subversion Repositories regexpline_backup

[/] [stable/] [2.0/] [datatypes/] [hmregexpline/] [hmregexplinetype.php] - Blame information for rev 3

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 3 xrow
<?php
2
 
3
/*
4
    Regular Expression datatype for eZ publish 3.x
5
    Copyright (C) 2005-2006  Hans Melis
6
 
7
    This program is free software; you can redistribute it and/or modify
8
    it under the terms of the GNU General Public License as published by
9
    the Free Software Foundation; either version 2 of the License, or
10
    (at your option) any later version.
11
 
12
    This program is distributed in the hope that it will be useful,
13
    but WITHOUT ANY WARRANTY; without even the implied warranty of
14
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
    GNU General Public License for more details.
16
*/
17
 
18
/*!
19
  \class   hmregexplinetype hmregexplinetype.php
20
  \ingroup eZDatatype
21
  \brief   Handles the datatype regexpline
22
  \version 2.0
23
  \date    Wednesday 01 March 2006 17:19:23 pm
24
  \author  Hans Melis
25
 
26
  By using regexpline you can ... do stuff :)
27
 
28
*/
29
 
30
include_once( 'kernel/classes/ezdatatype.php' );
31
 
32
include_once( 'kernel/common/i18n.php' );
33
 
34
define( 'EZ_DATATYPESTRING_REGEXPLINE', 'hmregexpline' );
35
 
36
class hmregexplinetype extends eZDataType
37
{
38
    /*!
39
      Constructor
40
    */
41
    function hmregexplinetype()
42
    {
43
        $this->eZDataType( EZ_DATATYPESTRING_REGEXPLINE,
44
                           ezi18n( 'extension/regexpline/datatype', 'Regular Expression Text', 'Datatype name' ),
45
                           array( 'serialize_supported' => true ) );
46
    }
47
 
48
    /*!
49
    Validates all variables given on content class level
50
     \return EZ_INPUT_VALIDATOR_STATE_ACCEPTED or EZ_INPUT_VALIDATOR_STATE_INVALID if
51
             the values are accepted or not
52
    */
53
    function validateClassAttributeHTTPInput( &$http, $base, &$classAttribute )
54
    {
55
        $regexpName = $base . "_hmregexpline_regexp_" . $classAttribute->attribute( 'id' );
56
        $presetName = $base . "_hmregexpline_preset_" . $classAttribute->attribute( 'id' );
57
 
58
        $regexp = $preset = array();
59
 
60
        if( $http->hasPostVariable( $regexpName ) )
61
        {
62
            $regexp = $http->postVariable( $regexpName );
63
        }
64
 
65
        if( $http->hasPostVariable( $presetName ) )
66
        {
67
            $preset = $http->postVariable( $presetName );
68
        }
69
 
70
        $content = array( 'regexp' => $regexp,
71
                          'preset' => $preset );
72
        $regexp = $this->getRegularExpression( $content );
73
 
74
        foreach( $regexp as $expr )
75
        {
76
            $check = @preg_match( $expr, 'Dummy string' );
77
 
78
            if( $check === false )
79
            {
80
                return EZ_INPUT_VALIDATOR_STATE_INVALID;
81
            }
82
        }
83
 
84
        return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
85
    }
86
 
87
    /*!
88
     Fetches all variables inputed on content class level
89
     \return true if fetching of class attributes are successfull, false if not
90
    */
91
    function fetchClassAttributeHTTPInput( &$http, $base, &$classAttribute )
92
    {
93
        $regexpName = $base . "_hmregexpline_regexp_" . $classAttribute->attribute( 'id' );
94
        $errorsName = $base . "_hmregexpline_errmsg_" . $classAttribute->attribute( 'id' );
95
        $helpName = $base . "_hmregexpline_helptext_" . $classAttribute->attribute( 'id' );
96
        $patternName = $base . "_hmregexpline_namepattern_" . $classAttribute->attribute( 'id' );
97
        $presetName = $base . "_hmregexpline_preset_" . $classAttribute->attribute( 'id' );
98
        $displayName = $base . "_hmregexpline_display_"  . $classAttribute->attribute( 'id' );
99
 
100
        $content = $classAttribute->content();
101
 
102
        if( $http->hasPostVariable( $regexpName ) )
103
        {
104
            $content['regexp'] = $http->postVariable( $regexpName );
105
        }
106
 
107
        if( $http->hasPostVariable( $errorsName ) )
108
        {
109
            $content['error_messages'] = $http->postVariable( $errorsName );
110
        }
111
 
112
        if( $http->hasPostVariable( $presetName ) )
113
        {
114
            $content['preset'] = $http->postVariable( $presetName );
115
        }
116
        else if( $http->hasPostVariable( 'ContentClassHasInput' ) )
117
        {
118
            $content['preset'] = array();
119
        }
120
 
121
        if( $http->hasPostVariable( $helpName ) )
122
        {
123
            $content['help_text'] = $http->postVariable( $helpName );
124
        }
125
 
126
        if( $http->hasPostVariable( $patternName ) )
127
        {
128
            $content['naming_pattern'] = $http->postVariable( $patternName );
129
        }
130
        else if( $http->hasPostVariable( 'ContentClassHasInput' ) )
131
        {
132
            $content['naming_pattern'] = '';
133
        }
134
 
135
        if( $http->hasPostVariable( $displayName ) )
136
        {
137
            $content['display_type'] = $http->postVariable( $displayName );
138
        }
139
        else if( $http->hasPostVariable( 'ContentClassHasInput' ) )
140
        {
141
            $content['display_type'] = 'line'; // default
142
        }
143
 
144
        $regexp = $this->getRegularExpression( $content );
145
        $subPatternCount = 0;
146
        $subPatterns = array();
147
 
148
        foreach( $regexp as $expr )
149
        {        
150
            $subPatternCount += @preg_match_all( "/\((?!\?\:)(.*)\)/U", $expr, $matches, PREG_PATTERN_ORDER );
151
            $subPatterns = array_merge( $subPatterns, $matches[1] );
152
        }
153
 
154
        $content['subpattern_count'] = $subPatternCount == false ? 0 : $subPatternCount;
155
        $content['subpatterns'] = $subPatterns;
156
 
157
        $classAttribute->setContent( $content );
158
        $classAttribute->store();
159
 
160
        return true;
161
    }
162
 
163
    function storeClassAttribute( &$classAttribute, $version )
164
    {
165
        $content = $classAttribute->content();
166
 
167
        $classAttribute->setAttribute( 'data_text5', serialize( $content ) );
168
    }
169
 
170
    function &classAttributeContent( &$classAttribute )
171
    {
172
        $content = unserialize( $classAttribute->attribute( 'data_text5' ) );
173
 
174
        if( !is_array( $content ) )
175
        {
176
            $content = array( 'regexp' => array(),
177
                              'error_messages' => array(),
178
                              'preset' => array(),
179
                              'help_text' => '',
180
                              'subpattern_count' => 0,
181
                              'subpatterns' => array(),
182
                              'naming_pattern' => '',
183
                              'display_type' => 'line' );
184
        }
185
 
186
        if( isset( $content['pattern_selection'] ) )
187
        {
188
            $this->migratePatternSelection( $content );
189
        }
190
 
191
        if( !is_array( $content['regexp'] ) )
192
        {
193
            $content['regexp'] = array( $content['regexp'] );
194
        }
195
 
196
        if( !is_array( $content['preset'] ) )
197
        {
198
            $tmpPreset = array();
199
 
200
            if( !empty( $content['preset'] ) )
201
            {
202
                $tmpPreset[] = $content['preset'];
203
            }
204
 
205
            $content['preset'] = $tmpPreset;
206
        }
207
 
208
        if( !isset( $content['display_type'] ) )
209
        {
210
            $content['display_type'] = 'line';
211
        }
212
 
213
        if( !isset( $content['error_messages'] ) )
214
        {
215
            $content['error_messages'] = array();
216
        }
217
 
218
        return $content;
219
    }
220
 
221
    /*!
222
     Validates input on content object level
223
     \return EZ_INPUT_VALIDATOR_STATE_ACCEPTED or EZ_INPUT_VALIDATOR_STATE_INVALID if
224
             the values are accepted or not
225
    */
226
    function validateObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
227
    {
228
        $status = $this->validateAttributeHTTPInput( $http, $base, $contentObjectAttribute, false );
229
 
230
        return $status;
231
    }
232
 
233
    /*!
234
     Fetches all variables from the object
235
     \return true if fetching of class attributes are successfull, false if not
236
    */
237
    function fetchObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
238
    {
239
        $textName = $base . "_hmregexpline_data_text_" . $contentObjectAttribute->attribute( 'id' );
240
 
241
        if( $http->hasPostVariable( $textName ) )
242
        {
243
            $text = $http->postVariable( $textName );
244
            $contentObjectAttribute->setContent( $text );
245
            $contentObjectAttribute->storeData();
246
            return true;
247
        }
248
        return false;
249
    }
250
 
251
    function storeObjectAttribute( &$contentObjectAttribute )
252
    {
253
        $text = $contentObjectAttribute->content();
254
 
255
        $contentObjectAttribute->setAttribute( 'data_text', $text );
256
    }
257
 
258
    /*!
259
     Returns the content.
260
    */
261
    function &objectAttributeContent( &$contentObjectAttribute )
262
    {
263
        $text = $contentObjectAttribute->attribute( 'data_text' );
264
 
265
        return $text;
266
    }
267
 
268
    function validateAttributeHTTPInput( &$http, $base, &$objectAttribute, $isInformationCollector = false )
269
    {
270
        $textName = $base . "_hmregexpline_data_text_" . $objectAttribute->attribute( 'id' );
271
        $classAttribute =& $objectAttribute->contentClassAttribute();
272
 
273
        $required = false;
274
        $must_validate = ( $isInformationCollector == $classAttribute->attribute( 'is_information_collector' ) );
275
 
276
        if( method_exists( $objectAttribute, 'validateIsRequired' ) )
277
        {
278
            $required = $objectAttribute->validateIsRequired();
279
        }
280
        else
281
        {
282
            $required = ( $classAttribute->attribute( 'is_required' ) == 1 );
283
        }
284
 
285
        if( $http->hasPostVariable( $textName ) )
286
        {
287
            $text = $http->postVariable( $textName );
288
            $classContent = $classAttribute->content();
289
 
290
            if( empty( $text ) and ( $required === true && $must_validate === true ) )
291
            {
292
                $objectAttribute->setValidationError( ezi18n( 'extension/regexpline/datatype', 'This is a required field which means you can\'t leave it empty' ) );
293
                return EZ_INPUT_VALIDATOR_STATE_INVALID;
294
            }
295
 
296
            if( !empty( $text ) )
297
            {
298
                $regexp = $this->getRegularExpression( $classContent );
299
 
300
                foreach( $regexp as $index => $expr )
301
                {
302
                    $res = @preg_match( $expr, $text );
303
 
304
                    if( $res === 0 )
305
                    {
306
                        // No match
307
                        $msg = $this->getErrorMessage( $classContent, $index );
308
 
309
                        if( $msg === null )
310
                        {
311
                            $msg = ezi18n( 'extension/regexpline/datatype', 'Your input did not meet the requirements.' );
312
                        }
313
 
314
                        $objectAttribute->setValidationError( $msg );
315
                        return EZ_INPUT_VALIDATOR_STATE_INVALID;
316
                    }
317
                }
318
            }
319
        }
320
        else
321
        {
322
            if( $required === true && $must_validate === true )
323
            {
324
                $objectAttribute->setValidationError( ezi18n( 'extension/regexpline/datatype', 'This is a required field which means you can\'t leave it empty' ) );
325
                return EZ_INPUT_VALIDATOR_STATE_INVALID;
326
            }
327
        }
328
 
329
        return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
330
    }
331
 
332
    function validateCollectionAttributeHTTPInput( &$http, $base, &$objectAttribute )
333
    {
334
        $status = $this->validateAttributeHTTPInput( $http, $base, $objectAttribute, true );
335
 
336
        return $status;
337
    }
338
 
339
    function fetchCollectionAttributeHTTPInput( &$collection, &$collectionAttribute, &$http, $base, &$contentObjectAttribute )
340
    {
341
        $textName = $base . "_hmregexpline_data_text_" . $contentObjectAttribute->attribute( 'id' );
342
 
343
        if( $http->hasPostVariable( $textName ) )
344
        {
345
            $text = $http->postVariable( $textName );
346
            $collectionAttribute->setAttribute( 'data_text', $text );
347
            return true;
348
        }
349
        return false;
350
    }
351
 
352
    /*!
353
     Returns the meta data used for storing search indeces.
354
    */
355
    function metaData( $contentObjectAttribute )
356
    {
357
        return $contentObjectAttribute->attribute( 'data_text' );
358
    }
359
 
360
    /*!
361
     Returns the value as it will be shown if this attribute is used in the object name pattern.
362
    */
363
    function title( &$contentObjectAttribute )
364
    {
365
        $classAttribute =& $contentObjectAttribute->contentClassAttribute();
366
        $classContent = $classAttribute->content();
367
        $content = $contentObjectAttribute->content();
368
        $title = "";
369
 
370
        // Exit if the input is empty
371
        if( $content == '' )
372
        {
373
            return $content;
374
        }
375
 
376
        if( isset( $classContent['pattern_selection'] ) )
377
        {
378
            $this->migratePatternSelection( $classContent );
379
        }
380
 
381
        $regexp = $this->getRegularExpression( $classContent );
382
        $res = 0;
383
        $matchArray = array( $content );
384
 
385
        foreach( $regexp as $index => $expr )
386
        {        
387
            $res += @preg_match( $expr, $content, $matches );
388
            unset( $matches[0] ); // We don't need this one
389
            $matchArray = array_merge( $matchArray, $matches );
390
        }
391
 
392
        // Only replace if there's at least a match
393
        if( (count( $matchArray ) - 1) == $classContent['subpattern_count'] &&
394
            $classContent['naming_pattern'] != '' )
395
        {
396
            $title = preg_replace( "/<([0-9]+)>/e", "\$matchArray[\\1]", $classContent['naming_pattern'] );
397
        }
398
 
399
        return $title;
400
    }
401
 
402
    /*!
403
     \return true if the datatype can be indexed
404
    */
405
    function isIndexable()
406
    {
407
        return true;
408
    }
409
 
410
    function isInformationCollector()
411
    {
412
        return true;
413
    }
414
 
415
    function &sortKey( &$contentObjectAttribute )
416
    {
417
        $text = $contentObjectAttribute->content();
418
 
419
        return $text;
420
    }
421
 
422
    function &sortKeyType()
423
    {
424
        return 'string';
425
    }
426
 
427
    function serializeContentClassAttribute( &$classAttribute, &$attributeNode, &$attributeParametersNode )
428
    {
429
        $serializedContent = $classAttribute->attribute( 'data_text5' );
430
 
431
        $attributeParametersNode->appendChild( eZDOMDocument::createElementCDATANode( 'content', $serializedContent ) );
432
    }
433
 
434
    function unserializeContentClassAttribute( &$classAttribute, &$attributeNode, &$attributeParametersNode )
435
    {
436
        $serializedContent = $attributeParametersNode->elementTextContentByName( 'content' );
437
 
438
        $classAttribute->setAttribute( 'data_text5', $serializedContent );
439
    }
440
 
441
 
442
    function getRegularExpression( &$classContent )
443
    {
444
        $regexp = $classContent['regexp'];
445
 
446
        if( !is_array( $classContent['preset'] ) )
447
        {
448
            $tmpPreset = array();
449
 
450
            if( !empty( $classContent['preset'] ) )
451
            {
452
                $tmpPreset[] = $content['preset'];
453
            }
454
 
455
            $classContent['preset'] = $tmpPreset;
456
        }
457
 
458
        if( count( $classContent['preset'] ) > 0 )
459
        {
460
            $tmpRegexp = array();
461
            $ini =& eZINI::instance( 'regexpline.ini' );
462
            $presets = $ini->variable( 'GeneralSettings', 'RegularExpressions' );
463
 
464
            foreach( $classContent['preset'] as $preset )
465
            {
466
                if( isset( $presets[$preset] ) )
467
                {
468
                    $tmpRegexp[$preset] = $presets[$preset];
469
                }
470
            }
471
 
472
            $regexp = $tmpRegexp;
473
        }
474
 
475
        if( !is_array( $regexp ) )
476
        {
477
            $regexp = array( $regexp );
478
        }
479
 
480
        return $regexp;
481
    }
482
 
483
    function getErrorMessage( &$classContent, $index )
484
    {
485
        $msg = null;
486
 
487
        if( isset( $classContent['error_messages'] ) && is_array( $classContent['error_messages'] ) )
488
        {
489
            if( isset( $classContent['error_messages'][$index] ) )
490
            {
491
                $msg = $classContent['error_messages'][$index];
492
            }
493
        }
494
 
495
        // Presets override
496
        if( count( $classContent['preset'] ) > 0 )
497
        {
498
            $ini =& eZINI::instance( 'regexpline.ini' );
499
            $presets = $ini->variable( 'GeneralSettings', 'RegularExpressions' );
500
            $messages = $ini->variable( 'GeneralSettings', 'ErrorMessages' );
501
 
502
            if( isset( $presets[$index] ) && isset( $messages[$index] ) )
503
            {
504
                $msg = $messages[$index];
505
            }
506
        }
507
 
508
        return $msg;
509
    }
510
 
511
    function migratePatternSelection( &$classContent )
512
    {
513
        // Migrate the old pattern_selection to the newer naming_pattern
514
        $content['naming_pattern'] = '';
515
 
516
        foreach( $content['pattern_selection'] as $pattern )
517
        {
518
            $content['naming_pattern'] .= "<$pattern>";
519
        }
520
 
521
        unset( $content['pattern_selection'] );  
522
    }
523
}
524
 
525
eZDataType::register( EZ_DATATYPESTRING_REGEXPLINE, "hmregexplinetype" );
526
 
527
?>