sio__annotation.inc

File

tripal_chado/includes/TripalFields/sio__annotation/sio__annotation.inc
View source
  1. <?php

  2. 

  3. class sio__annotation extends ChadoField {

  4. 

  5. 

  6.   // --------------------------------------------------------------------------

  7.   //                     EDITABLE STATIC CONSTANTS

  8.   //

  9.   // The following constants SHOULD be set for each descendent class.  They are

  10.   // used by the static functions to provide information to Drupal about

  11.   // the field and it's default widget and formatter.

  12.   // --------------------------------------------------------------------------

  13. 

  14.   // The default lable for this field.

  15.   public static $default_label = 'Annotations';

  16. 

  17.   // The default description for this field.

  18.   public static $description = 'This record is annotated with controlled vocabulary terms.';

  19. 

  20.   // Provide a list of instance specific settings. These can be access within

  21.   // the instanceSettingsForm.  When the instanceSettingsForm is submitted

  22.   // then Drupal with automatically change these settings for the instnace.

  23.   // It is recommended to put settings at the instance level whenever possible.

  24.   // If you override this variable in a child class be sure to replicate the

  25.   // term_name, term_vocab, term_accession and term_fixed keys as these are

  26.   // required for all TripalFields.

  27.   public static $default_instance_settings  = array(

  28.     // The short name for the vocabulary (e.g. shcema, SO, GO, PATO, etc.).

  29.     'term_vocabulary' => 'SIO',

  30.     // The name of the term.

  31.     'term_name' => 'annotation',

  32.     // The unique ID (i.e. accession) of the term.

  33.     'term_accession' => '001166',

  34.     // Set to TRUE if the site admin is allowed to change the term

  35.     // type. This will create form elements when editing the field instance

  36.     // to allow the site admin to change the term settings above.

  37.     'term_fixed' => FALSE,

  38.   );

  39. 

  40.   // The default widget for this field.

  41.   public static $default_widget = 'chado_linker__cvterm_widget';

  42. 

  43.   // The default formatter for this field.

  44.   public static $default_formatter = 'chado_linker__cvterm_formatter';

  45. 

  46.   // A boolean specifying that users should not be allowed to create

  47.   // fields and instances of this field type through the UI. Such

  48.   // fields can only be created programmatically with field_create_field()

  49.   // and field_create_instance().

  50.   public static $no_ui = FALSE;

  51. 

  52. 

  53.   /**

  54.    * @see TripalField::validate()

  55.    */

  56.   public function validate($entity_type, $entity, $langcode, $items, &$errors) {

  57. 

  58.     // If we don't have an entity then we don't want to validate.  The case

  59.     // where this could happen is when a user is editing the field settings

  60.     // and trying to set a default value. In that case there's no entity and

  61.     // we don't want to validate.  There will always be an entity for creation

  62.     // and update operations of a content type.

  63.     if (!$entity) {

  64.       return;

  65.     }

  66. 

  67.     $field_name = $this->field['field_name'];

  68. 

  69.     foreach ($items as $delta => $item) {

  70.       // Get the term that matches.

  71.       $cvterm_name = $item['cvterm_name'];

  72.       $cv_id = $item['cv_id'];

  73.       if($cvterm_name and $cv_id) {

  74.         $cvterm = chado_generate_var('cvterm', array(

  75.           'cv_id' => $cv_id,

  76.           'name' => $cvterm_name,

  77.         ));

  78.         if (!$cvterm) {

  79.           $errors[$field_name][$langcode][$delta][] = array(

  80.             'message' =>  t("Cannot find a term that matches the term name and vocabulary."),

  81.             'error' => 'cvterm_name'

  82.           );

  83.         }

  84.       }

  85.     }

  86.   }

  87. 

  88.   /**

  89.    * @see TripalField::elementInfo()

  90.    */

  91.   public function elementInfo() {

  92.     $field_table = $this->instance['settings']['chado_table'];

  93.     $schema = chado_get_schema($field_table);

  94. 

  95.     $vocabulary_term = chado_get_semweb_term('cvterm', 'cv_id');

  96.     $accession_term = chado_get_semweb_term('dbxref', 'accession');

  97.     $definition_term = chado_get_semweb_term('cvterm', 'definition');

  98. 

  99.     $field_term = $this->getFieldTermID();

  100.     $info = array(

  101.       $field_term => array(

  102.         'operations' => array(),

  103.         'sortable' => FALSE,

  104.         'searchable' => FALSE,

  105.         'type' => 'xs:complexType',

  106.         'readonly' => FALSE,

  107.         'elements' => array(

  108.           $vocabulary_term => array(

  109.             'sortable' => TRUE,

  110.             'searchable' => TRUE,

  111.             'label' => 'Annotation Term Vocabulary',

  112.             'type' => 'xs:string',

  113.             'readonly' => FALSE,

  114.             'required' => TRUE,

  115.           ),

  116.           $accession_term => array(

  117.             'sortable' => TRUE,

  118.             'searchable' => TRUE,

  119.             'label' => 'Annotation Term Accession',

  120.             'type' => 'xs:string',

  121.             'readonly' => FALSE,

  122.             'required' => TRUE,

  123.           ),

  124.           $definition_term => array(

  125.             'sortable' => TRUE,

  126.             'searchable' => TRUE,

  127.             'label' => 'Annotation Term Description',

  128.             'type' => 'xs:string',

  129.             'readonly' => FALSE,

  130.             'required' => FALSE,

  131.           ),

  132.         ),

  133.       ),

  134.     );

  135. 

  136.     if (array_key_exists('is_not', $schema['fields'])) {

  137.       $negation_term = chado_get_semweb_term($field_table, 'is_not');

  138.       $info[$field_term]['elements'][$negation_term] = array(

  139.         'sortable' => FALSE,

  140.         'searchable' => FALSE,

  141.         'label' => 'Annotation Term Negates',

  142.         'type' => 'xs:boolean',

  143.         'readonly' => FALSE,

  144.         'required' => FALSE,

  145.       );

  146.     }

  147.     if (array_key_exists('rank', $schema['fields'])) {

  148.       $rank_term = chado_get_semweb_term($field_table, 'rank');

  149.       $info[$field_term]['elements'][$rank_term] = array(

  150.         'sortable' => FALSE,

  151.         'searchable' => FALSE,

  152.         'label' => 'Annotation Term Rank',

  153.         'type' => 'xs:integer',

  154.         'readonly' => FALSE,

  155.         'required' => FALSE,

  156.       );

  157.     }

  158.     if (array_key_exists('pub_id', $schema['fields'])) {

  159.     }

  160.     return $info;

  161.   }

  162. 

  163.   /**

  164.    * @see ChadoField::query()

  165.    */

  166.   public function query($query, $condition) {

  167.     $alias = $this->field['field_name'];

  168.     $operator = $condition['operator'];

  169. 

  170.     $field_table = $this->instance['settings']['chado_table'];

  171.     $base_table = $this->instance['settings']['base_table'];

  172. 

  173.     $schema = chado_get_schema($field_table);

  174.     $pkey = $schema['primary key'][0];

  175.     $fkey_lcolumn = key($schema['foreign keys'][$base_table]['columns']);

  176.     $fkey_rcolumn = $schema['foreign keys'][$base_table]['columns'][$fkey_lcolumn];

  177. 

  178.     $field_term_id = $this->getFieldTermID();

  179. 

  180.     $vocabulary_term = $field_term_id . ',' . chado_get_semweb_term('cvterm', 'cv_id');

  181.     $accession_term = $field_term_id . ',' . chado_get_semweb_term('dbxref', 'accession');

  182.     $definition_term = $field_term_id . ',' . chado_get_semweb_term('cvterm', 'definition');

  183. 

  184. 

  185.     // Join to the xxx_cvterm table for this field.

  186.     $this->queryJoinOnce($query, $field_table, $alias, "base.$fkey_rcolumn = $alias.$fkey_lcolumn");

  187. 

  188.     if ($condition['column'] == $vocabulary_term) {

  189.       $this->queryJoinOnce($query, 'cvterm', $alias . '_cvterm', $alias . ".cvterm_id = " . $alias . "_cvterm.cvterm_id");

  190.       $this->queryJoinOnce($query, 'dbxref', $alias . '_dbxref', $alias . "_cvterm.dbxref_id = " . $alias . "_dbxref.dbxref_id");

  191.       $this->queryJoinOnce($query, 'db', $alias . '_db', $alias . "_db.db_id = " . $alias . "_dbxref.db_id");

  192.       $query->condition($alias . '_db.name', $condition['value'], $operator);

  193.     }

  194.     if ($condition['column'] == $accession_term) {

  195.       $this->queryJoinOnce($query, 'cvterm', $alias . '_cvterm', $alias . ".cvterm_id = " . $alias . "_cvterm.cvterm_id");

  196.       $this->queryJoinOnce($query, 'dbxref', $alias . '_dbxref', $alias . "_cvterm.dbxref_id = " . $alias . "_dbxref.dbxref_id");

  197.       $query->condition($alias . '_dbxref.accession', $condition['value'], $operator);

  198.     }

  199.     if ($condition['column'] == $definition_term) {

  200.       $this->queryJoinOnce($query, 'cvterm', $alias . '_cvterm', $alias . ".cvterm_id = " . $alias . "_cvterm.cvterm_id");

  201.       $query->condition($alias . '_cvterm.definition', $condition['value'], $operator);

  202.     }

  203.   }

  204. 

  205.   /**

  206.    * @see ChadoField::queryOrder()

  207.    */

  208.   public function queryOrder($query, $order) {

  209.     $alias = $this->field['field_name'];

  210. 

  211.     $field_table = $this->instance['settings']['chado_table'];

  212.     $base_table = $this->instance['settings']['base_table'];

  213. 

  214.     $schema = chado_get_schema($field_table);

  215.     $pkey = $schema['primary key'][0];

  216.     $fkey_lcolumn = key($schema['foreign keys'][$base_table]['columns']);

  217.     $fkey_rcolumn = $schema['foreign keys'][$base_table]['columns'][$fkey_lcolumn];

  218. 

  219.     $field_term_id = $this->getFieldTermID();

  220. 

  221.     $vocabulary_term = $field_term_id . ',' . chado_get_semweb_term('cvterm', 'cv_id');

  222.     $accession_term = $field_term_id . ',' . chado_get_semweb_term('dbxref', 'accession');

  223.     $definition_term = $field_term_id . ',' . chado_get_semweb_term('cvterm', 'definition');

  224. 

  225.     // Join to the xxx_cvterm table for this field.

  226.     $this->queryJoinOnce($query, $field_table, $alias, "base.$fkey_rcolumn = $alias.$fkey_lcolumn");

  227. 

  228.     if ($order['column'] == $vocabulary_term) {

  229.       $this->queryJoinOnce($query, 'cvterm', $alias . '_cvterm', $alias . ".cvterm_id = " . $alias . "_cvterm.cvterm_id", "LEFT OUTER");

  230.       $this->queryJoinOnce($query, 'dbxref', $alias . '_dbxref', $alias . "_cvterm.dbxref_id = " . $alias . "_dbxref.dbxref_id", "LEFT OUTER");

  231.       $this->queryJoinOnce($query, 'db', $alias . '_db', $alias . "_db.db_id = " . $alias . "_dbxref.db_id", "LEFT OUTER");

  232.       $query->orderBy($alias . "_db.name", $order['direction']);

  233.     }

  234.     if ($order['column'] == $accession_term) {

  235.       $this->queryJoinOnce($query, 'cvterm', $alias . '_cvterm', $alias . ".cvterm_id = " . $alias . "_cvterm.cvterm_id", "LEFT OUTER");

  236.       $this->queryJoinOnce($query, 'dbxref', $alias . '_dbxref', $alias . "_cvterm.dbxref_id = " . $alias . "_dbxref.dbxref_id", "LEFT OUTER");

  237.       $query->orderBy($alias . "_dbxref.accession", $order['direction']);

  238.     }

  239.     if ($order['column'] == $definition_term) {

  240.       $this->queryJoinOnce($query, 'cvterm', $alias . '_cvterm', $alias . ".cvterm_id = " . $alias . "_cvterm.cvterm_id");

  241.       $query->orderBy($alias . "_cvterm.definition", $order['direction']);

  242.     }

  243.   }

  244.   /**

  245.    *

  246.    * @see TripalField::load()

  247.    */

  248.   public function load($entity) {

  249.     $field_name = $this->field['field_name'];

  250.     $field_type = $this->field['type'];

  251.     $field_table = $this->instance['settings']['chado_table'];

  252.     $field_column = $this->instance['settings']['chado_column'];

  253.     $base_table = $this->instance['settings']['base_table'];

  254. 

  255.     // Get the FK that links to the base record.

  256.     $schema = chado_get_schema($field_table);

  257.     $pkey = $schema['primary key'][0];

  258.     $fkey_lcolumn = key($schema['foreign keys'][$base_table]['columns']);

  259.     $fkey_rcolumn = $schema['foreign keys'][$base_table]['columns'][$fkey_lcolumn];

  260. 

  261.     $vocabulary = chado_get_semweb_term('cvterm', 'cv_id');

  262.     $accession = chado_get_semweb_term('dbxref', 'accession');

  263.     $definition = chado_get_semweb_term('cvterm', 'definition');

  264.     if (array_key_exists('is_not', $schema['fields'])) {

  265.       $negation = chado_get_semweb_term($field_table, 'is_not');

  266.     }

  267.     if (array_key_exists('rank', $schema['fields'])) {

  268.       $rank_term = chado_get_semweb_term($field_table, 'rank');

  269.     }

  270. 

  271.     // Set some defaults for the empty record.

  272.     $chado_record = $entity->chado_record;

  273.     $entity->{$field_name}['und'][0] = array(

  274.       'value' => '',

  275.       'chado-' . $field_table . '__' . $pkey => '',

  276.       'chado-' . $field_table . '__' . $fkey_lcolumn => $chado_record->$fkey_rcolumn,

  277.       'chado-' . $field_table . '__cvterm_id' => '',

  278.     );

  279.     if (array_key_exists('is_not', $schema['fields'])) {

  280.       $entity->{$field_name}['und'][0]['chado-' . $field_table . '__is_not'] = '';

  281.     }

  282.     if (array_key_exists('rank', $schema['fields'])) {

  283.       $entity->{$field_name}['und'][0]['chado-' . $field_table . '__rank'] = '';

  284.     }

  285.     if (array_key_exists('pub_id', $schema['fields'])) {

  286.       $entity->{$field_name}['und'][0]['chado-' . $field_table . '__pub_id'] = '';

  287.     }

  288. 

  289.     // Get the annotations associated with this base record for this fields type.

  290.     $columns = array('*');

  291.     $match = array(

  292.       $fkey_lcolumn => $chado_record->$fkey_rcolumn,

  293.     );

  294.     $order_by = array($pkey => 'ASC');

  295.     if (array_key_exists('rank', $schema['fields'])) {

  296.       $order_by = array('rank' => 'ASC');

  297.     }

  298.     $options = array(

  299.       'return_array' => TRUE,

  300.       'order_by' => $order_by

  301.     );

  302.     $fcvterms = chado_select_record($field_table, $columns, $match, $options);

  303.     for ($i = 0; $i < count($fcvterms); $i++) {

  304.       $linker = $fcvterms[$i];

  305.       $cvterm = chado_generate_var('cvterm', array('cvterm_id' => $linker->cvterm_id));

  306.       $entity->{$field_name}['und'][$i] = array(

  307.         'value' => array(

  308.           $vocabulary => $cvterm->dbxref_id->db_id->name,

  309.           $accession => $cvterm->dbxref_id->accession,

  310.           $definition => isset($cvterm->definition) ? $cvterm->definition : ''

  311.         ),

  312.         'chado-' . $field_table . '__' . $pkey => $linker->$pkey,

  313.         'chado-' . $field_table . '__' . $fkey_lcolumn => $linker->$fkey_lcolumn,

  314.         'chado-' . $field_table . '__' . 'cvterm_id' => $linker->cvterm_id,

  315.       );

  316.       if (array_key_exists('is_not', $schema['fields'])) {

  317.         $entity->{$field_name}['und'][$i]['value'][$negation] = $linker->is_not;

  318.         $entity->{$field_name}['und'][$i]['chado-' . $field_table . '__is_not'] = $linker->is_not;

  319.       }

  320.       if (array_key_exists('rank', $schema['fields'])) {

  321.         $entity->{$field_name}['und'][$i]['value'][$rank_term] = $linker->rank;

  322.         $entity->{$field_name}['und'][$i]['chado-' . $field_table . '__rank'] = $linker->rank;

  323.       }

  324.       if (array_key_exists('pub_id', $schema['fields'])) {

  325.         $entity->{$field_name}['und'][$i]['chado-' . $field_table . '__pub_id'] = $linker->pub_id;

  326.       }

  327.     }

  328.   }

  329. }

  330. 

  331. /**

  332.  * Theme function for the dbxref_id_widget.

  333.  *

  334.  * @param $variables

  335.  */

  336. function theme_chado_linker__cvterm_widget($variables) {

  337.   $element = $variables['element'];

  338. 

  339.   // These two fields were added to the widget to help identify the fields

  340.   // for layout.

  341.   $table_name = $element['#table_name'];

  342.   $fkey = $element['#fkey_field'];

  343. 

  344.   $layout = "

  345.     <div class=\"annotation-cvterm-widget\">

  346.       <div class=\"annotation-cvterm-widget-item\">" .

  347.       drupal_render($element['cv__cv_id']) . "

  348.       </div>

  349.       <div class=\"annotation-cvterm-widget-item\">" .

  350.       drupal_render($element['cvterm__name']) . "

  351.       </div>

  352.       <div class=\"annotation-cvterm-widget-item\">" .

  353.       drupal_render($element['pub']) . "

  354.       </div>

  355.       <div class=\"annotation-cvterm-widget-item\">" .

  356.       drupal_render($element['chado-' . $table_name . '__is_not']) . "

  357.       </div>

  358.     </div>

  359.   ";

  360.   return $layout;

  361. }

  362. 

  363. /**

  364.  * An Ajax callback for the dbxref widget.

  365.  */

  366. function chado_linker__cvterm_widget_form_ajax_callback($form, $form_state) {

  367. 

  368.   $field_name = $form_state['triggering_element']['#parents'][0];

  369.   $delta = $form_state['triggering_element']['#parents'][2];

  370. 

  371. 

  372.   return $form[$field_name]['und'][$delta];

  373. }