Project

General

Profile

Statistics
| Branch: | Tag: | Revision:

cdm-dataportal / modules / cdm_dataportal / cdm_api / cdm_api.module @ c7f92453

History | View | Annotate | Download (79.2 KB)

1
<?php
2
  /**
3
   * @file
4
   * Required or useful functions for using CDM Data Store Webservices.
5
   *
6
   * Naming conventions:
7
   * ----------------------
8
   * - All webservice access methods are prefixed with cdm_ws.
9
   *
10
   * @copyright
11
   *   (C) 2007-2012 EDIT
12
   *   European Distributed Institute of Taxonomy
13
   *   http://www.e-taxonomy.eu
14
   *
15
   *   The contents of this module are subject to the Mozilla
16
   *   Public License Version 1.1.
17
   * @see http://www.mozilla.org/MPL/MPL-1.1.html
18
   *
19
   * @author
20
   *   - Andreas Kohlbecker <a.kohlbecker@BGBM.org>
21
   *   - Wouter Addink <w.addink@eti.uva.nl> (migration from Drupal 5 to Drupal7)
22
   */
23

    
24
  module_load_include('php', 'cdm_api', 'xml2json');
25
  module_load_include('php', 'cdm_api', 'commons');
26
  module_load_include('php', 'cdm_api', 'uuids');
27
  module_load_include('php', 'cdm_api', 'enums');
28
  module_load_include('php', 'cdm_api', 'webservice_uris');
29
  module_load_include('php', 'cdm_api', 'cdm_node');
30

    
31
  /**
32
   * Timeout used to override the default of 30 seconds
33
   * in @see drupal_http_request()
34
   *
35
   * @var CDM_HTTP_REQUEST_TIMEOUT: A float representing the maximum number of seconds the function
36
   *     call may take
37
   */
38
  define('CDM_HTTP_REQUEST_TIMEOUT', 90.0);
39

    
40

    
41

    
42
/**
43
 * orderBy webservice query parameter value
44
 */
45
define('CDM_ORDER_BY_ID_ASC', 'BY_ID_ASC');
46

    
47
/**
48
 * orderBy webservice query parameter value
49
 */
50
define('CDM_ORDER_BY_ID_DESC', 'BY_ID_DESC');
51
/**
52
 * orderBy webservice query parameter value
53
 */
54
define('CDM_ORDER_BY_TITLE_CACHE_ASC', 'BY_TITLE_CACHE_ASC');
55
/**
56
 * orderBy webservice query parameter value
57
 */
58
define('CDM_ORDER_BY_TITLE_CACHE_DESC', 'BY_TITLE_CACHE_DESC');
59
/**
60
 * orderBy webservice query parameter value
61
 */
62
define('CDM_ORDER_BY_NOMENCLATURAL_ORDER_ASC', 'BY_NOMENCLATURAL_ORDER_ASC');
63
/**
64
 * orderBy webservice query parameter value
65
 */
66
define('CDM_ORDER_BY_NOMENCLATURAL_ORDER_DESC', 'BY_NOMENCLATURAL_ORDER_DESC');
67
/**
68
 * orderBy webservice query parameter value
69
 */
70
define('CDM_ORDER_BY_ORDER_INDEX_ASC', 'BY_ORDER_INDEX_ASC');
71
/**
72
 * orderBy webservice query parameter value
73
 */
74
define('CDM_ORDER_BY_ORDER_INDEX_DESC', 'BY_ORDER_INDEX_DESC');
75

    
76

    
77
/**
78
 * Implements hook_menu().
79
 */
80
function cdm_api_menu() {
81
  $items = array();
82

    
83
  // usage: url('cdm_api/proxy/'.urlencode($content_url)."/$theme");
84
  $items['cdm_api/proxy'] = array(
85
    'page callback' => 'proxy_content',
86
    'access arguments' => array(
87
      'access cdm content',
88
    ),
89
    'type' => MENU_CALLBACK,
90
  );
91

    
92
  $items['cdm_api/setvalue/session'] = array(
93
    'page callback' => 'setvalue_session',
94
    'access arguments' => array(
95
      'access cdm content',
96
    ),
97
    'type' => MENU_CALLBACK,
98
  );
99

    
100
  return $items;
101
}
102

    
103
/**
104
 * Implements hook_block_info().
105
 */
106
function cdm_api_block_info() {
107

    
108
  $block['cdm_ws_debug'] = array(
109
      "info" => t("CDM web service debug"),
110
      "cache" => DRUPAL_NO_CACHE
111
  );
112
  return $block;
113
}
114

    
115
/**
116
 * Implements hook_block_view().
117
 */
118
function cdm_api_block_view($delta) {
119
  switch ($delta) {
120
    case 'cdm_ws_debug':
121

    
122
    $cdm_ws_url = variable_get('cdm_webservice_url', '');
123

    
124
    $field_map = array(
125
        'ws_uri' => t('URI') . ' <code>(' . $cdm_ws_url .'...)</code>',
126
        'time' => t('Time'),
127
        'fetch_seconds' => t('Fetching [s]'),
128
        'parse_seconds' => t('Parsing [s]'),
129
        'size_kb' => t('Size [kb]'),
130
        'status' => t('Status'),
131
        'data_links' =>  t('Links'),
132
    );
133

    
134

    
135
    if (!isset($_SESSION['cdm']['ws_debug'])) {
136
      $_SESSION['cdm']['ws_debug'] = array();
137
    }
138

    
139
    $header = '<thead><tr><th>' . join('</th><th>' , array_values($field_map)) . '</th></thead>';
140
    $footer = '<tfoot><tr><th>' . join('</th><th>' , array_values($field_map)) . '</th></tfoot>';
141
    $rows = array();
142

    
143
    foreach ($_SESSION['cdm']['ws_debug'] as $data){
144

    
145
      $data = unserialize($data);
146

    
147
      // stip of webservice base url
148
      $data['ws_uri'] = str_replace($cdm_ws_url, '', $data['ws_uri']);
149
      if($data['method'] == 'POST'){
150
        $data['ws_uri'] = 'POST: ' . $data['ws_uri'] . '?' . $data['post_data'];
151
      }
152

    
153
      $cells = array();
154
      foreach ($field_map as $field => $label){
155
        $cells[] = '<td class="' . $field . '">' .  $data[$field] . '</td>';
156
      }
157
      $rows[] = '<tr class="' . $data['status']  . '">' . join('' , $cells). '</tr>';
158
    }
159
    // clear session again
160
    $_SESSION['cdm']['ws_debug'] = array();
161

    
162
    _add_js_ws_debug();
163

    
164
    $block['subject'] = ''; // no subject, title in content for having a defined element id
165
    // otherwise it would depend on the theme
166
    $block['content'] =
167
        '<h4 id="cdm-ws-debug-button">' . t('CDM Debug') . '</h4>'
168
          // cannot use theme_table() since table footer is not jet supported in D7
169
        . '<div id="cdm-ws-debug-table-container"><table id="cdm-ws-debug-table">'
170
        . $header
171
        . '<tbody>' . join('', $rows) . '</tbody>'
172
        . $footer
173
        . '</table></div>';
174

    
175
    return $block;
176
  }
177
}
178

    
179
/**
180
 * Implements hook_cron().
181
 *
182
 * Expire outdated cache entries.
183
 */
184
function cdm_api_cron() {
185
  cache_clear_all(NULL, 'cache_cdm_ws');
186
}
187

    
188
// ===================== Tagged Text functions ================== //
189

    
190
/**
191
 * Converts an array of TaggedText items into corresponding html tags.
192
 *
193
 * Each item is provided with a class attribute which is set to the key of the
194
 * TaggedText item.
195
 *
196
 * @param array $taggedtxt
197
 *   Array with text items to convert.
198
 * @param string $tag
199
 *   Html tag name to convert the items into, default is 'span'.
200
 * @param string $glue
201
 *   The string by which the chained text tokens are concatenated together.
202
 *   Default is a blank character.
203
 *
204
 * @return string
205
 *   A string with HTML.
206
 */
207
function cdm_tagged_text_to_markup(array $taggedtxt, $tag = 'span', $glue = ' ', $skiptags = array()) {
208
  $out = '';
209
  $i = 0;
210
  foreach ($taggedtxt as $tt) {
211
    if (!in_array($tt->type, $skiptags) && strlen($tt->text) > 0) {
212
      $out .= (strlen($out) > 0 && ++$i < count($taggedtxt) ? $glue : '')
213
        . '<' . $tag . ' class="' . $tt->type . '">'
214
        . t('@text', array('@text' => $tt->text))
215
        . '</' . $tag . '>';
216
    }
217
  }
218
  return $out;
219
}
220

    
221

    
222
/**
223
 * Finds the text tagged with $tag_type in an array of taggedText instances.
224
 *
225
 * Note: This function is currently unused.
226
 *
227
 * @param array $taggedtxt
228
 *   Array with text items.
229
 * @param string $tag_type
230
 *   The type of tag for which to find text items in the $taggedtxt array, or NULL
231
 *   to return all texts.
232
 *
233
 * @return array
234
 *   An array with the texts mapped by $tag_type.
235
 */
236
function cdm_tagged_text_values(array $taggedtxt, $tag_type = NULL) {
237
  $tokens = array();
238
  if (!empty($taggedtxt)) {
239
    foreach ($taggedtxt as $tagtxt) {
240
      if ($tag_type === NULL || $tagtxt->type == $tag_type) {
241
        $tokens[] = $tagtxt->text;
242
      }
243
    }
244
  }
245
  return $tokens;
246
}
247

    
248
/**
249
 * Preprocess the taggedTitle arrays.
250
 *
251
 * Step 1: Turns 'newly' introduces tag types ("hybridSign")
252
 * into tag type "name"
253
 *
254
 * Step 2: Two taggedTexts which have the same type and which have
255
 * a separator between them are merged together.
256
 *
257
 * @param array $taggedTextList
258
 *    An array of TaggedText objects
259
 */
260
function normalize_tagged_text(&$taggedTextList) {
261

    
262
  if (is_array($taggedTextList)) {
263

    
264
    // First pass: rename.
265
    for ($i = 0; $i < count($taggedTextList); $i++) {
266

    
267
      if ($taggedTextList[$i]->type == "hybridSign") {
268
        $taggedTextList[$i]->type = "name";
269
      }
270
    }
271

    
272
    // Second pass: resolve separators.
273
    $taggedNameListNew = array();
274
    for ($i = 0; $i < count($taggedTextList); $i++) {
275

    
276
      // elements of the same type concatenated by a separator should be merged together
277
      if (isset($taggedTextList[$i + 2]) && $taggedTextList[$i + 1]->type == "separator" && $taggedTextList[$i]->type == $taggedTextList[$i + 2]->type) {
278
        $taggedName = clone $taggedTextList[$i];
279
        $taggedName->text = $taggedName->text . $taggedTextList[$i + 1]->text . $taggedTextList[$i + 2]->text;
280
        $taggedNameListNew[] = $taggedName;
281
        ++$i;
282
        ++$i;
283
        continue;
284
      }
285
      // no special handling
286
      $taggedNameListNew[] = $taggedTextList[$i];
287

    
288
    }
289
    $taggedTextList = $taggedNameListNew;
290
  }
291
}
292

    
293
function split_secref_from_tagged_text(&$tagged_text) {
294

    
295
  $extracted_tt = array();
296
  if (is_array($tagged_text)) {
297
    for ($i = 0; $i < count($tagged_text) - 1; $i++) {
298
      if ($tagged_text[$i + 1]->type == "secReference" && $tagged_text[$i]->type == "separator"){
299
        $extracted_tt[0] = $tagged_text[$i];
300
        $extracted_tt[1] = $tagged_text[$i + 1];
301
        unset($tagged_text[$i]);
302
        unset($tagged_text[$i + 1]);
303
        // also get the microfererence which could be in $tagged_text[$i + 3]
304
        if(isset($tagged_text[$i + 3])  && $tagged_text[$i + 2]->type == "separator" && $tagged_text[$i + 3]->type == "secReference"){
305
          $extracted_tt[2] = $tagged_text[$i + 2];
306
          $extracted_tt[3] = $tagged_text[$i + 3];
307
        }
308
        break;
309
      }
310
    }
311
  }
312
  return $extracted_tt;
313
}
314

    
315

    
316
function split_nomstatus_from_tagged_text(&$tagged_text) {
317

    
318
  $extracted_tt = array();
319
  if (is_array($tagged_text)) {
320
    for ($i = 0; $i < count($tagged_text) - 1; $i++) {
321
      if ($tagged_text[$i]->type == "nomStatus"){
322
        $extracted_tt[] = $tagged_text[$i];
323
        if(isset($tagged_text[$i + 1]) && $tagged_text[$i + 1]->type == "postSeparator"){
324
          $extracted_tt[] = $tagged_text[$i + 1];
325
          unset($tagged_text[$i + 1]);
326
        }
327
        if ($tagged_text[$i - 1]->type == "separator"){
328
          array_unshift($extracted_tt, $tagged_text[$i - 1]);
329
          unset($tagged_text[$i - 1]);
330
        }
331
        unset($tagged_text[$i]);
332
        break;
333
      }
334
    }
335
  }
336
  return $extracted_tt;
337
}
338

    
339
function find_tagged_text_elements($taggedTextList, $type){
340
  $matching_elements = array();
341
  if (is_array($taggedTextList)) {
342
    for ($i = 0; $i < count($taggedTextList) - 1; $i++) {
343
      if($taggedTextList[$i]->type == $type){
344
        $matching_elements[] = $taggedTextList[$i];
345
      }
346
    }
347
  }
348
  return $matching_elements;
349
}
350

    
351
// ===================== END of Tagged Text functions ================== //
352

    
353
/**
354
 * Lists the classifications a taxon belongs to
355
 *
356
 * @param CDM type Taxon $taxon
357
 *   the taxon
358
 *
359
 * @return array
360
 *   aray of CDM instances of Type Classification
361
 */
362
function get_classifications_for_taxon($taxon) {
363

    
364
  return cdm_ws_get(CDM_WS_TAXON_CLASSIFICATIONS, $taxon->uuid);;
365
}
366

    
367
/**
368
 * Returns the chosen FeatureTree for the taxon profile.
369
 *
370
 * The FeatureTree profile returned is the one that has been set in the
371
 * dataportal settings (layout->taxon:profile).
372
 * When the chosen FeatureTree is not found in the database,
373
 * the standard feature tree (UUID_DEFAULT_FEATURETREE) will be returned.
374
 *
375
 * @return mixed
376
 *   A cdm FeatureTree object.
377
 */
378
function get_profile_feature_tree() {
379
  static $profile_featureTree;
380

    
381
  if($profile_featureTree == NULL) {
382
    $profile_featureTree = cdm_ws_get(
383
      CDM_WS_FEATURETREE,
384
      variable_get(CDM_PROFILE_FEATURETREE_UUID, UUID_DEFAULT_FEATURETREE)
385
    );
386
    if (!$profile_featureTree) {
387
      $profile_featureTree = cdm_ws_get(CDM_WS_FEATURETREE, UUID_DEFAULT_FEATURETREE);
388
    }
389
  }
390

    
391
  return $profile_featureTree;
392
}
393

    
394
/**
395
 * Returns the chosen FeatureTree for SpecimenDescriptions.
396
 *
397
 * The FeatureTree returned is the one that has been set in the
398
 * dataportal settings (layout->taxon:specimen).
399
 * When the chosen FeatureTree is not found in the database,
400
 * the standard feature tree (UUID_DEFAULT_FEATURETREE) will be returned.
401
 *
402
 * @return mixed
403
 *   A cdm FeatureTree object.
404
 */
405
function cdm_get_occurrence_featureTree() {
406
  static $occurrence_featureTree;
407

    
408
  if($occurrence_featureTree == NULL) {
409
    $occurrence_featureTree = cdm_ws_get(
410
      CDM_WS_FEATURETREE,
411
      variable_get(CDM_OCCURRENCE_FEATURETREE_UUID, UUID_DEFAULT_FEATURETREE)
412
    );
413
    if (!$occurrence_featureTree) {
414
      $occurrence_featureTree = cdm_ws_get(CDM_WS_FEATURETREE, UUID_DEFAULT_FEATURETREE);
415
    }
416
  }
417
  return $occurrence_featureTree;
418
}
419

    
420
/**
421
 * Returns the FeatureTree for structured descriptions
422
 *
423
 * The FeatureTree returned is the one that has been set in the
424
 * dataportal settings (layout->taxon:profile).
425
 * When the chosen FeatureTree is not found in the database,
426
 * the standard feature tree (UUID_DEFAULT_FEATURETREE) will be returned.
427
 *
428
 * @return mixed
429
 *   A cdm FeatureTree object.
430
 */
431
function get_structured_description_featureTree() {
432
  static $structured_description_featureTree;
433

    
434
  if($structured_description_featureTree == NULL) {
435
    $structured_description_featureTree = cdm_ws_get(
436
        CDM_WS_FEATURETREE,
437
        variable_get(CDM_DATAPORTAL_STRUCTURED_DESCRIPTION_FEATURETREE_UUID, UUID_DEFAULT_FEATURETREE)
438
    );
439
    if (!$structured_description_featureTree) {
440
      $structured_description_featureTree = cdm_ws_get(
441
          CDM_WS_FEATURETREE,
442
          UUID_DEFAULT_FEATURETREE
443
      );
444
    }
445
  }
446
  return $structured_description_featureTree;
447
}
448

    
449

    
450
/**
451
 * @todo Please document this function.
452
 * @see http://drupal.org/node/1354
453
 */
454
function set_last_taxon_page_tab($taxonPageTab) {
455
  $_SESSION['cdm']['taxon_page_tab'] = $taxonPageTab;
456
}
457

    
458
/**
459
 * @todo Please document this function.
460
 * @see http://drupal.org/node/1354
461
 */
462
function get_last_taxon_page_tab() {
463
  if (isset($_SESSION['cdm']['taxon_page_tab'])) {
464
    return $_SESSION['cdm']['taxon_page_tab'];
465
  }
466
  else {
467
    return FALSE;
468
  }
469
}
470

    
471
/**
472
 *
473
 * @param object $media
474
 * @param array $mimeTypes
475
 * @param int $width
476
 * @param int $height
477
 *
478
 * @return array
479
 *   An array with preferred media representations or else an empty array.
480
 */
481
function cdm_preferred_media_representations($media, array $mimeTypes, $width = 400, $height = 300) {
482
  $prefRepr = array();
483
  if (!isset($media->representations[0])) {
484
    return $prefRepr;
485
  }
486

    
487
  while (count($mimeTypes) > 0) {
488
    // getRepresentationByMimeType
489
    $mimeType = array_shift($mimeTypes);
490

    
491
    foreach ($media->representations as &$representation) {
492
      // If the mimetype is not known, try inferring it.
493
      if (!$representation->mimeType) {
494
        if (isset($representation->parts[0])) {
495
          $representation->mimeType = infer_mime_type($representation->parts[0]->uri);
496
        }
497
      }
498

    
499
      if ($representation->mimeType == $mimeType) {
500
        // Preferred mimetype found -> erase all remaining mimetypes
501
        // to end loop.
502
        $mimeTypes = array();
503
        $dwa = 0;
504
        $dw = 0;
505
        $valid_parts_cnt = 0;
506
        // Look for part with the best matching size.
507
        foreach ($representation->parts as $part) {
508
          if(empty($part->uri)){
509
            // skip part if URI is missing
510
            continue;
511
          }
512
          $valid_parts_cnt++;
513
          if (isset($part->width) && isset($part->height)) {
514
            $dw = $part->width * $part->height - $height * $width;
515
          }
516
          if ($dw < 0) {
517
            $dw *= -1;
518
          }
519
          $dwa += $dw;
520
        }
521
        if($valid_parts_cnt > 0){
522
          $dwa = $dwa / $valid_parts_cnt;
523
          $prefRepr[$dwa . '_'] = $representation;
524
        }
525
      }
526
    }
527
  }
528
  // Sort the array.
529
  krsort($prefRepr);
530
  return $prefRepr;
531
}
532

    
533
/**
534
 * Infers the mime type of a file using the filename extension.
535
 *
536
 * The filename extension is used to infer the mime type.
537
 *
538
 * @param string $filepath
539
 *   The path to the respective file.
540
 *
541
 * @return string
542
 *   The mimetype for the file or FALSE if the according mime type could
543
 *   not be found.
544
 */
545
function infer_mime_type($filepath) {
546
  static $mimemap = NULL;
547
  if (!$mimemap) {
548
    $mimemap = array(
549
      'jpg' => 'image/jpeg',
550
      'jpeg' => 'image/jpeg',
551
      'png' => 'image/png',
552
      'gif' => 'image/gif',
553
      'giff' => 'image/gif',
554
      'tif' => 'image/tif',
555
      'tiff' => 'image/tif',
556
      'pdf' => 'application/pdf',
557
      'html' => 'text/html',
558
      'htm' => 'text/html',
559
    );
560
  }
561
  $extension = substr($filepath, strrpos($filepath, '.') + 1);
562
  if (isset($mimemap[$extension])) {
563
    return $mimemap[$extension];
564
  }
565
  else {
566
    // FIXME remove this hack just return FALSE;
567
    return 'text/html';
568
  }
569
}
570

    
571
/**
572
 * Converts an ISO 8601 org.joda.time.Partial to a year.
573
 *
574
 * The function expects an ISO 8601 time representation of a
575
 * org.joda.time.Partial of the form yyyy-MM-dd.
576
 *
577
 * @param string $partial
578
 *   ISO 8601 time representation of a org.joda.time.Partial.
579
 *
580
 * @return string
581
 *   Returns the year. In case the year is unknown (= ????), it returns NULL.
582
 */
583
function partialToYear($partial) {
584
  if (is_string($partial)) {
585
    $year = substr($partial, 0, 4);
586
    if (preg_match("/[0-9][0-9][0-9][0-9]/", $year)) {
587
      return $year;
588
    }
589
  }
590
  return '';
591
}
592

    
593
/**
594
 * Converts an ISO 8601 org.joda.time.Partial to a month.
595
 *
596
 * This function expects an ISO 8601 time representation of a
597
 * org.joda.time.Partial of the form yyyy-MM-dd.
598
 * In case the month is unknown (= ???) NULL is returned.
599
 *
600
 * @param string $partial
601
 *   ISO 8601 time representation of a org.joda.time.Partial.
602
 *
603
 * @return string
604
 *   A month.
605
 */
606
function partialToMonth($partial) {
607
  if (is_string($partial)) {
608
    $month = substr($partial, 5, 2);
609
    if (preg_match("/[0-9][0-9]/", $month)) {
610
      return $month;
611
    }
612
  }
613
  return '';
614
}
615

    
616
/**
617
 * Converts an ISO 8601 org.joda.time.Partial to a day.
618
 *
619
 * This function expects an ISO 8601 time representation of a
620
 * org.joda.time.Partial of the form yyyy-MM-dd and returns the day as string.
621
 * In case the day is unknown (= ???) NULL is returned.
622
 *
623
 * @param string $partial
624
 *   ISO 8601 time representation of a org.joda.time.Partial.
625
 *
626
 * @return string
627
 *   A day.
628
 */
629
function partialToDay($partial) {
630
  if (is_string($partial)) {
631
    $day = substr($partial, 8, 2);
632
    if (preg_match("/[0-9][0-9]/", $day)) {
633
      return $day;
634
    }
635
  }
636
  return '';
637
}
638

    
639
/**
640
 * Converts an ISO 8601 org.joda.time.Partial to YYYY-MM-DD.
641
 *
642
 * This function expects an ISO 8601 time representations of a
643
 * org.joda.time.Partial of the form yyyy-MM-dd and returns
644
 * four digit year, month and day with dashes:
645
 * YYYY-MM-DD eg: "2012-06-30", "1956-00-00"
646
 *
647
 * The partial may contain question marks eg: "1973-??-??",
648
 * these are turned in to '00' or are stripped depending of the $stripZeros
649
 * parameter.
650
 *
651
 * @param string $partial
652
 *   org.joda.time.Partial.
653
 * @param bool $stripZeros
654
 *   If set to TRUE the zero (00) month and days will be hidden:
655
 *   eg 1956-00-00 becomes 1956. The default is TRUE.
656
 * @param string @format
657
 * 	 Can ve used to specify the format of the date string, currently the following format strings are supported
658
 *    - "YYYY": Year only
659
 *    - "YYYY-MM-DD": this is the default
660
 *
661
 * @return string
662
 *   YYYY-MM-DD formatted year, month, day.
663
 */
664
function partialToDate($partial, $stripZeros = TRUE, $format= "YYYY-MM-DD") {
665

    
666
  $y = NULL; $m = NULL; $d = NULL;
667

    
668
  if(strpos($format, 'YY') !== FALSE){
669
    $y = partialToYear($partial);
670
  }
671
  if(strpos($format, 'MM') !== FALSE){
672
    $m = partialToMonth($partial);
673
  }
674
  if(strpos($format, 'DD') !== FALSE){
675
    $d = partialToDay($partial);
676
  }
677

    
678
  $y = $y ? $y : '00';
679
  $m = $m ? $m : '00';
680
  $d = $d ? $d : '00';
681

    
682
  $date = '';
683

    
684
  if ($y == '00' && $stripZeros) {
685
    return '';
686
  }
687
  else {
688
    $date = $y;
689
  }
690

    
691
  if ($m == '00' && $stripZeros) {
692
    return $date;
693
  }
694
  else {
695
    $date .= "-" . $m;
696
  }
697

    
698
  if ($d == '00' && $stripZeros) {
699
    return $date;
700
  }
701
  else {
702
    $date .= "-" . $d;
703
  }
704
  return $date;
705
}
706

    
707
/**
708
 * Converts a time period to a string.
709
 *
710
 * See also partialToDate($partial, $stripZeros).
711
 *
712
 * @param object $period
713
 *   An JodaTime org.joda.time.Period object.
714
 * @param bool $stripZeros
715
 *   If set to True, the zero (00) month and days will be hidden:
716
 *   eg 1956-00-00 becomes 1956. The default is TRUE.
717
 * @param string @format
718
 * 	 Can ve used to specify the format of the date string, currently the following format strings are supported
719
 *    - "YYYY": Year only
720
 *    - "YYYY-MM-DD": this is the default
721
 *
722
 * @return string
723
 *   Returns a date in the form of a string.
724
 */
725
function timePeriodToString($period, $stripZeros = TRUE, $format = "YYYY-MM-DD") {
726
  $dateString = '';
727
  if($period->freeText){
728
    $dateString = $period->freeText;
729
  } else {
730
    if ($period->start) {
731
      $dateString = partialToDate($period->start, $stripZeros, $format);
732
    }
733
    if ($period->end) {
734
      $dateString .= (strlen($dateString) > 0 ? ' ' . t('to') . ' ' : '') . partialToDate($period->end, $stripZeros, $format);
735
    }
736
  }
737
  return $dateString;
738
}
739

    
740
/**
741
 * returns the earliest date available in the $period in a normalized
742
 * form suitable for sorting, e.g.:
743
 *
744
 *  - 1956-00-00
745
 *  - 0000-00-00
746
 *  - 1957-03-00
747
 *
748
 * that is either the start date is returned if set otherwise the
749
 * end date
750
 *
751
 * @param  $period
752
 *    An JodaTime org.joda.time.Period object.
753
 * @return string normalized form of the date
754
 *   suitable for sorting
755
 */
756
function timePeriodAsOrderKey($period) {
757
  $dateString = '';
758
  if ($period->start) {
759
    $dateString = partialToDate($period->start, false);
760
  }
761
  if ($period->end) {
762
    $dateString .= partialToDate($period->end, false);
763
  }
764
  return $dateString;
765
}
766

    
767
/**
768
 * Composes a absolute CDM web service URI with parameters and querystring.
769
 *
770
 * @param string $uri_pattern
771
 *   String with place holders ($0, $1, ..) that should be replaced by the
772
 *   according element of the $pathParameters array.
773
 * @param array $pathParameters
774
 *   An array of path elements, or a single element.
775
 * @param string $query
776
 *   A query string to append to the URL.
777
 *
778
 * @return string
779
 *   A complete URL with parameters to a CDM webservice.
780
 */
781
function cdm_compose_url($uri_pattern, $pathParameters = array(), $query = NULL) {
782
  if (empty($pathParameters)) {
783
    $pathParameters = array();
784
  }
785

    
786
  // (1)
787
  // Substitute all place holders ($0, $1, ..) in the $uri_pattern by the
788
  // according element of the $pathParameters array.
789
  static $helperArray = array();
790
  if (isset($pathParameters) && !is_array($pathParameters)) {
791
    $helperArray[0] = $pathParameters;
792
    $pathParameters = $helperArray;
793
  }
794

    
795
  $i = 0;
796
  while (strpos($uri_pattern, "$" . $i) !== FALSE) {
797
    if (count($pathParameters) <= $i) {
798
        drupal_set_message(
799
          t('cdm_compose_url(): missing pathParameter @index for !uri_pattern',
800
            array('@index' => $i, '!uri-pattern' => $uri_pattern )),
801
          'error');
802
      break;
803
    }
804
    $uri_pattern = str_replace("$" . $i, rawurlencode($pathParameters[$i]), $uri_pattern);
805
    ++$i;
806
  }
807

    
808
  // (2)
809
  // Append all remaining element of the $pathParameters array as path
810
  // elements.
811
  if (count($pathParameters) > $i) {
812
    // Strip trailing slashes.
813
    if (strrchr($uri_pattern, '/') == strlen($uri_pattern)) {
814
      $uri_pattern = substr($uri_pattern, 0, strlen($uri_pattern) - 1);
815
    }
816
    while (count($pathParameters) > $i) {
817
      $uri_pattern .= '/' . rawurlencode($pathParameters[$i]);
818
      ++$i;
819
    }
820
  }
821

    
822
  // (3)
823
  // Append the query string supplied by $query.
824
  if (isset($query)) {
825
    $uri_pattern .= (strpos($uri_pattern, '?') !== FALSE ? '&' : '?') . $query;
826
  }
827

    
828
  $path = $uri_pattern;
829

    
830
  $uri = variable_get('cdm_webservice_url', '') . $path;
831
  return $uri;
832
}
833

    
834
/**
835
 * @todo wouldn't it more elegant and secure to only pass a uuid and additional function parameters
836
 *     together with a theme name to such a proxy function?
837
 *     Well this would not be covering all use cases but maybe all which involve AHAH.
838
 *     Maybe we want to have two different proxy functions, one with theming and one without?
839
 *
840
 * @param string $uri
841
 *     A URI to a CDM Rest service from which to retrieve an object
842
 * @param string|null $hook
843
 *     (optional) The hook name to which the retrieved object should be passed.
844
 *     Hooks can either be a theme_hook() or compose_hook() implementation
845
 *     'theme' hook functions return a string whereas 'compose' hooks are returning render arrays
846
 *     suitable for drupal_render()
847
 *
848
 * @todo Please document this function.
849
 * @see http://drupal.org/node/1354
850
 */
851
function proxy_content($uri, $hook = NULL) {
852

    
853
  $args = func_get_args();
854
  $do_gzip = function_exists('gzencode');
855
  $uriEncoded = array_shift($args);
856
  $uri = urldecode($uriEncoded);
857
  $hook = array_shift($args);
858
  $request_method = strtoupper($_SERVER["REQUEST_METHOD"]);
859

    
860
  $post_data = null;
861

    
862
  if ($request_method == "POST" || $request_method == "PUT") {
863
    // read response body via inputstream module
864
    $post_data = file_get_contents("php://input");
865
  }
866

    
867
  // Find and deserialize arrays.
868
  foreach ($args as &$arg) {
869
    // FIXME use regex to find serialized arrays.
870
    //       or should we accept json instead of php serializations?
871
    if (strpos($arg, "a:") === 0) {
872
      $arg = unserialize($arg);
873
    }
874
  }
875

    
876
  // In all these cases perform a simple get request.
877
  // TODO reconsider caching logic in this function.
878

    
879
  if (empty($hook)) {
880
    // simply return the webservice response
881
    // Print out JSON, the cache cannot be used since it contains objects.
882
    $http_response = cdm_http_request($uri, $request_method, $post_data);
883
    if (isset($http_response->headers)) {
884
      foreach ($http_response->headers as $hname => $hvalue) {
885
        drupal_add_http_header($hname, $hvalue);
886
      }
887
    }
888
    if (isset($http_response->data)) {
889
      print $http_response->data;
890
      flush();
891
    }
892
    exit(); // leave drupal here
893
  } else {
894
    // $hook has been supplied
895
    // handle $hook either as compose ot theme hook
896
    // pass through theme or comose hook
897
    // compose hooks can be called without data, therefore
898
    // passing the $uri in this case is not always a requirement
899

    
900
    if($uri && $uri != 'NULL') {
901
    // do a security check since the $uri will be passed
902
    // as absolute URI to cdm_ws_get()
903
      if (!_is_cdm_ws_uri($uri)) {
904
        drupal_set_message(
905
          'Invalid call of proxy_content() with callback parameter \'' . $hook . '\' and URI:' . $uri,
906
          'error'
907
        );
908
        return '';
909
      }
910

    
911
      $obj = cdm_ws_get($uri, NULL, $post_data, $request_method, TRUE);
912
    } else {
913
      $obj = NULL;
914
    }
915

    
916
    $reponse_data = NULL;
917

    
918
    if (function_exists('compose_' . $hook)){
919
      // call compose hook
920

    
921
      $elements =  call_user_func('compose_' . $hook, $obj);
922
      // pass the render array to drupal_render()
923
      $reponse_data = drupal_render($elements);
924
    } else {
925
      // call theme hook
926

    
927
      // TODO use theme registry to get the registered hook info and
928
      //    use these defaults
929
      switch($hook) {
930
        case 'cdm_taxontree':
931
          $variables = array(
932
            'tree' => $obj,
933
            'filterIncludes' => isset($args[0]) ? $args[0] : NULL,
934
            'show_filter_switch' => isset($args[1]) ? $args[1] : FALSE,
935
            'tree_node_callback' => isset($args[2]) ? $args[2] : FALSE,
936
            'element_name'=> isset($args[3]) ? $args[3] : FALSE,
937
            );
938
          $reponse_data = theme($hook, $variables);
939
          break;
940

    
941
        case 'cdm_list_of_taxa':
942
            $variables = array(
943
              'records' => $obj,
944
              'freetextSearchResults' => isset($args[0]) ? $args[0] : array(),
945
              'show_classification' => isset($args[1]) ? $args[1] : FALSE);
946
            $reponse_data = theme($hook, $variables);
947
            break;
948

    
949
        case 'cdm_media_caption':
950
          $variables = array(
951
          'media' => $obj,
952
          // $args[0] is set in taxon_image_gallery_default in
953
          // cdm_dataportal.page.theme.
954
          'elements' => isset($args[0]) ? $args[0] : array(
955
          'title',
956
          'description',
957
          'artist',
958
          'location',
959
          'rights',
960
          ),
961
          'fileUri' => isset($args[1]) ? $args[1] : NULL,
962
          );
963
          $reponse_data = theme($hook, $variables);
964
          break;
965

    
966
        default:
967
          drupal_set_message(t(
968
          'Theme !theme is not yet supported by the function !function.', array(
969
          '!theme' => $hook,
970
          '!function' => __FUNCTION__,
971
          )), 'error');
972
          break;
973
      } // END of theme hook switch
974
    } // END of tread as theme hook
975

    
976

    
977
    if($do_gzip){
978
      $reponse_data = gzencode($reponse_data, 2, FORCE_GZIP);
979
      drupal_add_http_header('Content-Encoding', 'gzip');
980
    }
981
    drupal_add_http_header('Content-Type', 'text/html; charset=utf-8');
982
    drupal_add_http_header('Content-Length', strlen($reponse_data));
983

    
984
    print $reponse_data;
985
  } // END of handle $hook either as compose ot theme hook
986

    
987
}
988

    
989
/**
990
 * @todo Please document this function.
991
 * @see http://drupal.org/node/1354
992
 */
993
function setvalue_session() {
994
  if ($_REQUEST['var'] && strlen($_REQUEST['var']) > 4) {
995
    $var_keys = substr($_REQUEST['var'], 1, strlen($_REQUEST['var']) - 2);
996
    $var_keys = explode('][', $var_keys);
997
  }
998
  else {
999
    return;
1000
  }
1001
  $val = isset($_REQUEST['val']) ? $_REQUEST['val'] : NULL;
1002

    
1003
  // Prevent from malicous tags.
1004
  $val = strip_tags($val);
1005

    
1006
  $session_var = &$_SESSION;
1007
  //$i = 0;
1008
  foreach ($var_keys as $key) {
1009
    // $hasMoreKeys = ++$i < count($session);
1010
    if (!isset($session_var[$key]) || !is_array($session_var[$key])) {
1011
      $session_var[$key] = array();
1012
    }
1013
    $session_var = &$session_var[$key];
1014
  }
1015
  $session_var = $val;
1016
  if (isset($_REQUEST['destination'])) {
1017
    drupal_goto($_REQUEST['destination']);
1018
  }
1019
}
1020

    
1021
/**
1022
 * @todo Please document this function.
1023
 * @see http://drupal.org/node/1354
1024
 */
1025
function uri_uriByProxy($uri, $theme = FALSE) {
1026
  // usage: url('cdm_api/proxy/'.urlencode($content_url)."/$theme");)
1027
  return url('cdm_api/proxy/' . urlencode($uri) . (isset($theme) ? "/$theme" : ''));
1028
}
1029

    
1030
/**
1031
 * Composes the the absolute REST service URI to the annotations pager
1032
 * for the given CDM entity.
1033
 *
1034
 * NOTE: Not all CDM Base types are yet supported.
1035
 *
1036
 * @param $cdmBase
1037
 *   The CDM entity to construct the annotations pager uri for
1038
 */
1039
function cdm_compose_annotations_uri($cdmBase) {
1040
  if (!$cdmBase->uuid) {
1041
    return;
1042
  }
1043

    
1044
  $ws_base_uri = NULL;
1045
  switch ($cdmBase->class) {
1046
    case 'TaxonBase':
1047
    case 'Taxon':
1048
    case 'Synonym':
1049
      $ws_base_uri = CDM_WS_TAXON;
1050
      break;
1051

    
1052
    case 'TaxonNameBase':
1053
    case 'NonViralName':
1054
    case 'BacterialName':
1055
    case 'BotanicalName':
1056
    case 'CultivarPlantName':
1057
    case 'ZoologicalName':
1058
    case 'ViralName':
1059
      $ws_base_uri = CDM_WS_NAME;
1060
      break;
1061

    
1062
    case 'Media':
1063
      $ws_base_uri = CDM_WS_MEDIA;
1064
      break;
1065

    
1066
    case 'Reference':
1067
      $ws_base_uri = CDM_WS_REFERENCE;
1068
      break;
1069

    
1070
    case 'Distribution':
1071
    case 'TextData':
1072
    case 'TaxonInteraction':
1073
    case 'QuantitativeData':
1074
    case 'IndividualsAssociation':
1075
    case 'Distribution':
1076
    case 'CommonTaxonName':
1077
    case 'CategoricalData':
1078
      $ws_base_uri = CDM_WS_DESCRIPTIONELEMENT;
1079
      break;
1080

    
1081
    case 'PolytomousKey':
1082
    case 'MediaKey':
1083
    case 'MultiAccessKey':
1084
      $ws_base_uri = $cdmBase->class;
1085
      $ws_base_uri{0} = strtolower($ws_base_uri{0});
1086
      break;
1087

    
1088
    default:
1089
      trigger_error(check_plain('Unsupported CDM Class - no annotations available for ' . $cdmBase->class), E_USER_ERROR);
1090
      return;
1091
  }
1092
  return cdm_compose_url($ws_base_uri, array(
1093
    $cdmBase->uuid,
1094
    'annotations',
1095
  ));
1096
}
1097

    
1098
/**
1099
 * Enter description here...
1100
 *
1101
 * @param string $resourceURI
1102
 * @param int $pageSize
1103
 *   The maximum number of entities returned per page.
1104
 *   The default page size as configured in the cdm server
1105
 *   will be used if set to NULL
1106
 *   to return all entities in a single page).
1107
 * @param int $pageNumber
1108
 *   The number of the page to be returned, the first page has the
1109
 *   pageNumber = 0
1110
 * @param array $query
1111
 *   A array holding the HTTP request query parameters for the request
1112
 * @param string $method
1113
 *   The HTTP method to use, valid values are "GET" or "POST"
1114
 * @param bool $absoluteURI
1115
 *   TRUE when the URL should be treated as absolute URL.
1116
 *
1117
 * @return the a CDM Pager object
1118
 *
1119
 */
1120
function cdm_ws_page($resourceURI, $pageSize, $pageNumber, array $query = array(), $method = 'GET', $absoluteURI = FALSE) {
1121

    
1122
  $query['pageNumber'] = $pageNumber;
1123
  $query['pageSize'] = $pageSize;
1124

    
1125
  return cdm_ws_get($resourceURI, NULL, queryString($query), $method, $absoluteURI);
1126
}
1127

    
1128
/**
1129
 * Fetches all entities from the given REST endpoint using the pager mechanism.
1130
 *
1131
 * @param string $resourceURI
1132
 * @param array $query
1133
 *   A array holding the HTTP request query parameters for the request
1134
 * @param string $method
1135
 *   The HTTP method to use, valid values are "GET" or "POST";
1136
 * @param bool $absoluteURI
1137
 *   TRUE when the URL should be treated as absolute URL.
1138
 *
1139
 * @return array
1140
 *     A list of CDM entitites
1141
 *
1142
 */
1143
function cdm_ws_fetch_all($resourceURI, array $query = array(), $method = 'GET', $absoluteURI = FALSE) {
1144
  $page_index = 0;
1145
  // using a bigger page size to avoid to many multiple requests
1146
  $page_size = 500;
1147
  $entities = array();
1148

    
1149
  while ($page_index !== FALSE){
1150
    $pager =  cdm_ws_page($resourceURI, $page_size, $page_index, $query,  $method, $absoluteURI);
1151
    if(isset($pager->records) && is_array($pager->records)) {
1152
      $entities = array_merge($entities, $pager->records);
1153
      if(!empty($pager->nextIndex)){
1154
        $page_index = $pager->nextIndex;
1155
      } else {
1156
        $page_index = FALSE;
1157
      }
1158
    } else {
1159
      $page_index = FALSE;
1160
    }
1161
  }
1162
  return $entities;
1163
}
1164

    
1165
/*
1166
function cdm_ws_taxonomy_compose_resourcePath($path = NULL){
1167
  $viewrank = _cdm_taxonomy_compose_viewrank();
1168
  return CDM_WS_PORTAL_TAXONOMY . '/' . ($viewrank ? $viewrank : '' ) . ($path
1169
  ? '/' . $path : '') ;
1170
}
1171
*/
1172

    
1173
/**
1174
 * @todo Enter description here...
1175
 *
1176
 * @param string $taxon_uuid
1177
 *  The UUID of a cdm taxon instance
1178
 * @param string $ignore_rank_limit
1179
 *   Whether to ignore the variable 'taxontree_ranklimit' set by admin in the settings
1180
 *
1181
 * @return string
1182
 *   A cdm REST service URL path to a Classification
1183
 */
1184
function cdm_compose_taxonomy_root_level_path($taxon_uuid = FALSE, $ignore_rank_limit = FALSE) {
1185

    
1186
  $view_uuid = get_current_classification_uuid();
1187
  $rank_uuid = NULL;
1188
  if (!$ignore_rank_limit) {
1189
    $rank_uuid = variable_get(TAXONTREE_RANKLIMIT, TAXONTREE_RANKLIMIT_DEFAULT);
1190
  }
1191

    
1192
  if (!empty($taxon_uuid)) {
1193
    return cdm_compose_url(CDM_WS_PORTAL_TAXONOMY_CHILDNODES_OF_TAXON, array(
1194
      $view_uuid,
1195
      $taxon_uuid,
1196
    ));
1197
  }
1198
  else {
1199
    if (is_uuid($rank_uuid)) {
1200
      return cdm_compose_url(CDM_WS_PORTAL_TAXONOMY_CHILDNODES_AT_RANK, array(
1201
        $view_uuid,
1202
        $rank_uuid,
1203
      ));
1204
    }
1205
    else {
1206
      return cdm_compose_url(CDM_WS_PORTAL_TAXONOMY_CHILDNODES, array(
1207
        $view_uuid,
1208
      ));
1209
    }
1210
  }
1211
}
1212

    
1213
/**
1214
 * Retrieves from the cdm web service with the first level of childnodes of a classification.
1215
 *
1216
 * The level is either the real root level ot it is a lover level if a rank limit has been set.
1217
 * (@see  cdm_compose_taxonomy_root_level_path() for more on the rank limit).
1218
 *
1219
 * Operates in two modes depending on whether the parameter
1220
 * $taxon_uuid is set or NULL.
1221
 *
1222
 * A) $taxon_uuid = NULL:
1223
 *  1. retrieve the Classification for the uuid set in the $_SESSION['cdm']['taxonomictree_uuid']
1224
 *  2. otherwise return the default classification as defined by the admin via the settings
1225
 *
1226
 * b) $taxon_uuid is set:
1227
 *   return the classification to whcih the taxon belongs to.
1228
 *
1229
 * @param UUID $taxon_uuid
1230
 *   The UUID of a cdm taxon instance
1231
 */
1232
function cdm_ws_taxonomy_root_level($taxon_uuid = NULL) {
1233

    
1234
    $response = NULL;
1235

    
1236
    // 1st try
1237
    $response = cdm_ws_get(cdm_compose_taxonomy_root_level_path($taxon_uuid), NULL, NULL, 'GET', TRUE);
1238

    
1239
    if ($response == NULL) {
1240
      // 2dn try by ignoring the rank limit
1241
      $response = cdm_ws_get(cdm_compose_taxonomy_root_level_path($taxon_uuid, TRUE), NULL, NULL, 'GET', TRUE);
1242
    }
1243

    
1244
    if ($response == NULL) {
1245
      // 3rd try, last fallback:
1246
      //    return the default classification
1247
      if (isset($_SESSION['cdm']['taxonomictree_uuid']) && is_uuid($_SESSION['cdm']['taxonomictree_uuid'])) {
1248
        // Delete the session value and try again with the default.
1249
        unset($_SESSION['cdm']['taxonomictree_uuid']);
1250
        drupal_set_message("Could not find a valid classification, falling back to the default classification.", 'warning');
1251
        return cdm_ws_taxonomy_root_level($taxon_uuid);
1252
      }
1253
      else {
1254
        // Check if taxonomictree_uuid is valid.
1255
        // expecting an array of taxonNodes,
1256
        // empty classifications are ok so no warning in this case!
1257
        $test = cdm_ws_get(cdm_compose_taxonomy_root_level_path(), NULL, NULL, 'GET', TRUE);
1258
        if (!is_array($test)) {
1259
          // The default set by the admin seems to be invalid or is not even set.
1260
          drupal_set_message(_no_classfication_uuid_message(), 'warning');
1261
        }
1262
        if (count($test) == 0) {
1263
          // The default set by the admin seems to be invalid or is not even set.
1264
          drupal_set_message("The chosen classification is empty.", 'status');
1265
        }
1266
      }
1267
    }
1268

    
1269
  return $response;
1270
}
1271

    
1272
/**
1273
 * Determines the tree path of the taxon given as uuid to the root of the classification tree.
1274
 * 
1275
 * The root either is the absolute root of the tree or a rank specific root if the TAXONTREE_RANKLIMIT
1276
 * variable is set.
1277
 *
1278
 * @param string $taxon_uuid
1279
 *
1280
 * @return array
1281
 *   An array of CDM TaxonNodeDTO objects
1282
 */
1283
function cdm_ws_taxonomy_pathFromRoot($taxon_uuid) {
1284
  $view_uuid = get_current_classification_uuid();
1285
  $rank_uuid = variable_get(TAXONTREE_RANKLIMIT, TAXONTREE_RANKLIMIT_DEFAULT);
1286

    
1287
  $response = NULL;
1288
  if (is_uuid($rank_uuid)) {
1289
    $response = cdm_ws_get(CDM_WS_PORTAL_TAXONOMY_PATH_FROM_TO_RANK, array(
1290
      $view_uuid,
1291
      $taxon_uuid,
1292
      $rank_uuid,
1293
    ));
1294
  }
1295
  else {
1296
    $response = cdm_ws_get(CDM_WS_PORTAL_TAXONOMY_PATH_FROM, array(
1297
      $view_uuid,
1298
      $taxon_uuid,
1299
    ));
1300
  }
1301

    
1302
  if ($response == NULL) {
1303
    // Error handing.
1304
//    if (is_uuid($_SESSION['cdm']['taxonomictree_uuid'])) {
1305
//      // Delete the session value and try again with the default.
1306
//      unset($_SESSION['cdm']['taxonomictree_uuid']);
1307
//      return cdm_ws_taxonomy_pathFromRoot($taxon_uuid);
1308
//    }
1309
//    else {
1310
      // Check if taxonomictree_uuid is valid.
1311
      $test = cdm_ws_get(cdm_compose_taxonomy_root_level_path(), NULL, NULL, 'GET', TRUE);
1312
      if ($test == NULL) {
1313
        // The default set by the admin seems to be invalid or is not even set.
1314
        drupal_set_message(_no_classfication_uuid_message(), 'warning');
1315
      }
1316
//    }
1317
  }
1318

    
1319
  return $response;
1320
}
1321

    
1322

    
1323
// =============================Terms and Vocabularies ========================================= //
1324

    
1325
/**
1326
 * Returns the localized representation for the given term.
1327
 *
1328
 * @param Object $definedTermBase
1329
 * 	  of cdm type DefinedTermBase
1330
 * @return string
1331
 * 	  the localized representation_L10n of the term,
1332
 *    otherwise the titleCache as fall back,
1333
 *    otherwise the default_representation which defaults to an empty string
1334
 */
1335
function cdm_term_representation($definedTermBase, $default_representation = '') {
1336
  if ( isset($definedTermBase->representation_L10n) ) {
1337
    return $definedTermBase->representation_L10n;
1338
  } elseif ( isset($definedTermBase->titleCache)) {
1339
    return $definedTermBase->titleCache;
1340
  }
1341
  return $default_representation;
1342
}
1343

    
1344
/**
1345
 * Returns the abbreviated localized representation for the given term.
1346
 *
1347
 * @param Object $definedTermBase
1348
 * 	  of cdm type DefinedTermBase
1349
 * @return string
1350
 * 	  the localized representation_L10n_abbreviatedLabel of the term,
1351
 *    if this representation is not available the function delegates the
1352
 *    call to cdm_term_representation()
1353
 */
1354
function cdm_term_representation_abbreviated($definedTermBase, $default_representation = '') {
1355
  if ( isset($definedTermBase->representation_L10n_abbreviatedLabel) ) {
1356
    return $definedTermBase->representation_L10n_abbreviatedLabel;
1357
  } else {
1358
    cdm_term_representation($definedTermBase, $default_representation);
1359
  }
1360
}
1361

    
1362
/**
1363
 * Transforms the list of the given term base instances to a alphabetical ordered options array.
1364
 *
1365
 * The options array is suitable for drupal form API elements that allow multiple choices.
1366
 * @see http://api.drupal.org/api/drupal/developer!topics!forms_api_reference.html/7#options
1367
 *
1368
 * @param array $terms
1369
 *   a list of CDM DefinedTermBase instances
1370
 *
1371
 * @param $term_label_callback
1372
 *   A callback function to override the term representations
1373
 *
1374
 * @return array
1375
 *   the terms in an array as options for a form element that allows multiple choices.
1376
 */
1377
function cdm_terms_as_options($terms, $term_label_callback = NULL){
1378
  $options = array();
1379
  if(isset($terms) && is_array($terms)) {
1380
    foreach ($terms as $term) {
1381
      if ($term_label_callback && function_exists($term_label_callback)) {
1382
        $options[$term->uuid] = call_user_func($term_label_callback, $term);
1383
      } else {
1384
        //TODO use cdm_term_representation() here?
1385
        $options[$term->uuid] = t('@term', array('@term' => $term->representation_L10n));
1386
      }
1387
    }
1388
  }
1389

    
1390
  return $options;
1391
}
1392

    
1393
/**
1394
 * Creates and array of options for drupal select form elements.
1395
 *
1396
 * @param $vocabulary_uuid
1397
 *   The UUID of the CDM Term Vocabulary
1398
 * @param $term_label_callback
1399
 *   An optional call back function which can be used to modify the term label
1400
 * @param bool $default_option
1401
 *   An additional element do be placed at the beginning og the list. This element will be the default option.
1402
 *   In order to put an empty element the beginning of the options pass an " " as argument.
1403
 * @param array $include_filter
1404
 *   An associative array consisting of a field name an regular expression. All term matching
1405
 *   these filter are included. The value of the field is converted to a String by var_export()
1406
 *   so a boolean 'true' can be matched by '/true/'
1407
 * @param string $order_by
1408
 *   One of the order by constants defined in this file
1409
 * @return mixed
1410
 */
1411
function cdm_vocabulary_as_option($vocabulary_uuid, $term_label_callback = NULL, $default_option = FALSE,
1412
                                  array $include_filter = null, $order_by = CDM_ORDER_BY_ORDER_INDEX_ASC) {
1413

    
1414
  static $vocabularyOptions = array();
1415

    
1416
  if (!isset($vocabularyOptions[$vocabulary_uuid])) {
1417
    $terms = cdm_ws_fetch_all('termVocabulary/' . $vocabulary_uuid . '/terms',
1418
      array(
1419
        'orderBy' => $order_by
1420
      )
1421
    );
1422

    
1423
    // apply the include filter
1424
    if($include_filter != null){
1425
      $included_terms = array();
1426

    
1427
      foreach ($terms as $term){
1428
        $include = true;
1429
        foreach ($include_filter as $field=>$regex){
1430
          $include =  preg_match($regex, var_export($term->$field, true)) === 1;
1431
          if(!$include){
1432
            break;
1433
          }
1434
        }
1435
        if($include){
1436
          $included_terms[] = $term;
1437
        }
1438
      }
1439

    
1440
      $terms = $included_terms;
1441
    }
1442

    
1443
    // make options list
1444
    $vocabularyOptions[$vocabulary_uuid] = cdm_terms_as_options($terms, $term_label_callback);
1445
  }
1446

    
1447
  $options = $vocabularyOptions[$vocabulary_uuid];
1448
  if($default_option !== FALSE){
1449
    array_unshift ($options, "");
1450
  }
1451
  return $options;
1452
}
1453

    
1454
/**
1455
 * @param $term_type one of
1456
 *  - Unknown
1457
 *  - Language
1458
 *  - NamedArea
1459
 *  - Rank
1460
 *  - Feature
1461
 *  - AnnotationType
1462
 *  - MarkerType
1463
 *  - ExtensionType
1464
 *  - DerivationEventType
1465
 *  - PresenceAbsenceTerm
1466
 *  - NomenclaturalStatusType
1467
 *  - NameRelationshipType
1468
 *  - HybridRelationshipType
1469
 *  - SynonymRelationshipType
1470
 *  - TaxonRelationshipType
1471
 *  - NameTypeDesignationStatus
1472
 *  - SpecimenTypeDesignationStatus
1473
 *  - InstitutionType
1474
 *  - NamedAreaType
1475
 *  - NamedAreaLevel
1476
 *  - RightsType
1477
 *  - MeasurementUnit
1478
 *  - StatisticalMeasure
1479
 *  - MaterialOrMethod
1480
 *  - Material
1481
 *  - Method
1482
 *  - Modifier
1483
 *  - Scope
1484
 *  - Stage
1485
 *  - KindOfUnit
1486
 *  - Sex
1487
 *  - ReferenceSystem
1488
 *  - State
1489
 *  - NaturalLanguageTerm
1490
 *  - TextFormat
1491
 *  - DeterminationModifier
1492
 *  - DnaMarker
1493
 *
1494
 * @param  $order_by
1495
 *  Optionally sort option (default: CDM_ORDER_BY_TITLE_CACHE_ASC)
1496
 *  possible values:
1497
 *    - CDM_ORDER_BY_ID_ASC
1498
 *    - CDM_ORDER_BY_ID_DESC
1499
 *    - CDM_ORDER_BY_TITLE_CACHE_ASC
1500
 *    - CDM_ORDER_BY_TITLE_CACHE_DESC
1501
 *    - CDM_ORDER_BY_ORDER_INDEX_ASC (can only be used with OrderedTerms!!)
1502
 *    - CDM_ORDER_BY_ORDER_INDEX_DESC (can only be used with OrderedTerms!!)
1503
 */
1504
function cdm_terms_by_type_as_option($term_type, $order_by = CDM_ORDER_BY_TITLE_CACHE_ASC, $term_label_callback = NULL){
1505
  $terms = cdm_ws_fetch_all(
1506
    CDM_WS_TERM,
1507
    array(
1508
      'class' => $term_type,
1509
      'orderBy' => $order_by
1510
    )
1511
  );
1512
  return cdm_terms_as_options($terms, $term_label_callback);
1513
}
1514

    
1515
/**
1516
 * @todo Please document this function.
1517
 * @see http://drupal.org/node/1354
1518
 */
1519
function cdm_rankVocabulary_as_option() {
1520
  $options = cdm_vocabulary_as_option(UUID_RANK, NULL, false);
1521
  return $options;
1522
}
1523

    
1524
/**
1525
 * @todo Please document this function.
1526
 * @see http://drupal.org/node/1354
1527
 */
1528
function _cdm_relationship_type_term_label_callback($term) {
1529
  if (isset($term->representation_L10n_abbreviatedLabel)) {
1530
    return $term->representation_L10n_abbreviatedLabel . ' : '
1531
    . t('@term', array('@term' => $term->representation_L10n));
1532
  }
1533
else {
1534
    return t('@term', array('@term' => $term->representation_L10n));
1535
  }
1536
}
1537

    
1538
// ========================================================================================== //
1539
/**
1540
 * @todo Improve documentation of this function.
1541
 *
1542
 * eu.etaxonomy.cdm.model.description.
1543
 * CategoricalData
1544
 * CommonTaxonName
1545
 * Distribution
1546
 * IndividualsAssociation
1547
 * QuantitativeData
1548
 * TaxonInteraction
1549
 * TextData
1550
 */
1551
function cdm_descriptionElementTypes_as_option($prependEmptyElement = FALSE) {
1552
  static $types = array(
1553
    "CategoricalData",
1554
    "CommonTaxonName",
1555
    "Distribution",
1556
    "IndividualsAssociation",
1557
    "QuantitativeData",
1558
    "TaxonInteraction",
1559
    "TextData",
1560
  );
1561

    
1562
  static $options = NULL;
1563
  if ($options == NULL) {
1564
    $options = array();
1565
    if ($prependEmptyElement) {
1566
      $options[' '] = '';
1567
    }
1568
    foreach ($types as $type) {
1569
      // No internatianalization here since these are purely technical terms.
1570
      $options["eu.etaxonomy.cdm.model.description." . $type] = $type;
1571
    }
1572
  }
1573
  return $options;
1574
}
1575

    
1576

    
1577
/**
1578
 * Fetches all TaxonDescription descriptions elements which are associated to the
1579
 * Taxon specified by the $taxon_uuid and merges the elements into the given
1580
 * feature tree.
1581
 * @param $feature_tree
1582
 *     The CDM FeatureTree to be used as template
1583
 * @param $taxon_uuid
1584
 *     The UUID of the taxon
1585
 * @param $excludes
1586
 *     UUIDs of features to be excluded
1587
 * @return$feature_tree
1588
 *     The CDM FeatureTree which was given as parameter merged tree whereas the
1589
 *     CDM FeatureNodes are extended by an additional field 'descriptionElements'
1590
 *     witch will hold the according $descriptionElements.
1591
 */
1592
function cdm_ws_descriptions_by_featuretree($feature_tree, $taxon_uuid, $exclude_uuids = array()) {
1593

    
1594
  if (!$feature_tree) {
1595
    drupal_set_message(check_plain(t("No 'FeatureTree' has been set so far.
1596
      In order to see the species profiles of your taxa, please select a
1597
      'FeatureTree' in the !settings"), array('!settings' => l(t('CDM Dataportal Settings'), 'admin/config/cdm_dataportal/layout'))), 'warning');
1598
    return FALSE;
1599
  }
1600

    
1601
  $description_elements = cdm_ws_fetch_all(CDM_WS_DESCRIPTIONELEMENT_BY_TAXON,
1602
      array(
1603
      'taxon' => $taxon_uuid,
1604
      'features' => cdm_featureTree_elements_toString($feature_tree->root, ',', 'uuid', $exclude_uuids)
1605
      ),
1606
      'POST'
1607
  );
1608

    
1609
  // Combine all descriptions into one feature tree.
1610
  $merged_nodes = _mergeFeatureTreeDescriptions($feature_tree->root->childNodes, $description_elements);
1611
  $feature_tree->root->childNodes = $merged_nodes;
1612

    
1613
  return $feature_tree;
1614
}
1615

    
1616
/**
1617
 * Returns a filtered a list of annotations for the cdm entity given as parameter $cdmBase.
1618
 * If the annotations are not yet already loded with the cdm entity the cdm REST service will
1619
 * be requested for the annotations.
1620
 *
1621
 * @param string $cdmBase
1622
 *   An annotatable cdm entity.
1623
 * @param array $includeTypes
1624
 *   If an array of annotation type uuids is supplied by this parameter the
1625
 *   list of annotations is resticted to those which belong to this type.
1626
 *
1627
 * @return array
1628
 *   An array of Annotation objects or an empty array.
1629
 */
1630
function cdm_ws_getAnnotationsFor(&$cdmBase, $includeTypes = FALSE) {
1631

    
1632
  if(!isset($cdmBase->annotations)){
1633
    $annotationUrl = cdm_compose_annotations_uri($cdmBase);
1634
    $cdmBase->annotations = cdm_ws_fetch_all($annotationUrl, array(), 'GET', TRUE);
1635
  }
1636

    
1637
  $annotations = array();
1638
  foreach ($cdmBase->annotations as $annotation) {
1639
    if ($includeTypes) {
1640
      if (
1641
        ( isset($annotation->annotationType->uuid) && in_array($annotation->annotationType->uuid, $includeTypes, TRUE) )
1642
        || ($annotation->annotationType === NULL && in_array('NULL_VALUE', $includeTypes, TRUE))
1643
      ) {
1644
        $annotations[] = $annotation;
1645
      }
1646
    }
1647
    else {
1648
      $annotations[] = $annotation;
1649
    }
1650
  }
1651
  return $annotations;
1652

    
1653
}
1654

    
1655
/**
1656
 * Loads the annotations from the REST service an adds them as field to the given $annotatable_entity.
1657
 *
1658
 * @param object $annotatable_entity
1659
 *   The CDM AnnotatableEntity to load annotations for
1660
 */
1661
function cdm_load_annotations(&$annotatable_entity) {
1662
  if (isset($annotatable_entity) && !isset($annotatable_entity->annotations)) {
1663
    $annotations = cdm_ws_getAnnotationsFor($annotatable_entity);
1664
    if (is_array($annotations)) {
1665
      $annotatable_entity->annotations = $annotations;
1666
    }
1667
  }
1668
}
1669

    
1670
/**
1671
 * Get a NomenclaturalReference string.
1672
 *
1673
 * Returns the NomenclaturalReference string with correctly placed
1674
 * microreference (= reference detail) e.g.
1675
 * in Phytotaxa 43: 1-48. 2012.
1676
 *
1677
 * @param string $referenceUuid
1678
 *   UUID of the reference.
1679
 * @param string $microreference
1680
 *   Reference detail.
1681
 *
1682
 * @return string
1683
 *   a NomenclaturalReference.
1684
 */
1685
function cdm_ws_getNomenclaturalReference($referenceUuid, $microreference) {
1686

    
1687
  // TODO the below statement avoids error boxes due to #4644 remove it once this ticket is solved
1688
  if(is_array($microreference) || is_object($microreference)) {
1689
    return '';
1690
  }
1691

    
1692
  $obj = cdm_ws_get(CDM_WS_NOMENCLATURAL_REFERENCE_CITATION, array(
1693
    $referenceUuid,
1694
  ), "microReference=" . urlencode($microreference));
1695

    
1696
  if ($obj) {
1697
    return $obj->String;
1698
  }
1699
  else {
1700
    return NULL;
1701
  }
1702
}
1703

    
1704
/**
1705
 * finds and returns the FeatureNode denoted by the given $feature_uuid
1706
 *
1707
 * @param $feature_tree_nodes
1708
 *    The nodes contained in CDM FeatureTree entitiy: $feature->root->childNodes
1709
 * @param $feature_uuid
1710
 *    The UUID of the Feature
1711
 * @return returns the FeatureNode or null
1712
 */
1713
function &cdm_feature_tree_find_node($feature_tree_nodes, $feature_uuid){
1714

    
1715
  // 1. scan this level
1716
  foreach ($feature_tree_nodes as $node){
1717
    if($node->feature->uuid == $feature_uuid){
1718
      return $node;
1719
    }
1720
  }
1721

    
1722
  // 2. descend into childen
1723
  foreach ($feature_tree_nodes as $node){
1724
    if(is_array($node->childNodes)){
1725
      $node = cdm_feature_tree_find_node($node->childNodes, $feature_uuid);
1726
      if($node) {
1727
        return $node;
1728
      }
1729
    }
1730
  }
1731
  $null_var = null; // kludgy workaround to avoid "PHP Notice: Only variable references should be returned by reference"
1732
  return $null_var;
1733
}
1734

    
1735
/**
1736
 * Merges the given featureNodes structure with the descriptionElements.
1737
 *
1738
 * This method is used in preparation for rendering the descriptionElements.
1739
 * The descriptionElements which belong to a specific feature node are appended
1740
 * to a the feature node by creating a new field:
1741
 *  - descriptionElements: the CDM DescriptionElements which belong to this feature
1742
 * The descriptionElements will be cleared in advance in order to allow reusing the
1743
 * same feature tree without the risk of mixing sets of description elements.
1744
 *
1745
 * which originally is not existing in the cdm.
1746
 *
1747
 *
1748
 *
1749
 * @param array $featureNodes
1750
 *    An array of cdm FeatureNodes which may be hierarchical since feature nodes
1751
 *    may have children.
1752
 * @param array $descriptionElements
1753
 *    An flat array of cdm DescriptionElements
1754
 * @return array
1755
 *    The $featureNodes structure enriched with the according $descriptionElements
1756
 */
1757
function _mergeFeatureTreeDescriptions($featureNodes, $descriptionElements) {
1758

    
1759
  foreach ($featureNodes as &$node) {
1760
    // since the $featureNodes array is reused for each description
1761
    // it is necessary to clear the custom node fields in advance
1762
    if(isset($node->descriptionElements)){
1763
      unset($node->descriptionElements);
1764
    }
1765

    
1766
    // Append corresponding elements to an additional node field:
1767
    // $node->descriptionElements.
1768
    foreach ($descriptionElements as $element) {
1769
      if ($element->feature->uuid == $node->feature->uuid) {
1770
        if (!isset($node->descriptionElements)) {
1771
          $node->descriptionElements = array();
1772
        }
1773
        $node->descriptionElements[] = $element;
1774
      }
1775
    }
1776

    
1777
    // Recurse into node children.
1778
    if (isset($node->childNodes[0])) {
1779
      $mergedChildNodes = _mergeFeatureTreeDescriptions($node->childNodes, $descriptionElements);
1780
      $node->childNodes = $mergedChildNodes;
1781
    }
1782

    
1783
    if(!isset($node->descriptionElements) && !isset($node->childNodes[0])){
1784
      unset($node);
1785
    }
1786

    
1787
  }
1788

    
1789
  return $featureNodes;
1790
}
1791

    
1792
/**
1793
 * Sends a GET or POST request to a CDM RESTService and returns a de-serialized object.
1794
 *
1795
 * The response from the HTTP GET request is returned as object.
1796
 * The response objects coming from the webservice configured in the
1797
 * 'cdm_webservice_url' variable are being cached in a level 1 (L1) and / or
1798
 *  in a level 2 (L2) cache.
1799
 *
1800
 * Since the L1 cache is implemented as static variable of the cdm_ws_get()
1801
 * function, this cache persists only per each single page execution.
1802
 * Any object coming from the webservice is stored into it by default.
1803
 * In contrast to this default caching mechanism the L2 cache only is used if
1804
 * the 'cdm_webservice_cache' variable is set to TRUE,
1805
 * which can be set using the modules administrative settings section.
1806
 * Objects stored in this L2 cache are serialized and stored
1807
 * using the drupal cache in the '{prefix}cache_cdm_ws' cache table. So the
1808
 * objects that are stored in the database will persist as
1809
 * long as the drupal cache is not being cleared and are available across
1810
 * multiple script executions.
1811
 *
1812
 * @param string $uri
1813
 *   URL to the webservice.
1814
 * @param array $pathParameters
1815
 *   An array of path parameters.
1816
 * @param string $query
1817
 *   A query string to be appended to the URL.
1818
 * @param string $method
1819
 *   The HTTP method to use, valid values are "GET" or "POST";
1820
 * @param bool $absoluteURI
1821
 *   TRUE when the URL should be treated as absolute URL.
1822
 *
1823
 * @return object| array
1824
 *   The de-serialized webservice response object.
1825
 */
1826
function cdm_ws_get($uri, $pathParameters = array(), $query = NULL, $method = "GET", $absoluteURI = FALSE) {
1827

    
1828
  static $cacheL1 = array();
1829

    
1830
  $data = NULL;
1831
  // store query string in $data and clear the query, $data will be set as HTTP request body
1832
  if($method == 'POST'){
1833
    $data = $query;
1834
    $query = NULL;
1835
  }
1836

    
1837
  // Transform the given uri path or pattern into a proper webservice uri.
1838
  if (!$absoluteURI) {
1839
    $uri = cdm_compose_url($uri, $pathParameters, $query);
1840
  }
1841

    
1842
  // read request parameter 'cacheL2_refresh'
1843
  // which allows refreshing the level 2 cache
1844
  $do_cacheL2_refresh = isset($_REQUEST['cacheL2_refresh']) && $_REQUEST['cacheL2_refresh'] == 1;
1845

    
1846
  $is_cdm_ws_uri = _is_cdm_ws_uri($uri);
1847
  $use_cacheL2 = variable_get('cdm_webservice_cache', 1);
1848

    
1849
  if($method == 'GET'){
1850
    $cache_key = $uri;
1851
  } else {
1852
    // sha1 creates longer hashes and thus will cause fewer collisions than md5.
1853
    // crc32 is faster but creates much shorter hashes
1854
    $cache_key = $uri . '[' . $method . ':' . sha1($data) .']';
1855
  }
1856

    
1857
  if (array_key_exists($cache_key, $cacheL1)) {
1858
    $cacheL1_obj = $cacheL1[$uri];
1859
  }
1860

    
1861
  $set_cacheL1 = FALSE;
1862
  if ($is_cdm_ws_uri && !isset($cacheL1_obj)) {
1863
    $set_cacheL1 = TRUE;
1864
  }
1865

    
1866
  // Only cache cdm webservice URIs.
1867
  $set_cacheL2 = $use_cacheL2 && $is_cdm_ws_uri && $set_cacheL1;
1868
  $cacheL2_entry = FALSE;
1869

    
1870
  if ($use_cacheL2 && !$do_cacheL2_refresh) {
1871
    // Try to get object from cacheL2.
1872
    $cacheL2_entry = cache_get($cache_key, 'cache_cdm_ws');
1873
  }
1874

    
1875
  if (isset($cacheL1_obj)) {
1876
    //
1877
    // The object has been found in the L1 cache.
1878
    //
1879
    $obj = $cacheL1_obj;
1880
    if (cdm_debug_block_visible()) {
1881
      cdm_ws_debug_add($uri, $method, $data, 0, 0, NULL, 'cacheL1');
1882
    }
1883
  }
1884
  elseif ($cacheL2_entry) {
1885
    //
1886
    // The object has been found in the L2 cache.
1887
    //
1888
    $duration_parse_start = microtime(TRUE);
1889
    $obj = unserialize($cacheL2_entry->data);
1890
    $duration_parse = microtime(TRUE) - $duration_parse_start;
1891

    
1892
    if (cdm_debug_block_visible()) {
1893
      cdm_ws_debug_add($uri, $method, $data, 0, $duration_parse, NULL, 'cacheL2');
1894
    }
1895
  }
1896
  else {
1897
    //
1898
    // Get the object from the webservice and cache it.
1899
    //
1900
    $duration_fetch_start = microtime(TRUE);
1901
    // Request data from webservice JSON or XML.
1902
    $response = cdm_http_request($uri, $method, $data);
1903
    $response_body = NULL;
1904
    if (isset($response->data)) {
1905
      $response_body = $response->data;
1906
    }
1907
    $duration_fetch = microtime(TRUE) - $duration_fetch_start;
1908
    $duration_parse_start = microtime(TRUE);
1909

    
1910
    // Parse data and create object.
1911
    $obj = cdm_load_obj($response_body);
1912

    
1913
    $duration_parse = microtime(TRUE) - $duration_parse_start;
1914

    
1915
    if (cdm_debug_block_visible()) {
1916
      if ($obj || $response_body == "[]") {
1917
        $status = 'valid';
1918
      }
1919
      else {
1920
        $status = 'invalid';
1921
      }
1922
      cdm_ws_debug_add($uri, $method, $data, $duration_fetch, $duration_parse, strlen($response_body), $status);
1923
    }
1924
    if ($set_cacheL2) {
1925
      // Store the object in cache L2.
1926
      // Comment @WA perhaps better if Drupal serializedatas here? Then the
1927
      // flag serialized is set properly in the cache table.
1928
      cache_set($cache_key, serialize($obj), 'cache_cdm_ws', CACHE_TEMPORARY);
1929
    }
1930
  }
1931
  if ($obj) {
1932
    // Store the object in cache L1.
1933
    if ($set_cacheL1) {
1934
      $cacheL1[$cache_key] = $obj;
1935
    }
1936
  }
1937
  return $obj;
1938
}
1939

    
1940
/**
1941
 * Processes and stores the given information in $_SESSION['cdm']['ws_debug'] as table row.
1942
 *
1943
 * The cdm_ws_debug block will display the debug information.
1944
 *
1945
 * @param $uri
1946
 *    The CDM REST URI to which the request has been send
1947
 * @param string $method
1948
 *    The HTTP request method, either 'GET' or 'POST'
1949
 * @param string $post_data
1950
 *    The datastring send with a post request
1951
 * @param $duration_fetch
1952
 *    The time in seconds it took to fetch the data from the web service
1953
 * @param $duration_parse
1954
 *    Time in seconds which was needed to parse the json response
1955
 * @param $datasize
1956
 *    Size of the data received from the server
1957
 * @param $status
1958
 *    A status string, possible values are: 'valid', 'invalid', 'cacheL1', 'cacheL2'
1959
 * @return bool
1960
 *    TRUE if adding the debug information was successful
1961
 */
1962
function cdm_ws_debug_add($uri, $method, $post_data, $duration_fetch, $duration_parse, $datasize, $status) {
1963

    
1964
  static $initial_time = NULL;
1965
  if(!$initial_time) {
1966
    $initial_time = microtime(TRUE);
1967
  }
1968
  $time = microtime(TRUE) - $initial_time;
1969

    
1970
  // Decompose uri into path and query element.
1971
  $uri_parts = explode("?", $uri);
1972
  $query = array();
1973
  if (count($uri_parts) == 2) {
1974
    $path = $uri_parts[0];
1975
  }
1976
  else {
1977
    $path = $uri;
1978
  }
1979

    
1980
  if(strpos($uri, '?') > 0){
1981
    $json_uri = str_replace('?', '.json?', $uri);
1982
    $xml_uri = str_replace('?', '.xml?', $uri);
1983
  } else {
1984
    $json_uri = $uri . '.json';
1985
    $xml_uri = $json_uri . '.xml';
1986
  }
1987

    
1988
  // data links to make data accecsible as json and xml
1989
  $data_links = '';
1990
  if (_is_cdm_ws_uri($path)) {
1991

    
1992
    // see ./js/http-method-link.js
1993

    
1994
    if($method == 'GET'){
1995
      $data_links .= '<a href="' . $xml_uri . '" target="data">xml</a>-';
1996
      $data_links .= '<a href="' . url('cdm_api/proxy/' . urlencode($xml_uri)) . '" target="data">proxied</a>';
1997
      $data_links .= '<br/>';
1998
      $data_links .= '<a href="' . $json_uri . '" target="data">json</a>-';
1999
      $data_links .= '<a href="' . url('cdm_api/proxy/' . urlencode($json_uri)) . '" target="data">proxied</a>';
2000
    } else {
2001
      $js_link_activation = 'class="http-' . $method . '-link" data-cdm-http-post="' . $post_data . '" type="application/x-www-form-urlencoded"';
2002
      $data_links .= '<a ' . $js_link_activation . ' href="' . url('cdm_api/proxy/' . urlencode($xml_uri)) . '" target="data">xml-proxied</a>';
2003
      $data_links .= '<br/>';
2004
      $data_links .= '<a ' . $js_link_activation . ' href="' . url('cdm_api/proxy/' . urlencode($json_uri)) . '" target="data">json-proxied</a>';
2005
    }
2006
  }
2007
  else {
2008
    $data_links .= '<a href="' . $uri . '" target="data">open</a>';
2009
  }
2010

    
2011
  //
2012
  $data = array(
2013
      'ws_uri' => $uri,
2014
      'method' => $method,
2015
      'post_data' => $post_data,
2016
      'time' => sprintf('%3.3f', $time),
2017
      'fetch_seconds' => sprintf('%3.3f', $duration_fetch),
2018
      'parse_seconds' => sprintf('%3.3f', $duration_parse),
2019
      'size_kb' => sprintf('%3.1f', ($datasize / 1024)) ,
2020
      'status' => $status,
2021
      'data_links' => $data_links
2022
  );
2023
  if (!isset($_SESSION['cdm']['ws_debug'])) {
2024
    $_SESSION['cdm']['ws_debug'] = array();
2025
  }
2026
  $_SESSION['cdm']['ws_debug'][] = serialize($data);
2027

    
2028
  // Mark this page as being uncacheable.
2029
  // taken over from drupal_get_messages() but it is unsure if we really need this here
2030
  drupal_page_is_cacheable(FALSE);
2031

    
2032
  // Messages not set when DB connection fails.
2033
  return isset($_SESSION['cdm']['ws_debug']) ? $_SESSION['cdm']['ws_debug'] : NULL;
2034
}
2035

    
2036
/**
2037
 * helper function to dtermine if the cdm_debug_block should be displayed or not
2038
 * the visibility depends on whether
2039
 *  - the block is enabled
2040
 *  - the visibility restrictions in the block settings are satisfied
2041
 */
2042
function cdm_debug_block_visible() {
2043
  static $is_visible = null;
2044

    
2045
  if($is_visible === null){
2046
      $block = block_load('cdm_api', 'cdm_ws_debug');
2047
      $is_visible = isset($block->status) && $block->status == 1;
2048
      if($is_visible){
2049
        $blocks = array($block);
2050
        // Checks the page, user role, and user-specific visibilty settings.
2051
        block_block_list_alter($blocks);
2052
        $is_visible = count($blocks) > 0;
2053
      }
2054
  }
2055
  return $is_visible;
2056
}
2057

    
2058
/**
2059
 * @todo Please document this function.
2060
 * @see http://drupal.org/node/1354
2061
 */
2062
function cdm_load_obj($response_body) {
2063
  $obj = json_decode($response_body);
2064

    
2065
  if (!(is_object($obj) || is_array($obj))) {
2066
    ob_start();
2067
    $obj_dump = ob_get_contents();
2068
    ob_clean();
2069
    return FALSE;
2070
  }
2071

    
2072
  return $obj;
2073
}
2074

    
2075
/**
2076
 * Do a http request to a CDM RESTful web service.
2077
 *
2078
 * @param string $uri
2079
 *   The webservice url.
2080
 * @param string $method
2081
 *   The HTTP method to use, valid values are "GET" or "POST"; defaults to
2082
 *   "GET" even if NULL, FALSE or any invalid value is supplied.
2083
 * @param $data: A string containing the request body, formatted as
2084
 *     'param=value&param=value&...'. Defaults to NULL.
2085
 *
2086
 * @return object
2087
 *   The object as returned by drupal_http_request():
2088
 *   An object that can have one or more of the following components:
2089
 *   - request: A string containing the request body that was sent.
2090
 *   - code: An integer containing the response status code, or the error code
2091
 *     if an error occurred.
2092
 *   - protocol: The response protocol (e.g. HTTP/1.1 or HTTP/1.0).
2093
 *   - status_message: The status message from the response, if a response was
2094
 *     received.
2095
 *   - redirect_code: If redirected, an integer containing the initial response
2096
 *     status code.
2097
 *   - redirect_url: If redirected, a string containing the URL of the redirect
2098
 *     target.
2099
 *   - error: If an error occurred, the error message. Otherwise not set.
2100
 *   - headers: An array containing the response headers as name/value pairs.
2101
 *     HTTP header names are case-insensitive (RFC 2616, section 4.2), so for
2102
 *     easy access the array keys are returned in lower case.
2103
 *   - data: A string containing the response body that was received.
2104
 */
2105
function cdm_http_request($uri, $method = "GET", $data = NULL) {
2106
  static $acceptLanguage = NULL;
2107
  $header = array();
2108
  
2109
  if(!$acceptLanguage && module_exists('i18n')){
2110
    $acceptLanguage = i18n_language_content()->language;
2111
  }
2112

    
2113
  if (!$acceptLanguage) {
2114
    if (function_exists('apache_request_headers')) {
2115
      $headers = apache_request_headers();
2116
      if (isset($headers['Accept-Language'])) {
2117
        $acceptLanguage = $headers['Accept-Language'];
2118
      }
2119
    }
2120
  }
2121

    
2122
  if ($method != "GET" && $method != "POST") {
2123
    drupal_set_message('cdm_api.module#cdm_http_request() : unsupported HTTP request method ', 'error');
2124
  }
2125

    
2126
  if (_is_cdm_ws_uri($uri)) {
2127
    $header['Accept'] = 'application/json';
2128
    $header['Accept-Language'] = $acceptLanguage;
2129
    $header['Accept-Charset'] = 'UTF-8';
2130
  }
2131

    
2132
  if($method == "POST") {
2133
    // content type is application/x-www-form-urlencoded, so the request body uses the same format as the query string
2134
    $header['Content-Type'] = 'application/x-www-form-urlencoded';
2135
  }
2136

    
2137

    
2138
  cdm_dd($uri);
2139
  return drupal_http_request($uri, array(
2140
      'headers' => $header,
2141
      'method' => $method,
2142
      'data' => $data,
2143
      'timeout' => CDM_HTTP_REQUEST_TIMEOUT
2144
      )
2145
   );
2146
}
2147

    
2148
/**
2149
 * Concatenates recursively the fields of all features contained in the given
2150
 * CDM FeatureTree root node.
2151
 *
2152
 * @param $rootNode
2153
 *     A CDM FeatureTree node
2154
 * @param
2155
 *     The character to be used as glue for concatenation, default is ', '
2156
 * @param $field_name
2157
 *     The field name of the CDM Features
2158
 * @param $excludes
2159
 *     Allows defining a set of values to be excluded. This refers to the values
2160
 *     in the field denoted by the $field_name parameter
2161
 *
2162
 */
2163
function cdm_featureTree_elements_toString($root_node, $separator = ', ', $field_name = 'representation_L10n', $excludes = array()) {
2164
  $out = '';
2165

    
2166
  $pre_child_separator = $separator;
2167
  $post_child_separator = '';
2168

    
2169
  foreach ($root_node->childNodes as $feature_node) {
2170
    $out .= ($out ? $separator : '');
2171
    if(!in_array($feature_node->feature->$field_name, $excludes)) {
2172
      $out .= $feature_node->feature->$field_name;
2173
      if (is_array($feature_node->childNodes) && count($feature_node->childNodes) > 0) {
2174
        $childlabels = cdm_featureTree_elements_toString($feature_node, $separator, $field_name);
2175
        if (strlen($childlabels)) {
2176
            $out .=  $pre_child_separator . $childlabels . $post_child_separator;
2177
        }
2178
      }
2179
    }
2180
  }
2181
  return $out;
2182
}
2183

    
2184
/**
2185
 * Create a one-dimensional form options array.
2186
 *
2187
 * Creates an array of all features in the feature tree of feature nodes,
2188
 * the node labels are indented by $node_char and $childIndent depending on the
2189
 * hierachy level.
2190
 *
2191
 * @param - $rootNode
2192
 * @param - $node_char
2193
 * @param - $childIndentStr
2194
 * @param - $childIndent
2195
 *   ONLY USED INTERNALLY!
2196
 *
2197
 * @return array
2198
 *   A one dimensional Drupal form options array.
2199
 */
2200
function _featureTree_nodes_as_feature_options($rootNode, $node_char = "&#9500;&#9472; ", $childIndentStr = '&nbsp;', $childIndent = '') {
2201
  $options = array();
2202
  foreach ($rootNode->childNodes as $featureNode) {
2203
    $indent_prefix = '';
2204
    if ($childIndent) {
2205
      $indent_prefix = $childIndent . $node_char . " ";
2206
    }
2207
    $options[$featureNode->feature->uuid] = $indent_prefix . $featureNode->feature->representation_L10n;
2208
    if (isset($featureNode->childNodes) && is_array($featureNode->childNodes)) {
2209
      // Foreach ($featureNode->childNodes as $childNode){
2210
      $childList = _featureTree_nodes_as_feature_options($featureNode, $node_char, $childIndentStr, $childIndent . $childIndentStr);
2211
      $options = array_merge_recursive($options, $childList);
2212
      // }
2213
    }
2214
  }
2215
  return $options;
2216
}
2217

    
2218
/**
2219
 * Returns an array with all available FeatureTrees and the representations of the selected
2220
 * FeatureTree as a detail view.
2221
 *
2222
 * @param boolean $add_default_feature_free
2223
 * @return array
2224
 *  associative array with following keys:
2225
 *  -options: Returns an array with all available Feature Trees
2226
 *  -treeRepresentations: Returns representations of the selected Feature Tree as a detail view
2227
 *
2228
 */
2229
function cdm_get_featureTrees_as_options($add_default_feature_free = FALSE) {
2230

    
2231
  $options = array();
2232
  $tree_representations = array();
2233
  $feature_trees = array();
2234

    
2235
  // Set tree that contains all features.
2236
  if ($add_default_feature_free) {
2237
    $options[UUID_DEFAULT_FEATURETREE] = t('Default Featuretree (contains all features)');
2238
    $feature_trees[] = cdm_ws_get(CDM_WS_FEATURETREE, UUID_DEFAULT_FEATURETREE);
2239
  }
2240

    
2241
  // Get feature trees from database.
2242
  $persited_trees = cdm_ws_fetch_all(CDM_WS_FEATURETREES);
2243
  if (is_array($persited_trees)) {
2244
    $feature_trees = array_merge($feature_trees, $persited_trees);
2245
  }
2246

    
2247
  foreach ($feature_trees as $featureTree) {
2248

    
2249
    if(!is_object($featureTree)){
2250
      continue;
2251
    }
2252
    // Do not add the DEFAULT_FEATURETREE again,
2253
    if ($featureTree->uuid != UUID_DEFAULT_FEATURETREE) {
2254
      $options[$featureTree->uuid] = $featureTree->titleCache;
2255
    }
2256

    
2257
    // Render the hierarchic tree structure
2258
    if (is_array( $featureTree->root->childNodes) && count( $featureTree->root->childNodes) > 0) {
2259

    
2260
      // Render the hierarchic tree structure.
2261
      $treeDetails = '<div class="featuretree_structure">'
2262
        . theme('FeatureTree_hierarchy', array('FeatureTreeUuid' =>  $featureTree->uuid))
2263
        . '</div>';
2264

    
2265
      $form = array();
2266
      $form['featureTree-' .  $featureTree->uuid] = array(
2267
        '#type' => 'fieldset',
2268
        '#title' => 'Show details',
2269
        '#attributes' => array('class' => array('collapsible collapsed')),
2270
        // '#collapsible' => TRUE,
2271
        // '#collapsed' => TRUE,
2272
      );
2273
      $form['featureTree-' .  $featureTree->uuid]['details'] = array(
2274
        '#markup' => $treeDetails,
2275
      );
2276

    
2277
      $tree_representations[$featureTree->uuid] = drupal_render($form);
2278
    }
2279

    
2280
  } // END loop over feature trees
2281

    
2282
  // return $options;
2283
  return array('options' => $options, 'treeRepresentations' => $tree_representations);
2284
}
2285

    
2286
/**
2287
 * Provides the list of available classifications in form of an options array.
2288
 *
2289
 * The options array is suitable for drupal form API elements that allow multiple choices.
2290
 * @see http://api.drupal.org/api/drupal/developer!topics!forms_api_reference.html/7#options
2291
 *
2292
 * The classifications are ordered alphabetically whereas the classification
2293
 * chosen as default will always appear on top of the array, followed by a
2294
 * blank line below.
2295
 *
2296
 * @param bool $add_none_option
2297
 *   is true an addtional 'none' option will be added, optional parameter, defaults to FALSE
2298
 *
2299
 * @return array
2300
 *   classifications in an array as options for a form element that allows multiple choices.
2301
 */
2302
function cdm_get_taxontrees_as_options($add_none_option = FALSE) {
2303

    
2304
  $taxonTrees = cdm_ws_fetch_all(CDM_WS_PORTAL_TAXONOMY);
2305

    
2306
  $default_classification_uuid = variable_get(CDM_TAXONOMICTREE_UUID, FALSE);
2307
  $default_classification_label = '';
2308

    
2309
  // add all classifications
2310
  $taxonomic_tree_options = array();
2311
  if ($add_none_option) {
2312
    $taxonomic_tree_options['NONE'] = ' '; // one Space character at beginning to force on top;
2313
  }
2314
  if ($taxonTrees) {
2315
    foreach ($taxonTrees as $tree) {
2316
      if (!$default_classification_uuid || $default_classification_uuid != $tree->uuid) {
2317
        $taxonomic_tree_options[$tree->uuid] = $tree->titleCache;
2318
      } else {
2319
        $taxonomic_tree_options[$tree->uuid] = '  '; // two Space characters to force on top but below 'none' option , will be replaced below by titleCache
2320
        $default_classification_label = $tree->titleCache;
2321
      }
2322
    }
2323
  }
2324
  // oder alphabetically the space
2325
  asort($taxonomic_tree_options);
2326

    
2327
  // now set the labels
2328
  //   for none
2329
  if ($add_none_option) {
2330
    $taxonomic_tree_options['NONE'] =t('--- ALL ---');
2331
  }
2332

    
2333
  //   for default_classification
2334
  if (is_uuid($default_classification_uuid)) {
2335
    $taxonomic_tree_options[$default_classification_uuid] =
2336
      $default_classification_label ? $default_classification_label : '--- INVALID CHOICE ---'
2337
      . (count($taxonTrees) > 1 ? ' [' . t('DEFAULT CLASSIFICATION') . ']': '');
2338
  }
2339

    
2340
  return $taxonomic_tree_options;
2341
}
2342

    
2343
/**
2344
 * @todo Please document this function.
2345
 * @see http://drupal.org/node/1354
2346
 */
2347
function cdm_api_secref_cache_prefetch(&$secUuids) {
2348
  // Comment @WA: global variables should start with a single underscore
2349
  // followed by the module and another underscore.
2350
  global $_cdm_api_secref_cache;
2351
  if (!is_array($_cdm_api_secref_cache)) {
2352
    $_cdm_api_secref_cache = array();
2353
  }
2354
  $uniqueUuids = array_unique($secUuids);
2355
  $i = 0;
2356
  $param = '';
2357
  while ($i++ < count($uniqueUuids)) {
2358
    $param .= $secUuids[$i] . ',';
2359
    if (strlen($param) + 37 > 2000) {
2360
      _cdm_api_secref_cache_add($param);
2361
      $param = '';
2362
    }
2363
  }
2364
  if ($param) {
2365
    _cdm_api_secref_cache_add($param);
2366
  }
2367
}
2368

    
2369
/**
2370
 * @todo Please document this function.
2371
 * @see http://drupal.org/node/1354
2372
 */
2373
function cdm_api_secref_cache_get($secUuid) {
2374
  global $_cdm_api_secref_cache;
2375
  if (!is_array($_cdm_api_secref_cache)) {
2376
    $_cdm_api_secref_cache = array();
2377
  }
2378
  if (!array_key_exists($secUuid, $_cdm_api_secref_cache)) {
2379
    _cdm_api_secref_cache_add($secUuid);
2380
  }
2381
  return $_cdm_api_secref_cache[$secUuid];
2382
}
2383

    
2384
/**
2385
 * @todo Please document this function.
2386
 * @see http://drupal.org/node/1354
2387
 */
2388
function cdm_api_secref_cache_clear() {
2389
  global $_cdm_api_secref_cache;
2390
  $_cdm_api_secref_cache = array();
2391
}
2392

    
2393

    
2394
/**
2395
 * Validates if the given string is a uuid.
2396
 *
2397
 * @param string $str
2398
 *   The string to validate.
2399
 *
2400
 * return bool
2401
 *   TRUE if the string is a UUID.
2402
 */
2403
function is_uuid($str) {
2404
  return is_string($str) && strlen($str) == 36 && strpos($str, '-');
2405
}
2406

    
2407
/**
2408
 * Checks if the given $object is a valid cdm entity.
2409
 *
2410
 * An object is considered a cdm entity if it has a string field $object->class
2411
 * with at least 3 characters and if it has a valid uuid in $object->uuid.
2412
 * The function is null save.
2413
 *
2414
 * @author a.kohlbecker <a.kohlbecker@bgbm.org>
2415
 *
2416
 * @param mixed $object
2417
 *   The object to validate
2418
 *
2419
 * @return bool
2420
 *   True if the object is a cdm entity.
2421
 */
2422
function is_cdm_entity($object) {
2423
  return isset($object->class) && is_string($object->class) && strlen($object->class) > 2 && is_string($object->uuid) && is_uuid($object->uuid);
2424
}
2425

    
2426
/**
2427
 * @todo Please document this function.
2428
 * @see http://drupal.org/node/1354
2429
 */
2430
function _cdm_api_secref_cache_add($secUuidsStr) {
2431
  global $_cdm_api_secref_cache;
2432
  $ref = cdm_ws_get(CDM_WS_REFERENCE, $secUuidsStr);
2433
  // Batch fetching not jet reimplemented thus:
2434
  /*
2435
  $assocRefSTOs = array(); if($refSTOs) { foreach($refSTOs as $ref){
2436
  $assocRefSTOs[$ref->uuid] = $ref; } $_cdm_api_secref_cache =
2437
  array_merge($_cdm_api_secref_cache, $assocRefSTOs); }
2438
  */
2439
  $_cdm_api_secref_cache[$ref->uuid] = $ref;
2440
}
2441

    
2442
/**
2443
 * Checks if the given uri starts with a cdm webservice url.
2444
 *
2445
 * Checks if the uri starts with the cdm webservice url stored in the
2446
 * Drupal variable 'cdm_webservice_url'.
2447
 * The 'cdm_webservice_url' can be set in the admins section of the portal.
2448
 *
2449
 * @param string $uri
2450
 *   The URI to test.
2451
 *
2452
 * @return bool
2453
 *   True if the uri starts with a cdm webservice url.
2454
 */
2455
function _is_cdm_ws_uri($uri) {
2456
  return str_beginsWith($uri, variable_get('cdm_webservice_url', '#EMPTY#'));
2457
}
2458

    
2459
/**
2460
 * @todo Please document this function.
2461
 * @see http://drupal.org/node/1354
2462
 */
2463
function queryString($elements) {
2464
  $query = '';
2465
  foreach ($elements as $key => $value) {
2466
    if (is_array($value)) {
2467
      foreach ($value as $v) {
2468
        $query .= (strlen($query) > 0 ? '&' : '') . $key . '=' . urlencode($v);
2469
      }
2470
    }
2471
    else {
2472
      $query .= (strlen($query) > 0 ? '&' : '') . $key . '=' . urlencode($value);
2473
    }
2474
  }
2475
  return $query;
2476
}
2477

    
2478
/**
2479
 * Implementation of the magic method __clone to allow deep cloning of objects
2480
 * and arrays.
2481
 */
2482
function __clone() {
2483
  foreach ($this as $name => $value) {
2484
    if (gettype($value) == 'object' || gettype($value) == 'array') {
2485
      $this->$name = clone($this->$name);
2486
    }
2487
  }
2488
}
2489

    
2490
/**
2491
 * Compares the given CDM Term instances by the  representationL10n.
2492
 *
2493
 * Can also be used with TermDTOs. To be used in usort()
2494
 *
2495
 * @see http://php.net/manual/en/function.usort.php
2496
 *
2497
 * @param $term1
2498
 *   The first CDM Term instance
2499
 * @param $term2
2500
 *   The second CDM Term instance
2501
 * @return int
2502
 *   The result of the comparison
2503
 */
2504
function compare_terms_by_representationL10n($term1, $term2) {
2505

    
2506
  if (!isset($term1->representation_L10n)) {
2507
    $term1->representationL10n = '';
2508
  }
2509
  if (!isset($term2->representation_L10n)) {
2510
    $term2->representationL10n = '';
2511
  }
2512

    
2513
  return strcmp($term1->representation_L10n, $term2->representation_L10n);
2514
}
2515

    
2516
function compare_terms_by_order_index($term1, $term2) {
2517

    
2518

    
2519
  if (!isset($term1->orderIndex)) {
2520
    $a = 0;
2521
  } else {
2522
    $a = $term1->orderIndex;
2523
  }
2524
  if (!isset($term2->orderIndex)) {
2525
    $b = 0;
2526
  } else {
2527
    $b = $term2->orderIndex;
2528
  }
2529

    
2530
  if ($a == $b) {
2531
    return 0;
2532
  }
2533
  return ($a < $b) ? -1 : 1;
2534

    
2535
}
2536

    
2537

    
2538
/**
2539
 * Make a 'deep copy' of an array.
2540
 *
2541
 * Make a complete deep copy of an array replacing
2542
 * references with deep copies until a certain depth is reached
2543
 * ($maxdepth) whereupon references are copied as-is...
2544
 *
2545
 * @see http://us3.php.net/manual/en/ref.array.php
2546
 *
2547
 * @param array $array
2548
 * @param array $copy passed by reference
2549
 * @param int $maxdepth
2550
 * @param int $depth
2551
 */
2552
function array_deep_copy(&$array, &$copy, $maxdepth = 50, $depth = 0) {
2553
  if ($depth > $maxdepth) {
2554
    $copy = $array;
2555
    return;
2556
  }
2557
  if (!is_array($copy)) {
2558
    $copy = array();
2559
  }
2560
  foreach ($array as $k => &$v) {
2561
    if (is_array($v)) {
2562
      array_deep_copy($v, $copy[$k], $maxdepth, ++$depth);
2563
    }
2564
    else {
2565
      $copy[$k] = $v;
2566
    }
2567
  }
2568
}
2569

    
2570
/**
2571
 * Adds java script to create and enable a toggler for the cdm webservice debug block content.
2572
 *
2573
 */
2574
function _add_js_ws_debug() {
2575

    
2576
  $data_tables_js = '/js/DataTables-1.9.4/media/js/jquery.dataTables.min.js';
2577
  $colorbox_js = '/js/colorbox/jquery.colorbox-min.js';
2578
  if (variable_get('cdm_js_devel_mode', FALSE)) {
2579
    // use the developer versions of js libs
2580
    $data_tables_js = '/js/DataTables-1.9.4/media/js/jquery.dataTables.js';
2581
    $colorbox_js = '/js/colorbox/jquery.colorbox.js';
2582
  }
2583
  drupal_add_js(drupal_get_path('module', 'cdm_dataportal') . $data_tables_js,
2584
    array(
2585
      'type' => 'file',
2586
      'weight' => JS_LIBRARY,
2587
      'cache' => TRUE)
2588
    );
2589

    
2590
  drupal_add_js(drupal_get_path('module', 'cdm_dataportal') . $colorbox_js,
2591
    array(
2592
      'type' => 'file',
2593
      'weight' => JS_LIBRARY,
2594
      'cache' => TRUE)
2595
    );
2596
  drupal_add_css(drupal_get_path('module', 'cdm_dataportal') . '/js/colorbox/colorbox.css');
2597
  drupal_add_css(drupal_get_path('module', 'cdm_dataportal') . '/js/DataTables-1.9.4/media/css/cdm_debug_table.css');
2598

    
2599
  drupal_add_js(drupal_get_path('module', 'cdm_dataportal') . '/js/ws_debug_block.js',
2600
    array(
2601
      'type' => 'file',
2602
      'weight' => JS_LIBRARY,
2603
      'cache' => TRUE)
2604
    );
2605
  drupal_add_js(drupal_get_path('module', 'cdm_dataportal') . '/js/http-method-link.js',
2606
    array(
2607
    'type' => 'file',
2608
    'weight' => JS_LIBRARY,
2609
    'cache' => TRUE)
2610
    );
2611

    
2612
}
2613

    
2614
/**
2615
 * @todo Please document this function.
2616
 * @see http://drupal.org/node/1354
2617
 */
2618
function _no_classfication_uuid_message() {
2619
  if (!cdm_ws_get(CDM_WS_PORTAL_TAXONOMY)) {
2620
    return t('This DataPortal is not configured properly or the CDM-Server may be absent.') . ' Please check the ' . l(t('CDM web service URL'), 'admin/config/cdm_dataportal/settings/general') . t(', or contact the maintainer of this DataPortal.');
2621
  }
2622
  return t('This DataPortal is not configured properly.') . l(t('Please choose a valid classification'), 'admin/config/cdm_dataportal/settings/general') . t(', or contact the maintainer of this DataPortal.');
2623
}
2624

    
2625
/**
2626
 * Implementation of hook flush_caches
2627
 *
2628
 * Add custom cache tables to the list of cache tables that
2629
 * will be cleared by the Clear button on the Performance page or whenever
2630
 * drupal_flush_all_caches is invoked.
2631
 *
2632
 * @author W.Addink <waddink@eti.uva.nl>
2633
 *
2634
 * @return array
2635
 *   An array with custom cache tables to include.
2636
 */
2637
function cdm_api_flush_caches() {
2638
  return array('cache_cdm_ws');
2639
}
2640

    
2641
/**
2642
 * Logs if the drupal variable 'cdm_debug_mode' ist set true to drupal_debug.txt in the site's temp directory.
2643
 *
2644
 * @param $data
2645
 *   The variable to log to the drupal_debug.txt log file.
2646
 * @param $label
2647
 *   (optional) If set, a label to output before $data in the log file.
2648
 *
2649
 * @return
2650
 *   No return value if successful, FALSE if the log file could not be written
2651
 *   to.
2652
 *
2653
 * @see cdm_dataportal_init() where the log file is reset on each requests
2654
 * @see dd()
2655
 * @see http://drupal.org/node/314112
2656
 *
2657
 */
2658
function cdm_dd($data, $label = NULL) {
2659
  if(module_exists('devel') && variable_get('cdm_debug_mode', FALSE) && file_stream_wrapper_get_class('temporary') ){
2660
    return dd($data, $label);
2661
  }
2662
}
2663

    
Add picture from clipboard (Maximum size: 40 MB)