Subversion Repositories regexpline_backup

[/] [stable/] [2.2/] [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( 'lib/ezutils/classes/ezini.php' );
33
 
34
include_once( 'kernel/common/i18n.php' );
35
 
36
define( 'EZ_DATATYPESTRING_REGEXPLINE', 'hmregexpline' );
37
 
38
class hmregexplinetype extends eZDataType
39
{
40
    /*!
41
      Constructor
42
    */
43
    function hmregexplinetype()
44
    {
45
        $this->eZDataType( EZ_DATATYPESTRING_REGEXPLINE,
46
                           ezi18n( 'extension/regexpline/datatype', 'Regular Expression Text', 'Datatype name' ),
47
                           array( 'serialize_supported' => true ) );
48
 
49
        $this->KeepTags = null;
50
    }
51
 
52
    /*!
53
    Validates all variables given on content class level
54
     \return EZ_INPUT_VALIDATOR_STATE_ACCEPTED or EZ_INPUT_VALIDATOR_STATE_INVALID if
55
             the values are accepted or not
56
    */
57
    function validateClassAttributeHTTPInput( &$http, $base, &$classAttribute )
58
    {
59
        $regexpName = $base . "_hmregexpline_regexp_" . $classAttribute->attribute( 'id' );
60
        $presetName = $base . "_hmregexpline_preset_" . $classAttribute->attribute( 'id' );
61
 
62
        $regexp = $preset = array();
63
 
64
        if( $http->hasPostVariable( $regexpName ) )
65
        {
66
            $regexp = $http->postVariable( $regexpName );
67
        }
68
 
69
        if( $http->hasPostVariable( $presetName ) )
70
        {
71
            $preset = $http->postVariable( $presetName );
72
        }
73
 
74
        $content = array( 'regexp' => $regexp,
75
                          'preset' => $preset );
76
        $regexp = $this->getRegularExpression( $content );
77
 
78
        foreach( $regexp as $expr )
79
        {
80
            $check = @preg_match( $expr, 'Dummy string' );
81
 
82
            if( $check === false )
83
            {
84
                return EZ_INPUT_VALIDATOR_STATE_INVALID;
85
            }
86
        }
87
 
88
        return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
89
    }
90
 
91
    /*!
92
     Fetches all variables inputed on content class level
93
     \return true if fetching of class attributes are successfull, false if not
94
    */
95
    function fetchClassAttributeHTTPInput( &$http, $base, &$classAttribute )
96
    {
97
        $regexpName = $base . "_hmregexpline_regexp_" . $classAttribute->attribute( 'id' );
98
        $errorsName = $base . "_hmregexpline_errmsg_" . $classAttribute->attribute( 'id' );
99
        $helpName = $base . "_hmregexpline_helptext_" . $classAttribute->attribute( 'id' );
100
        $patternName = $base . "_hmregexpline_namepattern_" . $classAttribute->attribute( 'id' );
101
        $presetName = $base . "_hmregexpline_preset_" . $classAttribute->attribute( 'id' );
102
        $displayName = $base . "_hmregexpline_display_"  . $classAttribute->attribute( 'id' );
103
        $negateName = $base . "_hmregexpline_negate_" . $classAttribute->attribute( 'id' );
104
 
105
        $content = $classAttribute->content();
106
 
107
        if( $http->hasPostVariable( $regexpName ) )
108
        {
109
            $content['regexp'] = $http->postVariable( $regexpName );
110
        }
111
 
112
        if( $http->hasPostVariable( $errorsName ) )
113
        {
114
            $content['error_messages'] = $http->postVariable( $errorsName );
115
        }
116
 
117
        if( $http->hasPostVariable( $presetName ) )
118
        {
119
            $content['preset'] = $http->postVariable( $presetName );
120
        }
121
        else if( $http->hasPostVariable( 'ContentClassHasInput' ) )
122
        {
123
            $content['preset'] = array();
124
        }
125
 
126
        if( $http->hasPostVariable( $helpName ) )
127
        {
128
            $content['help_text'] = $http->postVariable( $helpName );
129
        }
130
 
131
        if( $http->hasPostVariable( $patternName ) )
132
        {
133
            $content['naming_pattern'] = $http->postVariable( $patternName );
134
        }
135
        else if( $http->hasPostVariable( 'ContentClassHasInput' ) )
136
        {
137
            $content['naming_pattern'] = '';
138
        }
139
 
140
        if( $http->hasPostVariable( $displayName ) )
141
        {
142
            $content['display_type'] = $http->postVariable( $displayName );
143
        }
144
        else if( $http->hasPostVariable( 'ContentClassHasInput' ) )
145
        {
146
            $content['display_type'] = 'line'; // default
147
        }
148
 
149
        if( $http->hasPostVariable( $negateName ) )
150
        {
151
            $negates = $http->postVariable( $negateName );
152
            $content['negates'] = array();
153
 
154
            foreach( $negates as $key => $value )
155
            {
156
                $content['negates'][$key] = true;
157
            }
158
        }
159
        else if( $http->hasPostVariable( 'ContentClassHasInput' ) )
160
        {
161
            $content['negates'] = array();
162
        }
163
 
164
        $regexp = $this->getRegularExpression( $content );
165
        $subPatternCount = 0;
166
        $subPatterns = array();
167
 
168
        foreach( $regexp as $expr )
169
        {
170
            $subPatternCount += @preg_match_all( "/\((?!\?\:)(.*)\)/U", $expr, $matches, PREG_PATTERN_ORDER );
171
            $subPatterns = array_merge( $subPatterns, $matches[1] );
172
        }
173
 
174
        $content['subpattern_count'] = $subPatternCount == false ? 0 : $subPatternCount;
175
        $content['subpatterns'] = $subPatterns;
176
 
177
        $classAttribute->setContent( $content );
178
        $classAttribute->store();
179
 
180
        return true;
181
    }
182
 
183
    function storeClassAttribute( &$classAttribute, $version )
184
    {
185
        $content = $classAttribute->content();
186
 
187
        $classAttribute->setAttribute( 'data_text5', serialize( $content ) );
188
    }
189
 
190
    function &classAttributeContent( &$classAttribute )
191
    {
192
        $content = unserialize( $classAttribute->attribute( 'data_text5' ) );
193
 
194
        if( !is_array( $content ) )
195
        {
196
            $content = array( 'regexp' => array(),
197
                              'error_messages' => array(),
198
                              'negates' => array(),
199
                              'preset' => array(),
200
                              'help_text' => '',
201
                              'subpattern_count' => 0,
202
                              'subpatterns' => array(),
203
                              'naming_pattern' => '',
204
                              'display_type' => 'line' );
205
        }
206
 
207
        if( isset( $content['pattern_selection'] ) )
208
        {
209
            $this->migratePatternSelection( $content );
210
        }
211
 
212
        if( !is_array( $content['regexp'] ) )
213
        {
214
            $content['regexp'] = array( $content['regexp'] );
215
        }
216
 
217
        if( !is_array( $content['preset'] ) )
218
        {
219
            $tmpPreset = array();
220
 
221
            if( !empty( $content['preset'] ) )
222
            {
223
                $tmpPreset[] = $content['preset'];
224
            }
225
 
226
            $content['preset'] = $tmpPreset;
227
        }
228
 
229
        if( !isset( $content['display_type'] ) )
230
        {
231
            $content['display_type'] = 'line';
232
        }
233
 
234
        if( !isset( $content['error_messages'] ) )
235
        {
236
            $content['error_messages'] = array();
237
        }
238
 
239
        if( !isset( $content['negates'] ) )
240
        {
241
            $content['negates'] = array();
242
        }
243
 
244
        return $content;
245
    }
246
 
247
    /*!
248
     Validates input on content object level
249
     \return EZ_INPUT_VALIDATOR_STATE_ACCEPTED or EZ_INPUT_VALIDATOR_STATE_INVALID if
250
             the values are accepted or not
251
    */
252
    function validateObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
253
    {
254
        $status = $this->validateAttributeHTTPInput( $http, $base, $contentObjectAttribute, false );
255
 
256
        return $status;
257
    }
258
 
259
    /*!
260
     Fetches all variables from the object
261
     \return true if fetching of class attributes are successfull, false if not
262
    */
263
    function fetchObjectAttributeHTTPInput( &$http, $base, &$contentObjectAttribute )
264
    {
265
        $textName = $base . "_hmregexpline_data_text_" . $contentObjectAttribute->attribute( 'id' );
266
 
267
        if( $http->hasPostVariable( $textName ) )
268
        {
269
            $text = $http->postVariable( $textName );
270
            $contentObjectAttribute->setContent( $text );
271
            $contentObjectAttribute->storeData();
272
            return true;
273
        }
274
        return false;
275
    }
276
 
277
    function storeObjectAttribute( &$contentObjectAttribute )
278
    {
279
        $text = $contentObjectAttribute->content();
280
 
281
        $contentObjectAttribute->setAttribute( 'data_text', $text );
282
    }
283
 
284
    /*!
285
     Returns the content.
286
    */
287
    function &objectAttributeContent( &$contentObjectAttribute )
288
    {
289
        $text = $contentObjectAttribute->attribute( 'data_text' );
290
 
291
        return $text;
292
    }
293
 
294
    function hasObjectAttributeContent( &$contentObjectAttribute )
295
    {
296
        $text = $contentObjectAttribute->attribute( 'data_text' );
297
        $result = !empty( $text );
298
 
299
        return $result;
300
    }
301
 
302
    function validateAttributeHTTPInput( &$http, $base, &$objectAttribute, $isInformationCollector = false )
303
    {
304
        $textName = $base . "_hmregexpline_data_text_" . $objectAttribute->attribute( 'id' );
305
        $classAttribute =& $objectAttribute->contentClassAttribute();
306
 
307
        $required = false;
308
        $must_validate = ( $isInformationCollector == $classAttribute->attribute( 'is_information_collector' ) );
309
 
310
        if( method_exists( $objectAttribute, 'validateIsRequired' ) )
311
        {
312
            $required = $objectAttribute->validateIsRequired();
313
        }
314
        else
315
        {
316
            $required = ( $classAttribute->attribute( 'is_required' ) == 1 );
317
        }
318
 
319
        if( $http->hasPostVariable( $textName ) )
320
        {
321
            $text = $http->postVariable( $textName );
322
            $classContent = $classAttribute->content();
323
 
324
            if( empty( $text ) and ( $required === true && $must_validate === true ) )
325
            {
326
                $objectAttribute->setValidationError( ezi18n( 'extension/regexpline/datatype', 'This is a required field which means you can\'t leave it empty' ) );
327
                return EZ_INPUT_VALIDATOR_STATE_INVALID;
328
            }
329
 
330
            if( !empty( $text ) )
331
            {
332
                $regexp = $this->getRegularExpression( $classContent );
333
                $text = $this->stripTags( $objectAttribute, $text );
334
 
335
                foreach( $regexp as $index => $expr )
336
                {
337
                    $doNegate = isset( $classContent['negates'][$index] );
338
                    $res = @preg_match( $expr, $text );
339
 
340
                    if( $doNegate === false )
341
                    {
342
                        $condition = ( $res === 0 );
343
                    }
344
                    else
345
                    {
346
                        $condition = ( $res === 1 );
347
                    }
348
 
349
                    if( $condition )
350
                    {
351
                        // No match
352
                        $msg = $this->getErrorMessage( $classContent, $index );
353
 
354
                        if( $msg === null )
355
                        {
356
                            $msg = ezi18n( 'extension/regexpline/datatype', 'Your input did not meet the requirements.' );
357
                        }
358
 
359
                        $objectAttribute->setValidationError( $msg );
360
                        return EZ_INPUT_VALIDATOR_STATE_INVALID;
361
                    }
362
                }
363
            }
364
        }
365
        else
366
        {
367
            if( $required === true && $must_validate === true )
368
            {
369
                $objectAttribute->setValidationError( ezi18n( 'extension/regexpline/datatype', 'This is a required field which means you can\'t leave it empty' ) );
370
                return EZ_INPUT_VALIDATOR_STATE_INVALID;
371
            }
372
        }
373
 
374
        return EZ_INPUT_VALIDATOR_STATE_ACCEPTED;
375
    }
376
 
377
    function validateCollectionAttributeHTTPInput( &$http, $base, &$objectAttribute )
378
    {
379
        $status = $this->validateAttributeHTTPInput( $http, $base, $objectAttribute, true );
380
 
381
        return $status;
382
    }
383
 
384
    function fetchCollectionAttributeHTTPInput( &$collection, &$collectionAttribute, &$http, $base, &$contentObjectAttribute )
385
    {
386
        $textName = $base . "_hmregexpline_data_text_" . $contentObjectAttribute->attribute( 'id' );
387
 
388
        if( $http->hasPostVariable( $textName ) )
389
        {
390
            $text = $http->postVariable( $textName );
391
            $collectionAttribute->setAttribute( 'data_text', $text );
392
            return true;
393
        }
394
 
395
        return false;
396
    }
397
 
398
    /*!
399
     Returns the meta data used for storing search indeces.
400
    */
401
    function metaData( $contentObjectAttribute )
402
    {
403
        $data = $contentObjectAttribute->attribute( 'data_text' );
404
 
405
        $data = $this->stripTags( $contentObjectAttribute, $data );
406
 
407
        return $data;
408
    }
409
 
410
    /*!
411
     Returns the value as it will be shown if this attribute is used in the object name pattern.
412
    */
413
    function title( &$contentObjectAttribute )
414
    {
415
        $classAttribute =& $contentObjectAttribute->contentClassAttribute();
416
        $classContent = $classAttribute->content();
417
        $content = $contentObjectAttribute->content();
418
        $title = "";
419
 
420
        // Exit if the input is empty
421
        if( $content == '' )
422
        {
423
            return $content;
424
        }
425
        else
426
        {
427
            $content = $this->stripTags( $contentObjectAttribute, $content );
428
        }
429
 
430
        if( isset( $classContent['pattern_selection'] ) )
431
        {
432
            $this->migratePatternSelection( $classContent );
433
        }
434
 
435
        $regexp = $this->getRegularExpression( $classContent );
436
        $res = 0;
437
        $matchArray = array( $content );
438
 
439
        foreach( $regexp as $index => $expr )
440
        {
441
            $res += @preg_match( $expr, $content, $matches );
442
            unset( $matches[0] ); // We don't need this one
443
            $matchArray = array_merge( $matchArray, $matches );
444
        }
445
 
446
        // Only replace if there's at least a match
447
        if( (count( $matchArray ) - 1) == $classContent['subpattern_count'] )
448
        {
449
            if( $classContent['naming_pattern'] != '' )
450
            {
451
                $title = preg_replace( "/<([0-9]+)>/e", "\$matchArray[\\1]", $classContent['naming_pattern'] );
452
            }
453
            else
454
            {
455
                $title = $matchArray[0];
456
            }
457
        }
458
 
459
        return $title;
460
    }
461
 
462
    /*!
463
     \return true if the datatype can be indexed
464
    */
465
    function isIndexable()
466
    {
467
        return true;
468
    }
469
 
470
    function isInformationCollector()
471
    {
472
        return true;
473
    }
474
 
475
    function &sortKey( &$contentObjectAttribute )
476
    {
477
        $text = $contentObjectAttribute->content();
478
 
479
        return $text;
480
    }
481
 
482
    function &sortKeyType()
483
    {
484
        return 'string';
485
    }
486
 
487
    function serializeContentClassAttribute( &$classAttribute, &$attributeNode, &$attributeParametersNode )
488
    {
489
        $serializedContent = $classAttribute->attribute( 'data_text5' );
490
 
491
        $attributeParametersNode->appendChild( eZDOMDocument::createElementCDATANode( 'content', $serializedContent ) );
492
    }
493
 
494
    function unserializeContentClassAttribute( &$classAttribute, &$attributeNode, &$attributeParametersNode )
495
    {
496
        $serializedContent = $attributeParametersNode->elementTextContentByName( 'content' );
497
 
498
        $classAttribute->setAttribute( 'data_text5', $serializedContent );
499
    }
500
 
501
 
502
    function getRegularExpression( &$classContent )
503
    {
504
        $regexp = $classContent['regexp'];
505
 
506
        if( !is_array( $classContent['preset'] ) )
507
        {
508
            $tmpPreset = array();
509
 
510
            if( !empty( $classContent['preset'] ) )
511
            {
512
                $tmpPreset[] = $content['preset'];
513
            }
514
 
515
            $classContent['preset'] = $tmpPreset;
516
        }
517
 
518
        if( count( $classContent['preset'] ) > 0 )
519
        {
520
            $tmpRegexp = array();
521
            $ini =& eZINI::instance( 'regexpline.ini' );
522
            $presets = $ini->variable( 'GeneralSettings', 'RegularExpressions' );
523
 
524
            foreach( $classContent['preset'] as $preset )
525
            {
526
                if( isset( $presets[$preset] ) )
527
                {
528
                    $tmpRegexp[$preset] = $presets[$preset];
529
                }
530
            }
531
 
532
            $regexp = $tmpRegexp;
533
        }
534
 
535
        if( !is_array( $regexp ) )
536
        {
537
            $regexp = array( $regexp );
538
        }
539
 
540
        return $regexp;
541
    }
542
 
543
    function getErrorMessage( &$classContent, $index )
544
    {
545
        $msg = null;
546
 
547
        if( isset( $classContent['error_messages'] ) && is_array( $classContent['error_messages'] ) )
548
        {
549
            if( isset( $classContent['error_messages'][$index] ) )
550
            {
551
                $msg = $classContent['error_messages'][$index];
552
            }
553
        }
554
 
555
        // Presets override
556
        if( count( $classContent['preset'] ) > 0 )
557
        {
558
            $ini =& eZINI::instance( 'regexpline.ini' );
559
            $presets = $ini->variable( 'GeneralSettings', 'RegularExpressions' );
560
            $messages = $ini->variable( 'GeneralSettings', 'ErrorMessages' );
561
            $msgIndex = $index;
562
 
563
            if( isset( $classContent['negates'][$index] ) )
564
            {
565
                $msgIndex .= '_negate';
566
            }
567
 
568
            if( isset( $presets[$index] ) && isset( $messages[$msgIndex] ) )
569
            {
570
                $msg = $messages[$msgIndex];
571
            }
572
        }
573
 
574
        return $msg;
575
    }
576
 
577
    function migratePatternSelection( &$classContent )
578
    {
579
        // Migrate the old pattern_selection to the newer naming_pattern
580
        $content['naming_pattern'] = '';
581
 
582
        foreach( $content['pattern_selection'] as $pattern )
583
        {
584
            $content['naming_pattern'] .= "<$pattern>";
585
        }
586
 
587
        unset( $content['pattern_selection'] );
588
    }
589
 
590
    function doStripTags( &$objectAttribute )
591
    {
592
        if( $this->KeepTags === null )
593
        {
594
            $regIni =& eZINI::instance( 'regexpline.ini' );
595
 
596
            if( $regIni->hasVariable( 'GeneralSettings', 'KeepTags' ) )
597
            {
598
                include_once( 'kernel/classes/ezcontentobjecttreenode.php' );
599
                // Don't ask why they've put that function in there :-s
600
 
601
                $keepTags = $regIni->variable( 'GeneralSettings', 'KeepTags' );
602
                $keepTagsResult = array();
603
 
604
                foreach( $keepTags as $identifier )
605
                {
606
                    $keepTagsResult[] = eZContentObjectTreeNode::classAttributeIDByIdentifier( $identifier );
607
                }
608
 
609
                $this->KeepTags = $keepTagsResult;
610
            }
611
            else
612
            {
613
                return true;
614
            }
615
        }
616
 
617
        $shouldStrip = true;
618
        $classAttributeID =& $objectAttribute->attribute( 'contentclassattribute_id' );
619
 
620
        if( is_array( $this->KeepTags ) && in_array( $classAttributeID, $this->KeepTags ) )
621
        {
622
            $shouldStrip = false;
623
        }
624
 
625
        return $shouldStrip;
626
    }
627
 
628
    function stripTags( &$objectAttribute, $content )
629
    {
630
        if( $this->doStripTags( $objectAttribute ) === true )
631
        {
632
            $content = strip_tags( $content );
633
        }
634
 
635
        return $content;
636
    }
637
 
638
    var $KeepTags = null;
639
}
640
 
641
eZDataType::register( EZ_DATATYPESTRING_REGEXPLINE, "hmregexplinetype" );
642
 
643
?>