Project

General

Profile

Statistics
| Branch: | Tag: | Revision:

cdm-dataportal / modules / cdm_dataportal / includes / common.inc @ dd80884c

History | View | Annotate | Download (25.7 KB)

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

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

    
33

    
34
/**
35
 * Composes an HTML element class attribute value composed of
36
 * the short-name of the cdm class and the uuid of the entity.
37
 * This class attribute should be used wherever an cdm-entity is rendered.
38
 *
39
 * In case of Taxon entities or TaxonNodeDTOs the secReference is also added
40
 * to the class attributes as 'sec_uuid:<uuid>'. In case of TaxonNodeDTOs the
41
 * Taxon uuid is added also as taxon_uuid:<uuid>
42
 *
43
 * These according class selectors in css must be escaped, eg:
44
 *    .cdm\:TextData
45
 *
46
 * @param $cdm_entity
47
 *    A CDM entity, TaxonNodeDTO or TypedEntityReference
48
 */
49
function html_class_attribute_ref($cdm_entity) {
50

    
51
  $attributes = '';
52
  if (is_cdm_entity($cdm_entity)) {
53
    $attributes =  "cdm:" . $cdm_entity->class . " uuid:" . $cdm_entity->uuid;
54
  } elseif (isset($cdm_entity->class)) {
55
    switch ($cdm_entity->class){
56
      case 'TypedEntityReference':
57
        $attributes =  "cdm:" . $cdm_entity->type . " uuid:" . $cdm_entity->uuid;
58
      break;
59
      case 'TaxonNodeDto':
60
        $attributes .= " taxon_uuid:"  . $cdm_entity->taxonUuid . " sec_uuid:"  . $cdm_entity->secUuid;;
61
      break;
62
      case 'Taxon':
63
        if(isset($cdm_entity->sec->uuid)){
64
        $attributes .= " sec_uuid:"  . $cdm_entity->sec->uuid;
65
      }
66
      break;
67
    }
68
  }
69

    
70
  return $attributes;
71
}
72

    
73

    
74
/**
75
 * Compose an render array from a CDM Marker object.
76
 *
77
 * compose_hook() implementation
78
 *
79
 * @param object $marker
80
 *   CDM instance of type Marker
81
 * @return array
82
 *   A drupal render array
83
 *
84
 * @ingroup compose
85
 */
86
function compose_cdm_marker($marker) {
87

    
88
  $render_array = array(
89
      // ---- generic
90
      //  these entries should be common to all cdm enitiy render arrays
91
      '#theme' => 'cdm_marker', // TODO   add alternative theme funcitons: 'cdm_marker_' . marker.type.label
92
      '#attributes' => array('class' => html_class_attribute_ref($marker)),
93

    
94
      // ---- individual
95
      '#label' => $marker->markerType->representation_L10n . ': ' . (($marker->flag !== TRUE ? t('yes') : t('no'))),
96
  );
97

    
98
  return $render_array;
99
}
100

    
101
/**
102
 * Checks if the given $cdm_entitiy has a marker the type references by the
103
 * $marker_type_uuid and returns TRUE if a matching marker has been found.
104
 *
105
 * @param object $cdm_entitiy A CDM Entity
106
 * @param string $marker_type_uuid
107
 */
108
function cdm_entity_has_marker($cdm_entitiy, $marker_type_uuid) {
109
  if(isset($cdm_entitiy->markers[0]) && !is_uuid($marker_type_uuid)){
110
    foreach ($cdm_entitiy->markers as $marker) {
111
      if(isset($marker->markerType) && $marker->markerType->uuid == $marker_type_uuid){
112
        return TRUE;
113
      }
114
    }
115
  }
116
  return FALSE;
117
}
118

    
119
/**
120
 * Sorts an array of CDM IdentifiableSource instances by 1. by the
121
 * author teams family names and 2. by the publication date.
122
 *
123
 * @param array $sources
124
 *    The array of CDM IdentifiableSource instances
125
 * @return array
126
 *  An array of drupal render arrays
127
 */
128
function oder_and_render_original_sources($sources){
129
    $sort_array = array();
130
    foreach ($sources as $source) {
131

    
132
      $order_key = '';
133

    
134
      // find the familynames
135
      if(isset($source->citation->uuid) && !isset($source->citation->authorship)){
136
        $authorteam = cdm_ws_get(CDM_WS_REFERENCE_AUTHORTEAM, $source->citation->uuid);
137

    
138
        $persons = array();
139
        if($authorteam->class == 'Team'){
140
          if(isset($authorteam->teamMembers)){
141
            $persons = $authorteam->teamMembers;
142
          }
143
        } else {
144
          $persons[] = $authorteam;
145
        }
146

    
147
        foreach($persons as $person){
148
          if(!empty($person->lastname)){
149
            $order_key .= $person->lastname;
150
          } else {
151
            $order_key .= $person->titleCache;
152
          }
153
        }
154
        if(empty($order_key)){
155
          $order_key = $authorteam->titleCache;
156
        }
157

    
158
      }
159
      $order_key = str_pad($order_key, 50);
160

    
161
      // add publication date to the key
162
      if(isset($source->citation->datePublished)){
163
        $order_key .= '_' . timePeriodAsOrderKey($source->citation->datePublished);
164
      } else {
165
        $order_key .= '_' . "0000";
166
      }
167

    
168
      // padd key until unique
169
      while(array_key_exists($order_key, $sort_array)){
170
        $order_key .= "_";
171
      }
172

    
173
      $sort_array[$order_key] = render_original_source($source);
174
    }
175
    ksort($sort_array);
176
    return array_values ($sort_array);
177
}
178

    
179
/**
180
 * Compare callback to be used in usort to sort image sources of CDM OriginalSource instances.
181
 *
182
 * TODO the compare strategy implemented in oder_and_render_original_sources() is probably better but is not taking the
183
 * originalName into account.
184
 *
185
 * @param $a
186
 * @param $b
187
 */
188
function compare_original_sources($a, $b){
189

    
190
  $a_string = '';
191
  if(isset($a->citation->titleCache)) {
192
    $a_string = $a->citation->titleCache;
193
  }
194
  if((isset($a->nameUsedInSource))){
195
    $a_string .= $a->nameUsedInSource->titleCache;
196
  } elseif (isset($a->originalNameString)){
197
    $a_string .= $a->originalNameString;
198
  }
199

    
200
  $b_string = '';
201
  if(isset($b->citation->titleCache)) {
202
    $b_string = $b->citation->titleCache;
203
  };
204
  if((isset($b->nameUsedInSource))){
205
    $b_string .= $b->nameUsedInSource->titleCache;
206
  } elseif (isset($b->originalNameString)){
207
    $b_string .= $b->originalNameString;
208
  }
209

    
210
  if ($a_string == $b_string) {
211
    return 0;
212
  }
213
  return ($a_string < $b_string) ? -1 : 1;
214
}
215

    
216
/**
217
 * Compare callback to be used in usort to sort image sources of CDM Media instances.
218
 *
219
 * @param $a
220
 * @param $b
221
 */
222
function compare_text_data($a, $b) {
223

    
224
  if ($a->multilanguageText_L10n->text == $b->multilanguageText_L10n->text) {
225
    return 0;
226
  }
227
  return ($a->multilanguageText_L10n->text < $b->multilanguageText_L10n->text) ? -1 : 1;
228
}
229

    
230
  /**
231
   * Compare two different footnotes objects.
232
   *
233
   * The comparison is based on the footnote key. The one which is
234
   * displayed as footnote number.
235
   *
236
   * @param mixed $a
237
   *   Footnote object $a.
238
   * @param mixed $b
239
   *   Footnote object $b.
240
   */
241
  function footnotes_key_compare($a, $b) {
242
    $res = 0;
243
    if (empty($a) || empty($b)) {
244
      return $res;
245
    }
246
    if ($a->keyStr < $b->keyStr) {
247
      $res = -1;
248
    }
249
    elseif ($a->keyStr > $b->keyStr) {
250
      $res = 1;
251
    }
252
    return $res;
253
  }
254

    
255
/**
256
 * Provides an explanatory text on the statistical values representation as generated by statistical_values()
257
 *
258
 * @return string
259
 *     the text
260
 */
261
  function statistical_values_explanation(){
262
    return t("A single or the first number in square brackets denotes sample size");
263
  }
264

    
265
/**
266
 * Creates an array suitable to be used in statistical_values()
267
 * The min max structure is suitable for being used in the context
268
 * of GatheringEvents and StatisticalMeasures (see render_quantitative_statistics()).
269
 *
270
 * The order of the items is important for the display and must not be changed.
271
 *
272
 * @return array
273
 */
274
function statistical_values_array() {
275

    
276
  $min_max = [
277
    'Min' => NULL,
278
    'TypicalLowerBoundary' => NULL,
279
    'TypicalUpperBoundary' => NULL,
280
    'Max' => NULL,
281
    'SampleSize' => NULL,
282
    'Average' => NULL,
283
    'Variance' => NULL,
284
    'StandardDeviation' => NULL,
285
  ];
286
  return $min_max;
287
}
288

    
289
/**
290
 * Creates markup from a min max array.
291
 *
292
 * NOTE: use  statistical_values_array() to create an appropriate array
293
 *
294
 * Internally Min will be translated to TypicalLowerBoundary if no such value is present.
295
 * The same also accounts for Max and TypicalUpperBoundary.
296
 *
297
 * For further details see #3742, #8766
298
 *
299
 * @param $stat_vals_arr
300
 *  the statistical values array as produced by statistical_values_array()
301
 * @param $unit
302
 *  Defaults to no unit
303
 * @return string
304
 */
305
function statistical_values($stat_vals_arr, $unit = '') {
306

    
307
  static $xbar_equals = 'x&#772;='; // x&#772; is x-bar (http://www.personal.psu.edu/ejp10/blogs/gotunicode/2010/03/dealing-with-x-bar-x-and-p-hat.html)
308

    
309
  $min_max_markup = '';
310
  $other_vals_array = [];
311

    
312
  // --- sanitize values
313
  if(statistical_values_num_equals($stat_vals_arr, 'Min', 'TypicalLowerBoundary')){
314
    $stat_vals_arr['Min'] = NULL;
315
  }
316

    
317
  if(statistical_values_num_equals($stat_vals_arr, 'Max', 'TypicalUpperBoundary')){
318
    $stat_vals_arr['Max'] = NULL;
319
  }
320

    
321
  if($stat_vals_arr['TypicalLowerBoundary'] === null && $stat_vals_arr['Min'] !== null){
322
    $stat_vals_arr['TypicalLowerBoundary'] = $stat_vals_arr['Min'];
323
    $stat_vals_arr['Min'] = NULL;
324
  }
325

    
326
  if($stat_vals_arr['TypicalUpperBoundary'] === null && $stat_vals_arr['Max']  !== null){
327
    $stat_vals_arr['TypicalUpperBoundary'] = $stat_vals_arr['Max'];
328
    $stat_vals_arr['Max'] = NULL;
329
  }
330

    
331
  if (statistical_values_num_equals($stat_vals_arr, 'TypicalUpperBoundary', 'TypicalLowerBoundary')) {
332
    $stat_vals_arr['Average'] = $stat_vals_arr['TypicalUpperBoundary'];
333
    $stat_vals_arr['TypicalLowerBoundary'] = NULL;
334
    $stat_vals_arr['TypicalUpperBoundary'] = NULL;
335
  }
336

    
337
  // --- check for inconsistent cases, eg. only Max and average given
338
  if ($stat_vals_arr['TypicalLowerBoundary'] === NULL && $stat_vals_arr['TypicalUpperBoundary']  !== null) {
339
    // min missing
340
    $stat_vals_arr['TypicalLowerBoundary'] = '?';
341
  }
342
  if ($stat_vals_arr['TypicalLowerBoundary'] !== null && $stat_vals_arr['TypicalUpperBoundary'] === NULL) {
343
    // max missing
344
    $stat_vals_arr['TypicalUpperBoundary'] = '?';
345
  }
346

    
347
  if($stat_vals_arr['Average'] && $stat_vals_arr['TypicalUpperBoundary'] !== null && is_numeric($stat_vals_arr['TypicalUpperBoundary']) && $stat_vals_arr['TypicalLowerBoundary'] !== null && is_numeric($stat_vals_arr['TypicalLowerBoundary'] !== null)) {
348
    statistical_values_adjust_significant_figures($stat_vals_arr['Average'], $stat_vals_arr['TypicalLowerBoundary'], $stat_vals_arr['TypicalUpperBoundary']);
349
  }
350

    
351
  foreach ($stat_vals_arr as $key => $statistical_val) {
352

    
353
    if ($statistical_val !== NULL) {
354
      if ($statistical_val == '?') {
355
        $val_markup = $statistical_val;
356
      }
357
      else {
358
        if (is_numeric($statistical_val->_value)) {
359
          $val_markup = '<span class="'
360
            . html_class_attribute_ref($statistical_val) . ' '
361
            . (isset($statistical_val->type) ? $statistical_val->type->termType : '') . ' ' . $key . '" title="' . $key . '">'
362
            . $statistical_val->_value . '</span>';
363

    
364
        }
365
        else {
366
          $val_markup = NULL;
367
        }
368
      }
369

    
370
      if ($val_markup) {
371
        switch ($key) {
372
          // ---- min_max_element
373
          case 'Min':
374
            $min_max_markup .= "($val_markup&ndash;)";
375
            break;
376
          case 'Max':
377
            $min_max_markup .= "(&ndash;$val_markup)";
378
            break;
379
          case 'TypicalLowerBoundary':
380
            $min_max_markup .= "$val_markup";
381
            break;
382
          case 'TypicalUpperBoundary':
383
            $min_max_markup .= "&ndash;$val_markup";
384
            break;
385
          // ---- other values
386
          case 'SampleSize':
387
            $other_vals_array[$key] = $val_markup;
388
            break;
389
          case 'Average':
390
            $other_vals_array[$key] = $xbar_equals . $val_markup;
391
            break;
392
          case 'Variance':
393
            $other_vals_array[$key] = 'σ²=' . $val_markup;
394
            break;
395
          case 'StandardDeviation':
396
            $other_vals_array[$key] = 'σ=' . $val_markup;
397
            break;
398
        }
399
      }
400
    }
401
  }
402

    
403
  if(!$min_max_markup && !empty($other_vals_array['Average'])){
404
    // this could be the case in which we only have one value for Average
405
    // this trivial case needs to be displayed a simpler way
406
    $min_max_markup = str_replace($xbar_equals, '' , $other_vals_array['Average']);
407
    unset($other_vals_array['Average']);
408
    $min_max_markup .= '[' . join(';', $other_vals_array) . ']';
409
  } else {
410
    if(count($other_vals_array)){
411
      $min_max_markup .= '[' . join(';', $other_vals_array) . ']';
412
    }
413
  }
414

    
415
  return $min_max_markup . ($unit ? ' ' . $unit : '');
416
}
417

    
418
/**
419
 * Calculates the required precision for the taget value to be significantly different from min and may and rounds it.
420
 *
421
 * @param $target
422
 *    The statistical value to be rounded to the least significant precision
423
 * @param $min
424
 *    The lower bound to calculate the least significant precision
425
 * @param $max
426
 *    The upper bound to calculate the least significant precision
427
 * @param int $threshold
428
 *    Per default 1, but can be set to any other value > 0 and < 1 to define
429
 *    another threshold for the transition to the next precision level.
430
 *    E.g. A value of 0.5 will cause values > 50 and <= 500 to be shown with
431
 *    a precision of 2, whereas with a threshold of 1 the values > 10 and <= 100
432
 *    will be shown with a precision of 2 figures
433
 */
434
function statistical_values_adjust_significant_figures(&$target, $min,  $max, $threshold = 1){
435

    
436
  $precision = 1;
437
  if($min->_value !== $max->_value){
438
    $precision = floor(log10(abs($max->_value - $min->_value) * (1 / $threshold)));
439
    // increase precision by one
440
    $precision += $precision < 0 ? - 1 : 1;
441
  }
442

    
443
  $target->_value = sigFig($target->_value, $precision);
444
}
445

    
446
/**
447
 * based on an idea taken from https://stackoverflow.com/questions/37618679/format-number-to-n-significant-digits-in-php#answer-48283297
448
 *
449
 * @param $value
450
 * @param $digits
451
 *
452
 * @return float|string
453
 */
454
function sigFig($value, $digits, $round_only = true)
455
{
456
  if ($value == 0) {
457
    $decimalPlaces = $digits - 1;
458
  } elseif ($value < 0) {
459
    $decimalPlaces = $digits - floor(log10($value * -1)) - 1;
460
  } else {
461
    $decimalPlaces = $digits - floor(log10($value)) - 1;
462
  }
463

    
464
  $answer = ($decimalPlaces > 0) && !$round_only ?
465
    number_format($value, $decimalPlaces) : round($value, abs($decimalPlaces));
466
  return $answer;
467
}
468

    
469

    
470

    
471
/**
472
 * Used internally in statistical_values() do determine numerically equality of stat_vals_arr values
473
 *
474
 * @param $stat_vals_arr
475
 * @param $key1
476
 * @param $key2
477
 *
478
 * @return bool
479
 */
480
function statistical_values_num_equals($stat_vals_arr, $key1, $key2){
481

    
482
  return $stat_vals_arr[$key1] !== NULL && $stat_vals_arr[$key2] !== NULL && $stat_vals_arr[$key1]->_value == $stat_vals_arr[$key2]->_value && is_numeric($stat_vals_arr[$key1]->_value);
483
}
484

    
485
/**
486
 * Creates min max markup to represent a min-average-max measure optionally with an error value.
487
 *
488
 * The fields that are taken into account are:
489
 * - field_base_name = min
490
 * - field_base_nameMax = max
491
 * - field_base_nameText = free text
492
 * - field_base_nameError = error value
493
 *
494
 * @param $object
495
 *    The object having min max measurement fields e.g.: GatheringEvent
496
 * @param string $field_base_name
497
 *    The base name for all measurement fields. This name is at the same time the full name of the
498
 *    min value.
499
 * @return string
500
 *   The markup for the min max
501
 *
502
 * @see statistical_values()
503
 */
504
function statistical_values_from_gathering_event($object, $field_base_name)
505
{
506
  static $default_unit = 'm';
507

    
508
  $field_name = $field_base_name . 'Text';
509
  if (@is_string($object->$field_name)) {
510
    // Freetext overrides all other data
511
    $min_max_markup = ' ' . $object->$field_name;
512
  } else {
513
    // create markup for the atomized min max data
514
    $min_max_array = statistical_values_array();
515
    if (@is_numeric($object->$field_base_name)) {
516
      $min_max_array['Min'] = new stdClass();
517
      $min_max_array['Min']->_value = $object->$field_base_name;
518
    }
519
    $field_name = $field_base_name . 'Max';
520
    if (@is_numeric($object->$field_name)) {
521
      $min_max_array['Max'] = new stdClass();
522
      $min_max_array['Max']->_value = $object->$field_name;
523
    }
524
    $min_max_markup = statistical_values($min_max_array, $default_unit);
525
  }
526

    
527
  return $min_max_markup;
528
}
529

    
530
// TODO  move below code into new file: agent.inc
531

    
532
/*
533
 * Compose an render array from a CDM TaxonNodeAgentRelation object as Taxon Expert.
534
 *
535
 * compose_hook() implementation
536
 *
537
 * @param object $taxon_node_agent_relation
538
 *   CDM instance of type TaxonNodeAgentRelation
539
 * @return array
540
 *   A drupal render array
541
 *
542
 * @ingroup compose
543
 */
544
function compose_cdm_taxon_expert($taxon_node_agent_relation) {
545

    
546
  $agent_details = null;
547

    
548
  $label_suffix = ':';
549

    
550
  if($taxon_node_agent_relation->class == 'DefaultPagerImpl'){
551
    // oops this is a pager
552
    // this situation will occur when this compose is executed
553
    // through the proxy_content() method
554
    $taxon_node_agent_relation = $taxon_node_agent_relation->records[0];
555

    
556
  }
557

    
558
  if(is_object($taxon_node_agent_relation->agent)) {
559
    $agent_details = compose_cdm_team_or_person_base($taxon_node_agent_relation->agent);
560
    // all data will be added to the groups of the agent_details render array
561
    $groups = &$agent_details[0]['#groups'];
562

    
563
    @_description_list_group_add($groups, t('Role'). $label_suffix, $taxon_node_agent_relation->type->representation_L10n);
564

    
565
    $family_tnars = cdm_ws_fetch_all(CDM_WS_PORTAL_AGENT . '/' . $taxon_node_agent_relation->agent->uuid . '/taxonNodeAgentRelations', array("rank"=>"Familia"));
566

    
567
    $taxa_markup = array(
568
      '#theme_wrappers' => array('container'),
569
      '#attributes' => array('class' => array('managed_taxa')),
570
      '#wrapper_attributes' => array('class' => 'sublist-container')
571
      );
572
    foreach($family_tnars as $tnar){
573
      if(is_object($tnar->taxonNode->taxon)){
574
        $taxa_markup[$tnar->taxonNode->taxon->titleCache] = markup_to_render_array(render_taxon_or_name($tnar->taxonNode->taxon, url(path_to_taxon($tnar->taxonNode->taxon->uuid))));
575
      }
576
    }
577
    ksort($taxa_markup);
578

    
579
    @_description_list_group_add($groups, t('Families'). $label_suffix, array($taxa_markup));
580

    
581
  }
582

    
583
  return $agent_details;
584
}
585

    
586

    
587
/*
588
 * Compose an render array from a CDM TeamOrPersonBase object.
589
 *
590
 * compose_hook() implementation
591
 *
592
 * TODO: currently mainly implemented for Agent, add Team details
593
 *
594
 * @param object $team_or_person
595
 *   CDM instance of type TeamOrPersonBase
596
 * @return array
597
 *   A drupal render array
598
 *
599
 * @ingroup compose
600
 */
601
function compose_cdm_team_or_person_base($team_or_person, $data = array()) {
602

    
603
  $groups = array();
604

    
605
  $label_suffix = ':';
606

    
607
  // $weight = 0;
608
  if($team_or_person){
609

    
610
    if(is_object($team_or_person->lifespan)){
611
      // ToDo render as date* - date† ?
612
      @_description_list_group_add($groups, t('Lifespan'). $label_suffix, timePeriodToString($team_or_person->lifespan) /*, '' , $weight++ */);
613
    }
614

    
615
    // nomenclaturalTitle
616
    @_description_list_group_add($groups, "Nomenclatural Title". $label_suffix, $team_or_person->nomenclaturalTitle);
617
    // collectorTitle
618
    @_description_list_group_add($groups, "Collector Title". $label_suffix, $team_or_person->collectorTitle);
619

    
620
    // institutionalMemberships
621
    if(is_array($team_or_person->institutionalMemberships)){
622

    
623
      $institutes_ra =  array();
624
      foreach($team_or_person->institutionalMemberships as $membership) {
625
        $membership_groups = array();
626
        @_description_list_group_add($membership_groups, t('Department'). $label_suffix, $membership->department);
627
        @_description_list_group_add($membership_groups, t('Role'). $label_suffix, $membership->role);
628
        if(is_object($membership->period)){
629
          @_description_list_group_add($membership_groups, t('Period'). $label_suffix, timePeriodToString($membership->period));
630
        }
631
        if(is_object($membership->institute->contact)){
632
          $institute_contact_details = compose_cdm_contact($membership->institute->contact, $membership->institute->titleCache);
633
          if(is_array($institute_contact_details[0]['#groups'])){
634
            $membership_groups = array_merge($membership_groups, $institute_contact_details[0]['#groups']);
635
          }
636
        }
637
        if(count($membership_groups) > 0){
638
          $institutes_ra[]  = array(
639
            '#title' => $membership->institute->titleCache,
640
            '#theme' => 'description_list',
641
            '#groups' => $membership_groups,
642
            '#attributes' => array('class' => html_class_attribute_ref($membership)),
643
            '#wrapper_attributes' => array('class' => 'sublist-container')
644
          );
645
        } else {
646
          // no further details for the membership, display the title
647
          $institutes_ra[] = markup_to_render_array('<h3>' . $membership->institute->titleCache . '</h3>');
648
        }
649

    
650
      }
651

    
652
      $label = count($institutes_ra) > 1 ? t('Institutes'):  t('Institute');
653
      @_description_list_group_add($groups, $label. $label_suffix, $institutes_ra /*, '' , $weight++ */);
654
    }
655

    
656

    
657
    // Contact
658
    $agent_contact_details = compose_cdm_contact($team_or_person->contact, $team_or_person->titleCache);
659
    if(is_array($agent_contact_details[0]['#groups'])){
660
      $groups = array_merge($groups, $agent_contact_details[0]['#groups']);
661
    }
662

    
663
    // additional data
664
    foreach($data as $key=>$value){
665
      @_description_list_group_add($sub_dl_groups, t('@key', array('@key' => $key)), $value /*, '' , $weight++ */);
666
    }
667

    
668
  }
669

    
670
  $team_or_person_details = array(
671
    '#title' => $team_or_person->titleCache,
672
    '#theme' => 'description_list',
673
    '#groups' => $groups,
674
    '#attributes' => array('class' => html_class_attribute_ref($team_or_person)),
675
  );
676
  return array($team_or_person_details);
677
}
678

    
679

    
680
/*
681
 * Compose an render array from a CDM Contact object.
682
 *
683
 * compose_hook() implementation
684
 *
685
 * TODO: currently mainly implemented for Agent, add Team details
686
 *
687
 * @param object $contact
688
 *   CDM instance of type Contact
689
 * @param $title
690
 *   The title for the description list header
691
 * @param $weight
692
 *   Optional weight for the description list entries
693
 * @return array
694
 *   A drupal render array
695
 *
696
 * @ingroup compose
697
 */
698
function compose_cdm_contact($contact, $title, $weight = 0)
699
{
700

    
701
  $groups = array();
702

    
703
  $contact_details = null;
704

    
705
  $label_suffix = ':';
706

    
707
  $contact_field_names_map = array(
708
    'emailAddresses' => t('Email'),
709
    'urls' => t('Urls'),
710
    'phoneNumbers' => t('Phone'),
711
    'faxNumbers' => t('Fax'),
712
  );
713

    
714
  // Contact
715
  if(is_object($contact)){
716
    if(isset($contact->addresses)){
717
      // TODO ....
718
      // $sub_groups = array();
719
      // foreach($contact->addresses as $address){
720
      //   @_description_list_group_add($sub_groups, $label, $contact->$fieldName, '', $weight++);
721
      // }
722
    }
723
    foreach($contact_field_names_map as $fieldName => $label){
724
      if(is_array($contact->$fieldName)){
725
        @_description_list_group_add($groups, $label . $label_suffix, $contact->$fieldName, '', $weight++);
726
      }
727
    }
728
    $contact_details = array(
729
      '#title' => $title,
730
      '#theme' => 'description_list',
731
      '#groups' => $groups
732
    );
733

    
734

    
735
  } else if(is_string($title)) {
736
    // if the contact entity is empty but the title is given anyway
737
    // we are only adding the title, using the description_list
738
    // structure is not possible since it would be empty due to
739
    // missing group data
740
    $contact_details = array('#markup' => '<h3>' . $title . '</h3>');
741
  }
742

    
743
  return array($contact_details);
744

    
745
}
746

    
747
/**
748
 * Compose an render array from a CDM Extension objects.
749
 *
750
 * @param $extensions
751
 *    An array of CDM Extension objects
752
 * @return array
753
 *   A render array containing the fields of the supplied $sequence
754
 *
755
 * @ingroup compose
756
 */
757
function compose_extensions($extensions)
758
{
759
  $extensions_render_array= null;
760
  $extensions_by_type = array();
761
  foreach ($extensions as $extension) {
762
    if (@is_string($extension->value)) {
763
      if (!isset($extensions_by_type[$extension->type->representation_L10n])) {
764
        $extensions_by_type[$extension->type->representation_L10n] = array();
765
      }
766
      $extensions_by_type[$extension->type->representation_L10n][] = markup_to_render_array($extension->value);
767
    }
768
  }
769

    
770
  if (count($extensions_by_type)) {
771
    $sub_dl_groups = array();
772
    foreach ($extensions_by_type as $type_label => $text_list) {
773
      @_description_list_group_add($sub_dl_groups, $type_label . ':', $text_list);
774
    }
775
    $extensions_render_array = array(
776
      array('#theme' => 'description_list', '#groups' => $sub_dl_groups)
777
    );
778
    return $extensions_render_array;
779
  }
780
  return $extensions_render_array;
781
}
782

    
783
function formatParams($params) {
784
    $paramString = null;
785
    if (is_array($params)){
786
        $keys =array_keys($params);
787
        $paramString = '';
788
        foreach ($keys as $k ){
789
            if ($k != 'pageNumber' && $k != 'pageSize'){
790
                $paramString .= ' -'.$k.'='.urlencode($params[$k]);
791
            }
792
        }
793
    }
794
    return $paramString;
795
}
796

    
797
function formatWSParams($params) {
798
  $paramString = null;
799
    if (is_array($params)){
800
        $keys =array_keys($params);
801
        $paramString = '';
802
        foreach ($keys as $k ){
803
            if ($k != 'pageNumber' && $k != 'pageSize'){
804
                $paramString .= '&'.$k.'='.urlencode($params[$k]);
805
            }
806
        }
807
    }
808
    return $paramString;
809
}
810

    
811
/**
812
 *
813
 * @param $cdm_entity
814
 *
815
 * @return string the markup
816
 */
817
function render_cdm_entity_link($cdm_entity) {
818

    
819
  switch ($cdm_entity->class) {
820
    case 'TaxonDescription':
821
    case 'NameDescription':
822
    case 'SpecimenDescription':
823
      $link =  '<span class="' . html_class_attribute_ref($cdm_entity) . '">' . $cdm_entity->titleCache . '</span> ' . icon_link(path_to_description($cdm_entity->uuid));
824
      break;
825
    default:
826
      $link = '<span class="error">UNSUPPORTED CDM ENTITY TYPE</span>';
827
  }
828
  return $link;
829
}
830

    
831
/**
832
 * Creates an icon which links to the given path
833
 * @param $path
834
 *
835
 * @return string
836
 */
837
function icon_link($path, $fragment = '') {
838
  $iconlink = l(custom_icon_font_markup('icon-interal-link-alt-solid', ['class' => ['superscript']]), $path, ['html' => TRUE, 'fragment' => $fragment] );
839
  return $iconlink;
840
}
Add picture from clipboard (Maximum size: 40 MB)