Mercurial > hg > rr-repo
comparison modules/taxonomy/taxonomy.api.php @ 0:ff03f76ab3fe
initial version
author | danieleb <danielebarchiesi@me.com> |
---|---|
date | Wed, 21 Aug 2013 18:51:11 +0100 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:ff03f76ab3fe |
---|---|
1 <?php | |
2 | |
3 /** | |
4 * @file | |
5 * Hooks provided by the Taxonomy module. | |
6 */ | |
7 | |
8 /** | |
9 * @addtogroup hooks | |
10 * @{ | |
11 */ | |
12 | |
13 /** | |
14 * Act on taxonomy vocabularies when loaded. | |
15 * | |
16 * Modules implementing this hook can act on the vocabulary objects before they | |
17 * are returned by taxonomy_vocabulary_load_multiple(). | |
18 * | |
19 * @param $vocabulary | |
20 * An array of taxonomy vocabulary objects. | |
21 */ | |
22 function hook_taxonomy_vocabulary_load($vocabularies) { | |
23 $result = db_select('mytable', 'm') | |
24 ->fields('m', array('vid', 'foo')) | |
25 ->condition('m.vid', array_keys($vocabularies), 'IN') | |
26 ->execute(); | |
27 foreach ($result as $record) { | |
28 $vocabularies[$record->vid]->foo = $record->foo; | |
29 } | |
30 } | |
31 | |
32 /** | |
33 * Act on taxonomy vocabularies before they are saved. | |
34 * | |
35 * Modules implementing this hook can act on the vocabulary object before it is | |
36 * inserted or updated. | |
37 * | |
38 * @param $vocabulary | |
39 * A taxonomy vocabulary object. | |
40 */ | |
41 function hook_taxonomy_vocabulary_presave($vocabulary) { | |
42 $vocabulary->foo = 'bar'; | |
43 } | |
44 | |
45 /** | |
46 * Act on taxonomy vocabularies when inserted. | |
47 * | |
48 * Modules implementing this hook can act on the vocabulary object when saved | |
49 * to the database. | |
50 * | |
51 * @param $vocabulary | |
52 * A taxonomy vocabulary object. | |
53 */ | |
54 function hook_taxonomy_vocabulary_insert($vocabulary) { | |
55 if ($vocabulary->machine_name == 'my_vocabulary') { | |
56 $vocabulary->weight = 100; | |
57 } | |
58 } | |
59 | |
60 /** | |
61 * Act on taxonomy vocabularies when updated. | |
62 * | |
63 * Modules implementing this hook can act on the vocabulary object when updated. | |
64 * | |
65 * @param $vocabulary | |
66 * A taxonomy vocabulary object. | |
67 */ | |
68 function hook_taxonomy_vocabulary_update($vocabulary) { | |
69 db_update('mytable') | |
70 ->fields(array('foo' => $vocabulary->foo)) | |
71 ->condition('vid', $vocabulary->vid) | |
72 ->execute(); | |
73 } | |
74 | |
75 /** | |
76 * Respond to the deletion of taxonomy vocabularies. | |
77 * | |
78 * Modules implementing this hook can respond to the deletion of taxonomy | |
79 * vocabularies from the database. | |
80 * | |
81 * @param $vocabulary | |
82 * A taxonomy vocabulary object. | |
83 */ | |
84 function hook_taxonomy_vocabulary_delete($vocabulary) { | |
85 db_delete('mytable') | |
86 ->condition('vid', $vocabulary->vid) | |
87 ->execute(); | |
88 } | |
89 | |
90 /** | |
91 * Act on taxonomy terms when loaded. | |
92 * | |
93 * Modules implementing this hook can act on the term objects returned by | |
94 * taxonomy_term_load_multiple(). | |
95 * | |
96 * For performance reasons, information to be added to term objects should be | |
97 * loaded in a single query for all terms where possible. | |
98 * | |
99 * Since terms are stored and retrieved from cache during a page request, avoid | |
100 * altering properties provided by the {taxonomy_term_data} table, since this | |
101 * may affect the way results are loaded from cache in subsequent calls. | |
102 * | |
103 * @param $terms | |
104 * An array of term objects, indexed by tid. | |
105 */ | |
106 function hook_taxonomy_term_load($terms) { | |
107 $result = db_select('mytable', 'm') | |
108 ->fields('m', array('tid', 'foo')) | |
109 ->condition('m.tid', array_keys($terms), 'IN') | |
110 ->execute(); | |
111 foreach ($result as $record) { | |
112 $terms[$record->tid]->foo = $record->foo; | |
113 } | |
114 } | |
115 | |
116 /** | |
117 * Act on taxonomy terms before they are saved. | |
118 * | |
119 * Modules implementing this hook can act on the term object before it is | |
120 * inserted or updated. | |
121 * | |
122 * @param $term | |
123 * A term object. | |
124 */ | |
125 function hook_taxonomy_term_presave($term) { | |
126 $term->foo = 'bar'; | |
127 } | |
128 | |
129 /** | |
130 * Act on taxonomy terms when inserted. | |
131 * | |
132 * Modules implementing this hook can act on the term object when saved to | |
133 * the database. | |
134 * | |
135 * @param $term | |
136 * A taxonomy term object. | |
137 */ | |
138 function hook_taxonomy_term_insert($term) { | |
139 db_insert('mytable') | |
140 ->fields(array( | |
141 'tid' => $term->tid, | |
142 'foo' => $term->foo, | |
143 )) | |
144 ->execute(); | |
145 } | |
146 | |
147 /** | |
148 * Act on taxonomy terms when updated. | |
149 * | |
150 * Modules implementing this hook can act on the term object when updated. | |
151 * | |
152 * @param $term | |
153 * A taxonomy term object. | |
154 */ | |
155 function hook_taxonomy_term_update($term) { | |
156 db_update('mytable') | |
157 ->fields(array('foo' => $term->foo)) | |
158 ->condition('tid', $term->tid) | |
159 ->execute(); | |
160 } | |
161 | |
162 /** | |
163 * Respond to the deletion of taxonomy terms. | |
164 * | |
165 * Modules implementing this hook can respond to the deletion of taxonomy | |
166 * terms from the database. | |
167 * | |
168 * @param $term | |
169 * A taxonomy term object. | |
170 */ | |
171 function hook_taxonomy_term_delete($term) { | |
172 db_delete('mytable') | |
173 ->condition('tid', $term->tid) | |
174 ->execute(); | |
175 } | |
176 | |
177 /** | |
178 * Act on a taxonomy term that is being assembled before rendering. | |
179 * | |
180 * The module may add elements to $term->content prior to rendering. The | |
181 * structure of $term->content is a renderable array as expected by | |
182 * drupal_render(). | |
183 * | |
184 * @param $term | |
185 * The term that is being assembled for rendering. | |
186 * @param $view_mode | |
187 * The $view_mode parameter from taxonomy_term_view(). | |
188 * @param $langcode | |
189 * The language code used for rendering. | |
190 * | |
191 * @see hook_entity_view() | |
192 */ | |
193 function hook_taxonomy_term_view($term, $view_mode, $langcode) { | |
194 $term->content['my_additional_field'] = array( | |
195 '#markup' => $additional_field, | |
196 '#weight' => 10, | |
197 '#theme' => 'mymodule_my_additional_field', | |
198 ); | |
199 } | |
200 | |
201 /** | |
202 * Alter the results of taxonomy_term_view(). | |
203 * | |
204 * This hook is called after the content has been assembled in a structured | |
205 * array and may be used for doing processing which requires that the complete | |
206 * taxonomy term content structure has been built. | |
207 * | |
208 * If the module wishes to act on the rendered HTML of the term rather than the | |
209 * structured content array, it may use this hook to add a #post_render | |
210 * callback. Alternatively, it could also implement | |
211 * hook_preprocess_taxonomy_term(). See drupal_render() and theme() | |
212 * documentation respectively for details. | |
213 * | |
214 * @param $build | |
215 * A renderable array representing the node content. | |
216 * | |
217 * @see hook_entity_view_alter() | |
218 */ | |
219 function hook_taxonomy_term_view_alter(&$build) { | |
220 if ($build['#view_mode'] == 'full' && isset($build['an_additional_field'])) { | |
221 // Change its weight. | |
222 $build['an_additional_field']['#weight'] = -10; | |
223 } | |
224 | |
225 // Add a #post_render callback to act on the rendered HTML of the term. | |
226 $build['#post_render'][] = 'my_module_node_post_render'; | |
227 } | |
228 | |
229 /** | |
230 * @} End of "addtogroup hooks". | |
231 */ |