|
1
|
<?php
|
|
2
|
|
|
3
|
const BIBLIOGRAPHY_FOOTNOTE_KEY = PSEUDO_FEATURE_BIBLIOGRAPHY;
|
|
4
|
|
|
5
|
|
|
6
|
/**
|
|
7
|
* Returns the localized representations of the modifiers hold by the
|
|
8
|
* supplied cdm instance concatenated into one string.
|
|
9
|
*
|
|
10
|
* @param object $is_modifieable
|
|
11
|
* cdm instance of an class implementing the interface IModifieable:
|
|
12
|
* DescriptionElementBase, StateDate, State
|
|
13
|
*
|
|
14
|
* @return String
|
|
15
|
* localized representations of the modifiers hold by the
|
|
16
|
* supplied cdm instance concatenated into one string
|
|
17
|
*/
|
|
18
|
function cdm_modifiers_representations($is_modifieable, $glue = ', ') {
|
|
19
|
$modifiers_strings = array();
|
|
20
|
if (isset($is_modifieable->modifiers)) {
|
|
21
|
foreach ($is_modifieable->modifiers as $modifier) {
|
|
22
|
$modifiers_strings[] = cdm_term_representation($modifier);
|
|
23
|
}
|
|
24
|
}
|
|
25
|
return implode(', ', $modifiers_strings);
|
|
26
|
}
|
|
27
|
|
|
28
|
/**
|
|
29
|
* Filters the given set of description elements and prefers computed elements over others.
|
|
30
|
*
|
|
31
|
* Computed description elements
|
|
32
|
* are identified by the MarkerType.COMPUTED()
|
|
33
|
*
|
|
34
|
* If the given set contains at least one computed element only
|
|
35
|
* the computed elements are returned.
|
|
36
|
*
|
|
37
|
* @param array $description_elements
|
|
38
|
* An array of CDM DescriptionElementBase instances
|
|
39
|
*
|
|
40
|
* @return array
|
|
41
|
* only the computed description elements otherwise all others.
|
|
42
|
*
|
|
43
|
* @deprecated this is replaced by the cdmlib DistributionUtil class!!!
|
|
44
|
*/
|
|
45
|
function cdm_description_elements_prefer_computed($description_elements){
|
|
46
|
|
|
47
|
$computed_elements = array();
|
|
48
|
$other_elements = array();
|
|
49
|
|
|
50
|
if (!empty($description_elements)) {
|
|
51
|
foreach ($description_elements as $element) {
|
|
52
|
if (cdm_entity_has_marker($element, UUID_MARKERTYPE_COMPUTED)) {
|
|
53
|
$computed_elements[] = $element;
|
|
54
|
}
|
|
55
|
else {
|
|
56
|
$other_elements[] = $element;
|
|
57
|
}
|
|
58
|
}
|
|
59
|
}
|
|
60
|
|
|
61
|
if (count($computed_elements) > 0) {
|
|
62
|
return $computed_elements;
|
|
63
|
}
|
|
64
|
else {
|
|
65
|
return $other_elements;
|
|
66
|
}
|
|
67
|
}
|
|
68
|
|
|
69
|
/**
|
|
70
|
* Creates a query parameter array based on the setting stored in the drupal variable CDM_DISTRIBUTION_FILTER.
|
|
71
|
*
|
|
72
|
* @return array
|
|
73
|
* An array with distribution filter query parameters
|
|
74
|
*/
|
|
75
|
function cdm_distribution_filter_query() {
|
|
76
|
$cdm_distribution_filter = get_array_variable_merged(CDM_DISTRIBUTION_FILTER, CDM_DISTRIBUTION_FILTER_DEFAULT);
|
|
77
|
$query = array();
|
|
78
|
|
|
79
|
$feature_block_settings = get_feature_block_settings(UUID_DISTRIBUTION);
|
|
80
|
if($feature_block_settings['sort_elements'] == SORT_HIERARCHICAL){
|
|
81
|
$query['distributionOrder'] = 'AREA_ORDER';
|
|
82
|
}
|
|
83
|
|
|
84
|
$query['recipe'] = variable_get(DISTRIBUTION_CONDENSED_RECIPE, DISTRIBUTION_CONDENSED_RECIPE_DEFAULT);
|
|
85
|
|
|
86
|
|
|
87
|
|
|
88
|
if ($cdm_distribution_filter['filter_rules']['statusOrderPreference']) {
|
|
89
|
$query['statusOrderPreference'] = 1;
|
|
90
|
}
|
|
91
|
if ($cdm_distribution_filter['filter_rules']['subAreaPreference']) {
|
|
92
|
$query['subAreaPreference'] = 1;
|
|
93
|
}
|
|
94
|
if (is_array($cdm_distribution_filter['hiddenAreaMarkerType']) && count($cdm_distribution_filter['hiddenAreaMarkerType']) > 0) {
|
|
95
|
$query['hiddenAreaMarkerType'] = '';
|
|
96
|
foreach ($cdm_distribution_filter['hiddenAreaMarkerType'] as $marker_type => $enabled) {
|
|
97
|
if ($enabled) {
|
|
98
|
$query['hiddenAreaMarkerType'] .= ($query['hiddenAreaMarkerType'] ? ',' : '') . $marker_type;
|
|
99
|
}
|
|
100
|
}
|
|
101
|
}
|
|
102
|
|
|
103
|
return $query;
|
|
104
|
}
|
|
105
|
|
|
106
|
/**
|
|
107
|
* Merge the fields 'annotations', 'markers', 'sources', 'media' from the source CDM DescriptionElement into the target.
|
|
108
|
*
|
|
109
|
* @param object $target
|
|
110
|
* The source CDM DescriptionElement
|
|
111
|
* @param object $source
|
|
112
|
* The target CDM DescriptionElement
|
|
113
|
*/
|
|
114
|
function cdm_merge_description_elements($target, $source) {
|
|
115
|
static $fields_to_merge = array('annotations', 'markers', 'sources', 'media');
|
|
116
|
|
|
117
|
foreach ($fields_to_merge as $field) {
|
|
118
|
if (is_array($source->$field)) {
|
|
119
|
if (!is_array($target->$field)) {
|
|
120
|
$target->$field = $source->$field;
|
|
121
|
}
|
|
122
|
else {
|
|
123
|
$target->$field = array_merge($target->$field, $source->$field);
|
|
124
|
}
|
|
125
|
}
|
|
126
|
}
|
|
127
|
}
|
|
128
|
|
|
129
|
/**
|
|
130
|
* Adds an entry to the end of the table of content items list
|
|
131
|
*
|
|
132
|
* The table of content items are crated internally by calling
|
|
133
|
* toc_list_item() the resulting item is added to the statically cached
|
|
134
|
* list of toc elements
|
|
135
|
*
|
|
136
|
* @param string $label
|
|
137
|
* The label of toc entry
|
|
138
|
* @param $class_attribute_suffix
|
|
139
|
* The suffix to be appended to the class attribute prefix:
|
|
140
|
* "feature-toc-item-"
|
|
141
|
* @param string $fragment
|
|
142
|
* Optional parameter to define a url fragment different from the $label,
|
|
143
|
* if the $fragment is not defined the $label will be used
|
|
144
|
* @param boolean $as_first_element
|
|
145
|
* Place the new item as fist one. This parameter is ignored when $weight is
|
|
146
|
* being set
|
|
147
|
* @param integer $weight
|
|
148
|
* Defines the weight for the ordering the item in the toc list.
|
|
149
|
* The item will be placed at the end if weigth is NULL.
|
|
150
|
*
|
|
151
|
* @throws \Exception re-throws exception from theme()
|
|
152
|
*/
|
|
153
|
function cdm_toc_list_add_item($label, $class_attribute_suffix, $fragment = NULL, $as_first_element = FALSE, $weight = null) {
|
|
154
|
|
|
155
|
$toc_list_items = &cdm_toc_list();
|
|
156
|
|
|
157
|
if (!$fragment) {
|
|
158
|
$fragment = $label;
|
|
159
|
}
|
|
160
|
$fragment = generalizeString($fragment);
|
|
161
|
|
|
162
|
$class_attributes = 'feature-toc-item-' . $class_attribute_suffix;
|
|
163
|
|
|
164
|
$new_item = toc_list_item(
|
|
165
|
theme(
|
|
166
|
'cdm_feature_name',
|
|
167
|
array('feature_name' => $label)),
|
|
168
|
array('class' => $class_attributes),
|
|
169
|
$fragment
|
|
170
|
);
|
|
171
|
|
|
172
|
if ($weight === null && $as_first_element) {
|
|
173
|
reset($toc_list_items);
|
|
174
|
$weight = key($toc_list_items); // returns null for empty arrays
|
|
175
|
$weight = $weight !== null ? $weight - FEATURE_BLOCK_WEIGHT_INCREMENT : 0;
|
|
176
|
}
|
|
177
|
else if($weight === null) {
|
|
178
|
end($toc_list_items);
|
|
179
|
$weight = key($toc_list_items); // returns null for empty arrays
|
|
180
|
$weight = $weight !== null ? $weight + FEATURE_BLOCK_WEIGHT_INCREMENT : 0;
|
|
181
|
}
|
|
182
|
$toc_list_items[$weight] = $new_item;
|
|
183
|
ksort($toc_list_items); // sort so that the last element has always the highest weight
|
|
184
|
|
|
185
|
}
|
|
186
|
|
|
187
|
/**
|
|
188
|
* Returns the statically cached table of content items as render array.
|
|
189
|
*
|
|
190
|
* @see cdm_toc_list_add_item()
|
|
191
|
*
|
|
192
|
* @return array
|
|
193
|
* a render array of table of content items suitable for theme_item_list()
|
|
194
|
*/
|
|
195
|
function &cdm_toc_list(){
|
|
196
|
|
|
197
|
$toc_list_items = &drupal_static('toc_list_items', array());
|
|
198
|
|
|
199
|
return $toc_list_items;
|
|
200
|
}
|
|
201
|
|
|
202
|
/**
|
|
203
|
* Prepares an empty Drupal block for displaying description elements of a
|
|
204
|
* specific CDM Feature.
|
|
205
|
*
|
|
206
|
* The block can also be used for pseudo Features like a bibliography. Pseudo
|
|
207
|
* features are derived from other data on the fly and so not exist as such in
|
|
208
|
* the cdm data. For pseudo features the $feature can be created using
|
|
209
|
* make_pseudo_feature().
|
|
210
|
*
|
|
211
|
* @param $feature_name
|
|
212
|
* A label describing the feature, usually the localized feature
|
|
213
|
* representation.
|
|
214
|
* @param object $feature
|
|
215
|
* The CDM Feature for which the block is created.
|
|
216
|
*
|
|
217
|
* @return object
|
|
218
|
* A Drupal block object
|
|
219
|
*
|
|
220
|
* @throws \Exception re-throws exception from theme()
|
|
221
|
*/
|
|
222
|
function feature_block($feature_name, $feature) {
|
|
223
|
$block = new stdclass();
|
|
224
|
$block->module = 'cdm_dataportal';
|
|
225
|
$block->region = NULL;
|
|
226
|
$class_attribute = html_class_attribute_ref($feature);
|
|
227
|
$block_delta = $feature->class !== 'PseudoFeature' ? $feature_name : $feature->label;
|
|
228
|
$block->delta = generalizeString($block_delta);
|
|
229
|
$block->subject = '<a name="' . $block->delta . '"></a><span class="' . $class_attribute . '">'
|
|
230
|
. theme('cdm_feature_name', array('feature_name' => $feature_name))
|
|
231
|
. '</span>';
|
|
232
|
$block->module = "cdm_dataportal-feature";
|
|
233
|
$block->content = '';
|
|
234
|
return $block;
|
|
235
|
}
|
|
236
|
|
|
237
|
|
|
238
|
/**
|
|
239
|
* Returns a list of a specific type of IdentificationKeys.
|
|
240
|
*
|
|
241
|
* The list can be restricted by a taxon.
|
|
242
|
*
|
|
243
|
* @param string $type
|
|
244
|
* The simple name of the cdm class implementing the interface
|
|
245
|
* IdentificationKey, valid values are:
|
|
246
|
* PolytomousKey, MediaKey, MultiAccessKey.
|
|
247
|
* @param string $taxonUuid
|
|
248
|
* If given this parameter restrict the listed keys to those which have
|
|
249
|
* the taxon identified be this uuid in scope.
|
|
250
|
*
|
|
251
|
* @return array
|
|
252
|
* List with identification keys.
|
|
253
|
*/
|
|
254
|
function _list_IdentificationKeys($type, $taxonUuid = NULL, $pageSize = NULL, $pageNumber = NULL) {
|
|
255
|
if (!$type) {
|
|
256
|
drupal_set_message(t('Type parameter is missing'), 'error');
|
|
257
|
return;
|
|
258
|
}
|
|
259
|
$cdm_ws_base_path = NULL;
|
|
260
|
switch ($type) {
|
|
261
|
case "PolytomousKey":
|
|
262
|
$cdm_ws_base_path = CDM_WS_POLYTOMOUSKEY;
|
|
263
|
break;
|
|
264
|
|
|
265
|
case "MediaKey":
|
|
266
|
$cdm_ws_base_path = CDM_WS_MEDIAKEY;
|
|
267
|
break;
|
|
268
|
|
|
269
|
case "MultiAccessKey":
|
|
270
|
$cdm_ws_base_path = CDM_WS_MULTIACCESSKEY;
|
|
271
|
break;
|
|
272
|
|
|
273
|
}
|
|
274
|
|
|
275
|
if (!$cdm_ws_base_path) {
|
|
276
|
drupal_set_message(t('Type parameter is not valid: ') . $type, 'error');
|
|
277
|
}
|
|
278
|
|
|
279
|
$queryParameters = '';
|
|
280
|
if (is_numeric($pageSize)) {
|
|
281
|
$queryParameters = "pageSize=" . $pageSize;
|
|
282
|
}
|
|
283
|
else {
|
|
284
|
$queryParameters = "pageSize=0";
|
|
285
|
}
|
|
286
|
|
|
287
|
if (is_numeric($pageNumber)) {
|
|
288
|
$queryParameters = "pageNumber=" . $pageNumber;
|
|
289
|
}
|
|
290
|
else {
|
|
291
|
$queryParameters = "pageNumber=0";
|
|
292
|
}
|
|
293
|
$queryParameters = NULL;
|
|
294
|
if ($taxonUuid) {
|
|
295
|
$queryParameters = "findByTaxonomicScope=$taxonUuid";
|
|
296
|
}
|
|
297
|
$pager = cdm_ws_get($cdm_ws_base_path, NULL, $queryParameters);
|
|
298
|
|
|
299
|
if (!$pager || $pager->count == 0) {
|
|
300
|
return array();
|
|
301
|
}
|
|
302
|
return $pager->records;
|
|
303
|
}
|
|
304
|
|
|
305
|
|
|
306
|
/**
|
|
307
|
* Creates a list item for a table of content, suitable as data element for a themed list
|
|
308
|
*
|
|
309
|
* @see theme_list()
|
|
310
|
*
|
|
311
|
* @param $label
|
|
312
|
* @param $http_request_params
|
|
313
|
* @param $attributes
|
|
314
|
* @return array
|
|
315
|
*/
|
|
316
|
function toc_list_item($label, $attributes = array(), $fragment = null) {
|
|
317
|
|
|
318
|
// we better cache here since drupal_get_query_parameters has no internal static cache variable
|
|
319
|
$http_request_params = drupal_static('http_request_params', drupal_get_query_parameters());
|
|
320
|
|
|
321
|
$item = array(
|
|
322
|
'data' => l(
|
|
323
|
$label,
|
|
324
|
$_GET['q'],
|
|
325
|
array(
|
|
326
|
'attributes' => array('class' => array('toc')),
|
|
327
|
'fragment' => generalizeString($label),
|
|
328
|
'query' => $http_request_params,
|
|
329
|
)
|
|
330
|
),
|
|
331
|
);
|
|
332
|
$item['attributes'] = $attributes;
|
|
333
|
return $item;
|
|
334
|
}
|
|
335
|
|
|
336
|
/**
|
|
337
|
* Compare callback to be used in usort() to sort render arrays produced by
|
|
338
|
* compose_description_element().
|
|
339
|
*
|
|
340
|
* @param $a
|
|
341
|
* @param $b
|
|
342
|
*
|
|
343
|
* @return int Returns < 0 if $a['#value'].$a['#value-suffix'] from is less than
|
|
344
|
* $b['#value'].$b['#value-suffix'], > 0 if it is greater than $b['#value'].$b['#value-suffix'],
|
|
345
|
* and 0 if they are equal.
|
|
346
|
*/
|
|
347
|
function compare_description_element_render_arrays($a, $b){
|
|
348
|
if ($a['#value'].$a['#value-suffix'] == $b['#value'].$b['#value-suffix']) {
|
|
349
|
return 0;
|
|
350
|
}
|
|
351
|
return ($a['#value'].$a['#value-suffix'] < $b['#value'].$b['#value-suffix']) ? -1 : 1;
|
|
352
|
|
|
353
|
}
|
|
354
|
|
|
355
|
|
|
356
|
/**
|
|
357
|
* @param $element
|
|
358
|
* @param $feature_block_settings
|
|
359
|
* @param $element_markup
|
|
360
|
* @param $footnote_list_key_suggestion
|
|
361
|
* @param bool $prepend_feature_label
|
|
362
|
*
|
|
363
|
* @return array|null
|
|
364
|
*/
|
|
365
|
function compose_description_element($element, $feature_block_settings, $element_markup, $footnote_list_key_suggestion, $prepend_feature_label = FALSE)
|
|
366
|
{
|
|
367
|
|
|
368
|
$render_array = array(
|
|
369
|
'#type' => 'html_tag',
|
|
370
|
'#tag' => cdm_feature_block_element_tag_name($feature_block_settings),
|
|
371
|
|
|
372
|
'#attributes' => array(
|
|
373
|
'class' => array(
|
|
374
|
'DescriptionElement',
|
|
375
|
'DescriptionElement-' . $element->class,
|
|
376
|
html_class_attribute_ref($element)
|
|
377
|
)
|
|
378
|
),
|
|
379
|
|
|
380
|
'#value' => '',
|
|
381
|
'#value_suffix' => NULL
|
|
382
|
|
|
383
|
);
|
|
384
|
|
|
385
|
RenderHints::setAnnotationsAndSourceConfig(handle_annotations_and_sources_config($feature_block_settings));
|
|
386
|
$annotations_and_sources = handle_annotations_and_sources(
|
|
387
|
$element, $element_markup, $footnote_list_key_suggestion
|
|
388
|
);
|
|
389
|
|
|
390
|
$timescope_markup = '';
|
|
391
|
if(isset($element->timeperiod)){
|
|
392
|
$timescope_markup = ' ' . timePeriodToString($element->timeperiod, true);
|
|
393
|
}
|
|
394
|
|
|
395
|
// handle the special case were the TextData is used as container for original source with name
|
|
396
|
// used in source information without any text stored in it.
|
|
397
|
$names_used_in_source_markup = '';
|
|
398
|
if ($annotations_and_sources->hasNameUsedInSource() && empty($element_markup)) {
|
|
399
|
$names_used_in_source_markup = join(', ', $annotations_and_sources->getNameUsedInSource()) . ': ';
|
|
400
|
// remove all <span class="nameUsedInSource">...</span> from all source_references
|
|
401
|
// these are expected to be at the end of the strings
|
|
402
|
$pattern = '/ <span class="nameUsedInSource">.*$/';
|
|
403
|
foreach( $annotations_and_sources->getSourceReferences() as &$source_reference){
|
|
404
|
$source_reference = preg_replace($pattern , '', $source_reference);
|
|
405
|
}
|
|
406
|
}
|
|
407
|
|
|
408
|
$source_references_markup = '';
|
|
409
|
if ($annotations_and_sources->hasSourceReferences()) {
|
|
410
|
$source_references_markup = '<span class="sources">' . join(' ', $annotations_and_sources->getSourceReferences()) . '<span>';
|
|
411
|
}
|
|
412
|
|
|
413
|
$feature_label = '';
|
|
414
|
if ($prepend_feature_label) {
|
|
415
|
$feature_label = '<span class="nested-feature-tree-feature-label">' . $element->feature->representation_L10n . ':</span> ';
|
|
416
|
}
|
|
417
|
$content_markup = $names_used_in_source_markup . $element_markup . $timescope_markup . $source_references_markup;
|
|
418
|
|
|
419
|
if(!$content_markup && $feature_block_settings['sources_as_content'] !== 1){
|
|
420
|
// no textual content? So skip this element completely, even if there could be an footnote key
|
|
421
|
// see #4379
|
|
422
|
return null;
|
|
423
|
}
|
|
424
|
|
|
425
|
$render_array['#value'] = $feature_label . $content_markup;
|
|
426
|
$render_array['#value_suffix'] = $annotations_and_sources->footNoteKeysMarkup();
|
|
427
|
return $render_array;
|
|
428
|
}
|
|
429
|
|
|
430
|
/**
|
|
431
|
* Provides the according tag name for the description element markup which
|
|
432
|
* fits the $feature_block_settings['as_list'] value
|
|
433
|
*
|
|
434
|
* @param $feature_block_settings
|
|
435
|
* A feature_block_settings array, for details, please see
|
|
436
|
* get_feature_block_settings($feature_uuid = 'DEFAULT')
|
|
437
|
*
|
|
438
|
* @return mixed|string
|
|
439
|
*/
|
|
440
|
function cdm_feature_block_element_tag_name($feature_block_settings){
|
|
441
|
switch ($feature_block_settings['as_list']){
|
|
442
|
case 'ul':
|
|
443
|
case 'ol':
|
|
444
|
return 'li';
|
|
445
|
case 'div':
|
|
446
|
if(isset($feature_block_settings['element_tag'])){
|
|
447
|
return $feature_block_settings['element_tag'];
|
|
448
|
}
|
|
449
|
return 'span';
|
|
450
|
case 'dl':
|
|
451
|
return 'dd';
|
|
452
|
default:
|
|
453
|
return 'div'; // should never happen, throw error instead?
|
|
454
|
}
|
|
455
|
}
|
|
456
|
|
|
457
|
|
|
458
|
/* ==================== COMPOSE FUNCTIONS =============== */
|
|
459
|
|
|
460
|
/**
|
|
461
|
* Returns a set of feature blocks for a taxon profile from the $mergedFeatureNodes of a given $taxon.
|
|
462
|
*
|
|
463
|
* The taxon profile consists of drupal block elements, one for the description elements
|
|
464
|
* of a specific feature. The structure is defined by specific FeatureTree.
|
|
465
|
* The chosen FeatureTree is merged with the list of description elements prior to using this method.
|
|
466
|
*
|
|
467
|
* The merged nodes can be obtained by making use of the
|
|
468
|
* function cdm_ws_descriptions_by_featuretree().
|
|
469
|
*
|
|
470
|
* @see cdm_ws_descriptions_by_featuretree()
|
|
471
|
*
|
|
472
|
* @param $mergedFeatureNodes
|
|
473
|
*
|
|
474
|
* @param $taxon
|
|
475
|
*
|
|
476
|
* @return array
|
|
477
|
* A Drupal render array containing feature blocks and the table of content
|
|
478
|
*
|
|
479
|
* @ingroup compose
|
|
480
|
*/
|
|
481
|
function make_feature_block_list($mergedFeatureNodes, $taxon) {
|
|
482
|
|
|
483
|
$block_list = array();
|
|
484
|
|
|
485
|
$gallery_settings = getGallerySettings(CDM_DATAPORTAL_DESCRIPTION_GALLERY_NAME);
|
|
486
|
|
|
487
|
$use_description_features = array(UUID_USE);
|
|
488
|
|
|
489
|
|
|
490
|
RenderHints::pushToRenderStack('feature_block');
|
|
491
|
// Create a drupal block for each feature
|
|
492
|
$block_weight = - FEATURE_BLOCK_WEIGHT_INCREMENT;
|
|
493
|
foreach ($mergedFeatureNodes as $feature_node) {
|
|
494
|
|
|
495
|
$block_weight = $block_weight + FEATURE_BLOCK_WEIGHT_INCREMENT;
|
|
496
|
|
|
497
|
if ((isset($feature_node->descriptionElements['#type']) ||
|
|
498
|
has_feature_node_description_elements($feature_node)) && $feature_node->term->uuid != UUID_IMAGE) { // skip empty or suppressed features
|
|
499
|
|
|
500
|
RenderHints::pushToRenderStack($feature_node->term->uuid);
|
|
501
|
|
|
502
|
$feature_name = cdm_term_representation($feature_node->term, 'Unnamed Feature');
|
|
503
|
$feature_block_settings = get_feature_block_settings($feature_node->term->uuid);
|
|
504
|
|
|
505
|
|
|
506
|
$block = feature_block($feature_name, $feature_node->term);
|
|
507
|
$block->content = array();
|
|
508
|
$block_content_is_empty = TRUE;
|
|
509
|
|
|
510
|
if(array_search($feature_node->term->uuid, $use_description_features) !== false) {
|
|
511
|
// do not show features which belong to the UseDescriptions, these are
|
|
512
|
// handled by compose_feature_block_items_use_records() where the according descriptions are
|
|
513
|
// fetched again separately.
|
|
514
|
// UseDescriptions are a special feature introduced for palmweb
|
|
515
|
continue;
|
|
516
|
}
|
|
517
|
|
|
518
|
/*
|
|
519
|
* Content/DISTRIBUTION.
|
|
520
|
*/
|
|
521
|
if ($feature_node->term->uuid == UUID_DISTRIBUTION) {
|
|
522
|
$block = compose_feature_block_distribution($taxon, $feature_node->descriptionElements, $feature_node->term);
|
|
523
|
$block_content_is_empty = FALSE;
|
|
524
|
}
|
|
525
|
|
|
526
|
/*
|
|
527
|
* Content/COMMON_NAME.
|
|
528
|
*/
|
|
529
|
else if ($feature_node->term->uuid == UUID_COMMON_NAME) {
|
|
530
|
$common_names_render_array = compose_feature_block_items_feature_common_name($feature_node->descriptionElements, $feature_node->term);
|
|
531
|
$block->content[] = $common_names_render_array;
|
|
532
|
$block_content_is_empty = FALSE;
|
|
533
|
}
|
|
534
|
|
|
535
|
/*
|
|
536
|
* Content/Use Description (Use + UseRecord)
|
|
537
|
*/
|
|
538
|
else if ($feature_node->term->uuid == UUID_USE_RECORD) {
|
|
539
|
$block->content[] = cdm_block_use_description_content($taxon->uuid, $feature_node->term);
|
|
540
|
$block_content_is_empty = FALSE;
|
|
541
|
}
|
|
542
|
|
|
543
|
/*
|
|
544
|
* Content/ALL OTHER FEATURES.
|
|
545
|
*/
|
|
546
|
else {
|
|
547
|
|
|
548
|
$media_list = array();
|
|
549
|
$elements_render_array = array();
|
|
550
|
$child_elements_render_array = null;
|
|
551
|
|
|
552
|
if (isset($feature_node->descriptionElements[0])) {
|
|
553
|
$elements_render_array = compose_feature_block_items_generic($feature_node->descriptionElements, $feature_node->term);
|
|
554
|
}
|
|
555
|
|
|
556
|
// Content/ALL OTHER FEATURES/Subordinate Features
|
|
557
|
// subordinate features are printed inline in one floating text,
|
|
558
|
// it is expected hat subordinate features can "contain" TextData,
|
|
559
|
// Qualitative- and Qualitative- DescriptionElements
|
|
560
|
if (isset($feature_node->childNodes[0])) {
|
|
561
|
$child_elements_render_array = compose_feature_block_items_nested($feature_node, $media_list, $feature_block_settings);
|
|
562
|
$elements_render_array = array_merge($elements_render_array, $child_elements_render_array);
|
|
563
|
}
|
|
564
|
$block_content_is_empty = $block_content_is_empty && empty($media_list) && empty($elements_render_array);
|
|
565
|
if(!$block_content_is_empty){
|
|
566
|
$block->content[] = compose_feature_block_wrap_elements($elements_render_array, $feature_node->term, $feature_block_settings['glue']);
|
|
567
|
$block->content[] = compose_feature_media_gallery($feature_node, $media_list, $gallery_settings);
|
|
568
|
/*
|
|
569
|
* Footnotes for the feature block
|
|
570
|
*/
|
|
571
|
$block->content[] = markup_to_render_array(render_footnotes(PSEUDO_FEATURE_BIBLIOGRAPHY . '-' . $feature_node->term->uuid));
|
|
572
|
$block->content[] = markup_to_render_array(render_footnotes($feature_node->term->uuid));
|
|
573
|
}
|
|
574
|
} // END all other features
|
|
575
|
|
|
576
|
// allows modifying the block contents via a the hook_cdm_feature_node_block_content_alter
|
|
577
|
drupal_alter('cdm_feature_node_block_content', $block->content, $feature_node->term, $feature_node->descriptionElements);
|
|
578
|
|
|
579
|
if(!$block_content_is_empty){ // skip empty block content
|
|
580
|
$block_list[$block_weight] = $block;
|
|
581
|
cdm_toc_list_add_item(cdm_term_representation($feature_node->term), $feature_node->term->uuid, null, FALSE, $block_weight);
|
|
582
|
} // END: skip empty block content
|
|
583
|
} // END: skip empty or suppressed features
|
|
584
|
RenderHints::popFromRenderStack();
|
|
585
|
} // END: creating a block per feature
|
|
586
|
|
|
587
|
RenderHints::popFromRenderStack();
|
|
588
|
|
|
589
|
drupal_alter('cdm_feature_node_blocks', $block_list, $taxon);
|
|
590
|
|
|
591
|
ksort($block_list);
|
|
592
|
|
|
593
|
return $block_list;
|
|
594
|
}
|
|
595
|
|
|
596
|
/**
|
|
597
|
* Creates a render array of description elements held by child nodes of the given feature node.
|
|
598
|
*
|
|
599
|
* This function is called recursively!
|
|
600
|
*
|
|
601
|
* @param $feature_node
|
|
602
|
* The feature node.
|
|
603
|
* @param array $media_list
|
|
604
|
* List of CDM Media entities. All media of subordinate elements should be passed to the main feature.ä
|
|
605
|
* @param $feature_block_settings
|
|
606
|
* The feature block settings.
|
|
607
|
* @param $main_feature
|
|
608
|
* Only used internally in recursive calls.
|
|
609
|
*
|
|
610
|
* @return array
|
|
611
|
* A Drupal render array
|
|
612
|
*
|
|
613
|
* @ingroup compose
|
|
614
|
*/
|
|
615
|
function compose_feature_block_items_nested($feature_node, &$media_list, $feature_block_settings, $main_feature = NULL)
|
|
616
|
{
|
|
617
|
|
|
618
|
if(!$main_feature){
|
|
619
|
$main_feature = $feature_node->term;
|
|
620
|
}
|
|
621
|
/*
|
|
622
|
* TODO should be configurable, options; YES, NO, AUTOMATIC
|
|
623
|
* (automatic will only place the label if the first word of the description element text is not the same)
|
|
624
|
*/
|
|
625
|
$prepend_feature_label = false;
|
|
626
|
|
|
627
|
$render_arrays = array();
|
|
628
|
foreach ($feature_node->childNodes as $child_node) {
|
|
629
|
if (isset($child_node->descriptionElements[0])) {
|
|
630
|
foreach ($child_node->descriptionElements as $element) {
|
|
631
|
|
|
632
|
if (isset($element->media[0])) {
|
|
633
|
// Append media of subordinate elements to list of main
|
|
634
|
// feature.
|
|
635
|
$media_list = array_merge($media_list, $element->media);
|
|
636
|
}
|
|
637
|
|
|
638
|
$child_node_element = null;
|
|
639
|
switch ($element->class) {
|
|
640
|
case 'TextData':
|
|
641
|
$child_node_element = compose_description_element_text_data($element, $element->feature->uuid, $feature_block_settings, $prepend_feature_label);
|
|
642
|
break;
|
|
643
|
case 'CategoricalData':
|
|
644
|
$child_node_element = compose_description_element_categorical_data($element, $feature_block_settings, $prepend_feature_label);
|
|
645
|
break;
|
|
646
|
case 'QuantitativeData':
|
|
647
|
$child_node_element = compose_description_element_quantitative_data($element, $feature_block_settings, $prepend_feature_label);
|
|
648
|
|
|
649
|
}
|
|
650
|
if (is_array($child_node_element)) {
|
|
651
|
$render_arrays[] = $child_node_element;
|
|
652
|
}
|
|
653
|
}
|
|
654
|
}
|
|
655
|
|
|
656
|
if(isset($child_node->childNodes[0])){
|
|
657
|
$render_arrays = array_merge($render_arrays, compose_feature_block_items_nested($child_node, $media_list, $feature_block_settings, $main_feature ));
|
|
658
|
}
|
|
659
|
}
|
|
660
|
|
|
661
|
return $render_arrays;
|
|
662
|
}
|
|
663
|
|
|
664
|
/**
|
|
665
|
*
|
|
666
|
* @param $feature_node
|
|
667
|
* The merged feature three node which potentially contains media in its description elements.
|
|
668
|
* @param $media_list
|
|
669
|
* Additional media to be merged witht the media contained in the nodes description elements
|
|
670
|
* @param $gallery_settings
|
|
671
|
* @return array
|
|
672
|
*
|
|
673
|
* @ingroup compose
|
|
674
|
*/
|
|
675
|
function compose_feature_media_gallery($feature_node, $media_list, $gallery_settings) {
|
|
676
|
|
|
677
|
if (isset($feature_node->descriptionElements)) {
|
|
678
|
$media_list = array_merge($media_list, cdm_dataportal_media_from_descriptionElements($feature_node->descriptionElements));
|
|
679
|
}
|
|
680
|
|
|
681
|
$captionElements = array('title', 'rights');
|
|
682
|
|
|
683
|
if (isset($media_list[0]) && isset($gallery_settings['cdm_dataportal_media_maxextend']) && isset($gallery_settings['cdm_dataportal_media_cols'])) {
|
|
684
|
$gallery = compose_cdm_media_gallery(array(
|
|
685
|
'mediaList' => $media_list,
|
|
686
|
'galleryName' => CDM_DATAPORTAL_DESCRIPTION_GALLERY_NAME . '_' . $feature_node->term->uuid,
|
|
687
|
'maxExtend' => $gallery_settings['cdm_dataportal_media_maxextend'],
|
|
688
|
'cols' => $gallery_settings['cdm_dataportal_media_cols'],
|
|
689
|
'captionElements' => $captionElements,
|
|
690
|
));
|
|
691
|
return markup_to_render_array($gallery);
|
|
692
|
}
|
|
693
|
|
|
694
|
return markup_to_render_array('');
|
|
695
|
}
|
|
696
|
|
|
697
|
/**
|
|
698
|
* Composes the distribution feature block for a taxon
|
|
699
|
*
|
|
700
|
* @param $taxon
|
|
701
|
* @param $descriptionElements
|
|
702
|
* an associative array with two elements:
|
|
703
|
* - '#type': must be 'DTO'
|
|
704
|
* - 'DistributionInfoDTO': a CDM DistributionInfoDTO object as returned by the DistributionInfo web service
|
|
705
|
* @param $feature
|
|
706
|
*
|
|
707
|
* @return array
|
|
708
|
* A drupal render array
|
|
709
|
*
|
|
710
|
* @ingroup compose
|
|
711
|
*/
|
|
712
|
function compose_feature_block_distribution($taxon, $descriptionElements, $feature) {
|
|
713
|
$text_data_glue = '';
|
|
714
|
$text_data_sortOutArray = FALSE;
|
|
715
|
$text_data_enclosingTag = 'ul';
|
|
716
|
$text_data_out_array = array();
|
|
717
|
|
|
718
|
$distributionElements = NULL;
|
|
719
|
$distribution_info_dto = NULL;
|
|
720
|
$distribution_sortOutArray = FALSE;
|
|
721
|
|
|
722
|
$feature_block_settings = get_feature_block_settings(UUID_DISTRIBUTION);
|
|
723
|
|
|
724
|
// TODO use feature_block_settings instead of DISTRIBUTION_ORDER_MODE
|
|
725
|
if (variable_get(DISTRIBUTION_ORDER_MODE, DISTRIBUTION_ORDER_MODE_DEFAULT) != 'TREE') {
|
|
726
|
$distribution_glue = '';
|
|
727
|
$distribution_enclosingTag = 'dl';
|
|
728
|
} else {
|
|
729
|
$distribution_glue = '';
|
|
730
|
$distribution_enclosingTag = 'ul';
|
|
731
|
}
|
|
732
|
|
|
733
|
if (!isset($descriptionElements['#type']) || !$descriptionElements['#type'] == 'DTO') {
|
|
734
|
// skip the DISTRIBUTION section if there is no DTO type element
|
|
735
|
return array(); // FIXME is it ok to return an empty array?
|
|
736
|
}
|
|
737
|
|
|
738
|
$block = feature_block(
|
|
739
|
cdm_term_representation($feature, 'Unnamed Feature'),
|
|
740
|
$feature
|
|
741
|
);
|
|
742
|
$block->content = array();
|
|
743
|
|
|
744
|
// $$descriptionElements['TextData'] is added to to the feature node in merged_taxon_feature_tree()
|
|
745
|
if (isset($descriptionElements['TextData'])) {
|
|
746
|
// --- TextData
|
|
747
|
foreach ($descriptionElements['TextData'] as $text_data_element) {
|
|
748
|
$text_data_render_array = compose_description_element_text_data($text_data_element, $text_data_element->feature->uuid, $feature_block_settings);
|
|
749
|
$repr = drupal_render($text_data_render_array);
|
|
750
|
|
|
751
|
if (!array_search($repr, $text_data_out_array)) { // de-duplication !!
|
|
752
|
$text_data_out_array[] = $repr;
|
|
753
|
// TODO HINT: sorting in compose_feature_block_wrap_elements will
|
|
754
|
// not work since this array contains html attributes with uuids
|
|
755
|
// and what is about cases like the bibliography where
|
|
756
|
// any content can be prefixed with some foot-note anchors?
|
|
757
|
$text_data_sortOutArray = TRUE;
|
|
758
|
$text_data_glue = '<br/> ';
|
|
759
|
$text_data_enclosingTag = 'p';
|
|
760
|
}
|
|
761
|
}
|
|
762
|
}
|
|
763
|
|
|
764
|
|
|
765
|
if ($text_data_out_array && variable_get(DISTRIBUTION_TEXTDATA_DISPLAY_ON_TOP, 0)) {
|
|
766
|
$block->content[] = compose_feature_block_wrap_elements(
|
|
767
|
$text_data_out_array, $feature, $text_data_glue, $text_data_sortOutArray
|
|
768
|
);
|
|
769
|
}
|
|
770
|
|
|
771
|
// --- Distribution map
|
|
772
|
$distribution_map_query_parameters = NULL;
|
|
773
|
|
|
774
|
$map_visibility = variable_get(DISTRIBUTION_MAP_VISIBILITY, DISTRIBUTION_MAP_VISIBILITY_DEFAULT);
|
|
775
|
if(variable_get(DISTRIBUTION_MAP_VISIBILITY, DISTRIBUTION_MAP_VISIBILITY_DEFAULT) == 'always' ||
|
|
776
|
$map_visibility == 'automatic' && isset($descriptionElements['DistributionInfoDTO']->mapUriParams)
|
|
777
|
)
|
|
778
|
{
|
|
779
|
$distribution_map_query_parameters = $descriptionElements['DistributionInfoDTO']->mapUriParams;
|
|
780
|
}
|
|
781
|
$map_render_element = compose_distribution_map($distribution_map_query_parameters);
|
|
782
|
$block->content[] = $map_render_element;
|
|
783
|
|
|
784
|
$dto_out_array = array();
|
|
785
|
|
|
786
|
// --- Condensed Distribution
|
|
787
|
if(variable_get(DISTRIBUTION_CONDENSED) && isset($descriptionElements['DistributionInfoDTO']->condensedDistribution)){
|
|
788
|
$condensed_distribution_markup = '<p class="condensed_distribution">';
|
|
789
|
|
|
790
|
if(isset($descriptionElements['DistributionInfoDTO']->condensedDistribution->htmlString)){
|
|
791
|
$condensed_distribution_markup .= $descriptionElements['DistributionInfoDTO']->condensedDistribution->htmlString;
|
|
792
|
}
|
|
793
|
|
|
794
|
$condensed_distribution_markup .= ' ' . l(
|
|
795
|
font_awesome_icon_markup(
|
|
796
|
'fa-info-circle',
|
|
797
|
array(
|
|
798
|
'alt'=>'help',
|
|
799
|
'class' => array('superscript')
|
|
800
|
)
|
|
801
|
),
|
|
802
|
variable_get(DISTRIBUTION_CONDENSED_INFO_PATH, DISTRIBUTION_CONDENSED_INFO_PATH_DEFAULT) ,
|
|
803
|
array('html' => TRUE));
|
|
804
|
$condensed_distribution_markup .= '</p>';
|
|
805
|
$dto_out_array[] = $condensed_distribution_markup;
|
|
806
|
}
|
|
807
|
|
|
808
|
// --- tree or list
|
|
809
|
if (isset($descriptionElements['DistributionInfoDTO'])) {
|
|
810
|
$distribution_info_dto = $descriptionElements['DistributionInfoDTO'];
|
|
811
|
|
|
812
|
// --- tree
|
|
813
|
if (is_object($distribution_info_dto->tree)) {
|
|
814
|
$distribution_tree_render_array = compose_distribution_hierarchy($distribution_info_dto->tree, $feature_block_settings);
|
|
815
|
$dto_out_array[] = $distribution_tree_render_array;
|
|
816
|
}
|
|
817
|
|
|
818
|
// --- sorted element list
|
|
819
|
if (is_array($distribution_info_dto->elements) && count($distribution_info_dto->elements) > 0) {
|
|
820
|
foreach ($distribution_info_dto->elements as $descriptionElement) {
|
|
821
|
if (is_object($descriptionElement->area)) {
|
|
822
|
$sortKey = $descriptionElement->area->representation_L10n;
|
|
823
|
$distributionElements[$sortKey] = $descriptionElement;
|
|
824
|
}
|
|
825
|
}
|
|
826
|
ksort($distributionElements);
|
|
827
|
$distribution_element_render_array = compose_description_elements_distribution($distributionElements);
|
|
828
|
$dto_out_array[] = $distribution_element_render_array;
|
|
829
|
|
|
830
|
}
|
|
831
|
//
|
|
832
|
$block->content[] = compose_feature_block_wrap_elements(
|
|
833
|
$dto_out_array, $feature, $distribution_glue, $distribution_sortOutArray
|
|
834
|
);
|
|
835
|
}
|
|
836
|
|
|
837
|
// --- TextData at the bottom
|
|
838
|
if ($text_data_out_array && !variable_get(DISTRIBUTION_TEXTDATA_DISPLAY_ON_TOP, 0)) {
|
|
839
|
$block->content[] = compose_feature_block_wrap_elements(
|
|
840
|
$text_data_out_array, $feature, $text_data_glue, $text_data_sortOutArray
|
|
841
|
);
|
|
842
|
}
|
|
843
|
|
|
844
|
$block->content[] = markup_to_render_array(render_footnotes('BIBLIOGRAPHY-' . UUID_DISTRIBUTION));
|
|
845
|
$block->content[] = markup_to_render_array(render_footnotes(UUID_DISTRIBUTION));
|
|
846
|
|
|
847
|
return $block;
|
|
848
|
}
|
|
849
|
|
|
850
|
/**
|
|
851
|
* Creates the markup for the media associated a DescriptionElement instance.
|
|
852
|
*
|
|
853
|
* @param $descriptionElement
|
|
854
|
* the DescriptionElement instance
|
|
855
|
* @param $mimeTypePreference array
|
|
856
|
* An array of mime type strings. the order of the mimetypes is the order of preference.
|
|
857
|
* E.g.: array('application/pdf','image/jpeg')
|
|
858
|
*
|
|
859
|
* @return string
|
|
860
|
* The markup
|
|
861
|
*
|
|
862
|
* @ingroup compose
|
|
863
|
*/
|
|
864
|
function cdm_description_element_media($descriptionElement, $mimeTypePreference) {
|
|
865
|
|
|
866
|
$out = '';
|
|
867
|
|
|
868
|
_add_js_thickbox();
|
|
869
|
|
|
870
|
$feature = $descriptionElement->feature;
|
|
871
|
$medias = $descriptionElement->media;
|
|
872
|
|
|
873
|
foreach ($medias as $media) {
|
|
874
|
$pref_representations = cdm_preferred_media_representations($media, $mimeTypePreference, 300, 400);
|
|
875
|
$media_representation = array_shift($pref_representations);
|
|
876
|
if ($media_representation) {
|
|
877
|
|
|
878
|
$content_type_directory = media_content_type_dir($media_representation);
|
|
879
|
|
|
880
|
switch($content_type_directory){
|
|
881
|
case 'image':
|
|
882
|
$out .= compose_cdm_media_mime_image($media_representation, $feature);
|
|
883
|
break;
|
|
884
|
case 'application':
|
|
885
|
case 'text':
|
|
886
|
default:
|
|
887
|
$out .= compose_cdm_media_mime_application($media_representation, $feature);
|
|
888
|
}
|
|
889
|
}
|
|
890
|
else {
|
|
891
|
// Media has empty or corrupt representation
|
|
892
|
if(user_is_logged_in()){
|
|
893
|
drupal_set_message('The media entity (' . l($media->uuid, path_to_media($media->uuid)) .') has empty or corrupt representation parts. Maybe the URI is empty.' , 'warning');
|
|
894
|
}
|
|
895
|
}
|
|
896
|
}
|
|
897
|
return $out;
|
|
898
|
}
|
|
899
|
|
|
900
|
|
|
901
|
/**
|
|
902
|
* Composes a drupal render array for single CDM TextData description element.
|
|
903
|
*
|
|
904
|
* @param $element
|
|
905
|
* The CDM TextData description element.
|
|
906
|
* @param $feature_uuid
|
|
907
|
* @param bool $prepend_feature_label
|
|
908
|
* Used in nested feature trees to put the feature as label in front of the description element text representation.
|
|
909
|
*
|
|
910
|
* @return array
|
|
911
|
* A drupal render array with the following elements being used:
|
|
912
|
* - #tag: either 'div', 'li', ...
|
|
913
|
* ⁻ #attributes: class attributes
|
|
914
|
* - #value_prefix: (optionally) contains footnote anchors
|
|
915
|
* - #value: contains the textual content
|
|
916
|
* - #value_suffix: (optionally) contains footnote keys
|
|
917
|
*
|
|
918
|
* @ingroup compose
|
|
919
|
*/
|
|
920
|
function compose_description_element_text_data($element, $feature_uuid, $feature_block_settings, $prepend_feature_label = FALSE) {
|
|
921
|
|
|
922
|
$footnote_list_key_suggestion = $feature_uuid;
|
|
923
|
|
|
924
|
$element_markup = '';
|
|
925
|
if (isset($element->multilanguageText_L10n->text)) {
|
|
926
|
// TODO replacement of \n by <br> should be configurable
|
|
927
|
$element_markup = str_replace("\n", "<br/>", $element->multilanguageText_L10n->text);
|
|
928
|
}
|
|
929
|
|
|
930
|
$render_array = compose_description_element($element, $feature_block_settings, $element_markup, $footnote_list_key_suggestion, $prepend_feature_label);
|
|
931
|
|
|
932
|
return $render_array;
|
|
933
|
}
|
|
934
|
|
|
935
|
|
|
936
|
/**
|
|
937
|
* Theme function to render CDM DescriptionElements of the type TaxonInteraction.
|
|
938
|
*
|
|
939
|
* @param $element
|
|
940
|
* The CDM TaxonInteraction entity
|
|
941
|
*
|
|
942
|
* @return
|
|
943
|
* A drupal render array
|
|
944
|
*
|
|
945
|
* @ingroup compose
|
|
946
|
*/
|
|
947
|
function compose_description_element_taxon_interaction($element, $feature_block_settings) {
|
|
948
|
|
|
949
|
$out = '';
|
|
950
|
|
|
951
|
|
|
952
|
if (isset($element->description_L10n)) {
|
|
953
|
$out .= ' ' . $element->description_L10n;
|
|
954
|
}
|
|
955
|
|
|
956
|
if(isset($element->taxon2)){
|
|
957
|
$out = render_taxon_or_name($element->taxon2, url(path_to_taxon($element->taxon2->uuid)));
|
|
958
|
}
|
|
959
|
|
|
960
|
$render_array = compose_description_element($element, $feature_block_settings, $out, $element->feature->uuid);
|
|
961
|
|
|
962
|
return $render_array;
|
|
963
|
}
|
|
964
|
|
|
965
|
|
|
966
|
/**
|
|
967
|
* Renders a single instance of the type IndividualsAssociations.
|
|
968
|
*
|
|
969
|
* @param $element
|
|
970
|
* The CDM IndividualsAssociations entity.
|
|
971
|
* @param $feature_block_settings
|
|
972
|
*
|
|
973
|
* @return array
|
|
974
|
* Drupal render array
|
|
975
|
*
|
|
976
|
* @ingroup compose
|
|
977
|
*/
|
|
978
|
function compose_description_element_individuals_association($element, $feature_block_settings) {
|
|
979
|
|
|
980
|
$out = '';
|
|
981
|
|
|
982
|
$render_array = compose_cdm_specimen_or_observation($element->associatedSpecimenOrObservation);
|
|
983
|
|
|
984
|
if (isset($element->description_L10n)) {
|
|
985
|
$out .= ' ' . $element->description_L10n;
|
|
986
|
}
|
|
987
|
|
|
988
|
$out .= drupal_render($render_array);
|
|
989
|
|
|
990
|
$render_array = compose_description_element($element, $feature_block_settings, $out, $element->feature->uuid);
|
|
991
|
|
|
992
|
return $render_array;
|
|
993
|
}
|
|
994
|
|
|
995
|
/**
|
|
996
|
* Renders a single instance of the type CategoricalData.
|
|
997
|
*
|
|
998
|
* @param $element
|
|
999
|
* The CDM CategoricalData entity
|
|
1000
|
*
|
|
1001
|
* @param $feature_block_settings
|
|
1002
|
*
|
|
1003
|
* @param bool $prepend_feature_label
|
|
1004
|
* Used in nested feature trees to put the feature as label in front of the description element text representation.
|
|
1005
|
*
|
|
1006
|
* @return array
|
|
1007
|
* a drupal render array for given CategoricalData element
|
|
1008
|
*
|
|
1009
|
* @ingroup compose
|
|
1010
|
*/
|
|
1011
|
function compose_description_element_categorical_data($element, $feature_block_settings, $prepend_feature_label = FALSE) {
|
|
1012
|
|
|
1013
|
$state_data_markup = render_state_data($element);
|
|
1014
|
|
|
1015
|
$render_array = compose_description_element($element, $feature_block_settings, $state_data_markup, $element->feature->uuid, $prepend_feature_label);
|
|
1016
|
|
|
1017
|
return $render_array;
|
|
1018
|
}
|
|
1019
|
|
|
1020
|
/**
|
|
1021
|
* @param $element
|
|
1022
|
*
|
|
1023
|
* @return string
|
|
1024
|
* the markup
|
|
1025
|
*/
|
|
1026
|
function render_state_data($element) {
|
|
1027
|
|
|
1028
|
$state_data_items = [];
|
|
1029
|
|
|
1030
|
$out = '';
|
|
1031
|
|
|
1032
|
if (isset($element->stateData)) {
|
|
1033
|
foreach ($element->stateData as $state_data) {
|
|
1034
|
|
|
1035
|
$state = NULL;
|
|
1036
|
|
|
1037
|
if (isset($state_data->state)) {
|
|
1038
|
$state = cdm_term_representation($state_data->state);
|
|
1039
|
|
|
1040
|
$sample_count = 0;
|
|
1041
|
if (isset($state_data->count)) {
|
|
1042
|
$sample_count = $state_data->count;
|
|
1043
|
$state .= ' [' . $state_data->count . ']';
|
|
1044
|
}
|
|
1045
|
|
|
1046
|
if (isset($state_data->modifyingText_L10n)) {
|
|
1047
|
$state .= ' ' . $state_data->modifyingText_L10n;
|
|
1048
|
}
|
|
1049
|
|
|
1050
|
$modifiers_strings = cdm_modifiers_representations($state_data);
|
|
1051
|
$state_data_markup = $state . ($modifiers_strings ? ' ' . $modifiers_strings : '');
|
|
1052
|
// we could use strip_tags() to reduce the markup to text for the key but this is expensive
|
|
1053
|
$sort_key = str_pad($sample_count, 6, '0', STR_PAD_LEFT) . '_' . $state_data_markup;
|
|
1054
|
$state_data_items[$sort_key] = $state_data_markup;
|
|
1055
|
}
|
|
1056
|
|
|
1057
|
}
|
|
1058
|
krsort($state_data_items);
|
|
1059
|
$out = '<span class="' . html_class_attribute_ref($element) . '">' . join(', ', $state_data_items) . '</span>';
|
|
1060
|
}
|
|
1061
|
return $out;
|
|
1062
|
}
|
|
1063
|
|
|
1064
|
|
|
1065
|
/**
|
|
1066
|
* Theme function to render CDM DescriptionElements of the type QuantitativeData.
|
|
1067
|
*
|
|
1068
|
* The function renders the statisticalValues contained in the QuantitativeData
|
|
1069
|
* entity according to the following scheme:
|
|
1070
|
*
|
|
1071
|
* (ExtremeMin)-Min-Average-Max-(ExtremeMax)
|
|
1072
|
*
|
|
1073
|
* All modifiers of these values are appended.
|
|
1074
|
*
|
|
1075
|
* If the QuantitativeData is containing more statisticalValues with further
|
|
1076
|
* statisticalValue types, these additional measures will be appended to the
|
|
1077
|
* above string separated by whitespace.
|
|
1078
|
*
|
|
1079
|
* Special cases;
|
|
1080
|
* 1. Min==Max: this will be interpreted as Average
|
|
1081
|
*
|
|
1082
|
* @param $element
|
|
1083
|
* The CDM QuantitativeData entity
|
|
1084
|
*
|
|
1085
|
* @param $feature_block_settings
|
|
1086
|
*
|
|
1087
|
* @param bool $prepend_feature_label
|
|
1088
|
* Used in nested feature trees to put the feature as label in front of the description element text representation.
|
|
1089
|
*
|
|
1090
|
*
|
|
1091
|
* @return array
|
|
1092
|
* drupal render array for the given QuantitativeData element
|
|
1093
|
*
|
|
1094
|
* @ingroup compose
|
|
1095
|
*/
|
|
1096
|
function compose_description_element_quantitative_data($element, $feature_block_settings, $prepend_feature_label = FALSE) {
|
|
1097
|
/*
|
|
1098
|
* - statisticalValues
|
|
1099
|
* - value
|
|
1100
|
* - modifiers
|
|
1101
|
* - type
|
|
1102
|
* - unit->representation_L10n
|
|
1103
|
* - modifyingText
|
|
1104
|
* - modifiers
|
|
1105
|
* - sources
|
|
1106
|
*/
|
|
1107
|
|
|
1108
|
$out = render_quantitative_statistics($element);
|
|
1109
|
|
|
1110
|
$render_array = compose_description_element($element, $feature_block_settings, $out, $element->feature->uuid, $prepend_feature_label);
|
|
1111
|
|
|
1112
|
return $render_array;
|
|
1113
|
}
|
|
1114
|
|
|
1115
|
/**
|
|
1116
|
* Composes the HTML for quantitative statistics
|
|
1117
|
* @param $element
|
|
1118
|
*
|
|
1119
|
* @return string
|
|
1120
|
*/
|
|
1121
|
function render_quantitative_statistics($element) {
|
|
1122
|
|
|
1123
|
$out = '';
|
|
1124
|
$type_representation = NULL;
|
|
1125
|
$min_max = statistical_values_array();
|
|
1126
|
$sample_size_markup = null;
|
|
1127
|
|
|
1128
|
if (isset($element->statisticalValues)) {
|
|
1129
|
$out = '<span class=\"' . html_class_attribute_ref($element) . '\">';
|
|
1130
|
$other_values_markup = [];
|
|
1131
|
foreach ($element->statisticalValues as $statistical_val) {
|
|
1132
|
|
|
1133
|
// compile the full value string which also may contain modifiers
|
|
1134
|
if (isset($statistical_val->value)) {
|
|
1135
|
$statistical_val->_value = $statistical_val->value;
|
|
1136
|
}
|
|
1137
|
$val_modifiers_strings = cdm_modifiers_representations($statistical_val);
|
|
1138
|
if ($val_modifiers_strings) {
|
|
1139
|
$statistical_val->_value = ' ' . $val_modifiers_strings . ' ' . $statistical_val->_value;
|
|
1140
|
}
|
|
1141
|
|
|
1142
|
// either put into min max array or into $other_values
|
|
1143
|
// for generic output to be appended to 'min-max' string
|
|
1144
|
if (array_key_exists(statistical_measure_term2min_max_key($statistical_val->type), $min_max)) {
|
|
1145
|
$min_max[statistical_measure_term2min_max_key($statistical_val->type)] = $statistical_val;
|
|
1146
|
}
|
|
1147
|
else {
|
|
1148
|
drupal_set_message("Unsupported statistical value type: " . $statistical_val->type->uuid, "error");
|
|
1149
|
}
|
|
1150
|
} // end of loop over statisticalValues
|
|
1151
|
|
|
1152
|
// create markup
|
|
1153
|
$unit = null;
|
|
1154
|
if (isset($element->unit)) {
|
|
1155
|
$unit = ' <span class="unit" title="'
|
|
1156
|
. cdm_term_representation($element->unit) . '">'
|
|
1157
|
. cdm_term_representation_abbreviated($element->unit)
|
|
1158
|
. '</span>';
|
|
1159
|
}
|
|
1160
|
$min_max_markup = statistical_values($min_max, $unit);
|
|
1161
|
$out .= $min_max_markup . '</span>';
|
|
1162
|
}
|
|
1163
|
|
|
1164
|
if($sample_size_markup){
|
|
1165
|
$out .= ' ' . $sample_size_markup;
|
|
1166
|
|
|
1167
|
}
|
|
1168
|
|
|
1169
|
// modifiers of the description element itself
|
|
1170
|
$modifier_string = cdm_modifiers_representations($element);
|
|
1171
|
$out .= ($modifier_string ? ' ' . $modifier_string : '');
|
|
1172
|
if (isset($element->modifyingText_L10n)) {
|
|
1173
|
$out = $element->modifyingText_L10n . ' ' . $out;
|
|
1174
|
}
|
|
1175
|
return $out;
|
|
1176
|
}
|
|
1177
|
|
|
1178
|
function statistical_measure_term2min_max_key($term){
|
|
1179
|
static $uuid2key = [
|
|
1180
|
UUID_STATISTICALMEASURE_MIN => 'Min',
|
|
1181
|
UUID_STATISTICALMEASURE_MAX => 'Max',
|
|
1182
|
UUID_STATISTICALMEASURE_AVERAGE => 'Average',
|
|
1183
|
UUID_STATISTICALMEASURE_SAMPLESIZE => 'SampleSize',
|
|
1184
|
UUID_STATISTICALMEASURE_VARIANCE => 'Variance',
|
|
1185
|
UUID_STATISTICALMEASURE_TYPICALLOWERBOUNDARY => 'TypicalLowerBoundary',
|
|
1186
|
UUID_STATISTICALMEASURE_TYPICALUPPERBOUNDARY => 'TypicalUpperBoundary',
|
|
1187
|
UUID_STATISTICALMEASURE_STANDARDDEVIATION => 'StandardDeviation',
|
|
1188
|
UUID_STATISTICALMEASURE_EXACTVALUE => 'ExactValue',
|
|
1189
|
UUID_STATISTICALMEASURE_STATISTICALMEASUREUNKNOWNDATA => 'StatisticalMeasureUnknownData'
|
|
1190
|
];
|
|
1191
|
return $uuid2key[$term->uuid];
|
|
1192
|
}
|
|
1193
|
|
|
1194
|
|
|
1195
|
/**
|
|
1196
|
* Wraps the render array for the given feature into an enclosing html tag.
|
|
1197
|
*
|
|
1198
|
* Optionally the elements can be sorted and glued together by a separator string.
|
|
1199
|
*
|
|
1200
|
* @param array $description_element_render_arrays
|
|
1201
|
* An list of render arrays. Which are usually are produced by the compose_description_element()
|
|
1202
|
* function. The render arrays should be of #type=html_tag, so that they can understand the #attribute property.
|
|
1203
|
* @param $feature :
|
|
1204
|
* The feature to which the elements given in $elements are belonging to.
|
|
1205
|
* @param string $glue :
|
|
1206
|
* Defaults to empty string.
|
|
1207
|
* @param bool $sort
|
|
1208
|
* Boolean Whether to sort the $elements alphabetically, default is FALSE
|
|
1209
|
*
|
|
1210
|
* @return array
|
|
1211
|
* A Drupal render array
|
|
1212
|
*
|
|
1213
|
* @ingroup compose
|
|
1214
|
*/
|
|
1215
|
function compose_feature_block_wrap_elements(array $description_element_render_arrays, $feature, $glue = '', $sort = FALSE)
|
|
1216
|
{
|
|
1217
|
|
|
1218
|
$feature_block_settings = get_feature_block_settings($feature->uuid);
|
|
1219
|
$enclosing_tag = $feature_block_settings['as_list'];
|
|
1220
|
|
|
1221
|
if ($sort) { // TODO remove parameter and replace by $feature_block_settings['sort_elements']
|
|
1222
|
usort($description_element_render_arrays, 'compare_description_element_render_arrays');
|
|
1223
|
}
|
|
1224
|
|
|
1225
|
$is_first = true;
|
|
1226
|
foreach($description_element_render_arrays as &$element_render_array){
|
|
1227
|
if(!is_array($element_render_array)){
|
|
1228
|
$element_render_array = markup_to_render_array($element_render_array);
|
|
1229
|
}
|
|
1230
|
$element_render_array['#attributes']['class'][] = "feature-block-element";
|
|
1231
|
|
|
1232
|
// add the glue!
|
|
1233
|
if(!$is_first) {
|
|
1234
|
if (isset($element_render_array['#value'])) {
|
|
1235
|
$element_render_array['#value'] = $glue . $element_render_array['#value'];
|
|
1236
|
} elseif (isset($element_render_array['#markup'])) {
|
|
1237
|
$element_render_array['#markup'] = $glue . $element_render_array['#markup'];
|
|
1238
|
}
|
|
1239
|
}
|
|
1240
|
$is_first = false;
|
|
1241
|
}
|
|
1242
|
|
|
1243
|
$render_array['elements']['children'] = $description_element_render_arrays;
|
|
1244
|
|
|
1245
|
$render_array['elements']['#prefix'] = '<' . $enclosing_tag . ' class="feature-block-elements" id="' . $feature->representation_L10n . '">';
|
|
1246
|
$render_array['elements']['#suffix'] = '</' . $enclosing_tag . '>';
|
|
1247
|
|
|
1248
|
return $render_array;
|
|
1249
|
}
|
|
1250
|
|
|
1251
|
|
|
1252
|
/* compose nameInSource or originalNameString as markup
|
|
1253
|
*
|
|
1254
|
* @param $source
|
|
1255
|
* @param $do_link_to_name_used_in_source
|
|
1256
|
* @param $suppress_for_shown_taxon
|
|
1257
|
* the nameInSource will be suppressed when it has the same name as the accepted taxon
|
|
1258
|
* for which the taxon page is being created, Defaults to TRUE
|
|
1259
|
*
|
|
1260
|
* @return array
|
|
1261
|
* A Drupal render array with an additional element, the render array is empty
|
|
1262
|
* if the source had no name in source information
|
|
1263
|
* - #_plaintext: contains the plaintext version of the name (custom element)
|
|
1264
|
*
|
|
1265
|
* @ingroup compose
|
|
1266
|
*/
|
|
1267
|
function compose_name_in_source($source, $do_link_to_name_used_in_source, $suppress_for_shown_taxon = TRUE) {
|
|
1268
|
|
|
1269
|
$plaintext = NULL;
|
|
1270
|
$markup = NULL;
|
|
1271
|
$name_in_source_render_array = array();
|
|
1272
|
|
|
1273
|
static $taxon_page_accepted_name = '';
|
|
1274
|
$taxon_uuid = get_current_taxon_uuid();
|
|
1275
|
if($suppress_for_shown_taxon && $taxon_uuid && empty($taxon_page_accepted_name)){
|
|
1276
|
|
|
1277
|
$current_taxon = cdm_ws_get(CDM_WS_PORTAL_TAXON, $taxon_uuid);
|
|
1278
|
$taxon_page_accepted_name = $current_taxon->name->titleCache;
|
|
1279
|
}
|
|
1280
|
|
|
1281
|
if (isset($source->nameUsedInSource->uuid) && isset($source->nameUsedInSource->titleCache)) {
|
|
1282
|
// it is a DescriptionElementSource !
|
|
1283
|
$plaintext = $source->nameUsedInSource->titleCache;
|
|
1284
|
if($suppress_for_shown_taxon && $taxon_page_accepted_name == $plaintext){
|
|
1285
|
return $name_in_source_render_array; // SKIP this name
|
|
1286
|
}
|
|
1287
|
$markup = render_taxon_or_name($source->nameUsedInSource);
|
|
1288
|
if ($do_link_to_name_used_in_source) {
|
|
1289
|
$markup = l(
|
|
1290
|
$markup,
|
|
1291
|
path_to_name($source->nameUsedInSource->uuid),
|
|
1292
|
array(
|
|
1293
|
'attributes' => array(),
|
|
1294
|
'absolute' => TRUE,
|
|
1295
|
'html' => TRUE,
|
|
1296
|
));
|
|
1297
|
}
|
|
1298
|
}
|
|
1299
|
else if (isset($source->originalNameString) && !empty($source->originalNameString)) {
|
|
1300
|
// the name used in source can not be expressed as valid taxon name,
|
|
1301
|
// so the editor has chosen to put the freetext name into ReferencedEntityBase.originalNameString
|
|
1302
|
// field
|
|
1303
|
// using the originalNameString as key to avoid duplicate entries
|
|
1304
|
$plaintext = $source->originalNameString;
|
|
1305
|
if($suppress_for_shown_taxon && $taxon_page_accepted_name == $plaintext){
|
|
1306
|
return $name_in_source_render_array; // SKIP this name
|
|
1307
|
}
|
|
1308
|
$markup = $source->originalNameString;
|
|
1309
|
}
|
|
1310
|
|
|
1311
|
if ($plaintext) { // checks if we have any content
|
|
1312
|
$name_in_source_render_array = markup_to_render_array($markup);
|
|
1313
|
$name_in_source_render_array['#_plaintext'] = $plaintext;
|
|
1314
|
}
|
|
1315
|
|
|
1316
|
return $name_in_source_render_array;
|
|
1317
|
}
|
|
1318
|
|
|
1319
|
|
|
1320
|
|
|
1321
|
/**
|
|
1322
|
* Return HTML for a list of description elements.
|
|
1323
|
*
|
|
1324
|
* Usually these are of a specific feature type.
|
|
1325
|
*
|
|
1326
|
* @param $description_elements
|
|
1327
|
* array of descriptionElements which belong to the same feature.
|
|
1328
|
* These descriptions elements of a Description must be ordered by the chosen feature tree by
|
|
1329
|
* calling the function _mergeFeatureTreeDescriptions().
|
|
1330
|
* @see _mergeFeatureTreeDescriptions()
|
|
1331
|
*
|
|
1332
|
* @param $feature_uuid
|
|
1333
|
*
|
|
1334
|
* @return
|
|
1335
|
* A drupal render array for the $descriptionElements, may be an empty array if the textual content was empty.
|
|
1336
|
* Footnote key or anchors are not considered to be textual content.
|
|
1337
|
*
|
|
1338
|
* @ingroup compose
|
|
1339
|
*/
|
|
1340
|
function compose_feature_block_items_generic($description_elements, $feature) {
|
|
1341
|
|
|
1342
|
$elements_out_array = array();
|
|
1343
|
$distribution_tree = null;
|
|
1344
|
|
|
1345
|
/*
|
|
1346
|
* $feature_block_has_content will be set true if at least one of the
|
|
1347
|
* $descriptionElements contains some text which makes up some content
|
|
1348
|
* for the feature block. Footnote keys are not considered
|
|
1349
|
* to be content in this sense.
|
|
1350
|
*/
|
|
1351
|
$feature_block_has_content = false;
|
|
1352
|
|
|
1353
|
if (is_array($description_elements)) {
|
|
1354
|
foreach ($description_elements as $description_element) {
|
|
1355
|
/* decide based on the description element class
|
|
1356
|
*
|
|
1357
|
* Features handled here:
|
|
1358
|
* all except DISTRIBUTION, COMMON_NAME, USES, IMAGES,
|
|
1359
|
*
|
|
1360
|
* TODO provide api_hook as extension point for this?
|
|
1361
|
*/
|
|
1362
|
$feature_block_settings = get_feature_block_settings($description_element->feature->uuid);
|
|
1363
|
switch ($description_element->class) {
|
|
1364
|
case 'TextData':
|
|
1365
|
$elements_out_array[] = compose_description_element_text_data($description_element, $description_element->feature->uuid, $feature_block_settings);
|
|
1366
|
break;
|
|
1367
|
case 'CategoricalData':
|
|
1368
|
$elements_out_array[] = compose_description_element_categorical_data($description_element, $feature_block_settings);
|
|
1369
|
break;
|
|
1370
|
case 'QuantitativeData':
|
|
1371
|
$elements_out_array[] = compose_description_element_quantitative_data($description_element, $feature_block_settings);
|
|
1372
|
break;
|
|
1373
|
case 'IndividualsAssociation':
|
|
1374
|
$elements_out_array[] = compose_description_element_individuals_association($description_element, $feature_block_settings);
|
|
1375
|
break;
|
|
1376
|
case 'TaxonInteraction':
|
|
1377
|
$elements_out_array[] = compose_description_element_taxon_interaction($description_element, $feature_block_settings);
|
|
1378
|
break;
|
|
1379
|
case 'CommonTaxonName':
|
|
1380
|
$elements_out_array[] = compose_description_element_common_taxon_name($description_element, $feature_block_settings);
|
|
1381
|
break;
|
|
1382
|
case 'Uses':
|
|
1383
|
/* IGNORE Uses classes, these are handled completely in compose_feature_block_items_use_records() */
|
|
1384
|
break;
|
|
1385
|
default:
|
|
1386
|
$feature_block_has_content = true;
|
|
1387
|
$elements_out_array[] = markup_to_render_array('<li>No method for rendering unknown description class: ' . $description_element->class . '</li>');
|
|
1388
|
}
|
|
1389
|
$elements_out_array_last_item = $elements_out_array[count($elements_out_array) - 1];
|
|
1390
|
// considering not empty as long as the last item added is a render array
|
|
1391
|
$feature_block_has_content = $feature_block_has_content || !empty($elements_out_array_last_item['#type']);
|
|
1392
|
}
|
|
1393
|
|
|
1394
|
// If feature = CITATION sort the list of sources.
|
|
1395
|
// This is ONLY for FLORA MALESIANA and FLORE d'AFRIQUE CENTRALE.
|
|
1396
|
if (isset($description_element) && $description_element->feature->uuid == UUID_CITATION) {
|
|
1397
|
sort($elements_out_array);
|
|
1398
|
}
|
|
1399
|
}
|
|
1400
|
|
|
1401
|
// sanitize: remove empty and NULL items from the render array
|
|
1402
|
$tmp_out_array = $elements_out_array;
|
|
1403
|
$elements_out_array = array();
|
|
1404
|
foreach($tmp_out_array as $item){
|
|
1405
|
if(is_array($item) && count($item) > 0){
|
|
1406
|
$elements_out_array[] = $item;
|
|
1407
|
}
|
|
1408
|
}
|
|
1409
|
|
|
1410
|
return $elements_out_array;
|
|
1411
|
}
|
|
1412
|
|
|
1413
|
/**
|
|
1414
|
* Composes block of common names for the given DescriptionElements $elements which must be of the feature CommonName
|
|
1415
|
*
|
|
1416
|
* @parameter $elements
|
|
1417
|
* an array of CDM DescriptionElements either of type CommonName or TextData
|
|
1418
|
* @parameter $feature
|
|
1419
|
* the common feature of all $elements, must be CommonName
|
|
1420
|
*
|
|
1421
|
* @return
|
|
1422
|
* A drupal render array
|
|
1423
|
*
|
|
1424
|
* @ingroup compose
|
|
1425
|
*/
|
|
1426
|
function compose_feature_block_items_feature_common_name($elements, $feature, $weight = FALSE) {
|
|
1427
|
|
|
1428
|
$common_name_out = '';
|
|
1429
|
$common_name_feature_elements = array();
|
|
1430
|
$textData_commonNames = array();
|
|
1431
|
|
|
1432
|
$footnote_key_suggestion = 'common-names-feature-block';
|
|
1433
|
|
|
1434
|
$feature_block_settings = get_feature_block_settings(UUID_COMMON_NAME);
|
|
1435
|
|
|
1436
|
if (is_array($elements)) {
|
|
1437
|
foreach ($elements as $element) {
|
|
1438
|
|
|
1439
|
if ($element->class == 'CommonTaxonName') {
|
|
1440
|
|
|
1441
|
// common name without a language or area, should not happen but is possible
|
|
1442
|
$language_area_key = '';
|
|
1443
|
if (isset($element->language->representation_L10n)) {
|
|
1444
|
$language_area_key .= $element->language->representation_L10n;
|
|
1445
|
}
|
|
1446
|
if(isset($element->area->representation_L10n) && strlen($element->area->representation_L10n) > 0){
|
|
1447
|
$language_area_key .= ($language_area_key ? ' ' : '') . '(' . $element->area->representation_L10n . ')';
|
|
1448
|
}
|
|
1449
|
if($language_area_key){
|
|
1450
|
$language_area_key = '<span class="language-area-label">' . $language_area_key . '<span class="separator">: </span></span>';
|
|
1451
|
}
|
|
1452
|
|
|
1453
|
if(isset($common_names[$language_area_key][$element->name])) {
|
|
1454
|
// same name already exists for language and area combination, se we merge the description elements
|
|
1455
|
cdm_merge_description_elements($common_names[$language_area_key][$element->name], $element);
|
|
1456
|
} else{
|
|
1457
|
// otherwise add as new entry
|
|
1458
|
$common_names[$language_area_key][$element->name] = $element;
|
|
1459
|
}
|
|
1460
|
|
|
1461
|
}
|
|
1462
|
elseif ($element->class == 'TextData') {
|
|
1463
|
$textData_commonNames[] = $element;
|
|
1464
|
}
|
|
1465
|
}
|
|
1466
|
}
|
|
1467
|
// Handling common names.
|
|
1468
|
if (isset($common_names) && count($common_names) > 0) {
|
|
1469
|
// Sorting the array based on the key (language, + area if set).
|
|
1470
|
// Comment @WA there are common names without a language, so this sorting
|
|
1471
|
// can give strange results.
|
|
1472
|
ksort($common_names);
|
|
1473
|
|
|
1474
|
// loop over set of elements per language area
|
|
1475
|
foreach ($common_names as $language_area_key => $elements) {
|
|
1476
|
ksort($elements); // sort names alphabetically
|
|
1477
|
$per_language_area_out = array();
|
|
1478
|
|
|
1479
|
foreach ($elements as $element) {
|
|
1480
|
$common_name_render_array = compose_description_element_common_taxon_name($element, $feature_block_settings, $footnote_key_suggestion);
|
|
1481
|
$common_name_markup = drupal_render($common_name_render_array);
|
|
1482
|
// IMPORTANT!
|
|
1483
|
// during the above drupal_render the theme_html_tag function is executed, which adds a "\n" character to the end of the markup
|
|
1484
|
// this is an error and the trailing whitespace needs to be removed
|
|
1485
|
if(str_endsWith($common_name_markup, "\n")){
|
|
1486
|
$common_name_markup = substr($common_name_markup, 0, strlen($common_name_markup) - 1);
|
|
1487
|
}
|
|
1488
|
$per_language_area_out[] = $common_name_markup;
|
|
1489
|
}
|
|
1490
|
|
|
1491
|
$common_name_feature_elements[] = $language_area_key . join(', ', $per_language_area_out);
|
|
1492
|
} // End of loop over set of elements per language area
|
|
1493
|
|
|
1494
|
|
|
1495
|
$common_name_feature_elements_render_array = compose_feature_block_wrap_elements(
|
|
1496
|
$common_name_feature_elements, $feature, '; ', FALSE
|
|
1497
|
);
|
|
1498
|
$common_name_out .= drupal_render($common_name_feature_elements_render_array); // FIXME should this be a render array instead?
|
|
1499
|
|
|
1500
|
}
|
|
1501
|
|
|
1502
|
// Handling commons names as text data.
|
|
1503
|
$text_data_out = array();
|
|
1504
|
|
|
1505
|
foreach ($textData_commonNames as $text_data_element) {
|
|
1506
|
/* footnotes are not handled correctly in compose_description_element_text_data,
|
|
1507
|
need to set 'common-names-feature-block' as $footnote_key_suggestion */
|
|
1508
|
RenderHints::setFootnoteListKey($footnote_key_suggestion);
|
|
1509
|
$text_data_render_array = compose_description_element_text_data($text_data_element, $text_data_element->feature->uuid, $feature_block_settings);
|
|
1510
|
$text_data_out[] = drupal_render($text_data_render_array);
|
|
1511
|
}
|
|
1512
|
|
|
1513
|
$common_name_out_text_data = compose_feature_block_wrap_elements(
|
|
1514
|
$text_data_out, $feature
|
|
1515
|
);
|
|
1516
|
|
|
1517
|
$footnotes = render_footnotes('BIBLIOGRAPHY-' . $footnote_key_suggestion);
|
|
1518
|
$footnotes .= render_footnotes($footnote_key_suggestion);
|
|
1519
|
|
|
1520
|
return markup_to_render_array( // FIXME markup_to_render_array should no longer be needed
|
|
1521
|
'<div class="common-taxon-name">' . $common_name_out . '</div>'
|
|
1522
|
.'<div class="text-data">' . drupal_render($common_name_out_text_data) . '</div>'
|
|
1523
|
.$footnotes,
|
|
1524
|
$weight
|
|
1525
|
);
|
|
1526
|
}
|
|
1527
|
|
|
1528
|
/**
|
|
1529
|
* Renders a single instance of the type CommonTaxonName.
|
|
1530
|
*
|
|
1531
|
* @param $element
|
|
1532
|
* The CDM CommonTaxonName entity.
|
|
1533
|
* @param $feature_block_settings
|
|
1534
|
*
|
|
1535
|
* @param $footnote_key
|
|
1536
|
*
|
|
1537
|
* @return array
|
|
1538
|
* Drupal render array
|
|
1539
|
*
|
|
1540
|
* @ingroup compose
|
|
1541
|
*/
|
|
1542
|
function compose_description_element_common_taxon_name($element, $feature_block_settings, $footnote_key = NULL)
|
|
1543
|
{
|
|
1544
|
|
|
1545
|
if(!$footnote_key) {
|
|
1546
|
$footnote_key = $element->feature->uuid;
|
|
1547
|
}
|
|
1548
|
|
|
1549
|
$name = '';
|
|
1550
|
if(isset($element->name)){
|
|
1551
|
$name = $element->name;
|
|
1552
|
}
|
|
1553
|
|
|
1554
|
|
|
1555
|
return compose_description_element($element, $feature_block_settings, $name, $footnote_key);
|
|
1556
|
}
|
|
1557
|
|
|
1558
|
/**
|
|
1559
|
* Composes the render array for a CDM Distribution description element
|
|
1560
|
*
|
|
1561
|
* @param array $description_elements
|
|
1562
|
* Array of CDM Distribution instances
|
|
1563
|
* @param $enclosingTag
|
|
1564
|
* The html tag to be use for the enclosing element
|
|
1565
|
*
|
|
1566
|
* @return array
|
|
1567
|
* A Drupal render array
|
|
1568
|
*
|
|
1569
|
* @ingroup compose
|
|
1570
|
*/
|
|
1571
|
function compose_description_elements_distribution($description_elements){
|
|
1572
|
|
|
1573
|
$markup_array = array();
|
|
1574
|
RenderHints::pushToRenderStack('descriptionElementDistribution');
|
|
1575
|
RenderHints::setFootnoteListKey(UUID_DISTRIBUTION);
|
|
1576
|
|
|
1577
|
$feature_block_settings = get_feature_block_settings(UUID_DISTRIBUTION);
|
|
1578
|
$enclosingTag = cdm_feature_block_element_tag_name($feature_block_settings);
|
|
1579
|
|
|
1580
|
foreach ($description_elements as $description_element) {
|
|
1581
|
RenderHints::setAnnotationsAndSourceConfig(handle_annotations_and_sources_config($feature_block_settings));
|
|
1582
|
$annotations_and_sources = handle_annotations_and_sources(
|
|
1583
|
$description_element, $description_element->area->representation_L10n, UUID_DISTRIBUTION
|
|
1584
|
);
|
|
1585
|
|
|
1586
|
$status = distribution_status_label_and_markup([$description_element->status]);
|
|
1587
|
|
|
1588
|
$out = '';
|
|
1589
|
$out .= '<' . $enclosingTag . ' class="descriptionElement descriptionElement-' . $description_element->uuid
|
|
1590
|
. ' " title="' . $status['label']. '">'
|
|
1591
|
. $description_element->area->representation_L10n
|
|
1592
|
. $status['markup'];
|
|
1593
|
if($annotations_and_sources->hasSourceReferences()){
|
|
1594
|
$out .= ' ' . join(' ', $annotations_and_sources->getSourceReferences());
|
|
1595
|
}
|
|
1596
|
$out .= $annotations_and_sources->footNoteKeysMarkup() . '</' . $enclosingTag . '>';
|
|
1597
|
$markup_array[] = $out;
|
|
1598
|
}
|
|
1599
|
|
|
1600
|
RenderHints::popFromRenderStack();
|
|
1601
|
return markup_to_render_array(join('<span class="separator">' . $feature_block_settings['glue'] . '</span>', $markup_array));
|
|
1602
|
}
|
|
1603
|
|
|
1604
|
/**
|
|
1605
|
* @param array $distribution_status
|
|
1606
|
* @return array an array with following keys
|
|
1607
|
* - 'label': the plain text status label
|
|
1608
|
* - 'markup': markup for the status
|
|
1609
|
*/
|
|
1610
|
function distribution_status_label_and_markup(array $distribution_status, $status_glue = '‒ ') {
|
|
1611
|
|
|
1612
|
$status_markup = '';
|
|
1613
|
$status_label = '';
|
|
1614
|
|
|
1615
|
foreach($distribution_status as $status) {
|
|
1616
|
$status_label .= ($status_label ? $status_glue : '') . $status->representation_L10n ;
|
|
1617
|
$status_markup .= '<span class="distributionStatus"> '
|
|
1618
|
. ($status_markup ? $status_glue : '')
|
|
1619
|
. '<span class="distributionStatus-' . $status->idInVocabulary . '">'
|
|
1620
|
. $status->representation_L10n
|
|
1621
|
. '</span></span>';
|
|
1622
|
|
|
1623
|
};
|
|
1624
|
return ['label' => $status_label, 'markup' => $status_markup];
|
|
1625
|
}
|
|
1626
|
|
|
1627
|
|
|
1628
|
/**
|
|
1629
|
* Provides the merged feature tree for a taxon profile page.
|
|
1630
|
*
|
|
1631
|
* The merging of the profile feature tree is actually done in
|
|
1632
|
* _mergeFeatureTreeDescriptions(). See this method for details
|
|
1633
|
* on the structure of the merged tree.
|
|
1634
|
*
|
|
1635
|
* This method provides a hook which can be used to modify the
|
|
1636
|
* merged feature tree after it has been created, see
|
|
1637
|
* hook_merged_taxon_feature_tree_alter()
|
|
1638
|
*
|
|
1639
|
* @param $taxon
|
|
1640
|
* A CDM Taxon instance
|
|
1641
|
*
|
|
1642
|
* @return object
|
|
1643
|
* The merged feature tree
|
|
1644
|
*
|
|
1645
|
*/
|
|
1646
|
function merged_taxon_feature_tree($taxon) {
|
|
1647
|
|
|
1648
|
// 1. fetch descriptions_by_featuretree but exclude the distribution feature
|
|
1649
|
$merged_tree = cdm_ws_descriptions_by_featuretree(get_profile_feature_tree(), $taxon->uuid, array(UUID_DISTRIBUTION));
|
|
1650
|
|
|
1651
|
|
|
1652
|
// 2. find the distribution feature node
|
|
1653
|
$distribution_node =& cdm_feature_tree_find_node($merged_tree->root->childNodes, UUID_DISTRIBUTION);
|
|
1654
|
|
|
1655
|
if ($distribution_node) {
|
|
1656
|
// 3. get the distributionInfoDTO
|
|
1657
|
$query_parameters = cdm_distribution_filter_query();
|
|
1658
|
$query_parameters['part'] = array('mapUriParams');
|
|
1659
|
if(variable_get(DISTRIBUTION_CONDENSED)){
|
|
1660
|
$query_parameters['part'][] = 'condensedDistribution';
|
|
1661
|
}
|
|
1662
|
if (variable_get(DISTRIBUTION_ORDER_MODE, DISTRIBUTION_ORDER_MODE_DEFAULT) == 'TREE') {
|
|
1663
|
$query_parameters['part'][] = 'tree';
|
|
1664
|
}
|
|
1665
|
else {
|
|
1666
|
$query_parameters['part'][] = 'elements';
|
|
1667
|
}
|
|
1668
|
$query_parameters['omitLevels'] = array();
|
|
1669
|
foreach(variable_get(DISTRIBUTION_TREE_OMIT_LEVELS, array()) as $uuid){
|
|
1670
|
if(is_uuid($uuid)){
|
|
1671
|
$query_parameters['omitLevels'][] = $uuid;
|
|
1672
|
}
|
|
1673
|
}
|
|
1674
|
$customStatusColorsJson = variable_get(DISTRIBUTION_STATUS_COLORS, NULL);
|
|
1675
|
if ($customStatusColorsJson) {
|
|
1676
|
$query_parameters['statusColors'] = $customStatusColorsJson;
|
|
1677
|
}
|
|
1678
|
|
|
1679
|
$distribution_info_dto = cdm_ws_get(CDM_WS_PORTAL_DESCRIPTION_DISTRIBUTION_INFO_FOR, $taxon->uuid, queryString($query_parameters));
|
|
1680
|
// 4. get distribution TextData is there are any
|
|
1681
|
$distribution_text_data = cdm_ws_fetch_all(CDM_WS_DESCRIPTIONELEMENT_BY_TAXON,
|
|
1682
|
array(
|
|
1683
|
'taxon' => $taxon->uuid,
|
|
1684
|
'type' => 'TextData',
|
|
1685
|
'features' => UUID_DISTRIBUTION
|
|
1686
|
)
|
|
1687
|
);
|
|
1688
|
|
|
1689
|
// 5. put all distribution data into the distribution feature node
|
|
1690
|
if ($distribution_text_data //if text data exists
|
|
1691
|
|| ($distribution_info_dto && isset($distribution_info_dto->tree) && $distribution_info_dto->tree->rootElement->numberOfChildren > 0) // OR if tree element has distribution elements
|
|
1692
|
|| ($distribution_info_dto && !empty($distribution_info_dto->elements))
|
|
1693
|
) { // OR if DTO has distribution elements
|
|
1694
|
$distribution_node->descriptionElements = array('#type' => 'DTO');
|
|
1695
|
if ($distribution_text_data) {
|
|
1696
|
$distribution_node->descriptionElements['TextData'] = $distribution_text_data;
|
|
1697
|
}
|
|
1698
|
if ($distribution_info_dto) {
|
|
1699
|
$distribution_node->descriptionElements['DistributionInfoDTO'] = $distribution_info_dto;
|
|
1700
|
}
|
|
1701
|
}
|
|
1702
|
}
|
|
1703
|
|
|
1704
|
// allows modifying the merged tree via a the hook_cdm_feature_node_block_content_alter
|
|
1705
|
drupal_alter('merged_taxon_feature_tree', $taxon, $merged_tree);
|
|
1706
|
|
|
1707
|
return $merged_tree;
|
|
1708
|
}
|
|
1709
|
|
|
1710
|
/**
|
|
1711
|
* @param $distribution_tree
|
|
1712
|
* A tree cdm TreeNode items. A TreeNode item has a NamedArea as nodeId
|
|
1713
|
* and Distribution items as data array. Per data array some Distributions may
|
|
1714
|
* be with status information, others only with sources, others with both.
|
|
1715
|
* Each node may also have subordinate node items in the children field.
|
|
1716
|
* TreeNode:
|
|
1717
|
* - array data
|
|
1718
|
* - array children
|
|
1719
|
* - int numberOfChildren
|
|
1720
|
* - stdClass nodeId
|
|
1721
|
*
|
|
1722
|
* @param $feature_block_settings
|
|
1723
|
*
|
|
1724
|
* @return array
|
|
1725
|
* @throws \Exception
|
|
1726
|
*/
|
|
1727
|
function compose_distribution_hierarchy($distribution_tree, $feature_block_settings){
|
|
1728
|
|
|
1729
|
static $hierarchy_style;
|
|
1730
|
// TODO expose $hierarchy_style to administration or provide a hook
|
|
1731
|
if( !isset($hierarchy_style)){
|
|
1732
|
$hierarchy_style = get_array_variable_merged(DISTRIBUTION_HIERARCHY_STYLE, DISTRIBUTION_HIERARCHY_STYLE_DEFAULT);
|
|
1733
|
}
|
|
1734
|
|
|
1735
|
$render_array = array();
|
|
1736
|
|
|
1737
|
RenderHints::pushToRenderStack('descriptionElementDistribution');
|
|
1738
|
RenderHints::setFootnoteListKey(UUID_DISTRIBUTION);
|
|
1739
|
|
|
1740
|
// Returning NULL if there are no description elements.
|
|
1741
|
if ($distribution_tree == null) {
|
|
1742
|
return $render_array;
|
|
1743
|
}
|
|
1744
|
// for now we are not using a render array internally to avoid performance problems
|
|
1745
|
$markup = '';
|
|
1746
|
if (isset($distribution_tree->rootElement->children)) {
|
|
1747
|
$tree_nodes = $distribution_tree->rootElement->children;
|
|
1748
|
_compose_distribution_hierarchy($tree_nodes, $feature_block_settings, $markup, $hierarchy_style);
|
|
1749
|
}
|
|
1750
|
|
|
1751
|
$render_array['distribution_hierarchy'] = markup_to_render_array(
|
|
1752
|
$markup,
|
|
1753
|
0,
|
|
1754
|
'<div id="distribution_hierarchy" class="distribution_hierarchy">',
|
|
1755
|
'</div>'
|
|
1756
|
);
|
|
1757
|
|
|
1758
|
RenderHints::popFromRenderStack();
|
|
1759
|
|
|
1760
|
return $render_array;
|
|
1761
|
}
|
|
1762
|
|
|
1763
|
/**
|
|
1764
|
* this function should produce markup as the
|
|
1765
|
* compose_description_elements_distribution() function.
|
|
1766
|
*
|
|
1767
|
* @param array $tree_nodes
|
|
1768
|
* An array of cdm TreeNode items. A TreeNode item has a NamedArea as nodeId
|
|
1769
|
* and Distribution items as data array. Per data array some Distributions may
|
|
1770
|
* be with status information, others only with sources, others with both.
|
|
1771
|
* TreeNode:
|
|
1772
|
* - array data
|
|
1773
|
* - array children
|
|
1774
|
* - int numberOfChildren
|
|
1775
|
* - stdClass nodeId
|
|
1776
|
* @param array $feature_block_settings
|
|
1777
|
* @param $markup
|
|
1778
|
* @param $hierarchy_style
|
|
1779
|
* @param int $level_index
|
|
1780
|
*
|
|
1781
|
* @throws \Exception
|
|
1782
|
*
|
|
1783
|
* @see compose_description_elements_distribution()
|
|
1784
|
* @see compose_distribution_hierarchy()
|
|
1785
|
*
|
|
1786
|
*/
|
|
1787
|
function _compose_distribution_hierarchy(array $tree_nodes, array $feature_block_settings, &$markup, $hierarchy_style, $level_index = -1){
|
|
1788
|
|
|
1789
|
$level_index++;
|
|
1790
|
static $enclosingTag = "span";
|
|
1791
|
|
|
1792
|
$level_style = array_shift($hierarchy_style);
|
|
1793
|
if(count($hierarchy_style) == 0){
|
|
1794
|
// lowest defined level style will be reused for all following levels
|
|
1795
|
$hierarchy_style[] = $level_style;
|
|
1796
|
}
|
|
1797
|
|
|
1798
|
$node_index = -1;
|
|
1799
|
$per_node_markup = array();
|
|
1800
|
|
|
1801
|
foreach ($tree_nodes as $node){
|
|
1802
|
|
|
1803
|
$per_node_markup[++$node_index] = '';
|
|
1804
|
$label = $node->nodeId->representation_L10n;
|
|
1805
|
|
|
1806
|
$distributions = $node->data;
|
|
1807
|
$distribution_uuids = array();
|
|
1808
|
$distribution_aggregate = NULL;
|
|
1809
|
$status = ['label' => '', 'markup' => ''];
|
|
1810
|
|
|
1811
|
foreach($distributions as $distribution){
|
|
1812
|
$distribution_uuids[] = $distribution->uuid;
|
|
1813
|
// if there is more than one distribution we aggregate the sources and
|
|
1814
|
// annotations into a synthetic distribution so that the footnote keys
|
|
1815
|
// can be rendered consistently
|
|
1816
|
if(!$distribution_aggregate) {
|
|
1817
|
$distribution_aggregate = $distribution;
|
|
1818
|
if(isset($distribution->status)){
|
|
1819
|
$distribution_aggregate->status = [$distribution->status];
|
|
1820
|
} else {
|
|
1821
|
$distribution_aggregate->status = [];
|
|
1822
|
}
|
|
1823
|
if(!isset($distribution_aggregate->sources[0])){
|
|
1824
|
$distribution_aggregate->sources = array();
|
|
1825
|
}
|
|
1826
|
if(!isset($distribution_aggregate->annotations[0])){
|
|
1827
|
$distribution_aggregate->annotations = array();
|
|
1828
|
}
|
|
1829
|
} else {
|
|
1830
|
if(isset($distribution->status)){
|
|
1831
|
$distribution_aggregate->status[] = $distribution->status;
|
|
1832
|
}
|
|
1833
|
if(isset($distribution->sources[0])) {
|
|
1834
|
$distribution_aggregate->sources = array_merge($distribution_aggregate->sources,
|
|
1835
|
$distribution->sources);
|
|
1836
|
}
|
|
1837
|
if(isset($distribution->annotations[0])) {
|
|
1838
|
$distribution_aggregate->annotations = array_merge($distribution_aggregate->annotations,
|
|
1839
|
$distribution->annotations);
|
|
1840
|
}
|
|
1841
|
}
|
|
1842
|
}
|
|
1843
|
|
|
1844
|
$annotations_and_sources = null;
|
|
1845
|
if($distribution_aggregate) {
|
|
1846
|
RenderHints::setAnnotationsAndSourceConfig(handle_annotations_and_sources_config($feature_block_settings));
|
|
1847
|
$annotations_and_sources = handle_annotations_and_sources(
|
|
1848
|
$distribution_aggregate, $label, UUID_DISTRIBUTION
|
|
1849
|
);
|
|
1850
|
$status = distribution_status_label_and_markup($distribution_aggregate->status, $level_style['status_glue']);
|
|
1851
|
}
|
|
1852
|
|
|
1853
|
$per_node_markup[$node_index] .= '<' . $enclosingTag . ' class="descriptionElement'
|
|
1854
|
. join(' descriptionElement-', $distribution_uuids)
|
|
1855
|
. ' level_index_' . $level_index
|
|
1856
|
. ' " title="' . $status['label'] . '">'
|
|
1857
|
. '<span class="area_label">' . $label
|
|
1858
|
. $level_style['label_suffix'] . '</span>'
|
|
1859
|
. $status['markup']
|
|
1860
|
;
|
|
1861
|
|
|
1862
|
if(isset($annotations_and_sources)){
|
|
1863
|
if($annotations_and_sources->hasSourceReferences()){
|
|
1864
|
$per_node_markup[$node_index] .= ' ' . join(', ' , $annotations_and_sources->getSourceReferences());
|
|
1865
|
}
|
|
1866
|
if($annotations_and_sources->hasFootnoteKeys()) {
|
|
1867
|
$per_node_markup[$node_index] .= $annotations_and_sources->footNoteKeysMarkup();
|
|
1868
|
}
|
|
1869
|
}
|
|
1870
|
|
|
1871
|
if(isset($node->children[0])){
|
|
1872
|
$per_node_markup[$node_index] .= $level_style['item_suffix'];
|
|
1873
|
_compose_distribution_hierarchy(
|
|
1874
|
$node->children,
|
|
1875
|
$feature_block_settings,
|
|
1876
|
$per_node_markup[$node_index],
|
|
1877
|
$hierarchy_style,
|
|
1878
|
$level_index
|
|
1879
|
);
|
|
1880
|
}
|
|
1881
|
|
|
1882
|
$per_node_markup[$node_index] .= '</' . $enclosingTag . '>';
|
|
1883
|
}
|
|
1884
|
$markup .= $level_style['item_group_prefix'] . join( $level_style['item_glue'], $per_node_markup) . $level_style['item_group_postfix'];
|
|
1885
|
}
|
|
1886
|
|
|
1887
|
|
|
1888
|
/**
|
|
1889
|
* Provides the content for a block of Uses Descriptions for a given taxon.
|
|
1890
|
*
|
|
1891
|
* Fetches the list of TaxonDescriptions tagged with the MARKERTYPE_USE
|
|
1892
|
* and passes them to the theme function theme_cdm_UseDescription().
|
|
1893
|
*
|
|
1894
|
* @param string $taxon_uuid
|
|
1895
|
* The uuid of the Taxon
|
|
1896
|
*
|
|
1897
|
* @return array
|
|
1898
|
* A drupal render array
|
|
1899
|
*/
|
|
1900
|
function cdm_block_use_description_content($taxon_uuid, $feature) {
|
|
1901
|
|
|
1902
|
$use_description_content = array();
|
|
1903
|
|
|
1904
|
if (is_uuid($taxon_uuid )) {
|
|
1905
|
$markerTypes = array();
|
|
1906
|
$markerTypes['markerTypes'] = UUID_MARKERTYPE_USE;
|
|
1907
|
$useDescriptions = cdm_ws_fetch_all(CDM_WS_PORTAL_TAXON . '/' . $taxon_uuid . '/descriptions', $markerTypes);
|
|
1908
|
if (!empty($useDescriptions)) {
|
|
1909
|
$use_description_content = compose_feature_block_items_use_records($useDescriptions, $taxon_uuid, $feature);
|
|
1910
|
}
|
|
1911
|
}
|
|
1912
|
|
|
1913
|
return $use_description_content;
|
|
1914
|
}
|
|
1915
|
|
|
1916
|
/**
|
|
1917
|
* Creates a trunk of a feature object which can be used to build pseudo feature blocks like the Bibliography.
|
|
1918
|
*
|
|
1919
|
* @param $representation_L10n
|
|
1920
|
* @param String $pseudo_feature_key
|
|
1921
|
* Will be set as uuid but should be one of 'BIBLIOGRAPHY', ... more to come. See also get_feature_block_settings()
|
|
1922
|
*
|
|
1923
|
* @return object
|
|
1924
|
* The feature object
|
|
1925
|
*/
|
|
1926
|
function make_pseudo_feature($representation_L10n, $pseudo_feature_key = null){
|
|
1927
|
$feature = new stdClass;
|
|
1928
|
$feature->representation_L10n = $representation_L10n;
|
|
1929
|
$feature->uuid = NULL; // $pseudo_feature_key;
|
|
1930
|
$feature->label = $pseudo_feature_key;
|
|
1931
|
$feature->class = 'PseudoFeature';
|
|
1932
|
|
|
1933
|
return $feature;
|
|
1934
|
|
|
1935
|
}
|
|
1936
|
|
|
1937
|
/**
|
|
1938
|
* @param $root_nodes, for obtaining the root nodes from a description you can
|
|
1939
|
* use the function get_root_nodes_for_dataset($description);
|
|
1940
|
*
|
|
1941
|
* @return string
|
|
1942
|
*/
|
|
1943
|
function render_description_string($root_nodes, &$item_cnt = 0) {
|
|
1944
|
|
|
1945
|
$out = '';
|
|
1946
|
|
|
1947
|
$description_strings= [];
|
|
1948
|
if (!empty($root_nodes)) {
|
|
1949
|
foreach ($root_nodes as $root_node) {
|
|
1950
|
if(isset($root_node->descriptionElements)) {
|
|
1951
|
foreach ($root_node->descriptionElements as $element) {
|
|
1952
|
$feature_label = $element->feature->representation_L10n;
|
|
1953
|
if($item_cnt == 0){
|
|
1954
|
$feature_label = ucfirst($feature_label);
|
|
1955
|
}
|
|
1956
|
switch ($element->class) {
|
|
1957
|
case 'CategoricalData':
|
|
1958
|
$state_data = render_state_data($element);
|
|
1959
|
if (!empty($state_data)) {
|
|
1960
|
if(is_suppress_state_present_display($element, $root_node)){
|
|
1961
|
$description_strings[] = '<span class="'. html_class_attribute_ref($element) .'"><span class="label">' . $feature_label . '</span>: ' . '</span>';
|
|
1962
|
} else {
|
|
1963
|
$description_strings[] = '<span class="'. html_class_attribute_ref($element) .'"><span class="label">' . $feature_label . '</span>: ' . $state_data . '</span>;' ;
|
|
1964
|
}
|
|
1965
|
}
|
|
1966
|
break;
|
|
1967
|
case 'QuantitativeData':
|
|
1968
|
$description_strings[] = '<span class="'. html_class_attribute_ref($element) .'"><span class="label">' . $feature_label . '</span>: ' . render_quantitative_statistics($element) . '</span>;';
|
|
1969
|
break;
|
|
1970
|
}
|
|
1971
|
}
|
|
1972
|
$item_cnt++;
|
|
1973
|
}
|
|
1974
|
|
|
1975
|
// recurse child nodes
|
|
1976
|
$child_markup = render_description_string($root_node->childNodes, $item_cnt);
|
|
1977
|
if($child_markup){
|
|
1978
|
$description_strings[] = $child_markup;
|
|
1979
|
}
|
|
1980
|
}
|
|
1981
|
if(count($description_strings) > 0){
|
|
1982
|
// remove last semicolon
|
|
1983
|
$description_strings[count($description_strings) - 1] = preg_replace('/;$/', '', $description_strings[count($description_strings) - 1]);
|
|
1984
|
}
|
|
1985
|
$out = join(' ', $description_strings);
|
|
1986
|
}
|
|
1987
|
return $out;
|
|
1988
|
}
|
|
1989
|
|
|
1990
|
/**
|
|
1991
|
* Compose a description as a table of Feature<->State
|
|
1992
|
*
|
|
1993
|
* @param $description_uuid
|
|
1994
|
*
|
|
1995
|
* @return array
|
|
1996
|
* The drupal render array for the page
|
|
1997
|
*
|
|
1998
|
* @ingroup compose
|
|
1999
|
*/
|
|
2000
|
function compose_description_table($description_uuid, $descriptive_dataset_uuid = NULL) {
|
|
2001
|
|
|
2002
|
RenderHints::pushToRenderStack('description_table');
|
|
2003
|
|
|
2004
|
$render_array = [];
|
|
2005
|
|
|
2006
|
$description = cdm_ws_get(CDM_WS_PORTAL_DESCRIPTION, [$description_uuid]);
|
|
2007
|
$dataSet = NULL;
|
|
2008
|
// dataset passed as parameter
|
|
2009
|
if ($descriptive_dataset_uuid != NULL) {
|
|
2010
|
foreach ($description->descriptiveDataSets as $set) {
|
|
2011
|
if ($set->uuid == $descriptive_dataset_uuid) {
|
|
2012
|
$dataSet = $set;
|
|
2013
|
break;
|
|
2014
|
}
|
|
2015
|
}
|
|
2016
|
}
|
|
2017
|
|
|
2018
|
if(!empty($description->descriptiveDataSets)) {
|
|
2019
|
// only one dataset present
|
|
2020
|
if (!isset($dataSet) && sizeof($description->descriptiveDataSets) == 1) {
|
|
2021
|
foreach ($description->descriptiveDataSets as $dataSet) {
|
|
2022
|
break;
|
|
2023
|
}
|
|
2024
|
}
|
|
2025
|
|
|
2026
|
// generate description title
|
|
2027
|
RenderHints::pushToRenderStack('title');
|
|
2028
|
if (isset($dataSet)) {
|
|
2029
|
|
|
2030
|
$described_entity_title = NULL;
|
|
2031
|
if(isset($description->describedSpecimenOrObservation)){
|
|
2032
|
$described_entity_title = $description->describedSpecimenOrObservation->titleCache;
|
|
2033
|
} else if($description->taxon) {
|
|
2034
|
$described_entity_title = render_taxon_or_name($description->taxon);
|
|
2035
|
}
|
|
2036
|
$title = 'Descriptive Data ' . $dataSet->titleCache .
|
|
2037
|
($described_entity_title ? ' for ' . $described_entity_title : '');
|
|
2038
|
}
|
|
2039
|
$render_array['title'] = markup_to_render_array($title, null, '<h3 class="title">', '</h3>');
|
|
2040
|
RenderHints::popFromRenderStack();
|
|
2041
|
// END of --- generate description title
|
|
2042
|
|
|
2043
|
if (isset($description->types)) {
|
|
2044
|
foreach ($description->types as $type) {
|
|
2045
|
if ($type == 'CLONE_FOR_SOURCE') {
|
|
2046
|
$render_array['source'] = markup_to_render_array("Aggregation source from " . $description->created, null, '<div class="date-created">', '</div>');
|
|
2047
|
break;
|
|
2048
|
}
|
|
2049
|
}
|
|
2050
|
}
|
|
2051
|
}
|
|
2052
|
// multiple datasets present see #8714 "Show multiple datasets per description as list of links"
|
|
2053
|
else {
|
|
2054
|
$items = [];
|
|
2055
|
foreach ($description->descriptiveDataSets as $dataSet) {
|
|
2056
|
$path = path_to_description($description->uuid, $dataSet->uuid);
|
|
2057
|
$attributes['class'][] = html_class_attribute_ref($description);
|
|
2058
|
$items[] = [
|
|
2059
|
'data' => $dataSet->titleCache . icon_link($path),
|
|
2060
|
];
|
|
2061
|
}
|
|
2062
|
$render_array['description_elements'] = [
|
|
2063
|
'#title' => 'Available data sets for description',
|
|
2064
|
'#theme' => 'item_list',
|
|
2065
|
'#type' => 'ul',
|
|
2066
|
'#items' => $items,
|
|
2067
|
];
|
|
2068
|
}
|
|
2069
|
|
|
2070
|
$described_entities = [];
|
|
2071
|
if (isset($description->describedSpecimenOrObservation)) {
|
|
2072
|
$decr_entitiy = '<span class="label">Specimen:</span> ' . render_cdm_specimen_link($description->describedSpecimenOrObservation);
|
|
2073
|
$described_entities['specimen'] = markup_to_render_array($decr_entitiy, null, '<div>', '</div>');
|
|
2074
|
}
|
|
2075
|
if (isset($description->taxon)) {
|
|
2076
|
$decr_entitiy = '<span class="label">Taxon:</span> ' . render_taxon_or_name($description->taxon, url(path_to_taxon($description->taxon->uuid)));
|
|
2077
|
$described_entities['taxon'] = markup_to_render_array($decr_entitiy, null, '<div>', '</div>');
|
|
2078
|
}
|
|
2079
|
|
|
2080
|
if(count($described_entities)){
|
|
2081
|
$render_array['described_entities'] = $described_entities;
|
|
2082
|
$render_array['described_entities']['#prefix'] = '<div class="described-entities">';
|
|
2083
|
$render_array['described_entities']['#suffix'] = '</div>';
|
|
2084
|
}
|
|
2085
|
|
|
2086
|
|
|
2087
|
$root_nodes = get_root_nodes_for_dataset($description);
|
|
2088
|
|
|
2089
|
|
|
2090
|
$rows = [];
|
|
2091
|
$rows = description_element_table_rows($root_nodes, $rows);
|
|
2092
|
|
|
2093
|
// --- create headers
|
|
2094
|
$header = [0 => [], 1 => []];
|
|
2095
|
|
|
2096
|
foreach($rows as $row) {
|
|
2097
|
if(array_search('Character', $row['class']) && array_search('Character', $header[0]) === false){
|
|
2098
|
$header[0][] = 'Character';
|
|
2099
|
} elseif (array_search('Feature', $row['class']) && array_search('Feature', $header[0]) === false){
|
|
2100
|
$header[0][] = 'Feature';
|
|
2101
|
}
|
|
2102
|
if(array_search('has_state', $row['class']) && array_search('States', $header[1]) === false){
|
|
2103
|
$header[1][] = 'States';
|
|
2104
|
} elseif (array_search('has_values', $row['class']) && array_search('Values', $header[1]) === false){
|
|
2105
|
$header[1][] = 'Values';
|
|
2106
|
}
|
|
2107
|
}
|
|
2108
|
asort($header[0]);
|
|
2109
|
asort($header[1]);
|
|
2110
|
$header[0] = join('/', $header[0]);
|
|
2111
|
$header[1] = join('/', $header[1]);
|
|
2112
|
|
|
2113
|
// ---
|
|
2114
|
|
|
2115
|
if (!empty($rows)) {
|
|
2116
|
$render_array['table'] = markup_to_render_array(theme('table', [
|
|
2117
|
'header' => $header,
|
|
2118
|
'rows' => $rows,
|
|
2119
|
'caption' => statistical_values_explanation(),
|
|
2120
|
'title' => "Table"
|
|
2121
|
]));
|
|
2122
|
}
|
|
2123
|
|
|
2124
|
// --- sources
|
|
2125
|
if (isset($description->sources) and !empty($description->sources)) {
|
|
2126
|
$items = [];
|
|
2127
|
foreach ($description->sources as $source) {
|
|
2128
|
if ($source->type == 'Aggregation' and isset($source->cdmSource)){
|
|
2129
|
$cdm_source_entity = $source->cdmSource;
|
|
2130
|
switch($cdm_source_entity->class){
|
|
2131
|
case 'Taxon':
|
|
2132
|
$source_link_markup = render_taxon_or_name($cdm_source_entity) . icon_link(path_to_taxon($cdm_source_entity->uuid, false));
|
|
2133
|
break;
|
|
2134
|
case 'TaxonDescription':
|
|
2135
|
case 'NameDescription':
|
|
2136
|
case 'SpecimenDescription':
|
|
2137
|
$source_link_markup = render_cdm_entity_link($cdm_source_entity);
|
|
2138
|
break;
|
|
2139
|
default:
|
|
2140
|
$source_link_markup = '<span class="error">Unhandled CdmSource</span>';
|
|
2141
|
}
|
|
2142
|
$items[$cdm_source_entity->titleCache] = [
|
|
2143
|
'data' => $source_link_markup
|
|
2144
|
];
|
|
2145
|
}
|
|
2146
|
}
|
|
2147
|
ksort($items);
|
|
2148
|
$render_array['sources'] = [
|
|
2149
|
'#title' => 'Sources',
|
|
2150
|
'#theme' => 'item_list',
|
|
2151
|
'#type' => 'ul',
|
|
2152
|
'#items' => $items,
|
|
2153
|
'#attributes' => ['class' => 'sources']
|
|
2154
|
];
|
|
2155
|
$render_array['#prefix'] = '<div class="description-table">';
|
|
2156
|
$render_array['#suffix'] = '</div>';
|
|
2157
|
}
|
|
2158
|
|
|
2159
|
RenderHints::popFromRenderStack();
|
|
2160
|
|
|
2161
|
return $render_array;
|
|
2162
|
}
|
|
2163
|
|
|
2164
|
/**
|
|
2165
|
* For a given description returns the root nodes according to the
|
|
2166
|
*corresponding term tree. The term tree is determined as follow:
|
|
2167
|
* 1. If description is part of a descriptive data set the term tree of that
|
|
2168
|
* data set is used (FIXME handle multiple term trees)
|
|
2169
|
* 2. Otherwise the portal taxon profile tree is used
|
|
2170
|
* @param $description
|
|
2171
|
*
|
|
2172
|
* @return array
|
|
2173
|
*/
|
|
2174
|
function get_root_nodes_for_dataset($description) {
|
|
2175
|
if (!empty($description->descriptiveDataSets)) {
|
|
2176
|
foreach ($description->descriptiveDataSets as $dataSet) {
|
|
2177
|
break;// FIXME handle multiple term trees
|
|
2178
|
}
|
|
2179
|
$tree = cdm_ws_get(CDM_WS_TERMTREE, $dataSet->descriptiveSystem->uuid);
|
|
2180
|
$root_nodes = _mergeFeatureTreeDescriptions($tree->root->childNodes, $description->elements);
|
|
2181
|
}
|
|
2182
|
else {
|
|
2183
|
$root_nodes = _mergeFeatureTreeDescriptions(get_profile_feature_tree()->root->childNodes, $description->elements);
|
|
2184
|
}
|
|
2185
|
return $root_nodes;
|
|
2186
|
}
|
|
2187
|
|
|
2188
|
/**
|
|
2189
|
* Recursively creates an array of row items to be used in theme_table.
|
|
2190
|
*
|
|
2191
|
* The array items will have am element 'class' with information on the
|
|
2192
|
* nature of the DescriptionElement ('has_values' | 'has_state') and on the
|
|
2193
|
* type of the FeatureNode ('Feature' | 'Character')
|
|
2194
|
*
|
|
2195
|
* @param array $root_nodes
|
|
2196
|
* @param array $row_items
|
|
2197
|
* @param int $level
|
|
2198
|
* the depth in the hierarchy
|
|
2199
|
*
|
|
2200
|
* @return array
|
|
2201
|
* An array of row items to be used in theme_table
|
|
2202
|
*
|
|
2203
|
*
|
|
2204
|
*/
|
|
2205
|
function description_element_table_rows($root_nodes, $row_items, $level = 0) {
|
|
2206
|
|
|
2207
|
$indent_string = ' ';
|
|
2208
|
foreach ($root_nodes as $root_node) {
|
|
2209
|
if(isset($root_node->descriptionElements)) {
|
|
2210
|
foreach ($root_node->descriptionElements as $element) {
|
|
2211
|
$level_indent = str_pad('', $level * strlen($indent_string), $indent_string);
|
|
2212
|
switch ($element->class) {
|
|
2213
|
case 'QuantitativeData':
|
|
2214
|
$row_items[] = [
|
|
2215
|
'data' => [
|
|
2216
|
[
|
|
2217
|
'data' => markup_to_render_array($level_indent . $element->feature->representation_L10n),
|
|
2218
|
'class' => ['level_' . $level]
|
|
2219
|
],
|
|
2220
|
render_quantitative_statistics($element)
|
|
2221
|
],
|
|
2222
|
'class' => ['level_' . $level, 'has_values', $element->feature->class]
|
|
2223
|
];
|
|
2224
|
break;
|
|
2225
|
case 'CategoricalData':
|
|
2226
|
default:
|
|
2227
|
if (!empty($element->stateData)) {
|
|
2228
|
$supress_state_display = is_suppress_state_present_display($element, $root_node);
|
|
2229
|
if(!$supress_state_display){
|
|
2230
|
$state_cell = render_state_data($element);
|
|
2231
|
} else {
|
|
2232
|
$state_cell = "<span> </span>";
|
|
2233
|
}
|
|
2234
|
$row_items[] = [
|
|
2235
|
'data' => [
|
|
2236
|
[
|
|
2237
|
'data' => markup_to_render_array($level_indent . $element->feature->representation_L10n),
|
|
2238
|
'class' => ['level_' . $level]
|
|
2239
|
],
|
|
2240
|
$state_cell,
|
|
2241
|
],
|
|
2242
|
'class' => ['level_' . $level, 'has_state', $element->feature->class]
|
|
2243
|
];
|
|
2244
|
}
|
|
2245
|
break;
|
|
2246
|
}
|
|
2247
|
}
|
|
2248
|
}
|
|
2249
|
// recurse child nodes
|
|
2250
|
$row_items = description_element_table_rows($root_node->childNodes, $row_items, $level + 1);
|
|
2251
|
}
|
|
2252
|
return $row_items;
|
|
2253
|
}
|
|
2254
|
|
|
2255
|
/**
|
|
2256
|
* @param $element
|
|
2257
|
* @param $root_node
|
|
2258
|
*
|
|
2259
|
* @return bool
|
|
2260
|
*/
|
|
2261
|
function is_suppress_state_present_display($element, $root_node) {
|
|
2262
|
return count($element->stateData) == 1 & $element->stateData[0]->state->representation_L10n == 'present' && is_array($root_node->childNodes);
|
|
2263
|
}
|
|
2264
|
|
|
2265
|
|
|
2266
|
|