Subversion Repositories sortobjectsoperators

[/] [classes/] [contentobjecthelper.php] - Blame information for rev 1

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1 akozeka
<?php
2
 
3
/**
4
 * @license Code licensed under the GNU General Public License v2.0
5
 * @author
6
 * @copyright (C) Alex Kozeka 2011
7
 */
8
class ContentObjectHelper {
9
 
10
    public static $sortConditions = null;
11
    public static $sortedObjects = null;
12
 
13
    public static function getObjectsFromNodes( $nodesOrObjects ) {
14
        $objects = array();
15
 
16
        foreach ( $nodesOrObjects as $nodeOrObject ) {
17
            $object = null;
18
 
19
            switch ( get_class( $nodeOrObject ) ) {
20
            case 'eZContentObjectTreeNode':
21
                $object = $nodeOrObject->object();
22
                break;
23
 
24
            case 'eZContentObject':
25
                $object = $nodeOrObject;
26
                break;
27
 
28
            default:
29
                die( 'Unsupported class!' );
30
            }
31
 
32
            $objects[] = $object;
33
        }
34
 
35
        return $objects;
36
    }
37
 
38
    public static function getUniqueObjects( $nodesOrObjects ) {
39
        $uniqueObjects = array();
40
 
41
        foreach ( $nodesOrObjects as $nodeOrObject ) {
42
            $object = null;
43
 
44
            switch ( get_class( $nodeOrObject ) ) {
45
            case 'eZContentObjectTreeNode':
46
                $object = $nodeOrObject->object();
47
                $objectId = $object->attribute( 'id' );
48
                break;
49
 
50
            case 'eZContentObject':
51
                $object = $nodeOrObject;
52
                $objectId = $object->attribute( 'id' );
53
                break;
54
 
55
            default:
56
                die( 'Unsupported class!' );
57
            }
58
 
59
            $uniqueObjects[$objectId] = $object;
60
        }
61
 
62
        return $uniqueObjects;
63
    }
64
 
65
    public static function getSortedObjects( $nodesOrObjects, $sortConditions = array() ) {
66
        self::$sortConditions = $sortConditions;
67
 
68
        self::$sortedObjects = self::getObjectsFromNodes( $nodesOrObjects );
69
 
70
        uksort( self::$sortedObjects, array( 'self', 'sortConditionsBasedCmpFunc' ) );
71
 
72
        return array_values( self::$sortedObjects );
73
    }
74
 
75
    public static function getUniqueSortedObjects( $nodesOrObjects, $sortConditions = array() ) {
76
        self::$sortConditions = $sortConditions;
77
 
78
        self::$sortedObjects = self::getUniqueObjects( $nodesOrObjects );
79
 
80
        uksort( self::$sortedObjects, array( 'self', 'sortConditionsBasedCmpFunc' ) );
81
 
82
        return array_values( self::$sortedObjects );
83
    }
84
//
85
    public static function sortConditionsBasedCmpFunc( $a, $b ) {
86
        foreach ( self::$sortConditions as $i => $sortCondition ) {
87
            $objectA = self::$sortedObjects[$a];
88
            $objectB = self::$sortedObjects[$b];
89
 
90
            $isSortAsc = $sortCondition[0];
91
 
92
            for ( $attributePathIdx = 1; $attributePathIdx < count( $sortCondition ); $attributePathIdx++ ) {
93
                $objectAAttributeValue = null;
94
                $objectBAttributeValue = null;
95
 
96
                $attributePathItem = $sortCondition[$attributePathIdx];
97
                if ( is_array( $attributePathItem ) ) {
98
                    list( $attributeType, $attributeName ) = $attributePathItem;
99
                } else {
100
                    $attributeType = $attributePathItem;
101
                }
102
 
103
                switch ( $attributeType ) {
104
                case 'system_attribute':
105
                    $objectAAttributeValue = self::getObjectSystemAttributeValue( $objectA, $attributeName );
106
                    $objectBAttributeValue = self::getObjectSystemAttributeValue( $objectB, $attributeName );
107
                    break;
108
 
109
                case 'attribute':
110
                    $objectAAttributeValue = self::getObjectAttributeValue( $objectA, $attributeName );
111
                    $objectBAttributeValue = self::getObjectAttributeValue( $objectB, $attributeName );
112
                    break;
113
 
114
                case 'relation_attribute':
115
                    $objectA = self::getRelatedObject( $objectA, $attributeName );
116
                    $objectB = self::getRelatedObject( $objectB, $attributeName );
117
 
118
                    $objectAAttributeValue = '';
119
                    $objectBAttributeValue = '';
120
                    if ( $objectA === null && $objectB === null ) {
121
                        // Jumping to comparing function
122
                        break 2;
123
                    }
124
 
125
                    if ( $objectA === null ) {
126
                        // Making ObjectA to be less than ObjectB
127
                        // Jumping to comparing function
128
                        $objectBAttributeValue = 'a';
129
                        break 2;
130
                    }
131
                    if ( $objectB === null ) {
132
                        // Making ObjectA to be greater than ObjectB
133
                        // Jumping to comparing function
134
                        $objectAAttributeValue = 'a';
135
                        break 2;
136
                    }
137
                    break;
138
 
139
                case 'parent':
140
                    $objectA = $objectA->mainNode()->fetchParent()->object();
141
                    $objectB = $objectB->mainNode()->fetchParent()->object();
142
                    continue 2;
143
 
144
                default:
145
                    die( "Unknown attribute type: '{$attributeType}'!" );
146
                }
147
            }
148
 
149
            if ( $objectAAttributeValue === $objectBAttributeValue ) {
150
                // Jumping to next condition since objects are equal
151
                continue;
152
            }
153
 
154
            if ( $isSortAsc ) {
155
                return strcasecmp( $objectAAttributeValue, $objectBAttributeValue );
156
            } else {
157
                return -1 * strcasecmp( $objectAAttributeValue, $objectBAttributeValue );
158
            }
159
        }
160
 
161
        return 0;
162
    }    
163
 
164
    public static function getObjectAttribute( $object, $attributeName ) {
165
        $version = $object->currentVersion();
166
        $dataMap = $version->attribute( 'data_map' );
167
        return $dataMap[$attributeName];
168
    }
169
 
170
    public static function getObjectAttributeValue( $object, $attributeName ) {
171
        $attribute = self::getObjectAttribute( $object, $attributeName );
172
        return $attribute->toString();
173
    }
174
 
175
    public static function getObjectSystemAttributeValue( $object, $attributeName ) {
176
        return $object->attribute( $attributeName );
177
    }
178
 
179
    public static function getRelatedObject( $object, $attributeName, $params = false ) {
180
        $objectAttribute = self::getObjectAttribute( $object, $attributeName );
181
 
182
        $relatedObjects = $object->relatedContentObjectList(
183
            false,
184
            $object->attribute( 'id' ),
185
            $objectAttribute->attribute( 'contentclassattribute_id' ),
186
            false,
187
            $params
188
        );
189
 
190
        return ( count( $relatedObjects ) == 0 ) ? null : $relatedObjects[0];
191
    }
192
 
193
}
194
 
195
?>