tripal/tripal_chado/includes/TripalFields/sio__references/sio__references.inc

<?php

class sio__references extends ChadoField {


  // --------------------------------------------------------------------------
  //                     EDITABLE STATIC CONSTANTS
  //
  // The following constants SHOULD be set for each descendent class.  They are
  // used by the static functions to provide information to Drupal about
  // the field and it's default widget and formatter.
  // --------------------------------------------------------------------------

  // The default label for this field.
  public static $default_label = 'References';

  // The default description for this field.
  public static $description = 'Records references by this publication.';

  // Provide a list of instance specific settings. These can be accessed within
  // the instanceSettingsForm.  When the instanceSettingsForm is submitted
  // then Drupal will automatically change these settings for the instance.
  // It is recommended to put settings at the instance level whenever possible.
  // If you override this variable in a child class be sure to replicate the
  // term_name, term_vocab, term_accession and term_fixed keys as these are
  // required for all TripalFields.
  public static $default_instance_settings = [
    // The short name for the vocabulary (e.g. schema, SO, GO, PATO, etc.).
    'term_vocabulary' => 'SIO',
    // The name of the term.
    'term_name' => 'references',
    // The unique ID (i.e. accession) of the term.
    'term_accession' => '000631',
    // Set to TRUE if the site admin is allowed to change the term
    // type. This will create form elements when editing the field instance
    // to allow the site admin to change the term settings above.
    'term_fixed' => FALSE,
    // The table in Chado that the instance maps to.
    'chado_table' => 'pub',
    // The primary key column of hte table in Dhado.
    'chado_column' => 'pub_id',
    // The base table.
    'base_table' => 'pub',
    // The number of items to show on a page.
    'items_per_page' => 10,
  ];

  // The default widget for this field.
  public static $default_widget = 'sio__references_widget';

  // The default formatter for this field.
  public static $default_formatter = 'sio__references_formatter';

  // A boolean specifying that users should not be allowed to create
  // fields and instances of this field type through the UI. Such
  // fields can only be created programmatically with field_create_field()
  // and field_create_instance().
  public static $no_ui = FALSE;


  /**
   * @see TripalField::elementInfo()
   */
  public function elementInfo() {
    $field_term = $this->getFieldTermID();
    return [
      $field_term => [
        'operations' => [],
        'sortable' => FALSE,
        'searchable' => FALSE,
        'type' => 'xs:string',
        'readonly' => TRUE,
      ],
    ];
  }

  /**
   *
   * @see TripalField::load()
   */
  public function load($entity) {

    $field_name = $this->field['field_name'];
    $field_type = $this->field['type'];
    $field_table = $this->instance['settings']['chado_table'];
    $field_column = $this->instance['settings']['chado_column'];
    $base_table = $this->instance['settings']['base_table'];

    // Set some defaults for the empty record.
    $chado_record = $entity->chado_record;
    $entity->{$field_name}['und'][0] = [
      'value' => '',
    ];

    // Iterate through all of the _pub tables and look for any that have
    // linked to this record. If so then add them.
    $chado_tables = chado_get_table_names(TRUE);
    $delta = 0;
    foreach ($chado_tables as $chado_table) {
      $matches = [];
      if (preg_match('/^(.+?)_pub$/', $chado_table, $matches)) {

        $reference_table = $matches[1];

        // Get the schema for the pub linker table table.
        $schema = chado_get_schema($chado_table);

        // Skip tables that don't have a foreign key definition.
        if (!array_key_exists('foreign keys', $schema)) {
          continue;
        }

        // Get information about the linking table.
        $fkeys = $schema['foreign keys'];
        $fkleft = NULL;
        $fkright = NULL;
        $islinked = FALSE;
        foreach ($fkeys as $linked_table => $fk_details) {
          if ($linked_table == 'pub') {
            $islinked = TRUE;
          }
          if ($linked_table == $reference_table) {
            $fkleft = array_keys($fk_details['columns'])[0];
            $fkright = $fk_details['columns'][$fkleft];
          }
        }
        // If this table doesn't have an FK to a reference table
        // then it's just a table with a _pub in the name.
        if (!$fkleft) {
          continue;
        }
        // If this table does not have a FK to the pub table then
        // we don't want to search it.
        if (!$islinked) {
          continue;
        }


        // Build the SQL to find records assocaited with this publication.
        $ref_schema = chado_get_schema($reference_table);
        $ref_pkey = $ref_schema['primary key'][0];
        $select = "SELECT REF.* ";
        $from = "FROM {" . $chado_table . "} LINK
            INNER JOIN {" . $reference_table . "} REF on LINK.$fkleft = REF.$fkright
        ";
        if (array_key_exists('type_id', $ref_schema['fields'])) {
          $select .= ", CVT.name as type_name";
          $from .= "INNER JOIN {cvterm} CVT on REF.type_id = CVT.cvterm_id ";
        }

        // Get the mapping of the refrence table to a CV term in case the
        // records in the table don't have a type_id.
        $ref_mapping = db_select('chado_cvterm_mapping', 'CVM')
          ->fields('CVM')
          ->condition('chado_table', $reference_table)
          ->execute()
          ->fetchObject();
        $ref_type = NULL;
        if ($ref_mapping) {
          $ref_type = chado_get_cvterm(['cvterm_id' => $ref_mapping->cvterm_id]);
        }

        // Are the records in this table associated with a content type?
        // if so, we want to get those types so we can find the entity ID.
        $bundles = db_select('chado_bundle', 'CB')
          ->fields('CB', ['bundle_id'])
          ->condition('CB.data_table', $reference_table)
          ->execute();
        $entity_sql = '';
        while ($bundle_id = $bundles->fetchField()) {
          $entity_sql .= "SELECT entity_id FROM [chado_bio_data_" . $bundle_id . "] CBD" . $bundle_id . " WHERE record_id = LINK.$ref_pkey UNION ";
        }
        if (!empty($entity_sql)) {
          $entity_sql = rtrim($entity_sql, " UNION ");
          $entity_sql = ", (" . $entity_sql . " LIMIT 1) as entity_id";
        }


        // Iterate through all of the records in the linker table that
        // match the given pub ID.
        $sql = "$select $entity_sql $from WHERE LINK.pub_id = :pub_id";
        $args = [':pub_id' => $chado_record->pub_id];
        $records = chado_query($sql, $args);
        while($record = $records->fetchObject()) {
        //foreach ($records as $record) {

          // We want to add a 'type' and 'name' element to the values (at a
          // minimum) for each of the records.  Unfortunately, every base table
          // is different and there may not be an easy to identify name,
          // so... we'll do the best we can.
          $entity->{$field_name}['und'][$delta]['value'] = [];

          // First get the type of record.
          if (property_exists($record, 'type_name')) {
            $entity->{$field_name}['und'][$delta]['value']['rdfs:type'] = $record->type_name;
          }
          else {
            if ($ref_type) {
              $entity->{$field_name}['und'][$delta]['value']['rdfs:type'] = $ref_type->name;
            }
          }

          // Add in the name and uniquename (identifier) if those fields exist.
          if (property_exists($record, 'name')) {
            $entity->{$field_name}['und'][$delta]['value']['schema:name'] = $record->name;
          }
          if (property_exists($record, 'uniquename')) {
            $entity->{$field_name}['und'][$delta]['value']['data:0842'] = $record->name;
          }

          // If this records is also a published entity then include that.
          if (property_exists($record, 'entity_id') and !empty($record->entity_id)) {
            $entity->{$field_name}['und'][$delta]['value']['entity'] = 'TripalEntity:' . $record->entity_id;
          }

          // If this is the organism table then we will create the name
          // specially.
          if (property_exists($record, 'genus')) {
            $name = '<i>' . $record->genus . ' ' . $record->species . '</i>';
            if (property_exists($record, 'infraspecific_name')) {
              if ($record->$fkleft->type_id) {
                $name .= ' ' . $record->type_name;
              }
              $name .= ' ' . $record->infraspecific_name;
            }
            $entity->{$field_name}['und'][$delta]['value']['schema:name'] = $name;
            $entity->{$field_name}['und'][$delta]['value']['rdfs:type'] = $ref_type->name;
          }
          $delta++;
        }
      }
    }
  }
}