Project

General

Profile

Statistics
| Branch: | Tag: | Revision:

cdm-dataportal / modules / cdm_dataportal / includes / taxon.inc @ e7f3789b

History | View | Annotate | Download (26.2 KB)

1
<?php
2

    
3
/**
4
 * @file
5
 * Functions for dealing with CDM entities from the package model.taxon
6
 *
7
 * @copyright
8
 *   (C) 2007-2016 EDIT
9
 *   European Distributed Institute of Taxonomy
10
 *   http://www.e-taxonomy.eu
11
 *
12
 *   The contents of this module are subject to the Mozilla
13
 *   Public License Version 1.1.
14
 * @see http://www.mozilla.org/MPL/MPL-1.1.html
15
 *
16
 * @author
17
 *   - Andreas Kohlbecker <a.kohlbecker@BGBM.org>
18
 */
19

    
20
/**
21
 * @defgroup compose Compose functions
22
 * @{
23
 * Functions which are composing Drupal render arrays
24
 *
25
 * The cdm_dataportal module needs to compose rather complex render arrays from
26
 * the data returned by the CDM REST service. The compose functions are
27
 * responsible for creating the render arrays.
28
 *
29
 * All these functions are also implementations of the compose_hook()
30
 * which is used in the proxy_content() function.
31
 * @}
32
 */
33

    
34
define('TAXON_TYPE_SYNONYM', 'Synonym');
35
define('TAXON_TYPE_MISAPPLIEDNAME', 'misapplied-name');
36

    
37
/**
38
 * Returns HTML for misapplied names and invalid designations.
39
 *
40
 * Both relation types are currently treated the same!
41
 *
42
 * @param object taxonRelationships
43
 *   A TaxonRelationshipsDTO, see taxon/{uuid}/taxonRelationshipsDTO
44
 *
45
 * @param object focusedTaxon
46
 *  The taxon being in the focus of the application
47
 *
48
 * @return string
49
 *    the rendered html
50
 */
51
function cdm_taxonRelationships($taxonRelationshipsDTO, $focusedTaxon){
52

    
53
  static $relationship_type_order_weights = [
54
    //
55
    UUID_PROPARTE_MISAPPLIEDNAME_FOR => 0,
56
    UUID_PARTIAL_MISAPPLIEDNAME_FOR => 0,
57
    //
58
    UUID_INVALID_DESIGNATION_FOR  => 1,
59
    //
60
    UUID_MISAPPLIED_NAME_FOR  => 2,
61
    //
62
    UUID_PROPARTE_SYNONYM_FOR  => 3,
63
    UUID_PARTIAL_SYNONYM_FOR  => 3
64
  ];
65

    
66
  if (!$taxonRelationshipsDTO || $taxonRelationshipsDTO->size < 1) {
67
    return null;
68
  }
69

    
70
  static $dedup_rel_type_uuids = array(
71
    UUID_MISAPPLIED_NAME_FOR,
72
    UUID_INVALID_DESIGNATION_FOR,
73
    UUID_PARTIAL_MISAPPLIEDNAME_FOR,
74
    UUID_PROPARTE_MISAPPLIEDNAME_FOR
75
  );
76

    
77
  RenderHints::pushToRenderStack('taxon_relationships');
78
  $footnote_list_key = 'taxon_relationships';
79
  RenderHints::setFootnoteListKey($footnote_list_key);
80

    
81
  $misapplied = array();
82
  $joined_refs = array();
83

    
84
  $taxon_relationship_types = variable_get(CDM_TAXON_RELATIONSHIP_TYPES, unserialize(CDM_TAXON_RELATIONSHIP_TYPES_DEFAULT));
85

    
86
  // Aggregate misapplied names having the same fullname:
87
  //  - deduplicate misapplied names, so that the same name it not shown multiple times in case it
88
  //    the duplicates only have different sensu references with detail and appended phrase (see #5647)
89
  //  - show only the author team as short citation for the sec reference
90
  //  - show the according reference as footnote to this short citation
91
  //
92
  // Example:
93
  // "Xenoxylum foobar" sensu Grumbach¹; sensu Lem²
94
  //    1. Novel marsian species, Grumbach, 2022
95
  //    2. Flora solaris, Lem, 2019
96
  if (isset($taxonRelationshipsDTO->relations[0])) {
97
    foreach($taxonRelationshipsDTO->relations as $taxon_relation){
98

    
99
      if (in_array($taxon_relation->type->uuid, $taxon_relationship_types)) {
100

    
101
        if (in_array($taxon_relation->type->uuid, $dedup_rel_type_uuids)) {
102

    
103
          RenderHints::pushToRenderStack('misapplied_name_for'); // TODO the render path string should in future come from $taxonRelation->type->...
104

    
105
          // full name with relation symbol, rel sec as de-duplication key
106
          // the sensu part will be removed from the key below in case it is present
107
          $name_text = join(' ', cdm_tagged_text_values($taxon_relation->taggedText, array('name')));
108
          $full_name_key = cdm_tagged_text_to_string($taxon_relation->taggedText, array('symbol', 'appendedPhrase'));
109
          $symbol_text = join(' ', cdm_tagged_text_values($taxon_relation->taggedText, array('symbol')));
110
          $full_name_key = $name_text . ' ' . str_replace($name_text, '', $full_name_key) . ' ' . $symbol_text;
111

    
112
          cdm_taxonRelationships_process_relationship_dto($taxon_relation, $misapplied, $joined_refs, $relationship_type_order_weights , $full_name_key);
113

    
114
          RenderHints::popFromRenderStack();
115
        } else {
116
          RenderHints::pushToRenderStack('other_taxon_relationship');
117
          // All relationship types except misapplied_name_for and invalid_designation_for.
118

    
119
          $taxon_relationships_lines[] = cdm_tagged_text_to_markup($taxon_relation->taggedText);
120

    
121
          RenderHints::popFromRenderStack();
122
        }
123
      }
124
    } // END loop over $taxonRelationshipsDTO->relations
125

    
126
  }
127

    
128
  // Sort the $joined_refs and create footnotes and footnote keys.
129
  uasort($joined_refs, function($a, $b) {
130
    if ($a['order_by_key'] == $b['order_by_key']) {
131
      return 0;
132
    }
133
    return ($a['order_by_key'] < $b['order_by_key']) ? -1 : 1;
134
  });
135

    
136

    
137
  foreach ($joined_refs as $ref_key => $sensu_strings) {
138
    if(!empty($sensu_strings)) {
139
      $ref_key_tokens = explode('#', $ref_key);
140
      $sensu_uuid = $ref_key_tokens[0];
141
      $sensu_reference = cdm_ws_get(CDM_WS_REFERENCE, $sensu_uuid);
142
      if(!$sensu_reference){
143
        drupal_set_message("Problem fetching sensu reference with uuid " . $sensu_uuid, 'error');
144
      }
145
      if($sensu_strings['order_by_key'] != $sensu_reference->titleCache){
146
        $sensu_reference_markup = cdm_reference_markup($sensu_reference);
147
        $footnote_key = FootnoteManager::addNewFootnote($footnote_list_key, $sensu_reference_markup);
148
        $footnote_key = theme('cdm_footnote_key', array('footnoteKey' => $footnote_key));
149
        $joined_refs[$ref_key]['markup'] = '<span class="sensu">' . $sensu_strings['markup'] . $footnote_key . '</span>';
150
      }
151
    }
152
  }
153

    
154
  // ---- Generate output ---- //
155
  $out = '<div class="taxon-relationships">';
156
  if (count($misapplied) > 0) {
157
    ksort($misapplied); // order the misapplied by scientific name
158
    $out .= '<ul class="misapplied">';
159

    
160
    // create the list entries per misapplied name
161
    foreach ($misapplied as $misapplied_name) {
162
      $misapplied_name_markup = $misapplied_name['out'];
163
      // all sensu and auct. for this MAN
164
      if (isset($misapplied_name['sensu_uuids'])) {
165
        $sensu_refs_with_fkey = array();
166
        foreach ($misapplied_name['sensu_uuids'] as $sensu_data) {
167
          if($sensu_data['uuid']){
168
            $joined_ref_key = $sensu_data['uuid'] . ($sensu_data['citation_detail'] ? '#' .  $sensu_data['citation_detail'] : '');
169
            $sensu_refs_with_fkey[$sensu_data['prefix'] . $joined_refs[$joined_ref_key]['order_by_key']] = $sensu_data['prefix'] . $joined_refs[$joined_ref_key]['markup'];
170
          } else {
171
            $sensu_refs_with_fkey[$sensu_data['prefix']] = $sensu_data['prefix'];
172
          }
173
        }
174
        ksort($sensu_refs_with_fkey);
175
        $sensu_refs_with_fkey_markup = join('; ', $sensu_refs_with_fkey);
176
        if(strpos($misapplied_name_markup, '{PLACEHOLDER_secReference}') !== false){
177
          $misapplied_name_markup = str_replace('{PLACEHOLDER_secReference}', $sensu_refs_with_fkey_markup, $misapplied_name_markup);
178
          // just remove the appendedPhrase placeholder as was included in the sensu_refs_with_fkey_markup
179
          $misapplied_name_markup = str_replace('{PLACEHOLDER_appendedPhrase}', '', $misapplied_name_markup);
180
        } else {
181
          // no sec ref so there could only be the appended phrase
182
          $misapplied_name_markup = str_replace('{PLACEHOLDER_appendedPhrase}', $sensu_refs_with_fkey_markup, $misapplied_name_markup);
183
        }
184
      }
185

    
186
      // append the err. sec. if there is any for this MAN
187
      if (isset($misapplied_name['relsec_uuids'])) {
188
        $relsec_refs_with_fkey = array();
189
        foreach ($misapplied_name['relsec_uuids'] as $relsec_data) {
190
          if($relsec_data['uuid']) {
191
            $relsec_refs_with_fkey[$relsec_data['prefix'] . $joined_refs[$relsec_data['uuid']]['order_by_key']] = $relsec_data['prefix'] . $joined_refs[$relsec_data['uuid']]['markup'];
192
          }
193
        }
194
        ksort($relsec_refs_with_fkey);
195
        $relsec_refs_with_fkey_markup = join('; ', $relsec_refs_with_fkey);
196
        $misapplied_name_markup = str_replace('{PLACEHOLDER_relSecReference}', $relsec_refs_with_fkey_markup, $misapplied_name_markup);
197
      }
198
      // final line
199
      $out .= '<li class="synonym"><span class="misapplied">' . $misapplied_name_markup . ' </span></li>';
200
    }
201
    $out .= '</ul>';
202
  }
203

    
204
  if (isset($taxon_relationships_lines) && is_array($taxon_relationships_lines) && count($taxon_relationships_lines) > 0) {
205
    $out .= '<ul class="taxonRelationships">';
206
    foreach ($taxon_relationships_lines as $taxon_relationship_line) {
207
      $out .= '<li class="synonym">' . $taxon_relationship_line . '</li>';
208
    }
209
    $out .= '</ul>';
210
  }
211

    
212
  $footnotes = theme('cdm_footnotes', array('footnoteListKey' => $footnote_list_key, 'enclosingTag' => 'li'));
213
  $footnotes .= theme('cdm_annotation_footnotes', array('footnoteListKey' => $footnote_list_key, 'enclosingTag' => 'li'));
214

    
215
  $out .= '<ul class="footnotes">' . $footnotes . '</ul>';
216
  $out .= '</div>';
217

    
218
  RenderHints::popFromRenderStack();
219
  return $out;
220
}
221

    
222
/**
223
 * @param $taxon_relation
224
 * @param $misapplied
225
 * @param $joined_refs
226
 * @param $relationship_type_weights
227
 * @param $name_dedup_key
228
 */
229
function cdm_taxonRelationships_process_relationship_dto($taxon_relation, &$misapplied, &$joined_refs, $relationship_type_weights, $name_dedup_key) {
230

    
231
  $appended_phrase_text = join(' ', cdm_tagged_text_values($taxon_relation->taggedText, array('appendedPhrase')));
232
  // remove/extract appendedPhrase, secReference, relSecReference and add placeholders if needed
233
  tagged_text_extract($taxon_relation->taggedText, 'appendedPhrase', true);
234
  $sensu_tagged_text = tagged_text_extract_reference_and_detail($taxon_relation->taggedText, "secReference", true);
235
  $relsec_tagged_text = tagged_text_extract_reference_and_detail($taxon_relation->taggedText, "relSecReference", true);
236

    
237
  // prepend the weight value for the relationship type to the $name_dedup_key so that the key can be used for ordering the
238
  // entries in the $misapplied array
239
  if(isset($relationship_type_weights[$taxon_relation->type->uuid])){
240
    $reltype_weight = $relationship_type_weights[$taxon_relation->type->uuid];
241
  } else {
242
    $reltype_weight = 99;
243
  }
244
  $name_dedup_key = str_pad( $reltype_weight, 2, '0', STR_PAD_LEFT) . '-' . $name_dedup_key;
245

    
246
  if (isset($sensu_tagged_text[1])) {
247
    // for de-duplication everything else needs to be equal except for appendedPhrase + MAN.sec + MAN.secDetail. see #7658#note-21
248
    $name_dedup_key = str_replace(cdm_tagged_text_to_string($sensu_tagged_text), ' ', $name_dedup_key);
249
    $appended_phrase_text = $appended_phrase_text . array_shift($sensu_tagged_text)->text; // remove first element which contains the "sensu", this will be added later in this code
250
    $sensu_citation_detail = trim(join(' ', cdm_tagged_text_values($sensu_tagged_text, array('secMicroReference'))));
251
    $sensu_citation_short_markup = cdm_tagged_text_to_markup($sensu_tagged_text);
252
    $sensu_citation_short = cdm_tagged_text_to_string($sensu_tagged_text);
253
    $sensu_uuid = $sensu_tagged_text[0]->entityReference->uuid;
254
    $name_dedup_key = preg_replace('/\s+/', ' ', $name_dedup_key); // sanitize multiple whitespace characters
255
    $misapplied[$name_dedup_key]['sensu_uuids'][] = array('uuid' => $sensu_uuid, 'prefix' => $appended_phrase_text, 'citation_detail' => $sensu_citation_detail);
256
    $ref_key = $sensu_uuid . ($sensu_citation_detail ? '#' . $sensu_citation_detail : '');
257
    if (!isset($joined_refs[$ref_key])) {
258
      $joined_refs[$ref_key] = array(
259
        'order_by_key' => $sensu_citation_short,
260
        'markup' => $sensu_citation_short_markup // the footnote key will be appended later
261
      );
262
    }
263
  } else if ($appended_phrase_text) {
264
    // appended phrase without reference
265
    $name_dedup_key = preg_replace('/\s+/', ' ', $name_dedup_key); // sanitize multiple whitespace characters
266
    $misapplied[$name_dedup_key]['sensu_uuids'][] = array('uuid' => null, 'prefix' => $appended_phrase_text);
267
  }
268

    
269
  if (isset($relsec_tagged_text[1])) {
270
    $appended_phrase_text = array_shift($relsec_tagged_text)->text; // remove first element which contains the "err. sec", this will be added later in this code
271
    $relsec_citation_detail = trim(join(' ', cdm_tagged_text_values($relsec_tagged_text, array('secMicroReference'))));
272
    $relsec_citation_short_markup = cdm_tagged_text_to_markup($relsec_tagged_text);
273
    $relsec_citation_short = cdm_tagged_text_to_string($relsec_tagged_text);
274
    $relsec_uuid = $relsec_tagged_text[0]->entityReference->uuid;
275
    $misapplied[$name_dedup_key]['relsec_uuids'][] = array('uuid' => $relsec_uuid, 'prefix' => $appended_phrase_text, 'citation_detail' => $relsec_citation_detail);;
276
    $ref_key = $relsec_uuid . ($relsec_citation_detail ? '#' . $relsec_citation_detail : '');
277
    if (!isset($joined_refs[$ref_key])) {
278
      $joined_refs[$ref_key] = array(
279
        'order_by_key' => $relsec_citation_short,
280
        'markup' => $relsec_citation_short_markup // the footnote key will be appended later
281
      );
282
    }
283
  }
284

    
285
  if (!isset($misapplied[$name_dedup_key]['out'])) {
286
    // helpful for debugging: // cdm_tagged_text_add_options($taxon_relation->taggedText, array(array('filter-type' => 'symbol', 'attributes' => array('title' =>  array($taxon_relation->type->representations[0]->label)))));
287
    $misapplied[$name_dedup_key]['out'] = cdm_tagged_text_to_markup($taxon_relation->taggedText);
288
  } else {
289
    // We need to add the anchors for all of the other misapplied names not
290
    // being rendered explicitly.
291
    $misapplied[$name_dedup_key]['out'] = uuid_anchor($taxon_relation->taxonUuid, $misapplied[$name_dedup_key]['out']);
292
  }
293

    
294
}
295

    
296
/**
297
 * Renders a representation of the given taxon relationship.
298
 *
299
 * According name relationships are also being rendered.
300
 *
301
 * @param $taxon
302
 *  The CDM TaxonBase entity
303
 * @param $reltype_uuid
304
 *  The UUID of the TaxonRelationshipType
305
 * @param $relsign
306
 *  Optional. Can be  used to override the internal decision strategy on finding a suitable icon for the relationship
307
 * @param $reltype_representation
308
 *   Optional: Defines the value for the title attribute of the html element enclosing the relsign
309
 * @param $doubtful
310
 *   TODO
311
 * @param $doLinkTaxon
312
 *   The taxon will be rendered as clickable link when true.
313
 *
314
 * @return string
315
 *   Markup for the taxon relationship.
316
 *
317
 * @throws Exception
318
 */
319
function cdm_related_taxon($taxon, $reltype_uuid = NULL, $relsign = NULL, $reltype_representation = NULL, $doubtful=false, $doLinkTaxon = FALSE) {
320
  static $relsign_homo = '≡';
321
  static $relsign_hetero = '=';
322
  static $relsign_invalid = '&ndash;';
323
  static $nom_status_invalid_type_uuids =  array(
324
    UUID_NOMENCLATURALSTATUS_TYPE_INVALID,
325
    UUID_NOMENCLATURALSTATUS_TYPE_NUDUM,
326
    UUID_NOMENCLATURALSTATUS_TYPE_COMBINATIONINVALID,
327
    UUID_NOMENCLATURALSTATUS_TYPE_PROVISIONAL
328
  );
329

    
330
  // 'taxonRelationships';
331
  $footnoteListKey = NULL;
332

    
333
  $skip_tags = array();
334

    
335
  $is_invalid = false;
336

    
337
  if (!$relsign) {
338

    
339
    switch ($reltype_uuid) {
340
      case UUID_HETEROTYPIC_SYNONYM_OF:
341
      case UUID_SYNONYM_OF:
342
        $relsign = $relsign_hetero;
343
        break;
344

    
345
      case UUID_HOMOTYPIC_SYNONYM_OF:
346
        $relsign = $relsign_homo;
347
        break;
348

    
349
      case UUID_MISAPPLIED_NAME_FOR:
350
      case UUID_INVALID_DESIGNATION_FOR:
351
        $skip_tags[] = 'authors';
352
        $is_invalid = true;
353
        $relsign = $relsign_invalid;
354

    
355
        break;
356

    
357
      default:
358
        $relsign = $relsign_invalid;
359
    }
360

    
361
  }
362

    
363
  if($doubtful) {
364
    $relsign = '?' . $relsign;
365
  }
366

    
367
  /*
368
  Names with status invalid or nudum are to be displayed with the
369
  $relsign_invalid, these names appear at the end of all names in their
370
  homotypic group (ordered correctly by the java cdm_lib).
371
  */
372
  if (isset($taxon->name->status) && is_array($taxon->name->status)) {
373
    foreach ($taxon->name->status as $status) {
374
      if (in_array($status->type->uuid , $nom_status_invalid_type_uuids)) {
375
        $relsign = $relsign_invalid;
376
        break;
377
      }
378
    }
379
  }
380

    
381
  // Now rendering starts ..
382
  RenderHints::pushToRenderStack('related_taxon');
383

    
384
  if (isset($taxon->name->nomenclaturalReference)) {
385
    $referenceUri = url(path_to_reference($taxon->name->nomenclaturalReference->uuid));
386
  }
387
  $taxonUri = '';
388
  if ($doLinkTaxon) {
389
    $taxonUri = url(path_to_taxon($taxon->uuid, "synonymy"));
390
  }
391
  // Printing the taxonName and the handling the special case of annotations.
392
  if (!isset($referenceUri)) {
393
    $referenceUri = FALSE;
394
  }
395
  $out_taxon_part = render_taxon_or_name($taxon, $taxonUri, $referenceUri, TRUE, FALSE, $skip_tags, $is_invalid);
396
  $taxon_footnotes = theme('cdm_annotations_as_footnotekeys',
397
    array('cdmBase_list' => array(
398
      $taxon->name,
399
      $taxon,
400
    ),
401
      'footnote_list_key' => $footnoteListKey)
402
  );
403

    
404

    
405
  $name_relations = cdm_name_relationships_for_taxon($taxon);
406
  $name_relations_render_array = compose_name_relationships_inline($name_relations, $taxon->name->uuid, $taxon->uuid);
407

    
408
  $out = '<span class="relation_sign" title="' . $reltype_representation . '">' . $relsign . '</span>'
409
    . $out_taxon_part . $taxon_footnotes;
410
  if(isset($name_relations_render_array['list']['items'][0])){
411
    $out .= ' '  . drupal_render($name_relations_render_array);
412
  }
413

    
414
  $out = uuid_anchor($taxon->uuid, $out);
415

    
416
  RenderHints::popFromRenderStack();
417

    
418
  return $out;
419
}
420

    
421

    
422
/**
423
 * Creates markup for a taxon which is the accepted of another one
424
 *
425
 * @param $accepted_for_uuid
426
 *   The uuid of the accepted taxon
427
 */
428
function cdm_accepted_for($accepted_for_uuid) {
429

    
430
  if(!is_uuid($accepted_for_uuid)){
431
    return '';
432
  }
433

    
434
  RenderHints::pushToRenderStack('acceptedFor');
435
  $out = '';
436

    
437
  $synonym = cdm_ws_get(CDM_WS_PORTAL_TAXON, $accepted_for_uuid);
438
  if ($synonym) {
439
    $out .= '<span class="acceptedFor">';
440
    $out .= t('is accepted for ');
441
    $referenceUri = null;
442
    if (isset($synonym->name->nomenclaturalReference)) {
443
      $referenceUri = url(path_to_reference($synonym->name->nomenclaturalReference->uuid));
444
    }
445
    $out .= render_taxon_or_name($synonym->name, NULL, $referenceUri);
446
    $out .= theme('cdm_annotations_as_footnotekeys', array('cdmBase_list' => $synonym));
447
    $out .= '</span>';
448
  }
449
  RenderHints::popFromRenderStack();
450
  return $out;
451
}
452

    
453
/**
454
 * Compose function for a list of taxa.
455
 *
456
 * This function is for used to:
457
 *
458
 * 1. Display search results
459
 * 2. List the taxa for a taxon name in the name page.
460
 *
461
 * @param $taxon_list array
462
 *   The list of CDM Taxon entities. e.g. The records array as contained in a pager object.
463
 * @param $freetext_search_results array
464
 * @param $show_classification boolean
465
 *
466
 * @ingroup compose
467
 *
468
 */
469
function compose_list_of_taxa($taxon_list, $freetext_search_results = array(), $show_classification = false) {
470

    
471
  $unclassified_snippet = '<span class="unclassified">' . t('unclassified') . '</span>';
472

    
473
  RenderHints::pushToRenderStack('list_of_taxa');
474

    
475
  $gallery_settings = getGallerySettings(CDM_DATAPORTAL_SEARCH_GALLERY_NAME);
476

    
477
  $showMedia_taxa = $gallery_settings['cdm_dataportal_show_taxon_thumbnails'];
478
  $showMedia_synonyms = $gallery_settings['cdm_dataportal_show_synonym_thumbnails'];
479
  $searched_in_classification = cdm_dataportal_searched_in_classification();
480
  $searched_in_classification_uuid = null;
481
  if(isset($searched_in_classification->uuid)){
482
    $searched_in_classification_uuid = $searched_in_classification->uuid;
483
  }
484

    
485
  // .. Well, for sure not as performant as before, but better than nothing.
486
  $synonym_uuids = array();
487
  $misappied_uuids = array();
488
  foreach ($taxon_list as $taxon) {
489
    if ($taxon->class == "Synonym") {
490
      if (!array_key_exists($taxon->uuid, $synonym_uuids)) {
491
        $synonym_uuids[$taxon->uuid] = $taxon->uuid;
492
      }
493
    }
494
    elseif (!_cdm_dataportal_acceptedByCurrentView($taxon)) {
495
      // Assuming that it is a misappied name, will be further examined below.
496
      $misappied_uuids[$taxon->uuid] = $taxon->uuid;
497
    }
498
  }
499

    
500
  // Batch service not jet implemented:
501
  // $table_of_accepted = cdm_ws_property(CDM_WS_PORTAL_TAXON_ACCEPTED,
502
  // join(',', $synonym_uuids));
503
  // thus ...
504
  $table_of_accepted = array();
505

    
506
  foreach ($synonym_uuids as $relatedUuid) {
507
    $classification_filter = '';
508
    if($searched_in_classification_uuid){
509
      $classification_filter = 'classificationFilter=' . $searched_in_classification_uuid;
510
    }
511
    $table_of_accepted[$relatedUuid] = cdm_ws_get(
512
      CDM_WS_PORTAL_TAXON_ACCEPTED,
513
      array($relatedUuid),
514
      $classification_filter
515
    );
516
  }
517

    
518
  foreach ($misappied_uuids as $relatedUuid) {
519
    $taxonRelations = cdm_ws_get(CDM_WS_PORTAL_TAXON_RELATIONS, array(
520
      $relatedUuid,
521
    ));
522
    foreach ($taxonRelations as $relation) {
523
      if ($relation->type->uuid == UUID_MISAPPLIED_NAME_FOR && _cdm_dataportal_acceptedByCurrentView($relation->toTaxon)) {
524
        $table_of_accepted[$relatedUuid][] = $relation->toTaxon;
525
      }
526
    }
527
  }
528

    
529
  $out = '<div class="cdm-item-list" style="background-image: none;">';
530
  $itemCnt = -1;
531
  foreach ($taxon_list as $taxon) {
532
    $itemCnt++;
533
    if (isset($table_of_accepted[$taxon->uuid])) {
534
      // Its a synonym or misapplied name.
535
      $is_synonym = isset($synonym_uuids[$taxon->uuid]); //TODO better use the $taxon->class attribute?
536
      $taxon_type = $is_synonym ? TAXON_TYPE_SYNONYM :TAXON_TYPE_MISAPPLIEDNAME;
537

    
538
      $acceptedTaxa = $table_of_accepted[$taxon->uuid];
539

    
540
      if (!is_array($acceptedTaxa)) {
541
        $acceptedTaxa = array($acceptedTaxa);
542
      }
543

    
544
      foreach ($acceptedTaxa as $acceptedTaxon) {
545
        if (is_object($acceptedTaxon)) {
546

    
547
          $taxonUri = uri_to_synonym($taxon->uuid, $acceptedTaxon->uuid);
548
          $referenceUri = '';
549
          if (isset($acceptedTaxon->name->nomenclaturalReference)) {
550
            $referenceUri = url(path_to_reference($acceptedTaxon->name->nomenclaturalReference->uuid));
551
          }
552
          $taxon_or_name = $is_synonym ? $taxon->name : $taxon;
553
          // $taxon_or_name this is a trick to suppress the sec reference for synonyms
554
          // supplying the name will cause render_taxon_or_name() to not show the sec reference
555
          $out .= "<div class=\"item " . $taxon_type . "\">" . render_taxon_or_name($taxon_or_name, $taxonUri, $referenceUri);
556
          if($taxon_type == TAXON_TYPE_MISAPPLIEDNAME && is_object($taxon->sec)){
557
            if(isset($taxon->sec->authorship)){
558
              $authorship = $taxon->sec->authorship->titleCache;
559
            } else {
560
              $authorship = $taxon->sec->titleCache;
561
            }
562
            $out .=  ' sensu ' . $authorship;
563
          }
564
          if ($show_classification) {
565
            $classifications = get_classifications_for_taxon($taxon);
566
            $classification_titles = array();
567
            foreach ($classifications as $classification) {
568
              if (isset($classification->titleCache)) {
569
                $classification_titles[] = $classification->titleCache;
570
              }
571
            }
572
            if (count($classification_titles) == 0) {
573
              $classification_titles[] = $unclassified_snippet;
574
            }
575
            $out .= '<span class="classifications"><span class="separator"> : </span>' . implode(', ', $classification_titles) . '</span>';
576
          }
577
          $out .= theme('cdm_annotations_as_footnotekeys', array('cdmBase_list' => $taxon));
578
          if ($showMedia_synonyms) {
579
            $out .= theme('cdm_taxon_list_thumbnails', array('taxon' => $acceptedTaxon));
580
          }
581
        }
582
      }
583
    }
584
    else {
585
      // Its a Taxon.
586
      $taxonUri = url(path_to_taxon($taxon->uuid));
587
      $referenceUri = '';
588
      if (isset($taxon->name->nomenclaturalReference)) {
589
        $referenceUri = url(path_to_reference($taxon->name->nomenclaturalReference->uuid));
590
      }
591
      $out .= '<div class="item Taxon">' . render_taxon_or_name($taxon, $taxonUri, $referenceUri);
592
      if ($show_classification) {
593
        $classifications = get_classifications_for_taxon($taxon);
594
        $classification_titles = array();
595
        foreach ($classifications as $classification) {
596
          if (isset($classification->titleCache)) {
597
            $classification_titles[] = $classification->titleCache;
598
          }
599
        }
600
        if(count($classification_titles) == 0){
601
          $classification_titles[] = $unclassified_snippet;
602
        }
603
        $out .= '<span class="classifications"><span class="separator"> : </span>' . implode(', ', $classification_titles) . '</span>';
604
      }
605
      $out .= theme('cdm_annotations_as_footnotekeys', array('cdmBase_list' => $taxon));
606

    
607
      if ($showMedia_taxa) {
608
        $out .= theme('cdm_taxon_list_thumbnails', array('taxon' => $taxon));
609
      }
610
    }
611

    
612
    /*
613
     * the score field will be empty in case of MultiTermQueries like
614
     * WildcardQueries, since these are  constant score by default
615
     * since Lucene 2.9
616
     */
617
    if(isset($freetext_search_results[$itemCnt]) && $freetext_search_results[$itemCnt]->score && $freetext_search_results[$itemCnt]->maxScore){
618
      $percentage =  ( $freetext_search_results[$itemCnt]->score / $freetext_search_results[$itemCnt]->maxScore ) * 100;
619
      $out .= '<div class="score-bar"><div class="score-bar-indicator" style="width:' . $percentage .'% "></div></div>';
620
      $out .= '<div class="score-bar-value">' . number_format($percentage, 2) .'%</div>';
621
    }
622

    
623
    // Render highlighted fragments, these are made available by free text
624
    // searches.
625
    if (isset($freetext_search_results[$itemCnt]->fieldHighlightMap)) {
626
      $field_fragments = (array) $freetext_search_results[$itemCnt]->fieldHighlightMap;
627
      if (count($field_fragments) > 0) {
628
        $fragments_out = '';
629
        foreach ($field_fragments as $fieldName => $fragments) {
630
          $fragments_out .= '... <span class="' . $fieldName. '">' . filter_xss(join(" ... ", $fragments), array('b') ) . '</span>';
631
        }
632
        $out .= '<div class="fragment_highlight">' . $fragments_out . ' ...</div>';
633
      }
634
    }
635

    
636
    $out .= '</div>';
637
  }
638

    
639
  $out .= '</div>';
640
  RenderHints::popFromRenderStack();
641

    
642
  return markup_to_render_array($out); // TODO create render array of all list items in function
643
}
644

    
645

    
646
/**
647
 * Compose function for the taxonomic children
648
 *
649
 * @param $taxon_uuid
650
 *    The uuuid of the taxon to compose the list of taxonomic children for
651
 * @return
652
 *   A drupal render array.
653
 *
654
 * @ingroup compose
655
 */
656
function compose_taxonomic_children($taxon_uuid){
657

    
658
  $render_array = array();
659
  
660
  if($taxon_uuid) {
661
    $children = cdm_ws_get(CDM_WS_PORTAL_TAXONOMY_CHILDNODES_OF_TAXON, array(
662
      get_current_classification_uuid(),
663
      $taxon_uuid
664
      ));
665
    if($children){
666
      $taxonomic_children = theme('cdm_taxontree', array('tree' => $children));
667
      $render_array = markup_to_render_array($taxonomic_children);
668
    }
669
  }
670
  return $render_array;
671
}
672

    
Add picture from clipboard (Maximum size: 40 MB)