EDIT

<?php

/**

 * @file

 * Functions which are required or useful when accessing and processing CDM Data Store Webservices

 * ----------------------

 * Copyright (C) 2007 EDIT

 */

require_once ('xml2json.php');

  $requirements['cdm_api'] = array(

    'title' => t('CDM API')

  );

  if( function_exists('curl_init') ){

  $items = array();

  if ($may_cache) {

      'callback' => 'proxy_content',

      'access' => true,

      'type' => MENU_CALLBACK,

      'callback' => 'setvalue_session',

      'access' => true,

      'type' => MENU_CALLBACK,

    );

 * Implementation of hook_cron().

 *

 * Expire outdated cache entries

 */

function cdm_api_cron() {

  cache_clear_all(NULL, 'cache_cdm_ws');

}

  return array(

      'administer cdm_api'

/**

 * @param String $tag

  $i = 0;

  foreach($taggedtxt as $tt){

    if(!in_array($tt->type, $skiptags) && strlen($tt->text) > 0){

  }

  return $out;

/**

 * @param array $taggedtxt

 * @param string $tag_type

    if($tagtxt->type == $tag_type)

 * Returns the currently classification tree in use

 */

  if(is_uuid($_SESSION['cdm']['taxonomictree_uuid']) ){

    return $_SESSION['cdm']['taxonomictree_uuid'];

  } else {

}

function switch_to_taxonomictree_uuid($taxonomictree_uuid){

  $_SESSION['cdm']['taxonomictree_uuid'] = $taxonomictree_uuid;

}

function reset_taxonomictree_uuid($taxonomictree_uuid){

  unset($_SESSION['cdm']['taxonomictree_uuid']);

}

  $_SESSION['cdm']['taxon_page_tab'] = $taxonPageTab;

}

function get_last_taxon_page_tab(){

    return false;

  }

/**

 * media Array [4]

 *   representations Array [3]

 *       mimeType  image/jpeg

 *       representationParts Array [1]

 *           duration  0

 *           heigth  0

 *           size  0

 *           uri http://wp5.e-taxonomy.eu/dataportal/cichorieae/media/protolog/jpeg/Acanthocephalus_p1.jpg

 *           uuid  15c687f1-f79d-4b79-992f-7ba0f55e610b

 *           width 0

 *       suffix  jpg

 *       uuid  930b7d51-e7b6-4350-b21e-8124b14fe29b

 *   title

 *   uuid  17e514f1-7a8e-4daa-87ea-8f13f8742cf9

 *

 * @param unknown_type $width

 * @param unknown_type $height

 * @return unknown

 */

  }

    // getRepresentationByMimeType

    $mimeType = array_shift($mimeTypes);

      if(!$representation->mimeType){

        if(isset($representation->parts[0])){

          $representation->mimeType = infer_mime_type($representation->parts[0]->uri);

        }

      }

        $mimeTypes = array();

        $dwa = 0;

        // look for part with the best matching size

          if($dw < 0){

            $dw *= -1;

          }

          $dwa+= $dw;

        $prefRepr[$dwa.'_'.$mimeTypeKey] = $representation;

  // sort

  krsort($prefRepr);

  // return

  return $prefRepr;

}

 * Infers the mime type of a file using the filename extension.

 * @return the mimetype to the file or false if the according mime type could not be found

 */

function infer_mime_type($filepath){

  if(!$mimemap){

    $mimemap = array(

      'jpg'=>'image/jpeg',

      'jpeg'=>'image/jpeg',

      'png'=>'image/png',

      'gif'=>'image/gif',

      'giff'=>'image/gif',

      'tif'=>'image/tif',

      'html'=>'text/html',

      'htm'=>'text/html'

    );

  }

  $extension = substr($filepath, strrpos($filepath, '.') + 1);

  if(isset($mimemap[$extension])){

    return $mimemap[$extension];

  } else {

    return 'text/html'; //FIXME remove this hack just return false;

  }

 * of the form yyyy-MM-dd and returns the year as String.

 *

 * @return String

function partialToYear($partial){

      return $year;

/**

 * In case the month is unknown (= ???) null is returned.

 *

 * @return String

function partialToMonth($partial){

    $month = substr($partial, 5, 2);

    if($month != '??'){

      return $month;

    }

/**

 * In case the day is unknown (= ???) null is returned.

 *

 * @return String

function partialToDay($partial){

    $day = substr($partial, 7, 2);

    if($day != '??'){

      return $day;

    }

 * @param $pathParameters an array of path elements, or a single element

 * @param $query  A query string to append to the URL.

 * @return unknown_type

    $pathParameters = array();

  }

  $path_params = '';

  /* (1)

   * substitute all place holders ($0, $1, ..) in the

   */

  static $helperArray = array();

    $pathParameters = $helperArray;

  }

  while(strpos($uri_pattern, "$".$i) !== FALSE){

   * Append all remaining element of the $pathParameters array as path elements

   */

  if(count($pathParameters) > $i){

    // strip trailing slashes

      $uri_pattern = substr($uri_pattern, 0, strlen($uri_pattern) - 1);

    while(count($pathParameters) > $i){

   * Append the query string supplied by $query

   */

  if (isset($query)) {

    $uri_pattern .= (strpos($uri_pattern, '?') !== FALSE ? '&' : '?') . $query;

  return $uri;

  $uri = urldecode($uriEncoded);

    foreach($args as &$arg){

        $arg = unserialize($arg);

      }

      //find comma sepatated string in all args

//  		$arg = explode(',', $arg);

//  	}

    foreach ($parameters as $k=>$v)

    {

    $post_data = implode(',', $post_data);

    header('Content-Type: '.$theme);

    exit;

  } else {

    //TODO reconsider caching logic in this function

    if(!$theme){

      // print out JSON, the cache cannot be used since it contains objects

      foreach($http_response->headers as $hname=>$hvalue) {

        drupal_set_header($hname . ":" . $hvalue);

      }

      print $http_response->data;

      print call_user_func_array('theme', $args);

    }

  } else {

  // prevent from malicous tags

  $i = 0;

  foreach($keys as $key){

    $hasMoreKeys = ++$i < count($var);

    if($hasMoreKeys && (!isset($var[$key]) || !is_array($var[$key]))){

      $var[$key] = array();

    }

    $var = &$var[$key];

  }

  $var = $val;

  // usage: url('cdm_api/proxy/'.urlencode($content_url)."/$theme");)

  return url('cdm_api/proxy/'.urlencode($uri).($theme?"/$theme":''));

}

        return;

    }

        case 'TaxonBase':

        case 'Taxon':

        case 'Synonym':

            $ws_base_uri = CDM_WS_TAXON;

            break;

        case 'TaxonNameBase':

        case 'NonViralName':

        case 'BacterialName':

        case 'BotanicalName':

        case 'CultivarPlantName':

        case 'ZoologicalName':

        case 'ViralName':

            $ws_base_uri = CDM_WS_NAME;

            break;

        case 'Media':

            $ws_base_uri = CDM_WS_MEDIA;

            break;

            $ws_base_uri = CDM_WS_REFERENCE;

            break;

        case 'TextData':

        case 'TaxonInteraction':

        case 'QuantitativeData':

        case 'IndividualsAssociation':

        case 'Distribution':

        case 'CommonTaxonName':

          break;

        case 'MediaKey':

        case 'MultiAccessKey':

          $ws_base_uri{0} = strtolower($ws_base_uri{0});

    }

 * Enter description here...

 *

 * @param String $resourceURI

 * @param pageSize

 *            the maximum number of entities returned per page (can be null

 *            to return all entities in a single page)

 * @param pageNumber

 *            the number of the page to be returned, the first page has the

 *            pageNumber = 1

 * @return unknown

 */

function cdm_ws_page($resourceURI, $pageSize, $pageNumber){

//  $viewrank =  _cdm_taxonomy_compose_viewrank();

//  return CDM_WS_PORTAL_TAXONOMY . '/' . ($viewrank ? $viewrank : '' ) . ($path ? '/' . $path : '') ;

//}

/**

 * Enter description here...

 *

 * @param unknown_type $secUuid

 * @param unknown_type $path

 * @return unknown

 */

  $rankUuid = variable_get('taxontree_ranklimit', DEFAULT_TAXONTREE_RANKLIMIT);

  if($taxonUuid){

    return cdm_compose_url(CDM_WS_PORTAL_TAXONOMY_CHILDNODES_OF_TAXON, array($viewUuid, $taxonUuid));

  } else {

    if($rankUuid){

      return cdm_compose_url(CDM_WS_PORTAL_TAXONOMY_CHILDNODES_AT_RANK, array($viewUuid, $rankUuid));

    } else {

      return cdm_compose_url(CDM_WS_PORTAL_TAXONOMY, array($viewUuid));

    }

  }

    $response = null;

    $response = cdm_ws_get(cdm_compose_taxonomy_path($taxonUuid), null, null, null, TRUE);

      // error handing

      if(is_uuid($_SESSION['cdm']['taxonomictree_uuid'])) {

        // delete the session value and try again with the default

        unset($_SESSION['cdm']['taxonomictree_uuid']);

        return cdm_ws_taxonomy($taxonUuid);

      } else {

        // check if taxonomictree_uuid is valid

        $test = cdm_ws_get(cdm_compose_taxonomy_path(), null, null, null, TRUE);

      }

    }

/**

 * Enter description here...

 *

 * @param UUID $secUuid

 * @param String $path

 * @return unknown

 */

  }

    if(is_uuid($_SESSION['cdm']['taxonomictree_uuid'])) {

      // delete the session value and try again with the default

      unset($_SESSION['cdm']['taxonomictree_uuid']);

      return cdm_ws_taxonomy_pathFromRoot($taxonUuid);

    } else {

        // check if taxonomictree_uuid is valid

        if($test == null){

        }

  return cdm_Vocabulary_as_option(UUID_RANK);

}

    if(!isset($vocabularyOptions[$vocabularyUuid])){

      $vocab = cdm_ws_get(CDM_WS_TERMVOCABULARY, $vocabularyUuid);

      $vocabularyOptions[$vocabularyUuid] = array();

      if($vocab){

        foreach($vocab->terms as $term){

            $vocabularyOptions[$vocabularyUuid][$term->uuid] = call_user_func($term_label_callback, $term);

          } else {

	        $vocabularyOptions[$vocabularyUuid][$term->uuid] = t($term->representation_L10n);

          }

        array_reverse($vocabularyOptions[$vocabularyUuid]);

  }

  if(isset($term->representation_L10n_abbreviatedLabel)) {

    return $term->representation_L10n_abbreviatedLabel . ' : ' . t($term->representation_L10n);

  } else {

    return t($term->representation_L10n);

  }

}

  }

  $mergedTrees = array();

    // merge any description into a sparate feature tree

    foreach($descriptions as $desc){

      $mergedTree->root->children = $mergedNodes;

      $mergedTrees[] = $mergedTree;

    }

  } else {

    // combine all descripions into one feature tree

    foreach($descriptions as $desc){

    }

    $mergedTrees[] = $featureTree;

  }

  return $mergedTrees;

 * @param $cdmBase

 * @return an array or empty

 */

    if($annotationUrl){

      $annotationPager = cdm_ws_get($annotationUrl, null, null, null, true);

      if(is_array($annotationPager->records)){