Project

General

Profile

Download (84.4 KB) Statistics
| Branch: | Tag: | Revision:
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
  $annotations_and_sources = handle_annotations_and_sources(
386
    $element,
387
    handle_annotations_and_sources_config($feature_block_settings),
388
    $element_markup,
389
    $footnote_list_key_suggestion
390
  );
391

    
392
  $timescope_markup = '';
393
  if(isset($element->timeperiod)){
394
    $timescope_markup = ' ' . timePeriodToString($element->timeperiod, true);
395
  }
396

    
397
  // handle the special case were the TextData is used as container for original source with name
398
  // used in source information without any text stored in it.
399
  $names_used_in_source_markup = '';
400
  if (!empty($annotations_and_sources['names_used_in_source']) && empty($element_markup)) {
401
    $names_used_in_source_markup = join(', ', $annotations_and_sources['names_used_in_source']) . ': ';
402
    // remove all <span class="nameUsedInSource">...</span> from all source_references
403
    // these are expected to be at the end of the strings
404
    $pattern = '/ <span class="nameUsedInSource">.*$/';
405
    foreach( $annotations_and_sources['source_references'] as &$source_reference){
406
      $source_reference = preg_replace($pattern , '', $source_reference);
407
    }
408
  }
409

    
410
  $source_references_markup = '';
411
  if (!empty($annotations_and_sources['source_references'])) {
412
    $source_references_markup = '<span class="sources">' . join(' ', $annotations_and_sources['source_references']) . '<span>';
413
  }
414

    
415
  $feature_label = '';
416
  if ($prepend_feature_label) {
417
    $feature_label = '<span class="nested-feature-tree-feature-label">' . $element->feature->representation_L10n . ':</span> ';
418
  }
419
  $content_markup = $names_used_in_source_markup . $element_markup . $timescope_markup . $source_references_markup;
420

    
421
  if(!$content_markup && $feature_block_settings['sources_as_content'] !== 1){
422
    // no textual content? So skip this element completely, even if there could be an footnote key
423
    // see #4379
424
    return null;
425
  }
426

    
427
    $render_array['#value'] = $feature_label . $content_markup;
428
    $render_array['#value_suffix'] = $annotations_and_sources['foot_note_keys'];
429
  return $render_array;
430
}
431

    
432
/**
433
 * Creates a handle_annotations_and_sources configuration array from feature_block_settings.
434
 *
435
 * The handle_annotations_and_sources configuration array is meant to be used for the
436
 * method handle_annotations_and_sources().
437
 *
438
 * @param $feature_block_settings array
439
 *
440
 * @return array
441
 *   The configuration array for handle_annotations_and_sources()
442
 */
443
function handle_annotations_and_sources_config($feature_block_settings){
444

    
445
  $config = $feature_block_settings;
446
  unset($config['sources_as_content_to_bibliography']);
447
  $config['add_footnote_keys'] = 0;
448
  if($feature_block_settings['sources_as_content'] !== 1 || $feature_block_settings['sources_as_content_to_bibliography'] == 1) {
449
    $config['add_footnote_keys'] = 1;
450
  }
451
  $config['bibliography_aware'] = 1;
452

    
453
  return $config;
454
}
455

    
456
/**
457
 * @param $entity
458
 * @param $config array
459
 *   An associative array to configure the display of the annotations and
460
 *   sources. The array has the following keys
461
 *   - sources_as_content
462
 *   - link_to_name_used_in_source
463
 *   - link_to_reference
464
 *   - add_footnote_keys
465
 *   - bibliography_aware
466
 *   Valid values are 1 or 0.
467
 * @param $inline_text_prefix
468
 *   Only used to decide if the source references should be enclosed in
469
 *   brackets or not when displayed inline. This text will not be included into
470
 *   the response.
471
 * @param $footnote_list_key_suggestion string
472
 *    optional parameter. If this paramter is left empty (null, 0, "") the
473
 *   footnote key will be determined by the nested method calls by calling
474
 *   RenderHints::getFootnoteListKey(). NOTE: the footnore key for annotations
475
 *   will be set to RenderHints::getFootnoteListKey().'-annotations'. @return
476
 *   array an associative array with the following elements:
477
 *   - foot_note_keys: all footnote keys as markup
478
 *   - source_references: an array of the source references citations
479
 *   - names used in source: an associative array of the names in source,
480
 *        the name in source strings are de-duplicated
481
 *        !!!NOTE!!!!: this field will most probably be removed soon (TODO)
482
 *
483
 * @throws \Exception
484
 *
485
 * @see cdm_entities_annotations_footnotekeys()
486
 */
487
  function handle_annotations_and_sources($entity, $config, $inline_text_prefix, $footnote_list_key_suggestion) {
488

    
489
    $annotations_and_sources = array(
490
      'foot_note_keys' => NULL,
491
      'source_references' => [],
492
      'names_used_in_source' => []
493
    );
494

    
495
    // some entity types only have single sources:
496
    $sources = cdm_entity_sources_sorted($entity);
497

    
498
    if ($config['sources_as_content'] == 1) {
499
      foreach ($sources as $source) {
500
        if (_is_original_source_type($source)) {
501
          $reference_citation = render_original_source(
502
            $source,
503
            $config['link_to_reference'] == 1,
504
            $config['link_to_name_used_in_source'] == 1
505
          );
506

    
507
          if ($reference_citation) {
508
            if (empty($inline_text_prefix)) {
509
              $annotations_and_sources['source_references'][] = $reference_citation;
510
            } else {
511
              $annotations_and_sources['source_references'][] = ' (' . $reference_citation . ')';
512
            }
513
          }
514

    
515
          // also put the name in source into the array, these are already included in the $reference_citation but are
516
          // still required to be available separately in some contexts.
517
          $name_in_source_render_array = compose_name_in_source(
518
            $source,
519
            $config['link_to_name_used_in_source'] == 1
520
          );
521

    
522
          if (!empty($name_in_source_render_array)) {
523
            $annotations_and_sources['names_used_in_source'][$name_in_source_render_array['#_plaintext']] = drupal_render($name_in_source_render_array);
524
          }
525
        }
526
      } // END of loop over sources
527

    
528
      // annotations footnotes separate from sources
529
      $annotations_and_sources['foot_note_keys'] = footnote_keys_to_markup(
530
        cdm_entity_annotations_as_footnotekeys($entity, $footnote_list_key_suggestion), ', '
531
      );
532

    
533
    } // END of references inline
534

    
535
    // footnotes for sources and annotations or put into into bibliography if requested ...
536
    if ($config['add_footnote_keys'] == 1) {
537
        $annotations_and_sources['foot_note_keys'] = cdm_create_footnotes(
538
          $entity, ',',
539
          $footnote_list_key_suggestion,
540
          $config['link_to_reference'] == 1,
541
          $config['link_to_name_used_in_source'] == 1,
542
          !empty($config['bibliography_aware'])
543
        );
544
    }
545

    
546
    return $annotations_and_sources;
547
  }
548

    
549
/**
550
 * Get the source or the sources from a cdm entity and return them ordered by see compare_original_sources()
551
 * (Some entity types only have single sources)
552
 * @param $entity
553
 *
554
 * @return array
555
 */
556
function cdm_entity_sources_sorted($entity) {
557
  if (isset($entity->source) && is_object($entity->source)) {
558
    $sources = [$entity->source];
559
  }
560
  else if (isset($entity->sources)) {
561
    $sources = $entity->sources;
562
  }
563
  else {
564
    $sources = [];
565
  }
566
  usort($sources, 'compare_original_sources');
567
  return $sources;
568
}
569

    
570

    
571
/**
572
   * This method determines the footnote key for original sources to be shown in the bibliography block
573
   *
574
   * The footnote key depends on the value of the 'enabled' value of the bibliography_settings
575
   *    - enabled == 1 -> "BIBLIOGRAPHY"
576
   *    - enabled == 0 -> "BIBLIOGRAPHY-$key_suggestion"
577
   *
578
   * @see get_bibliography_settings() and @see constant BIBLIOGRAPHY_FOOTNOTE_KEY
579
   *
580
   * @param $key_suggestion string
581
   *    optional parameter. If this parameter is left empty (null, 0, "") the footnote key will be retrieved by
582
   *    calling RenderHints::getFootnoteListKey().
583

    
584
   *
585
   * @return string
586
   *  the footnote_list_key
587
   */
588
  function bibliography_footnote_list_key($key_suggestion = null) {
589
    if(!$key_suggestion){
590
      $key_suggestion = RenderHints::getFootnoteListKey();
591
    }
592
    $bibliography_settings = get_bibliography_settings();
593
    $footnote_list_key = $bibliography_settings['enabled'] == 1 ? BIBLIOGRAPHY_FOOTNOTE_KEY : BIBLIOGRAPHY_FOOTNOTE_KEY . '-' . $key_suggestion;
594
    return $footnote_list_key;
595
  }
596

    
597
/**
598
 * Provides the according tag name for the description element markup which
599
 * fits the  $feature_block_settings['as_list'] value
600
 *
601
 * @param $feature_block_settings
602
 *   A feature_block_settings array, for details, please see
603
 *   get_feature_block_settings($feature_uuid = 'DEFAULT')
604
 *
605
 * @return mixed|string
606
 */
607
  function cdm_feature_block_element_tag_name($feature_block_settings){
608
    switch ($feature_block_settings['as_list']){
609
      case 'ul':
610
      case 'ol':
611
        return 'li';
612
      case 'div':
613
        if(isset($feature_block_settings['element_tag'])){
614
          return $feature_block_settings['element_tag'];
615
        }
616
        return 'span';
617
      case 'dl':
618
        return 'dd';
619
      default:
620
        return 'div'; // should never happen, throw error instead?
621
    }
622
  }
623

    
624

    
625
/* ==================== COMPOSE FUNCTIONS =============== */
626

    
627
  /**
628
   * Returns a set of feature blocks for a taxon profile from the $mergedFeatureNodes of a given $taxon.
629
   *
630
   * The taxon profile consists of drupal block elements, one for the description elements
631
   * of a specific feature. The structure is defined by specific FeatureTree.
632
   * The chosen FeatureTree is merged with the list of description elements prior to using this method.
633
   *
634
   * The merged nodes can be obtained by making use of the
635
   * function cdm_ws_descriptions_by_featuretree().
636
   *
637
   * @see cdm_ws_descriptions_by_featuretree()
638
   *
639
   * @param $mergedFeatureNodes
640
   *
641
   * @param $taxon
642
   *
643
   * @return array
644
   *  A Drupal render array containing feature blocks and the table of content
645
   *
646
   * @ingroup compose
647
   */
648
  function make_feature_block_list($mergedFeatureNodes, $taxon) {
649

    
650
    $block_list = array();
651

    
652
    $gallery_settings = getGallerySettings(CDM_DATAPORTAL_DESCRIPTION_GALLERY_NAME);
653

    
654
    $use_description_features = array(UUID_USE);
655

    
656

    
657
    RenderHints::pushToRenderStack('feature_block');
658
    // Create a drupal block for each feature
659
    $block_weight = - FEATURE_BLOCK_WEIGHT_INCREMENT;
660
    foreach ($mergedFeatureNodes as $feature_node) {
661

    
662
      $block_weight = $block_weight + FEATURE_BLOCK_WEIGHT_INCREMENT;
663

    
664
      if ((isset($feature_node->descriptionElements['#type']) ||
665
          has_feature_node_description_elements($feature_node)) && $feature_node->term->uuid != UUID_IMAGE) { // skip empty or suppressed features
666

    
667
        RenderHints::pushToRenderStack($feature_node->term->uuid);
668
          
669
        $feature_name = cdm_term_representation($feature_node->term, 'Unnamed Feature');
670
        $feature_block_settings = get_feature_block_settings($feature_node->term->uuid);
671
        
672

    
673
        $block = feature_block($feature_name, $feature_node->term);
674
        $block->content = array();
675
        $block_content_is_empty = TRUE;
676

    
677
        if(array_search($feature_node->term->uuid, $use_description_features) !== false) {
678
          // do not show features which belong to the UseDescriptions, these are
679
          // handled by compose_feature_block_items_use_records() where the according descriptions are
680
          // fetched again separately.
681
          // UseDescriptions are a special feature introduced for palmweb
682
          continue;
683
        }
684

    
685
        /*
686
         * Content/DISTRIBUTION.
687
         */
688
        if ($feature_node->term->uuid == UUID_DISTRIBUTION) {
689
          $block = compose_feature_block_distribution($taxon, $feature_node->descriptionElements, $feature_node->term);
690
          $block_content_is_empty = FALSE;
691
        }
692

    
693
        /*
694
         * Content/COMMON_NAME.
695
         */
696
        else if ($feature_node->term->uuid == UUID_COMMON_NAME) {
697
          $common_names_render_array = compose_feature_block_items_feature_common_name($feature_node->descriptionElements, $feature_node->term);
698
          $block->content[] = $common_names_render_array;
699
          $block_content_is_empty = FALSE;
700
        }
701

    
702
        /*
703
         * Content/Use Description (Use + UseRecord)
704
         */
705
        else if ($feature_node->term->uuid == UUID_USE_RECORD) {
706
          $block->content[] = cdm_block_use_description_content($taxon->uuid, $feature_node->term);
707
          $block_content_is_empty = FALSE;
708
        }
709

    
710
        /*
711
         * Content/ALL OTHER FEATURES.
712
         */
713
        else {
714

    
715
          $media_list = array();
716
          $elements_render_array = array();
717
          $child_elements_render_array = null;
718

    
719
          if (isset($feature_node->descriptionElements[0])) {
720
            $elements_render_array = compose_feature_block_items_generic($feature_node->descriptionElements, $feature_node->term);
721
          }
722

    
723
          // Content/ALL OTHER FEATURES/Subordinate Features
724
          // subordinate features are printed inline in one floating text,
725
          // it is expected hat subordinate features can "contain" TextData,
726
          // Qualitative- and Qualitative- DescriptionElements
727
          if (isset($feature_node->childNodes[0])) {
728
            $child_elements_render_array = compose_feature_block_items_nested($feature_node, $media_list, $feature_block_settings);
729
            $elements_render_array = array_merge($elements_render_array, $child_elements_render_array);
730
          }
731
          $block_content_is_empty = $block_content_is_empty && empty($media_list) && empty($elements_render_array);
732
          if(!$block_content_is_empty){
733
            $block->content[] = compose_feature_block_wrap_elements($elements_render_array, $feature_node->term, $feature_block_settings['glue']);
734
            $block->content[] = compose_feature_media_gallery($feature_node, $media_list, $gallery_settings);
735
            /*
736
             * Footnotes for the feature block
737
             */
738
            $block->content[] = markup_to_render_array(cdm_footnotes(PSEUDO_FEATURE_BIBLIOGRAPHY . '-' . $feature_node->term->uuid));
739
            $block->content[] = markup_to_render_array(cdm_footnotes($feature_node->term->uuid));
740
            $block->content[] = markup_to_render_array(cdm_annotation_footnotes($feature_node->term->uuid));
741
          }
742
        } // END all other features
743

    
744
        // allows modifying the block contents via a the hook_cdm_feature_node_block_content_alter
745
        drupal_alter('cdm_feature_node_block_content', $block->content, $feature_node->term, $feature_node->descriptionElements);
746

    
747
        if(!$block_content_is_empty){ // skip empty block content
748
          $block_list[$block_weight] = $block;
749
          cdm_toc_list_add_item(cdm_term_representation($feature_node->term), $feature_node->term->uuid, null, FALSE, $block_weight);
750
        } // END: skip empty block content
751
      } // END: skip empty or suppressed features
752
      RenderHints::popFromRenderStack();
753
    } // END: creating a block per feature
754

    
755
    RenderHints::popFromRenderStack();
756

    
757
    drupal_alter('cdm_feature_node_blocks', $block_list, $taxon);
758

    
759
    ksort($block_list);
760

    
761
    return  $block_list;
762
  }
763

    
764
/**
765
 * Creates a render array of description elements  held by child nodes of the given feature node.
766
 *
767
 * This function is called recursively!
768
 *
769
 * @param $feature_node
770
 *   The feature node.
771
 * @param array $media_list
772
 *   List of CDM Media entities. All media of subordinate elements should be passed to the main feature.ä
773
 * @param $feature_block_settings
774
 *   The feature block settings.
775
 * @param $main_feature
776
 *  Only used internally in recursive calls.
777
 *
778
 * @return array
779
 *  A Drupal render array
780
 *
781
 * @ingroup compose
782
 */
783
function compose_feature_block_items_nested($feature_node, &$media_list, $feature_block_settings, $main_feature = NULL)
784
{
785

    
786
  if(!$main_feature){
787
    $main_feature = $feature_node->term;
788
  }
789
  /*
790
   * TODO should be configurable, options; YES, NO, AUTOMATIC
791
   * (automatic will only place the label if the first word of the description element text is not the same)
792
   */
793
  $prepend_feature_label = false;
794

    
795
  $render_arrays = array();
796
  foreach ($feature_node->childNodes as $child_node) {
797
    if (isset($child_node->descriptionElements[0])) {
798
      foreach ($child_node->descriptionElements as $element) {
799

    
800
        if (isset($element->media[0])) {
801
          // Append media of subordinate elements to list of main
802
          // feature.
803
          $media_list = array_merge($media_list, $element->media);
804
        }
805

    
806
        $child_node_element = null;
807
        switch ($element->class) {
808
          case 'TextData':
809
            $child_node_element = compose_description_element_text_data($element, $element->feature->uuid, $feature_block_settings, $prepend_feature_label);
810
            break;
811
          case 'CategoricalData':
812
            $child_node_element = compose_description_element_categorical_data($element, $feature_block_settings, $prepend_feature_label);
813
            break;
814
          case 'QuantitativeData':
815
            $child_node_element = compose_description_element_quantitative_data($element, $feature_block_settings, $prepend_feature_label);
816

    
817
        }
818
        if (is_array($child_node_element)) {
819
          $render_arrays[] = $child_node_element;
820
        }
821
      }
822
    }
823

    
824
    if(isset($child_node->childNodes[0])){
825
      $render_arrays = array_merge($render_arrays, compose_feature_block_items_nested($child_node, $media_list, $feature_block_settings, $main_feature ));
826
    }
827
  }
828

    
829
  return $render_arrays;
830
}
831

    
832
  /**
833
   *
834
   * @param $feature_node
835
   *  The merged feature three node which potentially contains media in its description elements.
836
   * @param $media_list
837
   *    Additional media to be merged witht the media contained in the nodes description elements
838
   * @param $gallery_settings
839
   * @return array
840
   *
841
   * @ingroup compose
842
   */
843
  function compose_feature_media_gallery($feature_node, $media_list, $gallery_settings) {
844

    
845
    if (isset($feature_node->descriptionElements)) {
846
      $media_list = array_merge($media_list, cdm_dataportal_media_from_descriptionElements($feature_node->descriptionElements));
847
    }
848

    
849
    $captionElements = array('title', 'rights');
850

    
851
    if (isset($media_list[0]) && isset($gallery_settings['cdm_dataportal_media_maxextend']) && isset($gallery_settings['cdm_dataportal_media_cols'])) {
852
      $gallery = compose_cdm_media_gallerie(array(
853
        'mediaList' => $media_list,
854
        'galleryName' => CDM_DATAPORTAL_DESCRIPTION_GALLERY_NAME . '_' . $feature_node->term->uuid,
855
        'maxExtend' => $gallery_settings['cdm_dataportal_media_maxextend'],
856
        'cols' => $gallery_settings['cdm_dataportal_media_cols'],
857
        'captionElements' => $captionElements,
858
      ));
859
      return markup_to_render_array($gallery);
860
    }
861

    
862
    return markup_to_render_array('');
863
  }
864

    
865
  /**
866
   * Composes the distribution feature block for a taxon
867
   *
868
   * @param $taxon
869
   * @param $descriptionElements
870
   *   an associative array with two elements:
871
   *   - '#type': must be 'DTO'
872
   *   - 'DistributionInfoDTO': a CDM DistributionInfoDTO object as returned by the DistributionInfo web service
873
   * @param $feature
874
   *
875
   * @return array
876
   *  A drupal render array
877
   *
878
   * @ingroup compose
879
   */
880
  function compose_feature_block_distribution($taxon, $descriptionElements, $feature) {
881
    $text_data_glue = '';
882
    $text_data_sortOutArray = FALSE;
883
    $text_data_enclosingTag = 'ul';
884
    $text_data_out_array = array();
885

    
886
    $distributionElements = NULL;
887
    $distribution_info_dto = NULL;
888
    $distribution_sortOutArray = FALSE;
889

    
890
    $feature_block_settings = get_feature_block_settings(UUID_DISTRIBUTION);
891

    
892
    // TODO use feature_block_settings instead of DISTRIBUTION_ORDER_MODE
893
    if (variable_get(DISTRIBUTION_ORDER_MODE, DISTRIBUTION_ORDER_MODE_DEFAULT) != 'TREE') {
894
      $distribution_glue = '';
895
      $distribution_enclosingTag = 'dl';
896
    } else {
897
      $distribution_glue = '';
898
      $distribution_enclosingTag = 'ul';
899
    }
900

    
901
    if (!isset($descriptionElements['#type']) || !$descriptionElements['#type'] == 'DTO') {
902
      // skip the DISTRIBUTION section if there is no DTO type element
903
      return array(); // FIXME is it ok to return an empty array?
904
    }
905

    
906
    $block = feature_block(
907
      cdm_term_representation($feature, 'Unnamed Feature'),
908
      $feature
909
    );
910
    $block->content = array();
911

    
912
    // $$descriptionElements['TextData'] is added to to the feature node in merged_taxon_feature_tree()
913
    if (isset($descriptionElements['TextData'])) {
914
      // --- TextData
915
      foreach ($descriptionElements['TextData'] as $text_data_element) {
916
        $text_data_render_array = compose_description_element_text_data($text_data_element, $text_data_element->feature->uuid, $feature_block_settings);
917
        $repr = drupal_render($text_data_render_array);
918

    
919
        if (!array_search($repr, $text_data_out_array)) { // de-duplication !!
920
          $text_data_out_array[] = $repr;
921
          // TODO HINT: sorting in compose_feature_block_wrap_elements will
922
          // not work since this array contains html attributes with uuids
923
          // and what is about cases like the bibliography where
924
          // any content can be prefixed with some foot-note anchors?
925
          $text_data_sortOutArray = TRUE;
926
          $text_data_glue = '<br/> ';
927
          $text_data_enclosingTag = 'p';
928
        }
929
      }
930
    }
931

    
932

    
933
    if ($text_data_out_array && variable_get(DISTRIBUTION_TEXTDATA_DISPLAY_ON_TOP, 0)) {
934
      $block->content[] = compose_feature_block_wrap_elements(
935
        $text_data_out_array, $feature, $text_data_glue, $text_data_sortOutArray
936
      );
937
    }
938

    
939
    // --- Distribution map
940
    $distribution_map_query_parameters = NULL;
941

    
942
    $map_visibility = variable_get(DISTRIBUTION_MAP_VISIBILITY, DISTRIBUTION_MAP_VISIBILITY_DEFAULT);
943
    if(variable_get(DISTRIBUTION_MAP_VISIBILITY, DISTRIBUTION_MAP_VISIBILITY_DEFAULT) == 'always' ||
944
        $map_visibility == 'automatic' && isset($descriptionElements['DistributionInfoDTO']->mapUriParams)
945
      )
946
    {
947
      $distribution_map_query_parameters = $descriptionElements['DistributionInfoDTO']->mapUriParams;
948
    }
949
    $map_render_element = compose_distribution_map($distribution_map_query_parameters);
950
    $block->content[] = $map_render_element;
951

    
952
    $dto_out_array = array();
953

    
954
    // --- Condensed Distribution
955
    if(variable_get(DISTRIBUTION_CONDENSED) && isset($descriptionElements['DistributionInfoDTO']->condensedDistribution)){
956
      $condensed_distribution_markup = '<p class="condensed_distribution">';
957

    
958
      $isFirst = true;
959
      if(isset($descriptionElements['DistributionInfoDTO']->condensedDistribution->indigenous[0])){
960
        foreach($descriptionElements['DistributionInfoDTO']->condensedDistribution->indigenous as $cdItem){
961
          if(!$isFirst){
962
            $condensed_distribution_markup .= ' ';
963
          }
964
          $condensed_distribution_markup .= '<span class="status_' . $cdItem->status->idInVocabulary . '">'
965
          . $cdItem->areaStatusLabel . '</span>';
966
          $isFirst = false;
967
        }
968
      }
969

    
970
      if(isset($descriptionElements['DistributionInfoDTO']->condensedDistribution->foreign[0])) {
971
        if(!$isFirst){
972
          $condensed_distribution_markup .= ' ';
973
        }
974
        $isFirst = TRUE;
975
        $condensed_distribution_markup .= '[';
976
        foreach ($descriptionElements['DistributionInfoDTO']->condensedDistribution->foreign as $cdItem) {
977
          if (!$isFirst) {
978
            $condensed_distribution_markup .= ' ';
979
          }
980
          $condensed_distribution_markup .= '<span class="status_' . $cdItem->status->titleCache . '">'
981
            . $cdItem->areaStatusLabel . '</span>';
982
          $isFirst = false;
983
        }
984
        $condensed_distribution_markup .= ']';
985
      }
986

    
987
      $condensed_distribution_markup .= '&nbsp;' . l(
988
          font_awesome_icon_markup(
989
            'fa-info-circle',
990
            array(
991
              'alt'=>'help',
992
              'class' => array('superscript')
993
            )
994
          ),
995
          variable_get(DISTRIBUTION_CONDENSED_INFO_PATH, DISTRIBUTION_CONDENSED_INFO_PATH_DEFAULT) ,
996
          array('html' => TRUE));
997
      $condensed_distribution_markup .= '</p>';
998
      $dto_out_array[] = $condensed_distribution_markup;
999
    }
1000

    
1001
    // --- tree or list
1002
    if (isset($descriptionElements['DistributionInfoDTO'])) {
1003
      $distribution_info_dto = $descriptionElements['DistributionInfoDTO'];
1004

    
1005
      // --- tree
1006
      if (is_object($distribution_info_dto->tree)) {
1007
        $distribution_tree_render_array = compose_distribution_hierarchy($distribution_info_dto->tree, $feature_block_settings);
1008
        $dto_out_array[] = $distribution_tree_render_array;
1009
      }
1010

    
1011
      // --- sorted element list
1012
      if (is_array($distribution_info_dto->elements) && count($distribution_info_dto->elements) > 0) {
1013
        foreach ($distribution_info_dto->elements as $descriptionElement) {
1014
          if (is_object($descriptionElement->area)) {
1015
            $sortKey = $descriptionElement->area->representation_L10n;
1016
            $distributionElements[$sortKey] = $descriptionElement;
1017
          }
1018
        }
1019
        ksort($distributionElements);
1020
        $distribution_element_render_array = compose_description_elements_distribution($distributionElements);
1021
        $dto_out_array[] = $distribution_element_render_array;
1022

    
1023
      }
1024
      //
1025
      $block->content[] = compose_feature_block_wrap_elements(
1026
        $dto_out_array, $feature, $distribution_glue, $distribution_sortOutArray
1027
      );
1028
    }
1029

    
1030
    // --- TextData at the bottom
1031
    if ($text_data_out_array && !variable_get(DISTRIBUTION_TEXTDATA_DISPLAY_ON_TOP, 0)) {
1032
      $block->content[] = compose_feature_block_wrap_elements(
1033
        $text_data_out_array, $feature, $text_data_glue, $text_data_sortOutArray
1034
      );
1035
    }
1036

    
1037
    $block->content[] = markup_to_render_array(cdm_footnotes('BIBLIOGRAPHY-' . UUID_DISTRIBUTION));
1038
    $block->content[] = markup_to_render_array(cdm_footnotes(UUID_DISTRIBUTION));
1039
    $block->content[] = markup_to_render_array(cdm_annotation_footnotes(UUID_DISTRIBUTION));
1040

    
1041
    return $block;
1042
  }
1043

    
1044

    
1045
  /**
1046
   * Composes a drupal render array for single CDM TextData description element.
1047
   *
1048
   * @param $element
1049
   *    The CDM TextData description element.
1050
   *  @param $feature_uuid
1051
   * @param bool $prepend_feature_label
1052
   *   Used in nested feature trees to put the feature as label in front of the description element text representation.
1053
   *
1054
   * @return array
1055
   *   A drupal render array with the following elements being used:
1056
   *    - #tag: either 'div', 'li', ...
1057
   *    ⁻ #attributes: class attributes
1058
   *    - #value_prefix: (optionally) contains footnote anchors
1059
   *    - #value: contains the textual content
1060
   *    - #value_suffix: (optionally) contains footnote keys
1061
   *
1062
   * @ingroup compose
1063
   */
1064
  function compose_description_element_text_data($element, $feature_uuid, $feature_block_settings, $prepend_feature_label = FALSE) {
1065

    
1066
    $footnote_list_key_suggestion = $feature_uuid;
1067

    
1068
    $element_markup = '';
1069
    if (isset($element->multilanguageText_L10n->text)) {
1070
      // TODO replacement of \n by <br> should be configurable
1071
      $element_markup = str_replace("\n", "<br/>", $element->multilanguageText_L10n->text);
1072
    }
1073

    
1074
    $render_array = compose_description_element($element, $feature_block_settings, $element_markup, $footnote_list_key_suggestion, $prepend_feature_label);
1075

    
1076
    return $render_array;
1077
  }
1078

    
1079

    
1080
/**
1081
 * Theme function to render CDM DescriptionElements of the type TaxonInteraction.
1082
 *
1083
 * @param $element
1084
 *  The CDM TaxonInteraction entity
1085
 *
1086
 * @return
1087
 *  A drupal render array
1088
 *
1089
 * @ingroup compose
1090
 */
1091
function compose_description_element_taxon_interaction($element, $feature_block_settings) {
1092

    
1093
  $out = '';
1094

    
1095

    
1096
  if (isset($element->description_L10n)) {
1097
    $out .=  ' ' . $element->description_L10n;
1098
  }
1099

    
1100
  if(isset($element->taxon2)){
1101
    $out = render_taxon_or_name($element->taxon2, url(path_to_taxon($element->taxon2->uuid)));
1102
  }
1103

    
1104
  $render_array = compose_description_element($element, $feature_block_settings, $out, $element->feature->uuid);
1105

    
1106
  return $render_array;
1107
}
1108

    
1109

    
1110
/**
1111
 * Renders a single instance of the type IndividualsAssociations.
1112
 *
1113
 * @param $element
1114
 *   The CDM IndividualsAssociations entity.
1115
 * @param $feature_block_settings
1116
 *
1117
 * @return array
1118
 *   Drupal render array
1119
 *
1120
 * @ingroup compose
1121
 */
1122
function compose_description_element_individuals_association($element, $feature_block_settings) {
1123

    
1124
  $out = '';
1125

    
1126
  $render_array = compose_cdm_specimen_or_observation($element->associatedSpecimenOrObservation);
1127

    
1128
  if (isset($element->description_L10n)) {
1129
    $out .=  ' ' . $element->description_L10n;
1130
  }
1131

    
1132
  $out .= drupal_render($render_array);
1133

    
1134
  $render_array = compose_description_element($element, $feature_block_settings, $out, $element->feature->uuid);
1135

    
1136
  return $render_array;
1137
}
1138

    
1139
/**
1140
 * Renders a single instance of the type CategoricalData.
1141
 *
1142
 * @param $element
1143
 *  The CDM CategoricalData entity
1144
 *
1145
 * @param $feature_block_settings
1146
 *
1147
 * @param bool $prepend_feature_label
1148
 *   Used in nested feature trees to put the feature as label in front of the description element text representation.
1149
 *
1150
 * @return array
1151
 *   a drupal render array for given CategoricalData element
1152
 *
1153
 * @ingroup compose
1154
 */
1155
function compose_description_element_categorical_data($element, $feature_block_settings, $prepend_feature_label = FALSE) {
1156

    
1157
  $state_data_markup = render_state_data($element);
1158

    
1159
  $render_array = compose_description_element($element, $feature_block_settings, $state_data_markup, $element->feature->uuid, $prepend_feature_label);
1160

    
1161
  return $render_array;
1162
}
1163

    
1164
/**
1165
 * @param $element
1166
 *
1167
 * @return string
1168
 * the markup
1169
 */
1170
function render_state_data($element) {
1171

    
1172
  $state_data_items = [];
1173

    
1174
  $out = '';
1175

    
1176
  if (isset($element->stateData)) {
1177
    foreach ($element->stateData as $state_data) {
1178

    
1179
      $state = NULL;
1180

    
1181
      if (isset($state_data->state)) {
1182
        $state = cdm_term_representation($state_data->state);
1183

    
1184
          $sample_count = 0;
1185
          if (isset($state_data->count)) {
1186
            $sample_count = $state_data->count;
1187
            $state .= ' [' . $state_data->count . ']';
1188
          }
1189
    
1190
          if (isset($state_data->modifyingText_L10n)) {
1191
            $state .= ' ' . $state_data->modifyingText_L10n;
1192
          }
1193
    
1194
          $modifiers_strings = cdm_modifiers_representations($state_data);
1195
          $state_data_markup = $state . ($modifiers_strings ? ' ' . $modifiers_strings : '');
1196
          // we could use strip_tags() to reduce the markup to text for the key but this is expensive
1197
          $sort_key = str_pad($sample_count, 6, '0', STR_PAD_LEFT) . '_' . $state_data_markup;
1198
          $state_data_items[$sort_key] = $state_data_markup;
1199
      }
1200

    
1201
    }
1202
    krsort($state_data_items);
1203
    $out = '<span class="' . html_class_attribute_ref($element) . '">' . join(', ', $state_data_items) .  '</span>';
1204
  }
1205
  return $out;
1206
}
1207

    
1208

    
1209
/**
1210
 * Theme function to render CDM DescriptionElements of the type QuantitativeData.
1211
 *
1212
 * The function renders the statisticalValues contained in the QuantitativeData
1213
 * entity according to the following scheme:
1214
 *
1215
 * (ExtremeMin)-Min-Average-Max-(ExtremeMax)
1216
 *
1217
 * All modifiers of these values are appended.
1218
 *
1219
 * If the QuantitativeData is containing more statisticalValues with further
1220
 * statisticalValue types, these additional measures will be appended to the
1221
 * above string separated by whitespace.
1222
 *
1223
 * Special cases;
1224
 * 1. Min==Max: this will be interpreted as Average
1225
 *
1226
 * @param $element
1227
 *  The CDM QuantitativeData entity
1228
 *
1229
 * @param $feature_block_settings
1230
 *
1231
 * @param bool $prepend_feature_label
1232
 *   Used in nested feature trees to put the feature as label in front of the description element text representation.
1233
 *
1234
 *
1235
 * @return array
1236
 *   drupal render array for the given QuantitativeData element
1237
 *
1238
 * @ingroup compose
1239
 */
1240
function compose_description_element_quantitative_data($element, $feature_block_settings, $prepend_feature_label = FALSE) {
1241
  /*
1242
   * - statisticalValues
1243
   *   - value
1244
   *   - modifiers
1245
   *   - type
1246
   * - unit->representation_L10n
1247
   * - modifyingText
1248
   * - modifiers
1249
   * - sources
1250
   */
1251

    
1252
  $out = render_quantitative_statistics($element);
1253

    
1254
  $render_array = compose_description_element($element, $feature_block_settings, $out, $element->feature->uuid, $prepend_feature_label);
1255

    
1256
  return $render_array;
1257
}
1258

    
1259
/**
1260
 * Composes the HTML for quantitative statistics
1261
 * @param $element
1262
 *
1263
 * @return string
1264
 */
1265
function render_quantitative_statistics($element) {
1266

    
1267
  $out = '';
1268
  $type_representation = NULL;
1269
  $min_max = statistical_values_array();
1270
  $sample_size_markup = null;
1271

    
1272
  if (isset($element->statisticalValues)) {
1273
    $out = '<span class=\"' . html_class_attribute_ref($element) . '\">';
1274
    $other_values_markup = [];
1275
    foreach ($element->statisticalValues as $statistical_val) {
1276

    
1277
      // compile the full value string which also may contain modifiers
1278
      if (isset($statistical_val->value)) {
1279
        $statistical_val->_value = $statistical_val->value;
1280
      }
1281
      $val_modifiers_strings = cdm_modifiers_representations($statistical_val);
1282
      if ($val_modifiers_strings) {
1283
        $statistical_val->_value = ' ' . $val_modifiers_strings . ' ' . $statistical_val->_value;
1284
      }
1285

    
1286
      // either put into min max array or into $other_values
1287
      // for generic output to be appended to 'min-max' string
1288
      if (array_key_exists(statistical_measure_term2min_max_key($statistical_val->type), $min_max)) {
1289
        $min_max[statistical_measure_term2min_max_key($statistical_val->type)] = $statistical_val;
1290
      }
1291
      else {
1292
        drupal_set_message("Unsupported statistical value type: " . $statistical_val->type->uuid, "error");
1293
      }
1294
    } // end of loop over statisticalValues
1295

    
1296
    // create markup
1297
    $unit = null;
1298
    if (isset($element->unit)) {
1299
      $unit = ' <span class="unit" title="'
1300
        . cdm_term_representation($element->unit) . '">'
1301
        . cdm_term_representation_abbreviated($element->unit)
1302
        . '</span>';
1303
    }
1304
    $min_max_markup = statistical_values($min_max, $unit);
1305
    $out .= $min_max_markup . '</span>';
1306
  }
1307

    
1308
  if($sample_size_markup){
1309
    $out .= ' ' . $sample_size_markup;
1310

    
1311
  }
1312

    
1313
  // modifiers of the description element itself
1314
  $modifier_string = cdm_modifiers_representations($element);
1315
  $out .= ($modifier_string ? ' ' . $modifier_string : '');
1316
  if (isset($element->modifyingText_L10n)) {
1317
    $out = $element->modifyingText_L10n . ' ' . $out;
1318
  }
1319
  return $out;
1320
}
1321

    
1322
function statistical_measure_term2min_max_key($term){
1323
  static $uuid2key = [
1324
    UUID_STATISTICALMEASURE_MIN => 'Min',
1325
    UUID_STATISTICALMEASURE_MAX => 'Max',
1326
    UUID_STATISTICALMEASURE_AVERAGE => 'Average',
1327
    UUID_STATISTICALMEASURE_SAMPLESIZE => 'SampleSize',
1328
    UUID_STATISTICALMEASURE_VARIANCE => 'Variance',
1329
    UUID_STATISTICALMEASURE_TYPICALLOWERBOUNDARY => 'TypicalLowerBoundary',
1330
    UUID_STATISTICALMEASURE_TYPICALUPPERBOUNDARY => 'TypicalUpperBoundary',
1331
    UUID_STATISTICALMEASURE_STANDARDDEVIATION => 'StandardDeviation',
1332
    UUID_STATISTICALMEASURE_EXACTVALUE => 'ExactValue',
1333
    UUID_STATISTICALMEASURE_STATISTICALMEASUREUNKNOWNDATA => 'StatisticalMeasureUnknownData'
1334
  ];
1335
  return $uuid2key[$term->uuid];
1336
}
1337

    
1338

    
1339
/**
1340
 * Wraps the render array for the given feature into an enclosing html tag.
1341
 *
1342
 * Optionally the elements can be sorted and glued together by a separator string.
1343
 *
1344
 * @param array $description_element_render_arrays
1345
 *   An list of render arrays. Which are usually are produced by the compose_description_element()
1346
 *   function. The render arrays should be of #type=html_tag, so that they can understand the #attribute property.
1347
 * @param  $feature :
1348
 *  The feature to which the elements given in $elements are belonging to.
1349
 * @param string $glue :
1350
 *  Defaults to empty string.
1351
 * @param bool $sort
1352
 *   Boolean Whether to sort the $elements alphabetically, default is FALSE
1353
 *
1354
 * @return array
1355
 *    A Drupal render array
1356
 *
1357
 * @ingroup compose
1358
 */
1359
  function compose_feature_block_wrap_elements(array $description_element_render_arrays, $feature, $glue = '', $sort = FALSE)
1360
  {
1361

    
1362
    $feature_block_settings = get_feature_block_settings($feature->uuid);
1363
    $enclosing_tag = $feature_block_settings['as_list'];
1364

    
1365
    if ($sort) { // TODO remove parameter and replace by $feature_block_settings['sort_elements']
1366
      usort($description_element_render_arrays, 'compare_description_element_render_arrays');
1367
    }
1368

    
1369
    $is_first = true;
1370
    foreach($description_element_render_arrays as &$element_render_array){
1371
      if(!is_array($element_render_array)){
1372
        $element_render_array = markup_to_render_array($element_render_array);
1373
      }
1374
      $element_render_array['#attributes']['class'][] = "feature-block-element";
1375

    
1376
      // add the glue!
1377
      if(!$is_first) {
1378
        if (isset($element_render_array['#value'])) {
1379
          $element_render_array['#value'] = $glue . $element_render_array['#value'];
1380
        } elseif (isset($element_render_array['#markup'])) {
1381
          $element_render_array['#markup'] = $glue . $element_render_array['#markup'];
1382
        }
1383
      }
1384
      $is_first = false;
1385
    }
1386

    
1387
    $render_array['elements']['children'] = $description_element_render_arrays;
1388

    
1389
    $render_array['elements']['#prefix'] = '<' . $enclosing_tag . ' class="feature-block-elements" id="' . $feature->representation_L10n . '">';
1390
    $render_array['elements']['#suffix'] = '</' . $enclosing_tag . '>';
1391

    
1392
    return $render_array;
1393
  }
1394

    
1395

    
1396
  /* compose nameInSource or originalNameString as markup
1397
   *
1398
   * @param $source
1399
   * @param $do_link_to_name_used_in_source
1400
   * @param $suppress_for_shown_taxon
1401
   *    the nameInSource will be suppressed when it has the same name as the accepted taxon
1402
   *    for which the taxon page is being created, Defaults to TRUE
1403
   *
1404
   * @return array
1405
   *    A Drupal render array with an additional element, the render array is empty
1406
   *    if the source had no name in source information
1407
   *    - #_plaintext: contains the plaintext version of the name (custom element)
1408
   *
1409
   * @ingroup compose
1410
   */
1411
  function compose_name_in_source($source, $do_link_to_name_used_in_source, $suppress_for_shown_taxon = TRUE) {
1412

    
1413
    $plaintext = NULL;
1414
    $markup = NULL;
1415
    $name_in_source_render_array = array();
1416

    
1417
    static $taxon_page_accepted_name = '';
1418
    $taxon_uuid = get_current_taxon_uuid();
1419
    if($suppress_for_shown_taxon && $taxon_uuid && empty($taxon_page_accepted_name)){
1420

    
1421
      $current_taxon = cdm_ws_get(CDM_WS_PORTAL_TAXON, $taxon_uuid);
1422
      $taxon_page_accepted_name = $current_taxon->name->titleCache;
1423
    }
1424

    
1425
    if (isset($source->nameUsedInSource->uuid) && isset($source->nameUsedInSource->titleCache)) {
1426
      // it is a DescriptionElementSource !
1427
      $plaintext = $source->nameUsedInSource->titleCache;
1428
      if($suppress_for_shown_taxon && $taxon_page_accepted_name == $plaintext){
1429
        return $name_in_source_render_array; // SKIP this name
1430
      }
1431
      $markup = render_taxon_or_name($source->nameUsedInSource);
1432
      if ($do_link_to_name_used_in_source) {
1433
        $markup = l(
1434
          $markup,
1435
          path_to_name($source->nameUsedInSource->uuid),
1436
          array(
1437
            'attributes' => array(),
1438
            'absolute' => TRUE,
1439
            'html' => TRUE,
1440
          ));
1441
      }
1442
    }
1443
    else if (isset($source->originalNameString) && !empty($source->originalNameString)) {
1444
      // the name used in source can not be expressed as valid taxon name,
1445
      // so the editor has chosen to put the freetext name into ReferencedEntityBase.originalNameString
1446
      // field
1447
      // using the originalNameString as key to avoid duplicate entries
1448
      $plaintext = $source->originalNameString;
1449
      if($suppress_for_shown_taxon && $taxon_page_accepted_name == $plaintext){
1450
        return $name_in_source_render_array; // SKIP this name
1451
      }
1452
      $markup = $source->originalNameString;
1453
    }
1454

    
1455
    if ($plaintext) { // checks if we have any content
1456
      $name_in_source_render_array = markup_to_render_array($markup);
1457
      $name_in_source_render_array['#_plaintext'] = $plaintext;
1458
    }
1459

    
1460
    return $name_in_source_render_array;
1461
  }
1462

    
1463

    
1464

    
1465
  /**
1466
   * Return HTML for a list of description elements.
1467
   *
1468
   * Usually these are of a specific feature type.
1469
   *
1470
   * @param $description_elements
1471
   *   array of descriptionElements which belong to the same feature.
1472
   *   These descriptions elements of a Description must be ordered by the chosen feature tree by
1473
   *   calling the function _mergeFeatureTreeDescriptions().
1474
   *   @see _mergeFeatureTreeDescriptions()
1475
   *
1476
   * @param  $feature_uuid
1477
   *
1478
   * @return
1479
   *    A drupal render array for the $descriptionElements, may be an empty array if the textual content was empty.
1480
   *    Footnote key or anchors are not considered to be textual content.
1481
   *
1482
   * @ingroup compose
1483
   */
1484
  function compose_feature_block_items_generic($description_elements, $feature) {
1485

    
1486
    $elements_out_array = array();
1487
    $distribution_tree = null;
1488

    
1489
    /*
1490
     * $feature_block_has_content will be set true if at least one of the
1491
     * $descriptionElements contains some text which makes up some content
1492
     * for the feature block. Footnote keys are not considered
1493
     * to be content in this sense.
1494
     */
1495
    $feature_block_has_content = false;
1496

    
1497
    if (is_array($description_elements)) {
1498
      foreach ($description_elements as $description_element) {
1499
          /* decide based on the description element class
1500
           *
1501
           * Features handled here:
1502
           * all except DISTRIBUTION, COMMON_NAME, USES, IMAGES,
1503
           *
1504
           * TODO provide api_hook as extension point for this?
1505
           */
1506
        $feature_block_settings = get_feature_block_settings($description_element->feature->uuid);
1507
        switch ($description_element->class) {
1508
          case 'TextData':
1509
            $elements_out_array[] = compose_description_element_text_data($description_element, $description_element->feature->uuid, $feature_block_settings);
1510
            break;
1511
          case 'CategoricalData':
1512
            $elements_out_array[] = compose_description_element_categorical_data($description_element, $feature_block_settings);
1513
            break;
1514
          case 'QuantitativeData':
1515
            $elements_out_array[] = compose_description_element_quantitative_data($description_element, $feature_block_settings);
1516
            break;
1517
          case 'IndividualsAssociation':
1518
            $elements_out_array[] = compose_description_element_individuals_association($description_element, $feature_block_settings);
1519
            break;
1520
          case 'TaxonInteraction':
1521
            $elements_out_array[] = compose_description_element_taxon_interaction($description_element, $feature_block_settings);
1522
            break;
1523
          case 'CommonTaxonName':
1524
            $elements_out_array[] = compose_description_element_common_taxon_name($description_element, $feature_block_settings);
1525
            break;
1526
          case 'Uses':
1527
            /* IGNORE Uses classes, these are handled completely in compose_feature_block_items_use_records()  */
1528
            break;
1529
          default:
1530
            $feature_block_has_content = true;
1531
            $elements_out_array[] = markup_to_render_array('<li>No method for rendering unknown description class: ' . $description_element->class . '</li>');
1532
        }
1533
        $elements_out_array_last_item = $elements_out_array[count($elements_out_array) - 1];
1534
        // considering not empty as long as the last item added is a render array
1535
        $feature_block_has_content = $feature_block_has_content || !empty($elements_out_array_last_item['#type']);
1536
      }
1537

    
1538
      // If feature = CITATION sort the list of sources.
1539
      // This is ONLY for FLORA MALESIANA and FLORE d'AFRIQUE CENTRALE.
1540
      if (isset($description_element) && $description_element->feature->uuid == UUID_CITATION) {
1541
        sort($elements_out_array);
1542
      }
1543
    }
1544

    
1545
    // sanitize: remove empty and NULL items from the render array
1546
    $tmp_out_array = $elements_out_array;
1547
    $elements_out_array = array();
1548
    foreach($tmp_out_array as $item){
1549
      if(is_array($item) && count($item) > 0){
1550
        $elements_out_array[] = $item;
1551
      }
1552
    }
1553

    
1554
    return $elements_out_array;
1555
  }
1556

    
1557
/**
1558
 * Composes block of common names for the given DescriptionElements $elements which must be of the feature CommonName
1559
 *
1560
 * @parameter $elements
1561
 *  an array of CDM DescriptionElements either of type CommonName or TextData
1562
 * @parameter $feature
1563
 *  the common feature of all $elements, must be CommonName
1564
 *
1565
 * @return
1566
 *   A drupal render array
1567
 *
1568
 * @ingroup compose
1569
 */
1570
function compose_feature_block_items_feature_common_name($elements, $feature, $weight = FALSE) {
1571

    
1572
  $common_name_out = '';
1573
  $common_name_feature_elements = array();
1574
  $textData_commonNames = array();
1575

    
1576
  $footnote_key_suggestion = 'common-names-feature-block';
1577

    
1578
  $feature_block_settings = get_feature_block_settings(UUID_COMMON_NAME);
1579

    
1580
  if (is_array($elements)) {
1581
    foreach ($elements as $element) {
1582

    
1583
      if ($element->class == 'CommonTaxonName') {
1584

    
1585
        // common name without a language or area, should not happen but is possible
1586
        $language_area_key = '';
1587
        if (isset($element->language->representation_L10n)) {
1588
          $language_area_key .= $element->language->representation_L10n ;
1589
        }
1590
        if(isset($element->area->titleCache) && strlen($element->area->titleCache) > 0){
1591
          $language_area_key .= ($language_area_key ? ' '  : '') . '(' . $element->area->titleCache . ')';
1592
        }
1593
        if($language_area_key){
1594
          $language_area_key = '<span class="language-area-label">' . $language_area_key . '<span class="separator">: </span></span>';
1595
        }
1596

    
1597
        if(isset($common_names[$language_area_key][$element->name])) {
1598
          // same name already exists for language and area combination, se we merge the description elements
1599
          cdm_merge_description_elements($common_names[$language_area_key][$element->name], $element);
1600
        } else{
1601
          // otherwise add as new entry
1602
          $common_names[$language_area_key][$element->name] = $element;
1603
        }
1604

    
1605
      }
1606
      elseif ($element->class == 'TextData') {
1607
        $textData_commonNames[] = $element;
1608
      }
1609
    }
1610
  }
1611
  // Handling common names.
1612
  if (isset($common_names) && count($common_names) > 0) {
1613
    // Sorting the array based on the key (language, + area if set).
1614
    // Comment @WA there are common names without a language, so this sorting
1615
    // can give strange results.
1616
    ksort($common_names);
1617

    
1618
    // loop over set of elements per language area
1619
    foreach ($common_names as $language_area_key => $elements) {
1620
      ksort($elements); // sort names alphabetically
1621
      $per_language_area_out = array();
1622

    
1623
      foreach ($elements as $element) {
1624
        $common_name_render_array = compose_description_element_common_taxon_name($element, $feature_block_settings, $footnote_key_suggestion);
1625
        $common_name_markup = drupal_render($common_name_render_array);
1626
        // IMPORTANT!
1627
        // during the above drupal_render the theme_html_tag function is executed, which adds a "\n" character to the end of the markup
1628
        // this is an error and the trailing whitespace needs to be removed
1629
        if(str_endsWith($common_name_markup, "\n")){
1630
          $common_name_markup = substr($common_name_markup, 0, strlen($common_name_markup) - 1);
1631
        }
1632
        $per_language_area_out[] = $common_name_markup;
1633
      }
1634

    
1635
      $common_name_feature_elements[] = $language_area_key . join(', ', $per_language_area_out);
1636
    } // End of loop over set of elements per language area
1637

    
1638

    
1639
    $common_name_feature_elements_render_array = compose_feature_block_wrap_elements(
1640
      $common_name_feature_elements, $feature, '; ', FALSE
1641
    );
1642
    $common_name_out .= drupal_render($common_name_feature_elements_render_array); // FIXME should this be a render array instead?
1643

    
1644
  }
1645

    
1646
  // Handling commons names as text data.
1647
  $text_data_out = array();
1648

    
1649
  foreach ($textData_commonNames as $text_data_element) {
1650
    /* footnotes are not handled correctly in compose_description_element_text_data,
1651
       need to set 'common-names-feature-block' as $footnote_key_suggestion */
1652
    RenderHints::setFootnoteListKey($footnote_key_suggestion);
1653
    $text_data_render_array = compose_description_element_text_data($text_data_element, $text_data_element->feature->uuid, $feature_block_settings);
1654
    $text_data_out[] = drupal_render($text_data_render_array);
1655
  }
1656

    
1657
  $common_name_out_text_data = compose_feature_block_wrap_elements(
1658
    $text_data_out, $feature
1659
  );
1660

    
1661
  $footnotes = cdm_footnotes('BIBLIOGRAPHY-' . $footnote_key_suggestion);
1662
  $footnotes .= cdm_footnotes($footnote_key_suggestion); // FIXME is this needed at all?
1663
  $footnotes .= cdm_annotation_footnotes($footnote_key_suggestion);
1664

    
1665
  return  markup_to_render_array(  // FIXME markup_to_render_array should no longer be needed
1666
    '<div class="common-taxon-name">' . $common_name_out . '</div>'
1667
    .'<div class="text-data">' . drupal_render($common_name_out_text_data) . '</div>'
1668
    .$footnotes,
1669
    $weight
1670
  );
1671
}
1672

    
1673
/**
1674
 * Renders a single instance of the type CommonTaxonName.
1675
 *
1676
 * @param $element
1677
 *   The CDM CommonTaxonName entity.
1678
 * @param $feature_block_settings
1679
 *
1680
 * @param $footnote_key_suggestion
1681
 *
1682
 * @param $element_tag_name
1683
 *
1684
 * @return array
1685
 *   Drupal render array
1686
 *
1687
 * @ingroup compose
1688
 */
1689
function compose_description_element_common_taxon_name($element, $feature_block_settings, $footnote_key_suggestion = NULL)
1690
{
1691

    
1692
  if(!$footnote_key_suggestion) {
1693
    $footnote_key_suggestion = $element->feature->uuid;
1694
  }
1695

    
1696
  $name = '';
1697
  if(isset($element->name)){
1698
    $name = $element->name;
1699
  }
1700

    
1701

    
1702
  return compose_description_element($element, $feature_block_settings, $name, $footnote_key_suggestion);
1703
}
1704

    
1705
/**
1706
 * Composes the render array for a CDM Distribution description element
1707
 *
1708
 * @param array $description_elements
1709
 *   Array of CDM Distribution instances
1710
 * @param $enclosingTag
1711
 *   The html tag to be use for the enclosing element
1712
 *
1713
 * @return array
1714
 *   A Drupal render array
1715
 *
1716
 * @ingroup compose
1717
 */
1718
function compose_description_elements_distribution($description_elements){
1719

    
1720
  $markup_array = array();
1721
  RenderHints::pushToRenderStack('descriptionElementDistribution');
1722
  RenderHints::setFootnoteListKey(UUID_DISTRIBUTION);
1723

    
1724
  $feature_block_settings = get_feature_block_settings(UUID_DISTRIBUTION);
1725
  $enclosingTag = cdm_feature_block_element_tag_name($feature_block_settings);
1726

    
1727
  foreach ($description_elements as $description_element) {
1728
    $annotations_and_sources = handle_annotations_and_sources(
1729
      $description_element,
1730
      handle_annotations_and_sources_config($feature_block_settings),
1731
      $description_element->area->representation_L10n,
1732
      UUID_DISTRIBUTION
1733
    );
1734

    
1735

    
1736
    $status = distribution_status_label_and_markup([$description_element]);
1737

    
1738
    $out = '';
1739
    $out .= '<' . $enclosingTag . ' class="descriptionElement descriptionElement-' . $description_element->uuid
1740
      . ' " title="' . $status['label']. '">'
1741
      . $description_element->area->representation_L10n
1742
      . $status['markup'];
1743
    if(!empty($annotations_and_sources['source_references'])){
1744
      $out .= ' ' . join(' ', $annotations_and_sources['source_references'] );
1745
    }
1746
    $out .= $annotations_and_sources['foot_note_keys']   . '</' . $enclosingTag . '>';
1747
    $markup_array[] = $out;
1748
  }
1749

    
1750
  RenderHints::popFromRenderStack();
1751
  return markup_to_render_array(join('<span class="separator">' . $feature_block_settings['glue'] . '</span>', $markup_array));
1752
}
1753

    
1754
  /**
1755
   * @param array $distribution_status
1756
   * @return array an array with following keys
1757
   *   - 'label': the plain text status label
1758
   *   - 'markup': markup for the status
1759
   */
1760
  function distribution_status_label_and_markup(array $distribution_status, $status_glue = '&#8210; ') {
1761

    
1762
    $status_markup = '';
1763
    $status_label = '';
1764

    
1765
    foreach($distribution_status as $status) {
1766
      $status_label .= ($status_label ? $status_glue : '') . $status->representation_L10n;
1767
      $status_markup .=  '<span class="distributionStatus"> '
1768
        . ($status_markup ? $status_glue : '')
1769
        . '<span class="distributionStatus-' . $status->idInVocabulary . '">'
1770
        .  $status->representation_L10n
1771
        . '</span></span>';
1772

    
1773
    };
1774
    return ['label' => $status_label, 'markup' => $status_markup];
1775
  }
1776

    
1777

    
1778
  /**
1779
   * Provides the merged feature tree for a taxon profile page.
1780
   *
1781
   * The merging of the profile feature tree is actually done in
1782
   * _mergeFeatureTreeDescriptions(). See this method  for details
1783
   * on the structure of the merged tree.
1784
   *
1785
   * This method provides a hook which can be used to modify the
1786
   * merged feature tree after it has been created, see
1787
   * hook_merged_taxon_feature_tree_alter()
1788
   *
1789
   * @param $taxon
1790
   *    A CDM Taxon instance
1791
   *
1792
   * @return object
1793
   *    The merged feature tree
1794
   *
1795
   */
1796
  function merged_taxon_feature_tree($taxon) {
1797

    
1798
    // 1. fetch descriptions_by_featuretree but exclude the distribution feature
1799
    $merged_tree = cdm_ws_descriptions_by_featuretree(get_profile_feature_tree(), $taxon->uuid, array(UUID_DISTRIBUTION));
1800

    
1801

    
1802
    // 2. find the distribution feature node
1803
    $distribution_node =& cdm_feature_tree_find_node($merged_tree->root->childNodes, UUID_DISTRIBUTION);
1804

    
1805
    if ($distribution_node) {
1806
      // 3. get the distributionInfoDTO
1807
      $query_parameters = cdm_distribution_filter_query();
1808
      $query_parameters['part'] = array('mapUriParams');
1809
      if(variable_get(DISTRIBUTION_CONDENSED)){
1810
        $query_parameters['part'][] = 'condensedDistribution';
1811
      }
1812
      if (variable_get(DISTRIBUTION_ORDER_MODE, DISTRIBUTION_ORDER_MODE_DEFAULT) == 'TREE') {
1813
        $query_parameters['part'][] = 'tree';
1814
      }
1815
      else {
1816
        $query_parameters['part'][] = 'elements';
1817
      }
1818
      $query_parameters['omitLevels'] = array();
1819
      foreach(variable_get(DISTRIBUTION_TREE_OMIT_LEVELS, array()) as $uuid){
1820
        if(is_uuid($uuid)){
1821
          $query_parameters['omitLevels'][] = $uuid;
1822
        }
1823
      }
1824
      $customStatusColorsJson = variable_get(DISTRIBUTION_STATUS_COLORS, NULL);
1825
      if ($customStatusColorsJson) {
1826
        $query_parameters['statusColors'] = $customStatusColorsJson;
1827
      }
1828

    
1829
      $distribution_info_dto = cdm_ws_get(CDM_WS_PORTAL_DESCRIPTION_DISTRIBUTION_INFO_FOR, $taxon->uuid, queryString($query_parameters));
1830
      // 4. get distribution TextData is there are any
1831
      $distribution_text_data = cdm_ws_fetch_all(CDM_WS_DESCRIPTIONELEMENT_BY_TAXON,
1832
        array(
1833
          'taxon' => $taxon->uuid,
1834
          'type' => 'TextData',
1835
          'features' => UUID_DISTRIBUTION
1836
        )
1837
      );
1838

    
1839
      // 5. put all distribution data into the distribution feature node
1840
      if ($distribution_text_data //if text data exists
1841
        || ($distribution_info_dto && isset($distribution_info_dto->tree) && $distribution_info_dto->tree->rootElement->numberOfChildren > 0) // OR if tree element has distribution elements
1842
        || ($distribution_info_dto && !empty($distribution_info_dto->elements))
1843
      ) { // OR if DTO has distribution elements
1844
        $distribution_node->descriptionElements = array('#type' => 'DTO');
1845
        if ($distribution_text_data) {
1846
          $distribution_node->descriptionElements['TextData'] = $distribution_text_data;
1847
        }
1848
        if ($distribution_info_dto) {
1849
          $distribution_node->descriptionElements['DistributionInfoDTO'] = $distribution_info_dto;
1850
        }
1851
      }
1852
    }
1853

    
1854
    // allows modifying the merged tree via a the hook_cdm_feature_node_block_content_alter
1855
    drupal_alter('merged_taxon_feature_tree', $taxon, $merged_tree);
1856

    
1857
    return $merged_tree;
1858
  }
1859

    
1860
  /**
1861
   * @param $distribution_tree
1862
   *  A tree cdm TreeNode items. A TreeNode item has a NamedArea as nodeId
1863
   *  and Distribution items as data array. Per data array some Distributions may
1864
   *  be with status information, others only with sources, others with both.
1865
   *  Each node may also have subordinate node items in the children field.
1866
   *  TreeNode:
1867
   *   - array data
1868
   *   - array children
1869
   *   - int numberOfChildren
1870
   *   - stdClass nodeId
1871
   *
1872
   * @param $feature_block_settings
1873
   *
1874
   * @return array
1875
   * @throws \Exception
1876
   */
1877
  function compose_distribution_hierarchy($distribution_tree, $feature_block_settings){
1878

    
1879
    static $hierarchy_style;
1880
    // TODO expose $hierarchy_style to administration or provide a hook
1881
    if( !isset($hierarchy_style)){
1882
      $hierarchy_style = get_array_variable_merged(DISTRIBUTION_HIERARCHY_STYLE, DISTRIBUTION_HIERARCHY_STYLE_DEFAULT);
1883
    }
1884

    
1885
    $render_array = array();
1886

    
1887
    RenderHints::pushToRenderStack('descriptionElementDistribution');
1888
    RenderHints::setFootnoteListKey(UUID_DISTRIBUTION);
1889

    
1890
    // Returning NULL if there are no description elements.
1891
    if ($distribution_tree == null) {
1892
      return $render_array;
1893
    }
1894
    // for now we are not using a render array internally to avoid performance problems
1895
    $markup = '';
1896
    if (isset($distribution_tree->rootElement->children)) {
1897
      $tree_nodes = $distribution_tree->rootElement->children;
1898
      _compose_distribution_hierarchy($tree_nodes, $feature_block_settings, $markup, $hierarchy_style);
1899
    }
1900

    
1901
    $render_array['distribution_hierarchy'] = markup_to_render_array(
1902
      $markup,
1903
      0,
1904
      '<div id="distribution_hierarchy" class="distribution_hierarchy">',
1905
      '</div>'
1906
    );
1907

    
1908
    RenderHints::popFromRenderStack();
1909

    
1910
    return $render_array;
1911
  }
1912

    
1913
/**
1914
 * this function should produce markup as the
1915
 * compose_description_elements_distribution() function.
1916
 *
1917
 * @param array $tree_nodes
1918
 *  An array of cdm TreeNode items. A TreeNode item has a NamedArea as nodeId
1919
 *  and Distribution items as data array. Per data array some Distributions may
1920
 *  be with status information, others only with sources, others with both.
1921
 *  TreeNode:
1922
 *   - array data
1923
 *   - array children
1924
 *   - int numberOfChildren
1925
 *   - stdClass nodeId
1926
 * @param array $feature_block_settings
1927
 * @param $markup
1928
 * @param $hierarchy_style
1929
 * @param int $level_index
1930
 *
1931
 * @throws \Exception
1932
 *
1933
 * @see compose_description_elements_distribution()
1934
 * @see compose_distribution_hierarchy()
1935
 *
1936
 */
1937
  function _compose_distribution_hierarchy(array $tree_nodes, array $feature_block_settings, &$markup, $hierarchy_style, $level_index = -1){
1938

    
1939
    $level_index++;
1940
    static $enclosingTag = "span";
1941

    
1942
    $level_style = array_shift($hierarchy_style);
1943
    if(count($hierarchy_style) == 0){
1944
      // lowest defined level style will be reused for all following levels
1945
      $hierarchy_style[] = $level_style;
1946
    }
1947

    
1948
    $node_index = -1;
1949
    $per_node_markup = array();
1950

    
1951
    foreach ($tree_nodes as $node){
1952

    
1953
      $per_node_markup[++$node_index] = '';
1954
      $label = $node->nodeId->representation_L10n;
1955

    
1956
      $distributions = $node->data;
1957
      $distribution_uuids = array();
1958
      $distribution_aggregate = NULL;
1959
      $status = ['label' => '', 'markup' => ''];
1960

    
1961
      foreach($distributions as $distribution){
1962
        $distribution_uuids[] = $distribution->uuid;
1963
        // if there is more than one distribution we aggregate the sources and
1964
        // annotations into a synthetic distribution so that the footnote keys
1965
        // can be rendered consistently
1966
        if(!$distribution_aggregate) {
1967
          $distribution_aggregate = $distribution;
1968
          if(isset($distribution->status)){
1969
            $distribution_aggregate->status = [$distribution->status];
1970
          } else {
1971
            $distribution_aggregate->status = [];
1972
          }
1973
          if(!isset($distribution_aggregate->sources[0])){
1974
            $distribution_aggregate->sources = array();
1975
          }
1976
          if(!isset($distribution_aggregate->annotations[0])){
1977
            $distribution_aggregate->annotations = array();
1978
          }
1979
        } else {
1980
          if(isset($distribution->status)){
1981
            $distribution_aggregate->status[] = $distribution->status;
1982
          }
1983
          if(isset($distribution->sources[0])) {
1984
            $distribution_aggregate->sources = array_merge($distribution_aggregate->sources,
1985
              $distribution->sources);
1986
          }
1987
          if(isset($distribution->annotations[0])) {
1988
            $distribution_aggregate->annotations = array_merge($distribution_aggregate->annotations,
1989
              $distribution->annotations);
1990
          }
1991
        }
1992
      }
1993

    
1994
      $annotations_and_sources =  null;
1995
      if($distribution_aggregate) {
1996
        $annotations_and_sources = handle_annotations_and_sources(
1997
          $distribution_aggregate,
1998
          handle_annotations_and_sources_config($feature_block_settings),
1999
          $label,
2000
          UUID_DISTRIBUTION
2001
        );
2002

    
2003
        $status = distribution_status_label_and_markup($distribution_aggregate->status, $level_style['status_glue']);
2004
      }
2005

    
2006
      $per_node_markup[$node_index] .= '<' . $enclosingTag . ' class="descriptionElement'
2007
        . join(' descriptionElement-', $distribution_uuids)
2008
        . ' level_index_' . $level_index
2009
        . ' " title="' . $status['label'] . '">'
2010
        . '<span class="area_label">' . $label
2011
        . $level_style['label_suffix'] . '</span>'
2012
        . $status['markup']
2013
      ;
2014

    
2015
      if(isset($annotations_and_sources)){
2016
        if(!empty($annotations_and_sources['source_references'])){
2017
          $per_node_markup[$node_index] .= ' ' . join(', ' , $annotations_and_sources['source_references']);
2018
        }
2019
        if($annotations_and_sources['foot_note_keys']) {
2020
          $per_node_markup[$node_index] .= $annotations_and_sources['foot_note_keys'];
2021
        }
2022
      }
2023

    
2024
      if(isset($node->children[0])){
2025
        _compose_distribution_hierarchy(
2026
          $node->children,
2027
          $feature_block_settings,
2028
          $per_node_markup[$node_index],
2029
          $hierarchy_style,
2030
          $level_index
2031
        );
2032
      }
2033

    
2034
      $per_node_markup[$node_index] .= '</' . $enclosingTag . '>';
2035
    }
2036
    $markup .= $level_style['item_group_prefix']  . join( $level_style['item_glue'], $per_node_markup) . $level_style['item_group_postfix'];
2037
  }
2038

    
2039

    
2040
/**
2041
 * Provides the content for a block of Uses Descriptions for a given taxon.
2042
 *
2043
 * Fetches the list of TaxonDescriptions tagged with the MARKERTYPE_USE
2044
 * and passes them to the theme function theme_cdm_UseDescription().
2045
 *
2046
 * @param string $taxon_uuid
2047
 *   The uuid of the Taxon
2048
 *
2049
 * @return array
2050
 *   A drupal render array
2051
 */
2052
function cdm_block_use_description_content($taxon_uuid, $feature) {
2053

    
2054
  $use_description_content = array();
2055

    
2056
  if (is_uuid($taxon_uuid )) {
2057
    $markerTypes = array();
2058
    $markerTypes['markerTypes'] = UUID_MARKERTYPE_USE;
2059
    $useDescriptions = cdm_ws_fetch_all(CDM_WS_PORTAL_TAXON . '/' . $taxon_uuid . '/descriptions', $markerTypes);
2060
    if (!empty($useDescriptions)) {
2061
      $use_description_content = compose_feature_block_items_use_records($useDescriptions, $taxon_uuid, $feature);
2062
    }
2063
  }
2064

    
2065
  return $use_description_content;
2066
}
2067

    
2068
/**
2069
 * Creates a trunk of a feature object which can be used to build pseudo feature blocks like the Bibliography.
2070
 *
2071
 * @param $representation_L10n
2072
 * @param String $pseudo_feature_key
2073
 *    Will be set as uuid but should be one of 'BIBLIOGRAPHY', ... more to come. See also get_feature_block_settings()
2074
 *
2075
 * @return object
2076
 *  The feature object
2077
 */
2078
function make_pseudo_feature($representation_L10n, $pseudo_feature_key = null){
2079
  $feature = new stdClass;
2080
  $feature->representation_L10n = $representation_L10n;
2081
  $feature->uuid = NULL; // $pseudo_feature_key;
2082
  $feature->label = $pseudo_feature_key;
2083
  $feature->class = 'PseudoFeature';
2084

    
2085
  return $feature;
2086

    
2087
}
2088

    
2089
/**
2090
 * @param $root_nodes, for obtaining the  root nodes from a description you can
2091
 * use the function get_root_nodes_for_dataset($description);
2092
 *
2093
 * @return string
2094
 */
2095
function render_description_string($root_nodes, &$item_cnt = 0) {
2096

    
2097
  $out = '';
2098

    
2099
  $description_strings= [];
2100
  if (!empty($root_nodes)) {
2101
    foreach ($root_nodes as $root_node) {
2102
      if(isset($root_node->descriptionElements)) {
2103
        foreach ($root_node->descriptionElements as $element) {
2104
          $feature_label = $element->feature->representation_L10n;
2105
          if($item_cnt == 0){
2106
            $feature_label = ucfirst($feature_label);
2107
          }
2108
          switch ($element->class) {
2109
            case 'CategoricalData':
2110
              $state_data = render_state_data($element);
2111
              if (!empty($state_data)) {
2112
                if(is_suppress_state_present_display($element, $root_node)){
2113
                  $description_strings[] = '<span class="'. html_class_attribute_ref($element) .'"><span class="label">' . $feature_label . '</span>: '  . '</span>';
2114
                } else {
2115
                  $description_strings[] = '<span class="'. html_class_attribute_ref($element) .'"><span class="label">' . $feature_label . '</span>: ' . $state_data . '</span>;' ;
2116
                }
2117
              }
2118
              break;
2119
            case 'QuantitativeData':
2120
              $description_strings[] = '<span class="'. html_class_attribute_ref($element) .'"><span class="label">' . $feature_label . '</span>: ' . render_quantitative_statistics($element) . '</span>;';
2121
              break;
2122
          }
2123
        }
2124
        $item_cnt++;
2125
      }
2126

    
2127
      // recurse child nodes
2128
      $child_markup = render_description_string($root_node->childNodes, $item_cnt);
2129
      if($child_markup){
2130
        $description_strings[] = $child_markup;
2131
      }
2132
    }
2133
    if(count($description_strings) > 0){
2134
      // remove last semicolon
2135
      $description_strings[count($description_strings) - 1] = preg_replace('/;$/', '', $description_strings[count($description_strings) - 1]);
2136
    }
2137
    $out  = join($description_strings,  ' ');
2138
  }
2139
  return $out;
2140
}
2141

    
2142
/**
2143
 * Compose a description as a table of Feature<->State
2144
 *
2145
 * @param $description_uuid
2146
 *
2147
 * @return array
2148
 *    The drupal render array for the page
2149
 *
2150
 * @ingroup compose
2151
 */
2152
function  compose_description_table($description_uuid, $descriptive_dataset_uuid = NULL) {
2153

    
2154
  RenderHints::pushToRenderStack('description_table');
2155

    
2156
  $render_array = [];
2157

    
2158
  $description = cdm_ws_get(CDM_WS_PORTAL_DESCRIPTION, [$description_uuid]);
2159
  $dataSet = NULL;
2160
  // dataset passed as parameter
2161
  if ($descriptive_dataset_uuid != NULL) {
2162
    foreach ($description->descriptiveDataSets as $set) {
2163
      if ($set->uuid == $descriptive_dataset_uuid) {
2164
        $dataSet = $set;
2165
        break;
2166
      }
2167
    }
2168
  }
2169

    
2170
  if(!empty($description->descriptiveDataSets)) {
2171
    // only one dataset present
2172
    if (!isset($dataSet) && sizeof($description->descriptiveDataSets) == 1) {
2173
      foreach ($description->descriptiveDataSets as $dataSet) {
2174
        break;
2175
      }
2176
    }
2177

    
2178
    // generate description title
2179
    RenderHints::pushToRenderStack('title');
2180
    if (isset($dataSet)) {
2181

    
2182
      $described_entity_title = NULL;
2183
      if(isset($description->describedSpecimenOrObservation)){
2184
        $described_entity_title = $description->describedSpecimenOrObservation->titleCache;
2185
      } else if($description->taxon) {
2186
          $described_entity_title = render_taxon_or_name($description->taxon);
2187
      }
2188
      $title = 'Descriptive Data ' . $dataSet->titleCache .
2189
        ($described_entity_title ? ' for ' . $described_entity_title : '');
2190
    }
2191
    $render_array['title'] = markup_to_render_array($title, null, '<h3 class="title">', '</h3>');
2192
    RenderHints::popFromRenderStack();
2193
    // END of --- generate description title
2194

    
2195
    if (isset($description->types)) {
2196
      foreach ($description->types as $type) {
2197
        if ($type == 'CLONE_FOR_SOURCE') {
2198
          $render_array['source'] = markup_to_render_array("Aggregation source from " . $description->created, null, '<div class="date-created">', '</div>');
2199
          break;
2200
        }
2201
      }
2202
    }
2203
  }
2204
  // multiple datasets present see #8714 "Show multiple datasets per description as list of links"
2205
  else {
2206
    $items = [];
2207
    foreach ($description->descriptiveDataSets as $dataSet) {
2208
      $path = path_to_description($description->uuid, $dataSet->uuid);
2209
      $attributes['class'][] = html_class_attribute_ref($description);
2210
      $items[] = [
2211
        'data' => $dataSet->titleCache . icon_link($path),
2212
      ];
2213
    }
2214
    $render_array['description_elements'] = [
2215
      '#title' => 'Available data sets for description',
2216
      '#theme' => 'item_list',
2217
      '#type' => 'ul',
2218
      '#items' => $items,
2219
    ];
2220
  }
2221

    
2222
  $described_entities = [];
2223
  if (isset($description->describedSpecimenOrObservation)) {
2224
    $decr_entitiy = '<span class="label">Specimen:</span> ' . render_cdm_specimen_link($description->describedSpecimenOrObservation);
2225
    $described_entities['specimen'] = markup_to_render_array($decr_entitiy, null, '<div>', '</div>');
2226
  }
2227
  if (isset($description->taxon)) {
2228
    $decr_entitiy = '<span class="label">Taxon:</span> ' . render_taxon_or_name($description->taxon, url(path_to_taxon($description->taxon->uuid)));
2229
    $described_entities['taxon'] = markup_to_render_array($decr_entitiy, null, '<div>', '</div>');
2230
  }
2231

    
2232
  if(count($described_entities)){
2233
    $render_array['described_entities'] = $described_entities;
2234
    $render_array['described_entities']['#prefix'] = '<div class="described-entities">';
2235
    $render_array['described_entities']['#suffix'] = '</div>';
2236
  }
2237

    
2238

    
2239
  $root_nodes = get_root_nodes_for_dataset($description);
2240

    
2241

    
2242
  $rows = [];
2243
  $rows = description_element_table_rows($root_nodes, $rows);
2244

    
2245
  // --- create headers
2246
  $header = [0 => [], 1 => []];
2247

    
2248
  foreach($rows as $row) {
2249
    if(array_search('Character', $row['class']) && array_search('Character', $header[0]) === false){
2250
      $header[0][] = 'Character';
2251
    } elseif (array_search('Feature', $row['class']) && array_search('Feature', $header[0]) === false){
2252
      $header[0][] = 'Feature';
2253
    }
2254
    if(array_search('has_state', $row['class']) && array_search('States', $header[1]) === false){
2255
      $header[1][] = 'States';
2256
    } elseif (array_search('has_values', $row['class']) && array_search('Values', $header[1]) === false){
2257
      $header[1][] = 'Values';
2258
    }
2259
  }
2260
  asort($header[0]);
2261
  asort($header[1]);
2262
  $header[0] = join('/', $header[0]);
2263
  $header[1] = join('/', $header[1]);
2264

    
2265
  // ---
2266

    
2267
  if (!empty($rows)) {
2268
    $render_array['table'] = markup_to_render_array(theme('table', [
2269
      'header' => $header,
2270
      'rows' => $rows,
2271
      'caption' => statistical_values_explanation(),
2272
      'title' => "Table"
2273
    ]));
2274
  }
2275

    
2276
  // --- sources
2277
  if (isset($description->sources) and !empty($description->sources)) {
2278
    $items = [];
2279
    foreach ($description->sources as $source) {
2280
      if ($source->type == 'Aggregation' and isset($source->cdmSource)){
2281
        $cdm_source_entity = $source->cdmSource;
2282
        switch($cdm_source_entity->class){
2283
          case 'Taxon':
2284
            $source_link_markup = render_taxon_or_name($cdm_source_entity) . icon_link(path_to_taxon($cdm_source_entity->uuid, false));
2285
            break;
2286
          case 'TaxonDescription':
2287
          case 'NameDescription':
2288
          case 'SpecimenDescription':
2289
            $source_link_markup = render_cdm_entity_link($cdm_source_entity);
2290
            break;
2291
          default:
2292
            $source_link_markup = '<span class="error">Unhandled CdmSource</span>';
2293
        }
2294
        $items[$cdm_source_entity->titleCache] = [
2295
          'data' => $source_link_markup
2296
        ];
2297
      }
2298
    }
2299
    ksort($items);
2300
    $render_array['sources'] = [
2301
      '#title' => 'Sources',
2302
      '#theme' => 'item_list',
2303
      '#type' => 'ul',
2304
      '#items' => $items,
2305
      '#attributes' => ['class' => 'sources']
2306
    ];
2307
    $render_array['#prefix'] = '<div class="description-table">';
2308
    $render_array['#suffix'] = '</div>';
2309
  }
2310

    
2311
  RenderHints::popFromRenderStack();
2312

    
2313
  return $render_array;
2314
}
2315

    
2316
/**
2317
 * For a given description returns the root nodes according to the
2318
 *corresponding term tree. The term tree is determined as follow:
2319
 * 1. If description is part of a descriptive data set the term tree of that
2320
 *    data set is used (FIXME handle multiple term trees)
2321
 * 2. Otherwise the portal taxon profile tree is used
2322
 * @param $description
2323
 *
2324
 * @return array
2325
 */
2326
function get_root_nodes_for_dataset($description) {
2327
  if (!empty($description->descriptiveDataSets)) {
2328
    foreach ($description->descriptiveDataSets as $dataSet) {
2329
      break;// FIXME handle multiple term trees
2330
    }
2331
    $tree = cdm_ws_get(CDM_WS_TERMTREE, $dataSet->descriptiveSystem->uuid);
2332
    $root_nodes = _mergeFeatureTreeDescriptions($tree->root->childNodes, $description->elements);
2333
  }
2334
  else {
2335
    $root_nodes = _mergeFeatureTreeDescriptions(get_profile_feature_tree()->root->childNodes, $description->elements);
2336
  }
2337
  return $root_nodes;
2338
}
2339

    
2340
/**
2341
 * Recursively creates an array of row items to be used in theme_table.
2342
 *
2343
 * The array items will have am element 'class' with information on the
2344
 * nature of the DescriptionElement ('has_values' | 'has_state') and on the
2345
 * type of the FeatureNode ('Feature' | 'Character')
2346
 *
2347
 * @param array $root_nodes
2348
 * @param array $row_items
2349
 * @param int $level
2350
 *     the depth in the hierarchy
2351
 *
2352
 * @return array
2353
 *  An array of row items to be used in theme_table
2354
 *
2355
 *
2356
 */
2357
function description_element_table_rows($root_nodes, $row_items, $level = 0) {
2358

    
2359
  $indent_string = '&nbsp;&nbsp;&nbsp;';
2360
  foreach ($root_nodes as $root_node) {
2361
    if(isset($root_node->descriptionElements)) {
2362
      foreach ($root_node->descriptionElements as $element) {
2363
        $level_indent = str_pad('', $level * strlen($indent_string), $indent_string);
2364
        switch ($element->class) {
2365
          case 'QuantitativeData':
2366
            $row_items[] = [
2367
              'data' => [
2368
                [
2369
                  'data' => markup_to_render_array($level_indent . $element->feature->representation_L10n),
2370
                  'class' => ['level_' . $level]
2371
                ],
2372
                render_quantitative_statistics($element)
2373
              ],
2374
              'class' => ['level_' . $level, 'has_values', $element->feature->class]
2375
            ];
2376
            break;
2377
          case 'CategoricalData':
2378
            default:
2379
            if (!empty($element->stateData)) {
2380
              $supress_state_display = is_suppress_state_present_display($element, $root_node);
2381
              if(!$supress_state_display){
2382
                $state_cell = render_state_data($element);
2383
              } else {
2384
                $state_cell = "<span> </span>";
2385
              }
2386
              $row_items[] = [
2387
                'data' => [
2388
                  [
2389
                    'data' => markup_to_render_array($level_indent . $element->feature->representation_L10n),
2390
                    'class' => ['level_' . $level]
2391
                  ],
2392
                  $state_cell,
2393
                ],
2394
                'class' => ['level_' . $level, 'has_state', $element->feature->class]
2395
              ];
2396
            }
2397
            break;
2398
        }
2399
      }
2400
    }
2401
    // recurse child nodes
2402
    $row_items = description_element_table_rows($root_node->childNodes, $row_items, $level + 1);
2403
  }
2404
  return $row_items;
2405
}
2406

    
2407
/**
2408
 * @param $element
2409
 * @param $root_node
2410
 *
2411
 * @return bool
2412
 */
2413
function is_suppress_state_present_display($element, $root_node) {
2414
  return count($element->stateData) == 1 & $element->stateData[0]->state->representation_L10n == 'present' && is_array($root_node->childNodes);
2415
}
2416

    
2417

    
2418

    
(3-3/14)