analyzedphenotypes.module

<?php

/**
 * @file
 * The main functionality of this module.
 */



// Include system variables API.
module_load_include('inc', 'analyzedphenotypes', 'api/analyzedphenotypes.systemvars.api');
// Include general API and helper functions.
module_load_include('inc', 'analyzedphenotypes', 'api/analyzedphenotypes.api');

// Include Tripal/Chado support API.
module_load_include('inc', 'analyzedphenotypes', 'api/analyzedphenotypes.trait.api');
module_load_include('inc', 'analyzedphenotypes', 'api/analyzedphenotypes.cv.api');
module_load_include('inc', 'analyzedphenotypes', 'api/analyzedphenotypes.genus.api');
module_load_include('inc', 'analyzedphenotypes', 'api/analyzedphenotypes.projects.api');
module_load_include('inc', 'analyzedphenotypes', 'api/analyzedphenotypes.database.api');
module_load_include('inc', 'analyzedphenotypes', 'api/analyzedphenotypes.tripaljob.api');
module_load_include('inc', 'analyzedphenotypes', 'api/analyzedphenotypes.ontology.api');

// Materialized views, data summary.
module_load_include('inc', 'analyzedphenotypes', 'api/analyzedphenotypes.materializedview.api');

// Expected, downloadable, header combinationns - column headers.
module_load_include('inc', 'analyzedphenotypes', 'api/analyzedphenotypes.columnheaders.api');
// Field names.
module_load_include('inc', 'analyzedphenotypes', 'api/analyzedphenotypes.formfields.api');

// Unit and data types.
module_load_include('inc', 'analyzedphenotypes', 'api/analyzedphenotypes.datatype.api');
// Validators.
module_load_include('inc', 'analyzedphenotypes', 'includes/analyzedphenotypes.validators');
// Fields.
module_load_include('inc', 'analyzedphenotypes', 'includes/TripalFields/analyzedphenotypes.fields');
module_load_include('inc', 'analyzedphenotypes', 'includes/TripalFields/hp__phenotypic_variability/hp__phenotypic_variability_formatterforms');
module_load_include('inc', 'analyzedphenotypes', 'includes/TripalFields/ncit__data/ncit__data_formatterforms');

/**
 * Implements hook_menu().
 */
function analyzedphenotypes_menu() {
  $items = array();

  // DATA SUMMARY:

  // Main menu items for phenotypes: shows a beanplot -select trait and project.
  $items['phenotypes'] = array(
    'title' => 'Phenotypes',
    'description' => 'Summarizes phenotypic data available.',
    'page callback' => 'analyzed_phenotypes_all_data_summary_page',
    'access arguments' => array('access analyzed phenotypes'),
    'file' => 'includes/analyzedphenotypes.summary.page.inc',
    'type' => MENU_NORMAL_ITEM,
  );

  // Violin Plot.
  $items['phenotypes/trait-distribution'] = array(
    'title' => 'Trait Distribution Plot',
    'description' => 'Summarizes phenotypic data for a given trait and project.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('analyzedphenotypes_traitplot_app_form'),
    'access arguments' => array('access analyzed phenotypes'),
    'file' => 'includes/analyzedphenotypes.traitplot.page.inc',
    'type' => MENU_NORMAL_ITEM,
  );

  $items['json/phenotypes/traitplot/%/%/%/%'] = array(
    'page callback' => 'analyzedphenotypes_traitplot_json',
    'page arguments' => array(3, 4, 5, 6),
    'access arguments' => array('access analyzed phenotypes'),
    'file' => 'includes/analyzedphenotypes.traitplot.page.inc',
    'type' => MENU_CALLBACK,
  );

  $tripal_extension_ap = 'admin/tripal/extension/analyzedphenotypes';

  // Main administrative pages for analyzed phenotypes.
  $items[$tripal_extension_ap] = array(
    'title' => 'Analyzed Phenotypes',
    'description' => 'Provides phenotypic trait pages, charts, upload and download for partially filtered (not raw) phenotypic data.',
    'access arguments' => array('administer tripal'),
  );


  // CONFIGURATION PAGE:

  $items[$tripal_extension_ap . '/setup'] = array(
    'title' => 'Set-up Ontologies',
    'description' => 'Set the controlled vocabularies to be used by this module, as well, as other options to customize it to your data.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('analyzedphenotypes_setup_form'),
    'access arguments' => array('administer tripal'),
    'file' => 'includes/analyzedphenotypes.configuration.page.inc',
    'weight' => 2,
    'type' => MENU_NORMAL_ITEM,
  );

  $items[$tripal_extension_ap . '/config'] = array(
    'title' => 'Configure',
    'description' => 'Customize the display of this module.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('analyzedphenotypes_config_form'),
    'access arguments' => array('administer tripal'),
    'file' => 'includes/analyzedphenotypes.configuration.page.inc',
    'weight' => 2,
    'type' => MENU_NORMAL_ITEM,
  );

  // FORM IMPLEMENTATIONS:

  // DOWNLOAD DATA.
  $items['phenotypes/download'] = array(
    'title' => 'Download Analyzed Phenotypic Data',
    'description' => 'Download Analyzed Phenotypic Data.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('analyzedphenotypes_downloaddata_form'),
    'access arguments' => array('access administration pages'),
    'file' => 'includes/analyzedphenotypes.downloaddata.page.inc',
    'weight' => 2,
    'type' => MENU_NORMAL_ITEM,
  );

  // MENU CALLBACK:


  // Generate data in JSON object.
  // Global menu callback used to generate JSON.
  $items[$tripal_extension_ap . '/json/%/%'] = array(
    'page callback' => 'analyzedphenotypes_data_json',
    'page arguments' => array(5, 6),
    'access arguments' => array('upload analyzed phenotypes'),
    'type' => MENU_CALLBACK,
  );

  $items[$tripal_extension_ap . '/phenotyped-stock/json/%/%'] = array(
    'page callback' => 'analyzedphenotypes_autocomplete_phenotyped_stock',
    'page arguments' => array(6,7),
    'access arguments' => array('access content'),
    'type' => MENU_CALLBACK,
  );

  // Generate validation result.
  $items[$tripal_extension_ap . '/validation_result/%/%'] = array(
    'page callback' => 'ap_report_validationresult',
    'page arguments' => array(5, 6),
    'access arguments' => array('upload analyzed phenotypes'),
    'type' => MENU_CALLBACK,
  );

  // Tripal Download Implementation.
  $items['phenotype/download/analyzed_phenotypic_data'] = array(
    'title' => 'Analyzed Phenotypic Data Download',
    'page callback' => 'trpdownload_download_page',
    'page arguments' => array('analyzedphenotypes_download'),
    'access arguments' => array('access administration pages'),
    'type' => MENU_CALLBACK,
  );


  return $items;
}


/**
 * Implements hook_permission().
 */
function analyzedphenotypes_permission() {
  return array(
    // Administer Tripal.
    'administer tripal' => array(
      'title' => t('Administer Tripal'),
    ),
    // Upload Analyzed Phenotypes.
    'upload analyzed phenotypes' => array(
      'title' => t('Upload Analyzed Phenotypic Data'),
    ),
    // Download Analyzed Phenotypes.
    'download analyzed phenotypes' => array(
      'title' => t('Download Analyzed Phenotypic Data'),
    ),
    // Access Analyzed Phenotypes.
    'access analyzed phenotypes' => array(
      'title' => t('Access Analyzed Phenotypic Data'),
    ),
  );
}


/**
 * Implements hook_theme().
 */
function analyzedphenotypes_theme($existing, $type, $theme, $path) {
  $items = array();

  // Form implementations:

  // Configuration form.
  $items['analyzedphenotypes_configuration_form'] = array(
    'template' => 'analyzedphenotypes_pages',
    'render element' => 'form',
    'path' => $path . '/theme',
  );

  // Data downloader.
  $items['analyzedphenotypes_downloaddata_form'] = array(
    'template' => 'analyzedphenotypes_pages',
    'render element' => 'form',
    'path' => $path . '/theme',
  );

  // Form table.
  $items['analyzedphenotypes_form_table'] = array(
    'render element' => 'form',
  );

  // Module page directory
  $items['analyzedphenotypes_admin_page_directory'] = array(
    'template' => 'analyzedphenotypes_pages',
    'render element' => 'form',
    'path' => $path . '/theme',
  );

  // Report errors generated by validators.
  $items['analyzedphenotypes_validator_report'] = array(
    'template' => 'analyzedphenotypes_validators',
    'path' => $path . '/theme',
  );

  // Phenotype Trait Summary Fields.
  $items['analyzedphenotypes_trait_summary_fields'] = array(
    'render element' => 'element',
  );


  return $items;
}


/**
 * Theme callback to render analyzedphenotypes_form_table field type.
 *
 * Credits to : Electronic Press
 * @link http://e9p.net/theming-drupal-7-form-elements-table. @endlink
 */
function theme_analyzedphenotypes_form_table(&$variables) {
  $form = $variables['form'];
  $rows = $form['rows'];
  $header = $form['#header'];

  // Setup the structure to be rendered and returned.
  $content = array(
    '#theme' => 'table',
    '#header' => $header,
    '#rows' => array(),
  );

  foreach (element_children($rows) as $row_index) {
    $row = array();

    foreach (element_children($rows[$row_index]) as $col_index) {
      $row[] = drupal_render($rows[$row_index][$col_index]);
    }

    // A row in the table.
    $content['#rows'][] = $row;
  }


  // Render the table and return.
  return drupal_render($content);
}


/**
 * Implements hook_preprocess().
 */
function analyzedphenotypes_preprocess_analyzedphenotypes_admin_page_directory(&$variables, $hook) {
  $variables['path_extension'] = 'admin/tripal/extension/analyzedphenotypes';
  $variables['directory'] = $variables['form']['#ap_admin_directory'];


  return $variables;
}

/**
 * Implements hook_libraries_info().
 *
 * Define external libraries: Spreadsheet Writer.
 */
function analyzedphenotypes_libraries_info() {
  // Spreadsheet writer.
  // Let Drupal decide where library is.
  $lib_writer = libraries_get_path('PHP_XLSXWriter_plus');

  $libraries['spreadsheet_writer'] = array(
    'name' => 'PHP_XLSXWriter_plus Spreadsheet Writer',
    'vendor url' => 'https://github.com/SystemDevil/PHP_XLSXWriter_plus',
    'version' => 1,
    'download url' => 'https://github.com/SystemDevil/PHP_XLSXWriter_plus/archive/master.zip',
    'library path' => $lib_writer,
    'files' => array('xlsxwriter.class.php'),
  );

  return $libraries;
}

/**
 * Used for autocomplete in forms for identifying stocks
 *
 * @param $string
 *   The string to search for.
 *
 * @return
 *   A json array of terms that begin with the provided string.
 *
 * @ingroup tripal_stock_api
 */
function analyzedphenotypes_autocomplete_phenotyped_stock($trait_id, $string = '') {
  $items = [];

  $sql = "
    SELECT
      B.stock_id as id, B.uniquename, B.name,
      O.genus, O.species,
      CVT.name as type
    FROM {stock} B
      INNER JOIN {organism} O ON O.organism_id = B.organism_id
      INNER JOIN {cvterm} CVT ON CVT.cvterm_id = B.type_id
    WHERE
      (lower(B.uniquename) like lower(:str)
        OR lower(B.name) like lower(:str))
      AND B.stock_id IN (SELECT stock_id from {mview_phenotype} WHERE trait_id=:trait)
    ORDER by B.name
    LIMIT 10 OFFSET 0
  ";
  $records = chado_query($sql, [':trait' => $trait_id, ':str' => $string . '%']);
  while ($r = $records->fetchObject()) {
    $key = "$r->name [id: $r->id]";
    $items[$key] = "$r->name ($r->uniquename, $r->type, $r->genus $r->species)";
  }

  drupal_json_output($items);

}

/**
 * Function callback: Convert query results or parameters suplied to an array of JSON object
 * and supply the result to field or form elements (ie. autocomplete form field, validation
 * progress etc.) that requires data in this notation.
 *
 * @param $page_argument_5
 *   A string indicating the source of call and what type of data is requested.
 *   #5 of the menu's page aruguments.
 *   eg. Projects, ontology etc.
 * @param $page_argument_6
 *   Additional parameter required.
 *   #6 of the menu's page aruguments.
 *   eg. Job Id when generating progress report for Job Status source type.
 * @param $key
 *   Default to null, value entered in a field (eg. autocomplete field).
 *
 * @return
 *   A JSON object.
 *
 * @see hook_menu() implementation - Generate data in JSON object, above that handles all page elements in this
 *   module that requires JSON.
 */
function analyzedphenotypes_data_json($page_argument_5, $page_argument_6, $key = null) {
  $data_JSON = array();

  $property = $page_argument_5;
  $parameter = $page_argument_6;

  switch($property) {
    //
    case 'projects':
      // Fetch project/experiment that matches a keyword in AP data loader
      // Select experiment autocomplete form field in:
      //   admin.form.inc - analyzedphenotypes_loader_form_upload() : Stage #1 - Select experiment, genus and upload file.
      // Parameters:
      //   $page_argument_5 : projects.
      //   $page_argument_6 : experiment.
      //   $key : Keyword enterd in the field.
      $data_JSON = array();

      // Pattern match projects, return the first 10.
      $projectprop = ap_match_projectname(
        array('key' => $key),
        array('fullmatch' => FALSE, 'limitrows' => 10)
      );

      if ($projectprop) {
        foreach($projectprop as $id => $name) {
          $data_JSON[$name] = $name;
        }
      }

      break;

    //
    case 'jobstatus':
      // Update job status of a Tripal Job request in AP data loader page in:
      //   admin.form.inc - analyzedphenotypes_loader_form_validates() : Stage #2 - Validate data.
      //   admin.form.inc - analyzedphenotypes_loader_form_save() : Stage #4 - Save Data.
      // Parameters:
      //   $page_argument_5 : jobstatus.
      //   $page_argument_6 : Tripal Job job id number.
      //   $key : null.
      $data_JSON = array();

      $job = ap_get_tripaljob($parameter);

      if ($job) {
        $job_status = strtolower(trim($job['status']));

        if ($job_status == 'completed') {
          // Job completed, return completed!
          // Set job to completed - 100%.
          $progress = 100;
          $message  = 'Completed';

          if ($job['progress'] != $progress) {
            ap_update_tripaljob_progress($parameter, $progress);
          }
        }
        else {
          // Job not complete. Next percent to pass on to the progress bar.
          // Percent written by write function called in validators.
          $tripal_jobprop = ap_read_tripaljob_progress($parameter, 'jobprogress');

          $progress = (empty($tripaljobprop)) ? '...' : trim($tripaljobprop);
          $message = ($progress == '100' || $job['status'] == $job_status)
            ? 'Completed' : $job['status'];
        }

        $data_JSON = array(
          'percentage' => $progress,
          'message' => $message,
        );
      }

      break;

    //
    case 'ontology':
      // Fetch otology terms that matches a keyword in AP data loader
      // Enter ontology term autocomplete form feild in:
      //   admin.form.inc - analyzedphenotypes_loader_form_describe() : Stage #3 - Describe Traits.
      // Parameters:
      //   $page_argument_5 : ontology.
      //   $page_argument_6 : genus ontology (on) configuration settings.
      //   $key : null.
      $data_JSON = array();

      // Fetch terms in a cv.
      $ontology_suggestions = ap_get_cvterm(
        array('keyword' => $key, 'genus' => $parameter),
        array('dataset' => 'cvtermidname')
      );

      // Limit the result shown to 10. This will
      // prevent a long list that will break the layout since
      // Drupal does not add a scrollbars to drop select when
      // it is long list.
      $suggest_limit = 10;

      foreach($ontology_suggestions as $i => $term) {
        $data_JSON[ $term['name'] ] = $term['name'];

        if ($i == $suggest_limit) break;
      }

      break;

    //
    case 'cvterms':
      // Fetch controlled vocabulary terms that matches a keyword in AP data loader
      // configuration page term autocomplete form field in:
      //   admin.form.inc - analyzedphenotypes_admin_settings().
      // Parameters:
      //   $page_argument_5 : cvterms.
      //   $page_argument_6 : cv.
      //   $key : Keyword entered in the field.
      $data_JSON = array();

      // Fetch all terms that match a keyword. No conditions to scope of search.
      $cvterms = ap_get_cvterm(
        array('keyword' => $key),
        array('dataset' => 'namecvname_format')
      );

      // Limit the result shown to 10. This will
      // prevent a long list that will break the layout since
      // Drupal does not add a scrollbars to drop select when
      // it is long list.
      $suggest_limit = 10;

      foreach($cvterms as $i => $term) {
        $data_JSON[ $term['namecvname'] ] = $term['namecvname'];

        if ($i == $suggest_limit) break;
      }

      break;

    //
    case 'germplasm':
      $field_values = unserialize($parameter);

      foreach($field_values as $i => $g) {
        $data_JSON[$g] = $g;
      }

      break;

    //
    case 'traitunit':
      // Fetch all units.
      $units = ap_define_datatypes();

      // Only the ones that have the keyword get suggested
      // to the unit field in describe trait.
      foreach($units as $u => $i) {
        if (stristr($u, $key)) {
          // Has the keyword?
          $data_JSON[$u] = $u . ' (' . $i['name'] . ')';
        }
      }

      break;

    //
    case 'projectgenus':
      // Fetch the genus of of the project if it
      // has been previously set.
      $project_name = strip_tags($parameter);

      if ($project_name) {
        $project_genus = ap_get_projectgenus(
          array('project_name' => $project_name)
        );

        if ($project_genus) {
          $data_JSON['genus'] = $project_genus;
        }
      }

      break;

    //
    // Define additional case here.

    // default:
  }


  print drupal_json_output($data_JSON);

  // Do not show the Drupal headers and formatting.
  // This is critical as if anything else is printed to the screen you will see
  // an AJAX error instead of your progress bar ;-).
  exit();
}


// TRIPAL DOWNLOAD API IMPLEMENTATION

/**
 * Implements hook_register_tripaldownload_type().
 */
function analyzedphenotypes_register_trpdownload_type() {
  $types = array();

  // The key is the machine name of my download type.
  $types['analyzedphenotypes_download'] = array(
    // A human readable name to show in an administrative interface one day.
    'type_name' => 'Analyzed Phenotypic Data Download',
    // A human readable description of the format.
    'format' => '',
    // An array of functions that the API will use to customize your experience.
    'functions' => array(
      // The function that tripal jobs will call to generate the file.
      'generate_file' => 'analyzedphenotypes_trpdownload_generate_file',
      // OPTIONAL: provide a summary to the user on the download page.
      'summarize' => 'analyzedphenotypes_trpdownload_summarize_download',
      // OPTIONAL: determine your own filename.
      'get_filename' => 'analyzedphenotypes_trpdownload_get_filename',
      // OPTIONAL: Change the file suffix (defaults to .txt)
      'get_file_suffix' => 'analyzedphenotypes_trpdownload_get_suffix',
      // OPTIONAL: determine the human-readable format based on a function.
      'get_format' => 'analyzedphenotypes_trpdownload_get_readable_format',
    ),
  );


  return $types;
}

/**
 * Generate a readable and unique filename for the file to be generated.
 */
function analyzedphenotypes_trpdownload_get_filename($vars) {
  // Filename.
  $filename = 'analyzed_phenotypic_data_download' . date('YMd') .'_'. time();


  return $filename;
}

/**
 * determine the human-readable format based on a function.
 */
function analyzedphenotypes_trpdownload_get_readable_format($vars) {
   // File Extension from file type field options.
  foreach($vars as $l => $v) {
    if(is_array($v)) {
      foreach($v as $j => $m) {
        if ($j == 'code') {
          $code = $m;
        }
      }
    }
  }

  $v = base64_decode($code);

  if (!empty($v)) {
    // Field names.
    $fldname = ap_construct_download_fieldnames();
    $filters = explode('&', $v);

    foreach($filters as $i) {
      list($filter, $value) = explode('=', $i);

      if ($filter == $fldname['filetype']['base']) {
        $file_type = trim($value);
        break;
      }
    }

    switch($file_type) {
      case 'tsv':
        $format = 'Tab Separated Values (.tsv)';
        break;

      case 'csv':
        $format = 'Comma Separated Values (.csv)';
        break;

      case 'xlsx':
        $format = 'Microsoft Excel Spreadsheet (.xlsx)';
        break;
    }


    return $format;
  }
}

/**
 * Determine the file suffix for the file to be generated.
 */
function analyzedphenotypes_trpdownload_get_suffix($vars) {
  // File Extension from file type field options.
  foreach($vars as $l => $v) {
    if(is_array($v)) {
      foreach($v as $j => $m) {
        if ($j == 'code') {
          $code = $m;
        }
      }
    }
  }

  $v = base64_decode($code);

  if (!empty($v)) {
    // Field names.
    $fldname = ap_construct_download_fieldnames();
    $filters = explode('&', $v);

    foreach($filters as $i) {
      list($filter, $value) = explode('=', $i);

      if ($filter == $fldname['filetype']['base']) {
        $file_type = trim($value);
        break;
      }
    }


    return $file_type;
  }
}


/**
 * Function callback: generate csv file.
 */
function analyzedphenotypes_trpdownload_generate_file($vars, $job_id = NULL) {
  // Use this character to separate entries in a string.
  $delimiter = '~';

  $code = '';
  foreach($vars['q'] as $j => $m) {
    if ($j == 'code') {
      $code = $m;
      break;
    }
  }
  $filename = $vars['filename'];

  // Start extracting filters.
  if (empty($code) && empty($filename)) {
    die('Could not generate file. No filters selected.');
  }
  else {
    // Filters selected.
    $v = base64_decode($code);

    if (empty($v)) {
      die('Could not generate file. No filters selected.');
    }
    else {
      // Convert the query string to key and value pair.
      // Key should still match field name returned by _fieldnames().
      // FILTER or FORM FIELD VALUE.
      $filters = explode('&', $v);
      $filter_value = array();

      foreach($filters as $i) {
        @list($filter, $value) = explode('=', $i);

        // Field name = Value selected.
        $filter_value[$filter] = $value;
      }
      print "Parameters include: " . print_r($filter_value, TRUE);

      // Global/standard field names used in form, submit etc.
      // experiment, genus, species, traits, year, location, germplasmtype,
      // missingdata, filetype, averagerep, rfriendly, columnheaders
      $fldname = ap_construct_download_fieldnames();
      // File type field name value.
      $file_type = $filter_value[ $fldname['filetype']['base'] ];

      // Fetch all valid file types for download.
      // Use the result to ensure that only these registered types are allowed.
      $d = ap_define_datafile_extensions('file_download');
      $download_type = array_keys($d);

      if (in_array($file_type, $download_type)) {
        // TSV, CSV or XLSX.

        // This array will hold datapoints for write-to-file.
        $to_write = array();

        // Start by reading the column headers field. This contains the headers
        // programmatically picked and/or selected by user. In addition, this
        // contains the set of columns required as well as the order it appears in file.

        // FILTER/FIELD NAME: columnheaders.
        $h = $filter_value[ $fldname['columnheaders']['base'] ];
        // Entries are delimited by $delimeter value, break it to individual unit.
        $g = explode($delimiter, $h);
        $column_headers_picked = array_map('trim', $g);

        // Save indicies of important columns.
        $i_expt = array_search('Experiment', $column_headers_picked);
        $i_germ = array_search('Germplasm Name', $column_headers_picked);
        $i_year = array_search('Year',  $column_headers_picked);
        $i_locn = array_search('Location',  $column_headers_picked);
        $coli = array_flip( $column_headers_picked );

        // Make a blank row.
        $blank_row = array_keys($column_headers_picked);
        foreach($blank_row as $k => $v) { $blank_row[$k] = ''; }

        // Make a clone copy of this array.
        $tmp_column_headers_picked = $column_headers_picked;

        // Does user want it RFriendly-ied?
        // FILTER/FIELD NAME: rfriendly.
        if ($filter_value[ $fldname['rfriendly']['base'] ]) {
          $column_headers_picked_rfriendly = array();

          foreach($column_headers_picked as $col) {
            $col = trim($col);

            if (!empty($col)) {
              $rf = ap_convert_rcolumnheader($col);
              $column_headers_picked_rfriendly[] = $rf;
            }
          }

          // Reset the original column headers and use this rfriendly version.
          unset($column_headers_picked);
          $column_headers_picked = $column_headers_picked_rfriendly;
        }

        // The first item to write are the column headers.
        $to_write[] = $column_headers_picked;

        // Fetch dataset for a given filters.
        $filters = $filter_value;

        // Match field to actual chado column names.
        // Limit rows to project, trait, year, location, germplasm type and germplasm.
        $column = array(
          $fldname['experiment']['base']    => 'mp.experiment_id',
          $fldname['traits']['base']        => "mp.trait_id||','||mp.method_id||','||mp.unit_id",
          $fldname['germplasmtype']['base'] => 's.type_id',
          $fldname['year']['base']          => 'mp.year',
          $fldname['location']['base']      => 'mp.location',
          // As entered in the germplasm field.
          $fldname['germplasm']['base']     => "CONCAT(s.name, ' (', s.uniquename, ')')",
        );

        $limit = array();
        foreach($column as $filter => $col) {
          $filter_val = $filters[$filter];

          // Convert filter so chado_query arguments (:placeholder = value).
          // Exclude filter with value = all.
          if ($filter_val != 'all') {
            $placeholder = ':' . $filter;

            $limit['limit'][] = $col . ' IN (' . $placeholder . ')';
            $limit['args'][$placeholder] = explode($delimiter, $filter_val);
          }
        }
        $limit['limit'] = implode(' AND ', $limit['limit']);

        // If the user selected optional columns then we need to add them to the query...
        // (e.g. origin, data collector).
        // @todo currently the column headers functionality seems broken...

        // Get ready to compile the file.
        // Each row from the following SQL query is a trait-value cell in the resulting file.
        // As such we need to loop over multiple results to compile a single row...
        // The query is sorted to allow us to do this.
        // Variable to hold the current row as we compile it.
        $cur_row = $blank_row;
        $cur_row_key = NULL;
        // Finally, our query uses the phenotype mview for better performance.
        $sql = "
          SELECT
            mp.experiment_id, mp.experiment_name,
            mp.trait_id||','||mp.method_id||','||mp.unit_id as trait_key,
            mp.trait_name, mp.method_name, mp.unit_name,
            s.stock_id, mp.stock_name,
            mp.location, mp.year,
            mp.values
          FROM {mview_phenotype} mp
	          LEFT JOIN {stock} s ON s.stock_id=mp.stock_id
          WHERE " . $limit['limit'] . "
          ORDER BY experiment_id ASC, location ASC, year ASC, stock_name ASC
        ";
        $result = chado_query($sql, $limit['args']);
        // Now, for each result from the query...
        foreach($result as $r) {

          // Is this a new row?
          $result_key = implode($delimiter, array($r->experiment,$r->stock_id,$r->location,$r->year));
          // If it is a new row then we need to...
          if ($cur_row_key !== $result_key) {

            // 1) Save the last row...
            if ($cur_row != $blank_row) {
              ksort($cur_row);
              $to_write[] = $cur_row;
            }

            // 2) initialize it.
            $cur_row_key = $result_key;
            $cur_row = $blank_row;
            if ($i_expt !== FALSE) { $cur_row[$i_expt] = $r->experiment_name; }
            $cur_row[$i_germ] = $r->stock_name;
            $cur_row[$i_locn] = $r->location;
            $cur_row[$i_year] = $r->year;
          }

          // Add the current trait to the row.
          // The values are storaged as a JSON array so first convert them.
          $values = json_decode($r->values);
          if (is_array($values)) {
            $value = array_sum($values)/count($values);
            $value = round($value, 2);

            $full_trait_name = $r->trait_name.' ('.$r->method_name.'; '.$r->unit_name.')';
            $i_trait = $coli[$full_trait_name];
            $cur_row[$i_trait] = $value;
          }
          else {
            // @todo  add an error message here.
          }
        }

        if ($to_write) {
          analyzedphenotypes_trpdownload_writefile($filename, $to_write, $file_type);
        }
      }
      else {
        // File type not supported.
        die('Could not generate file. File type not supported.');
      }
    //
    }
  }
}

/**
 * FUNCTION GENERATE FILE.
 * Create a tsv, csv and xlsx file.
 *
 * @param $filename
 *   String, destination filename.
 * @param $data_rows
 *   An array containing the headers (index 0) and data points to write to a file.
 * @param $file_type
 *   String, indicating the type of file (tsv, csv, xlsx).
 */
function analyzedphenotypes_trpdownload_writefile($filename, $data_rows, $file_type) {
  $filepath = variable_get('trpdownload_fullpath', '') . $filename;

  switch($file_type) {
    //
    case 'tsv':
    //
    case 'csv':
      $FILE = fopen($filepath, 'w') or die ('Unable to create file to write to...');

      foreach($data_rows as $row) {
        if ($file_type == 'tsv') {
          fputcsv($FILE, $row, "\t");
        }
        else {
          fputcsv($FILE, $row);
        }
      }

      fclose($FILE);

      break;

    //
    case 'xlsx':
      // Load spreadsheet writer library.
      $xlsx_writer = libraries_load('spreadsheet_writer');
      include_once $xlsx_writer['library path'] . '/'. $xlsx_writer['files'][0];

      $writer = new XLSXWriter();
      @$writer->writeSheet($data_rows, 'measurements', array(), array());
      $writer->writeToFile($filepath);

      break;
  }
}


// AP TRAIT SUMMARY FIELDS:


/**
 * Implementes hook_field_group_formatter_info().
 * Define field group.
 * Credits to: https://www.drupal.org/node/1017962
 */
function analyzedphenotypes_field_group_formatter_info() {
  $info = array();

  // Field group of type: traitsummary.
  $settings = array(
    'traitsummary' => array(
      'label' => t('Analyzed Phenotypes Data Summary'),
      'description' => t('This fieldgroup renders the Analyzed Phenotypes Data Summary with the field title as an item'),
      'instance_settings' => array(
        'id' => '',
        'classes' => '',
      )
    )
  );

  // Form and Display key the same.
  $info = array(
    'form' => $settings,
    'display' => $settings,
  );


  return $info;
}


/**
 * Implements hook_field_group_format_settings().
 * Form elements format settings, add validation callback, js handler etc. here
 */
function analyzedphenotypes_field_group_format_settings($group) {
  $form = array();

  if ($group->format_type == 'traitsummary') {
    // Apply additional settings here:
    $form['instance_settings'] = array('weight' => 1);
  }


  return $form;
}


/**
 * Implements hook_field_group_pre_render().
 * Create wrapper field, add js, css and cool stuff.
 */
function analyzedphenotypes_field_group_pre_render(&$element, $group, &$form) {
  if ($group->format_type == 'traitsummary') {
    // Refer to this element for any styling.
    $wrapper_id = 'ap-trait-summary-field-wrapper';

    // Wrap the content type to div wrapper.
    $element['#prefix'] = '<div id="' . $wrapper_id . '">';
    $element['#suffix'] = '<div class="bg">&nbsp;</div></div>';

    // Use the function callback to override theme used to field.
    $element['#theme_wrappers'] = array('analyzedphenotypes_trait_summary_fields');
  }
}


/**
 * Implements hook_field_group_build_pre_render_alter().
 * Apply css and js.
 * NOTE: does not seem to work when attached to other hooks above.
 */
function analyzedphenotypes_field_group_build_pre_render_alter(&$element) {
  $ap_path = drupal_get_path('module', 'analyzedphenotypes') . '/theme/';

  $element['#attached']['js'][]  = $ap_path . 'js/analyzedphenotypes.trait.summary.fieldgroup.js';
  $element['#attached']['css'][] = $ap_path . 'css/analyzedphenotypes.trait.summary.fieldgroup.css';
}


/**
 * Function callback: Theme the items.
 */
function theme_analyzedphenotypes_trait_summary_fields($variables) {
  $element = $variables['element'];

  $markup = '
    <div class="container-data-category">
      <div class="container-round-icon">
        <div class="data-icon">
          <img src="%s" height="45" widht="40" alt="%s" title="%s" />
        </div>
      </div>

      <div class="container-data-text">
        <em>%s</em>
      </div>
    </div>';

  $output = '';

  foreach (element_children($element) as $e) {
    $field_title = $element[$e]['#title'];
    $field_value = current($element[$e]['#items'][0]['value']);

    $raw_value_title = number_format($field_value['count']) . ' ' . $field_title;
    $value = ap_shortval($field_value['count']) . ' ' . $field_title;
    $image = file_create_url($field_value['image']);

    $output .= sprintf($markup, $image, $raw_value_title, $raw_value_title, $value);
  }


  return $output;
}