tripal_core.chado_nodes.api.inc

API to handle much of the common functionality implemented when creating a drupal node type.

File

tripal_core/api/tripal_core.chado_nodes.api.inc
View source
  1. <?php
  2. /**
  3. * @file
  4. * API to handle much of the common functionality implemented when creating a drupal node type.
  5. */
  6. /**
  7. * @defgroup tripal_chado_node_api Chado Node API
  8. * @ingroup tripal_chado_api
  9. * @{
  10. * Many Tripal modules implement Drupal node types as a means of displaying chado
  11. * records individually through Drupal as a single web page. In order to do this, many of
  12. * the same drupal hooks are implemented and the code between modules is actually quite
  13. * similar. This API aims to abstract much of the common functionality in order to make
  14. * it easier for new Tripal modules to implement drupal node types and to centralize the
  15. * maintenance effort as much as possible.
  16. *
  17. * A generic sync form has been created. See chado_node_sync_form() for
  18. * instructions on how to implement this form in your module.
  19. *
  20. * Many of the base chado tables also have associated prop, _dbxref and _relationship
  21. * tables. Generic mini-forms have been created to help you handle these forms. To
  22. * implement this functionality you call the mini-form from your module node form and
  23. * then call the associated update functions from both your hook_insert and hook_update.
  24. * The functions of interest are as follows:
  25. * - chado_add_node_form_properties() and chado_update_node_form_properties()
  26. * to provide an interface for adding/removing properties
  27. * - chado_add_node_form_dbxrefs() and chado_update_node_form_dbxrefs()
  28. * to provide an interface for adding/removing additional database references
  29. * - chado_add_node_form_relationships() and chado_update_node_form_relationships()
  30. * to provide an interface for adding/removing relationships between chado records
  31. * from your base table
  32. * @}
  33. */
  34. /**
  35. * Get chado id for a node. E.g, if you want to get 'analysis_id' from the
  36. * 'analysis' table for a synced 'chado_analysis' node, (the same for
  37. * organisms and features):
  38. * $analysis_id = chado_get_id_from_nid ('analysis', $node->nid)
  39. * $organism_id = chado_get_id_from_nid ('organism', $node->nid)
  40. * $feature_id = chado_get_id_from_nid ('feature', $node->nid)
  41. *
  42. * @param $table
  43. * The chado table the chado record is from
  44. * @param $nid
  45. * The value of the primary key of node
  46. * @param $linking_table
  47. * The Drupal table linking the chado record to it's node.
  48. * This field is optional and defaults to chado_$table
  49. *
  50. * @return
  51. * The chado id of the associated chado record
  52. *
  53. * @ingroup tripal_chado_node_api
  54. */
  55. function chado_get_id_from_nid($table, $nid, $linking_table = NULL) {
  56. if (empty($linking_table)) {
  57. $linking_table = 'chado_' . $table;
  58. }
  59. $sql = "SELECT " . $table . "_id as id FROM {$linking_table} WHERE nid = :nid";
  60. return db_query($sql, array(':nid' => $nid))->fetchField();
  61. }
  62. /**
  63. * Get node id for a chado feature/organism/analysis. E.g, if you want to
  64. * get the node id for an analysis, use:
  65. * $nid = chado_get_nid_from_id ('analysis', $analysis_id)
  66. * Likewise,
  67. * $nid = chado_get_nid_from_id ('organism', $organism_id)
  68. * $nid = chado_get_nid_from_id ('feature', $feature_id)
  69. *
  70. * @param $table
  71. * The chado table the id is from
  72. * @param $id
  73. * The value of the primary key from the $table chado table (ie: feature_id)
  74. * @param $linking_table
  75. * The Drupal table linking the chado record to it's node.
  76. * This field is optional and defaults to chado_$table
  77. *
  78. * @return
  79. * The nid of the associated node
  80. *
  81. * @ingroup tripal_chado_node_api
  82. */
  83. function chado_get_nid_from_id($table, $id, $linking_table = NULL) {
  84. if (empty($linking_table)) {
  85. $linking_table = 'chado_' . $table;
  86. }
  87. $sql = "SELECT nid FROM {" . $linking_table . "} WHERE " . $table . "_id = :" . $table . "_id";
  88. return db_query($sql, array(":" . $table . "_id" => $id))->fetchField();
  89. }
  90. /**
  91. * Determine the chado base table for a given content type
  92. *
  93. * @param $content_type
  94. * The machine name of the content type (node type) you want to
  95. * determine the base chado table of
  96. * @param $module
  97. * (Optional) The machine-name of the module implementing the
  98. * content type
  99. *
  100. * @return
  101. * The name of the chado base table for the specified content type
  102. *
  103. * @ingroup tripal_chado_node_api
  104. */
  105. function chado_node_get_base_table($content_type, $module = FALSE) {
  106. if ($module) {
  107. $node_info = call_user_func($details['module'] . '_node_info');
  108. }
  109. else {
  110. $node_types = module_invoke_all('node_info');
  111. if (isset($node_types[$content_type])) {
  112. $node_info = $node_types[$content_type];
  113. }
  114. else {
  115. return FALSE;
  116. }
  117. }
  118. if (isset($node_info['chado_node_api']['base_table'])) {
  119. return $node_info['chado_node_api']['base_table'];
  120. }
  121. else {
  122. return FALSE;
  123. }
  124. }
  125. /**
  126. * @section
  127. * Common Functionality for Properties, Dbxrefs and relationships chado node API
  128. */
  129. /**
  130. * Validate the Triggering element from a node form.
  131. *
  132. * We are going to inspect the post to determine what PHP knows is the triggering
  133. * element and if it doesn't agree with Drupal then we are actually going to
  134. * change it in Drupal.
  135. *
  136. * This fixes an obscure bug triggered when a property is added and then
  137. * a relationship removed, Drupal thinks the first property remove button was
  138. * clicked and instead removes a property (not a relationship) and renders the new
  139. * property table in the relationship table page space.
  140. *
  141. * NOTE: Many Drupal issues state that this problem is solved if the #name
  142. * of the button is unique (which it is in our case) but we are still experiencing
  143. * incorrectly determined triggering elements so we need to handle it ourselves.
  144. */
  145. function chado_validate_node_form_triggering_element($form, &$form_state) {
  146. // We are going to inspect the post to determine what PHP knows is the triggering
  147. // element and if it doesn't agree with Drupal then we are actually going to
  148. // change it in Drupal.
  149. if ($_POST['_triggering_element_name'] != $form_state['triggering_element']['#name']) {
  150. $form_state['triggering_element']['#name'] = $_POST['_triggering_element_name'];
  151. }
  152. }
  153. /**
  154. * Validate Adding Subtables entries from the node forms.
  155. * Supported subtables: Properties, Relationships, Additional DBxrefs.
  156. *
  157. * @param array $form
  158. * @param array $form_state
  159. */
  160. function chado_add_node_form_subtables_add_button_validate($form, &$form_state) {
  161. // Based on triggering element call the correct validation function
  162. // ASUMPTION #1: each of the buttons must have property, dbxref or relationship
  163. // as the first part of the #name to uniquely identify the subsection.
  164. if (preg_match('/^([a-z]+).*/', $form_state['triggering_element']['#name'], $matches)) {
  165. $subsection = $matches[1];
  166. switch($subsection) {
  167. case 'properties':
  168. chado_add_node_form_properties_add_button_validate($form, $form_state);
  169. break;
  170. case 'dbxrefs':
  171. chado_add_node_form_dbxrefs_add_button_validate($form, $form_state);
  172. break;
  173. case 'relationships':
  174. chado_add_node_form_relationships_add_button_validate($form, $form_state);
  175. break;
  176. }
  177. }
  178. }
  179. /**
  180. * Add subtable entries to the node forms.
  181. * Supported subtables: Properties, Relationships, Additional DBxrefs.
  182. *
  183. * @param array $form
  184. * @param array $form_state
  185. */
  186. function chado_add_node_form_subtables_add_button_submit($form, &$form_state) {
  187. // Based on triggering element call the correct submit function
  188. // ASUMPTION #1: each of the buttons must have properties, dbxrefs or relationships
  189. // as the first part of the #name to uniquely identify the subsection.
  190. if (preg_match('/^([a-z]+).*/', $form_state['triggering_element']['#name'], $matches)) {
  191. $subsection = $matches[1];
  192. switch($subsection) {
  193. case 'properties':
  194. chado_add_node_form_properties_add_button_submit($form, $form_state);
  195. break;
  196. case 'dbxrefs':
  197. chado_add_node_form_dbxrefs_add_button_submit($form, $form_state);
  198. break;
  199. case 'relationships':
  200. chado_add_node_form_relationships_add_button_submit($form, $form_state);
  201. break;
  202. }
  203. }
  204. // This is needed to ensure the form builder function is called for the node
  205. // form in order for any of these changes to be seen.
  206. $form_state['rebuild'] = TRUE;
  207. }
  208. /**
  209. * Validate Removing Subtables entries from the node forms.
  210. * Supported subtables: Properties, Relationships, Additional DBxrefs.
  211. *
  212. * Since Removing isn't associated with any user input the only thing we
  213. * need to validate is that Drupal has determined the triggering element correctly.
  214. * That said, we will call each subtables associated validate function just incase
  215. * there is some case-specific validation we do not know of or have not anticipated.
  216. *
  217. * @param array $form
  218. * @param array $form_state
  219. */
  220. function chado_add_node_form_subtables_remove_button_validate($form, &$form_state) {
  221. // We need to validate the trigerring element since Drupal has known
  222. // issues determining this correctly when there are multiple buttons
  223. // with the same label.
  224. chado_validate_node_form_triggering_element($form, $form_state);
  225. // Based on triggering element call the correct validation function
  226. // ASUMPTION #1: each of the buttons must have property, dbxref or relationship
  227. // as the first part of the #name to uniquely identify the subsection.
  228. if (preg_match('/^([a-z]+).*/', $form_state['triggering_element']['#name'], $matches)) {
  229. $subsection = $matches[1];
  230. switch($subsection) {
  231. case 'properties':
  232. chado_add_node_form_properties_remove_button_validate($form, $form_state);
  233. break;
  234. case 'dbxrefs':
  235. chado_add_node_form_dbxrefs_remove_button_validate($form, $form_state);
  236. break;
  237. case 'relationships':
  238. chado_add_node_form_relationships_remove_button_validate($form, $form_state);
  239. break;
  240. }
  241. }
  242. }
  243. /**
  244. * Remove subtable entries to the node forms.
  245. * Supported subtables: Properties, Relationships, Additional DBxrefs.
  246. *
  247. * @param array $form
  248. * @param array $form_state
  249. */
  250. function chado_add_node_form_subtables_remove_button_submit($form, &$form_state) {
  251. // Based on triggering element call the correct submit function
  252. // ASUMPTION #1: each of the buttons must have properties, dbxrefs or relationships
  253. // as the first part of the #name to uniquely identify the subsection.
  254. if (preg_match('/^([a-z]+).*/', $form_state['triggering_element']['#name'], $matches)) {
  255. $subsection = $matches[1];
  256. switch($subsection) {
  257. case 'properties':
  258. chado_add_node_form_properties_remove_button_submit($form, $form_state);
  259. break;
  260. case 'dbxrefs':
  261. chado_add_node_form_dbxrefs_remove_button_submit($form, $form_state);
  262. break;
  263. case 'relationships':
  264. chado_add_node_form_relationships_remove_button_submit($form, $form_state);
  265. break;
  266. }
  267. }
  268. // This is needed to ensure the form builder function is called for the node
  269. // form in order for any of these changes to be seen.
  270. $form_state['rebuild'] = TRUE;
  271. }
  272. /**
  273. * Ajax function which returns the section of the form to be re-rendered
  274. * for either the properties, dbxref or relationship sub-sections.
  275. *
  276. * @ingroup tripal_core
  277. */
  278. function chado_add_node_form_subtable_ajax_update($form, &$form_state) {
  279. // We need to validate the trigerring element since Drupal has known
  280. // issues determining this correctly when there are multiple buttons
  281. // with the same label.
  282. chado_validate_node_form_triggering_element($form, $form_state);
  283. // Based on triggering element render the correct part of the form.
  284. // ASUMPTION: each of the buttons must have property, dbxref or relationship
  285. // as the first part of the #name to uniquely identify the subsection.
  286. if (preg_match('/^([a-z]+).*/', $form_state['triggering_element']['#name'], $matches)) {
  287. $subsection = $matches[1];
  288. switch($subsection) {
  289. case 'properties':
  290. return $form['properties']['property_table'];
  291. break;
  292. case 'dbxrefs':
  293. return $form['addtl_dbxrefs']['dbxref_table'];
  294. break;
  295. case 'relationships':
  296. return $form['relationships']['relationship_table'];
  297. break;
  298. }
  299. }
  300. }
  301. /**
  302. * @section
  303. * Sync Form
  304. */
  305. /**
  306. * Generic Sync Form to aid in sync'ing (create drupal nodes linking to chado content)
  307. * any chado node type.
  308. *
  309. * To use this you need to add a call to it from your hook_menu() and
  310. * add some additional information to your hook_node_info(). The Following code gives an
  311. * example of how this might be done:
  312. * @code
  313. function modulename_menu() {
  314. // the machine name of your module
  315. $module_name = 'tripal_example';
  316. // the base specified in hook_node_info
  317. $node_type = 'chado_example';
  318. // This menu item will be a tab on the admin/tripal/chado/tripal_example page
  319. // that is not selected by default
  320. $items['admin/tripal/chado/tripal_example/sync'] = array(
  321. 'title' => ' Sync',
  322. 'description' => 'Sync examples from Chado with Drupal',
  323. 'page callback' => 'drupal_get_form',
  324. 'page arguments' => array('chado_node_sync_form', $module_name, $node_type),
  325. 'access arguments' => array('administer tripal examples'),
  326. 'type' => MENU_LOCAL_TASK,
  327. 'weight' => 0
  328. );
  329. return $items;
  330. }
  331. function modulename_node_info() {
  332. return array(
  333. 'chado_example' => array(
  334. 'name' => t('example'),
  335. 'base' => 'chado_example',
  336. 'description' => t('A Chado example is a collection of material that can be sampled and have experiments performed on it.'),
  337. 'has_title' => TRUE,
  338. 'locked' => TRUE,
  339. // this is what differs from the regular Drupal-documented hook_node_info()
  340. 'chado_node_api' => array(
  341. 'base_table' => 'example', // The name of the chado base table
  342. 'hook_prefix' => 'chado_example', // Usually the name of the node type
  343. 'linking_table' => 'chado_example', // Specifies the linking table used
  344. // to map records to Drupal nodes.
  345. // if 'linking_table' is not specified
  346. // it defaults to the node_type name.
  347. 'record_type_title' => array(
  348. 'singular' => t('Example'), // Singular human-readable title
  349. 'plural' => t('Examples') // Plural human-readable title
  350. ),
  351. 'sync_filters' => array( // filters for syncing
  352. 'type_id' => TRUE, // TRUE if there is an example.type_id field
  353. 'organism_id' => TRUE, // TRUE if there is an example.organism_id field
  354. 'checkboxes' => array('name') // If the 'checkboxes' key is present then the
  355. // value must be an array of column names in
  356. // base table. The values from these columns will
  357. // be retreived, contentated with a space delimeter
  358. // and provided in a list of checkboxes
  359. // for the user to choose which to sync.
  360. ),
  361. )
  362. ),
  363. );
  364. }
  365. * @endcode
  366. *
  367. * For more information on how you can override some of this behaviour while still
  368. * benifiting from as much of the common architecture as possible see the following
  369. * functions: hook_chado_node_sync_create_new_node(), hook_chado_node_sync_form(),
  370. * hook_chado_node_sync_select_query().
  371. *
  372. * @ingroup tripal_chado_node_api
  373. */
  374. function chado_node_sync_form($form, &$form_state) {
  375. $form = array();
  376. if (isset($form_state['build_info']['args'][0])) {
  377. $module = $form_state['build_info']['args'][0];
  378. $node_type = $form_state['build_info']['args'][1];
  379. $node_info = call_user_func($module . '_node_info');
  380. // If a linking table is set in the node_info array then use that,
  381. // otherwise ues the node_type as the linking table.
  382. if (array_key_exists('linking_table', $node_info[$node_type]['chado_node_api'])) {
  383. $linking_table = $node_info[$node_type]['chado_node_api']['linking_table'];
  384. }
  385. else {
  386. $linking_table = 'chado_' . $node_info[$node_type]['chado_node_api']['base_table'];
  387. }
  388. $args = $node_info[$node_type]['chado_node_api'];
  389. $form_state['chado_node_api'] = $args;
  390. }
  391. $form['linking_table'] = array(
  392. '#type' => 'hidden',
  393. '#value' => $linking_table
  394. );
  395. $form['node_type'] = array(
  396. '#type' => 'hidden',
  397. '#value' => $node_type
  398. );
  399. // define the fieldsets
  400. $form['sync'] = array(
  401. '#type' => 'fieldset',
  402. '#title' => 'Sync ' . $args['record_type_title']['plural'],
  403. '#descrpition' => '',
  404. );
  405. $form['sync']['description'] = array(
  406. '#type' => 'item',
  407. '#value' => t("%title_plural of the types listed ".
  408. "below in the %title_singular Types box will be synced (leave blank to sync all types). You may limit the ".
  409. "%title_plural to be synced by a specific organism. Depending on the ".
  410. "number of %title_plural in the chado database this may take a long ".
  411. "time to complete. ",
  412. array(
  413. '%title_singular' => $args['record_type_title']['singular'],
  414. '%title_plural' => $args['record_type_title']['plural']
  415. )),
  416. );
  417. if ($args['sync_filters']['type_id']) {
  418. $form['sync']['type_ids'] = array(
  419. '#title' => t('%title_singular Types',
  420. array(
  421. '%title_singular' => $args['record_type_title']['singular'],
  422. '%title_plural' => $args['record_type_title']['plural']
  423. )),
  424. '#type' => 'textarea',
  425. '#description' => t("Enter the names of the %title_singular types to sync. " .
  426. "Leave blank to sync all %title_plural. Separate each type with a comma ".
  427. "or new line. Pages for these %title_singular ".
  428. "types will be created automatically for %title_plural that exist in the ".
  429. "chado database. The names must match ".
  430. "exactly (spelling and case) with terms in the ontologies",
  431. array(
  432. '%title_singular' => strtolower($args['record_type_title']['singular']),
  433. '%title_plural' => strtolower($args['record_type_title']['plural'])
  434. )),
  435. '#default_value' => (isset($form_state['values']['type_id'])) ? $form_state['values']['type_id'] : '',
  436. );
  437. }
  438. // get the list of organisms
  439. if ($args['sync_filters']['organism_id']) {
  440. $sql = "SELECT * FROM {organism} ORDER BY genus, species";
  441. $results = chado_query($sql);
  442. $organisms[] = '';
  443. foreach ($results as $organism) {
  444. $organisms[$organism->organism_id] = "$organism->genus $organism->species ($organism->common_name)";
  445. }
  446. $form['sync']['organism_id'] = array(
  447. '#title' => t('Organism'),
  448. '#type' => t('select'),
  449. '#description' => t("Choose the organism for which %title_plural types set above will be synced.",
  450. array(
  451. '%title_singular' => $args['record_type_title']['singular'],
  452. '%title_plural' => $args['record_type_title']['plural']
  453. )),
  454. '#options' => $organisms,
  455. '#default_value' => (isset($form_state['values']['organism_id'])) ? $form_state['values']['organism_id'] : 0,
  456. );
  457. }
  458. // get the list of organisms
  459. if (array_key_exists('checkboxes', $args['sync_filters'])) {
  460. // get the base schema
  461. $base_table = $args['base_table'];
  462. $table_info = chado_get_schema($base_table);
  463. // if the base table does not have a primary key or has more than one then
  464. // we can't proceed, otherwise, generate the checkboxes
  465. if (array_key_exists('primary key', $table_info) and count($table_info['primary key']) == 1) {
  466. $pkey = $table_info['primary key'][0];
  467. $columns = $args['sync_filters']['checkboxes'];
  468. $select_cols = '';
  469. foreach ($columns as $column) {
  470. $select_cols .= $base_table . '.' . $column . "|| ' ' ||";
  471. }
  472. // Remove trailing || ' ' ||
  473. $select_cols = substr($select_cols, 0, -9);
  474. $base_table_id = $base_table . '_id';
  475. $select = array($base_table . '.' . $pkey, $select_cols . ' as value');
  476. $joins = array();
  477. $where_clauses = array();
  478. $where_args = array();
  479. // Allow module to update the query.
  480. $hook_query_alter = $node_type . '_chado_node_sync_select_query';
  481. if (function_exists($hook_query_alter)) {
  482. $update = call_user_func($hook_query_alter, array(
  483. 'select' => $select,
  484. 'joins' => $joins,
  485. 'where_clauses' => $where_clauses,
  486. 'where_args' => $where_args,
  487. ));
  488. // Now add in any new changes
  489. if ($update and is_array($update)) {
  490. $select = $update['select'];
  491. $joins = $update['joins'];
  492. $where_clauses = $update['where_clauses'];
  493. $where_args = $update['where_args'];
  494. }
  495. }
  496. // Build Query, we do a left join on the chado_xxxx table in the Drupal schema
  497. // so that if no criteria are specified we only get those items that have not
  498. // yet been synced.
  499. // @todo: re-write the query to support external chado databases.
  500. $query = "SELECT " . implode(', ', $select) . ' ' .
  501. 'FROM {' . $base_table . '} ' . $base_table . ' ' . implode(' ', $joins) . ' '.
  502. " LEFT JOIN [$linking_table] CT ON CT.$base_table_id = $base_table.$base_table_id " .
  503. "WHERE CT.$base_table_id IS NULL";
  504. // extend the where clause if needed
  505. $where = '';
  506. $sql_args = array();
  507. foreach ($where_clauses as $category => $items) {
  508. $where .= ' AND (';
  509. foreach ($items as $item) {
  510. $where .= $item . ' OR ';
  511. }
  512. $where = substr($where, 0, -4); // remove the trailing 'OR'
  513. $where .= ') ';
  514. $sql_args = array_merge($sql_args, $where_args[$category]);
  515. }
  516. if ($where) {
  517. $query .= $where;
  518. }
  519. $query .= " ORDER BY $base_table." . implode(", $base_table.", $columns);
  520. $results = chado_query($query, $sql_args);
  521. $values = array();
  522. foreach ($results as $result) {
  523. $values[$result->$pkey] = $result->value;
  524. }
  525. if (count($values) > 0) {
  526. $form['sync']['ids'] = array(
  527. '#title' => 'Avaliable ' . $args['record_type_title']['plural'],
  528. '#type' => 'checkboxes',
  529. '#options' => $values,
  530. '#default_value' => (isset($form_state['values']['ids'])) ? $form_state['values']['ids'] : array(),
  531. '#suffix' => '</div><br>',
  532. '#prefix' => t("The following %title_plural have not been synced. Check those to be synced or leave all unchecked to sync them all.",
  533. array(
  534. '%title_singular' => strtolower($args['record_type_title']['singular']),
  535. '%title_plural' => strtolower($args['record_type_title']['plural'])
  536. )) . '<div style="height: 200px; overflow: scroll">',
  537. );
  538. }
  539. else {
  540. $form['sync']['no_ids'] = array(
  541. '#markup' => "<p>There are no " . strtolower($args['record_type_title']['plural']) . " to sync.</p>",
  542. );
  543. }
  544. }
  545. }
  546. // if we provide a list of checkboxes we shouldn't need a max_sync
  547. else {
  548. $form['sync']['max_sync'] = array(
  549. '#type' => 'textfield',
  550. '#title' => t('Maximum number of records to Sync'),
  551. '#description' => t('Leave this field empty to sync all records, regardless of number'),
  552. '#default_value' => (isset($form_state['values']['max_sync'])) ? $form_state['values']['max_sync'] : '',
  553. );
  554. }
  555. $form['sync']['button'] = array(
  556. '#type' => 'submit',
  557. '#value' => t('Sync ' . $args['record_type_title']['plural']),
  558. '#weight' => 3,
  559. );
  560. $form['cleanup'] = array(
  561. '#type' => 'fieldset',
  562. '#title' => t('Clean Up')
  563. );
  564. $form['cleanup']['description'] = array(
  565. '#markup' => t("<p>With Drupal and chado residing in different databases " .
  566. "it is possible that nodes in Drupal and " . strtolower($args['record_type_title']['plural']) . " in Chado become " .
  567. "\"orphaned\". This can occur if a node in Drupal is " .
  568. "deleted but the corresponding chado records is not and/or vice " .
  569. "versa. Click the button below to resolve these discrepancies.</p>"),
  570. '#weight' => -10,
  571. );
  572. $form['cleanup']['cleanup_batch_size'] = array(
  573. '#type' => 'textfield',
  574. '#title' => t('Batch Size'),
  575. '#description' => t('The number of records to analyze together in a batch. If you are having memory issues you might want to decrease this number.'),
  576. '#default_value' => variable_get('chado_node_api_cleanup_batch_size', 25000),
  577. );
  578. $form['cleanup']['button'] = array(
  579. '#type' => 'submit',
  580. '#value' => 'Clean up orphaned ' . strtolower($args['record_type_title']['plural']),
  581. '#weight' => 2,
  582. );
  583. // Allow each module to alter this form as needed
  584. $hook_form_alter = $args['hook_prefix'] . '_chado_node_sync_form';
  585. if (function_exists($hook_form_alter)) {
  586. $form = call_user_func($hook_form_alter, $form, $form_state);
  587. }
  588. return $form;
  589. }
  590. /**
  591. * Generic Sync Form Validate
  592. *
  593. * @ingroup tripal_core
  594. */
  595. function chado_node_sync_form_validate($form, &$form_state) {
  596. if (empty($form_state['values']['cleanup_batch_size'])) {
  597. $form_state['values']['cleanup_batch_size'] = 25000;
  598. drupal_set_message('You entered a Batch Size of 0 for Cleaning-up orphaned nodes. Since this is not valid, we reset it to the default of 25,000.', 'warning');
  599. }
  600. elseif (!is_numeric($form_state['values']['cleanup_batch_size'])) {
  601. form_set_error('cleanup_batch_size', 'The batch size must be a postitive whole number.');
  602. }
  603. else {
  604. // Round the value just to make sure.
  605. $form_state['values']['cleanup_batch_size'] = abs(round($form_state['values']['cleanup_batch_size']));
  606. }
  607. }
  608. /**
  609. * Generic Sync Form Submit
  610. *
  611. * @ingroup tripal_core
  612. */
  613. function chado_node_sync_form_submit($form, $form_state) {
  614. global $user;
  615. if (preg_match('/^Sync/', $form_state['values']['op'])) {
  616. // get arguments
  617. $args = $form_state['chado_node_api'];
  618. $module = $form_state['chado_node_api']['hook_prefix'];
  619. $base_table = $form_state['chado_node_api']['base_table'];
  620. $linking_table = $form_state['values']['linking_table'];
  621. $node_type = $form_state['values']['node_type'];
  622. // Allow each module to hijack the submit if needed
  623. $hook_form_hijack_submit = $args['hook_prefix'] . '_chado_node_sync_form_submit';
  624. if (function_exists($hook_form_hijack_submit)) {
  625. return call_user_func($hook_form_hijack_submit, $form, $form_state);
  626. }
  627. // Get the types separated into a consistent string
  628. $types = array();
  629. if (isset($form_state['values']['type_ids'])) {
  630. // seperate by new line or comma.
  631. $temp_types = preg_split("/[,\n\r]+/", $form_state['values']['type_ids']);
  632. // remove any extra spacing around the types
  633. for($i = 0; $i < count($temp_types); $i++) {
  634. // skip empty types
  635. if (trim($temp_types[$i]) == '') {
  636. continue;
  637. }
  638. $types[$i] = trim($temp_types[$i]);
  639. }
  640. }
  641. // Get the ids to be synced
  642. $ids = array();
  643. if (array_key_exists('ids', $form_state['values'])){
  644. foreach ($form_state['values']['ids'] as $id => $selected) {
  645. if ($selected) {
  646. $ids[] = $id;
  647. }
  648. }
  649. }
  650. // get the organism to be synced
  651. $organism_id = FALSE;
  652. if (array_key_exists('organism_id', $form_state['values'])) {
  653. $organism_id = $form_state['values']['organism_id'];
  654. }
  655. // Job Arguments
  656. $job_args = array(
  657. 'base_table' => $base_table,
  658. 'max_sync' => (!empty($form_state['values']['max_sync'])) ? $form_state['values']['max_sync'] : FALSE,
  659. 'organism_id' => $organism_id,
  660. 'types' => $types,
  661. 'ids' => $ids,
  662. 'linking_table' => $linking_table,
  663. 'node_type' => $node_type
  664. );
  665. $title = "Sync " . $args['record_type_title']['plural'];
  666. tripal_add_job($title, $module, 'chado_node_sync_records', $job_args, $user->uid);
  667. }
  668. if (preg_match('/^Clean up orphaned/', $form_state['values']['op'])) {
  669. $module = $form_state['chado_node_api']['hook_prefix'];
  670. $base_table = $form_state['chado_node_api']['base_table'];
  671. $linking_table = $form_state['values']['linking_table'];
  672. $node_type = $form_state['values']['node_type'];
  673. $job_args = array($base_table, $form_state['values']['cleanup_batch_size'], $linking_table, $node_type);
  674. variable_set('chado_node_api_cleanup_batch_size', $form_state['values']['cleanup_batch_size']);
  675. tripal_add_job($form_state['values']['op'], $module, 'chado_cleanup_orphaned_nodes', $job_args, $user->uid);
  676. }
  677. }
  678. /**
  679. * Generic function for syncing records in Chado with Drupal nodes.
  680. *
  681. * @param $base_table
  682. * The name of the Chado table containing the record that should be synced
  683. * @param $max_sync
  684. * Optional: A numeric value to indicate the maximum number of records to sync.
  685. * @param $organism_id
  686. * Optional: Limit the list of records to be synced to only those that
  687. * are associated with this organism_id. If the record is not assocaited
  688. * with an organism then this field is not needed.
  689. * @param $types
  690. * Optional: Limit the list of records to be synced to only those that
  691. * match the types listed in this array.
  692. * @param $ids
  693. * Optional: Limit the list of records to bye synced to only those whose
  694. * primary key value matches the ID provided in this array.
  695. * @param $linking_table
  696. * Optional: Tripal maintains "linking" tables in the Drupal schema
  697. * to link Drupal nodes with Chado records. By default these tables
  698. * are named as 'chado_' . $base_table. But if for some reason the
  699. * linking table is not named in this way then it can be provided by this
  700. * argument.
  701. * @param $node_type
  702. * Optional: Tripal maintains "linking" tables in the Drupal schema
  703. * to link Drupal nodes with Chado records. By default, Tripal expects that
  704. * the node_type and linking table are named the same. However, if this
  705. * is not the case, you can provide the node type name here.
  706. * @param $job_id
  707. * Optional. Used by the Trpial Jobs system when running this function
  708. * as a job. It is not needed othewise.
  709. *
  710. * @ingroup tripal_chado_node_api
  711. */
  712. function chado_node_sync_records($base_table, $max_sync = FALSE,
  713. $organism_id = FALSE, $types = array(), $ids = array(),
  714. $linking_table = FALSE, $node_type = FALSE, $job_id = NULL) {
  715. global $user;
  716. $base_table_id = $base_table . '_id';
  717. if (!$linking_table) {
  718. $linking_table = 'chado_' . $base_table;
  719. }
  720. if (!$node_type) {
  721. $node_type = 'chado_' . $base_table;
  722. }
  723. print "\nSync'ing $base_table records. ";
  724. // START BUILDING QUERY TO GET ALL RECORD FROM BASE TABLE THAT MATCH
  725. $select = array("$base_table.*");
  726. $joins = array();
  727. $where_clauses = array();
  728. $where_args = array();
  729. // If types are supplied then handle them
  730. $restrictions = '';
  731. if (count($types) > 0) {
  732. $restrictions .= " Type(s): " . implode(', ',$types) . "\n";
  733. $select[] = 'cvterm.name as cvtname';
  734. $joins[] = "LEFT JOIN {cvterm} cvterm ON $base_table.type_id = cvterm.cvterm_id";
  735. foreach ($types as $type) {
  736. $sanitized_type = str_replace(' ','_',$type);
  737. $where_clauses['type'][] = "cvterm.name = :type_name_$sanitized_type";
  738. $where_args['type'][":type_name_$sanitized_type"] = $type;
  739. }
  740. }
  741. // if IDs have been supplied
  742. if ($ids) {
  743. $restrictions .= " Specific Records: " . count($ids) . " recored(s) specified.\n";
  744. foreach ($ids as $id) {
  745. $where_clauses['id'][] = "$base_table.$base_table_id = :id_$id";
  746. $where_args['id'][":id_$id"] = $id;
  747. }
  748. }
  749. // If Organism is supplied
  750. if ($organism_id) {
  751. $organism = chado_select_record('organism', array('*'), array('organism_id' => $organism_id));
  752. $restrictions .= " Organism: " . $organism[0]->genus . " " . $organism[0]->species . "\n";
  753. $select[] = 'organism.*';
  754. $joins[] = "LEFT JOIN {organism} organism ON organism.organism_id = $base_table.organism_id";
  755. $where_clauses['organism'][] = 'organism.organism_id = :organism_id';
  756. $where_args['organism'][':organism_id'] = $organism_id;
  757. }
  758. // Allow module to add to query
  759. $hook_query_alter = $node_type . '_chado_node_sync_select_query';
  760. if (function_exists($hook_query_alter)) {
  761. $update = call_user_func($hook_query_alter, array(
  762. 'select' => $select,
  763. 'joins' => $joins,
  764. 'where_clauses' => $where_clauses,
  765. 'where_args' => $where_args,
  766. ));
  767. // Now add in any new changes
  768. if ($update and is_array($update)) {
  769. $select = $update['select'];
  770. $joins = $update['joins'];
  771. $where_clauses = $update['where_clauses'];
  772. $where_args = $update['where_args'];
  773. }
  774. }
  775. // Build Query, we do a left join on the chado_xxxx table in the Drupal schema
  776. // so that if no criteria are specified we only get those items that have not
  777. // yet been synced.
  778. // @todo: re-write to support external chado databases.
  779. $query = "
  780. SELECT " . implode(', ', $select) . ' ' .
  781. 'FROM {' . $base_table . '} ' . $base_table . ' ' . implode(' ', $joins) . ' '.
  782. " LEFT JOIN [$linking_table] CT ON CT.$base_table_id = $base_table.$base_table_id " .
  783. "WHERE CT.$base_table_id IS NULL ";
  784. // extend the where clause if needed
  785. $where = '';
  786. $sql_args = array();
  787. foreach ($where_clauses as $category => $items) {
  788. $where .= ' AND (';
  789. foreach ($items as $item) {
  790. $where .= $item . ' OR ';
  791. }
  792. $where = substr($where, 0, -4); // remove the trailing 'OR'
  793. $where .= ') ';
  794. $sql_args = array_merge($sql_args, $where_args[$category]);
  795. }
  796. if ($where) {
  797. $query .= $where;
  798. }
  799. $query .- " ORDER BY " . $base_table_id;
  800. // If Maximum number to Sync is supplied
  801. if ($max_sync) {
  802. $query .= " LIMIT $max_sync";
  803. $restrictions .= " Limited to $max_sync records.\n";
  804. }
  805. if ($restrictions) {
  806. print "Records matching these criteria will be synced: \n$restrictions";
  807. }
  808. else {
  809. print "\n";
  810. }
  811. // execute the query
  812. $results = chado_query($query, $sql_args);
  813. // Iterate through records that need to be synced
  814. $count = $results->rowCount();
  815. $interval = intval($count * 0.01);
  816. if ($interval < 1) {
  817. $interval = 1;
  818. }
  819. print "\n$count $base_table records found.\n";
  820. $i = 0;
  821. //$transaction = db_transaction();
  822. print "\nNOTE: Syncing is performed using a database transaction. \n" .
  823. "If the sync fails or is terminated prematurely then the entire set of \n" .
  824. "synced items is rolled back and will not be found in the database\n\n";
  825. try {
  826. $percent = 0;
  827. foreach ($results as $record) {
  828. // Update the job status every 1% features.
  829. if ($job_id and $i % $interval == 0) {
  830. $percent = sprintf("%.2f", (($i + 1) / $count) * 100);
  831. print "Syncing $base_table " . ($i + 1) . " of $count (" . $percent . "%). Memory: " . number_format(memory_get_usage()) . " bytes.\r";
  832. tripal_set_job_progress($job_id, intval(($i/$count)*100));
  833. }
  834. // Check if the record is already in the chado linking table
  835. // (ie: check to see if it is already linked to a node).
  836. $result = db_select($linking_table, 'lnk')
  837. ->fields('lnk',array('nid'))
  838. ->condition($base_table_id, $record->{$base_table_id}, '=')
  839. ->execute()
  840. ->fetchObject();
  841. if (empty($result)) {
  842. // Create generic new node.
  843. $new_node = new stdClass();
  844. $new_node->type = $node_type;
  845. $new_node->uid = $user->uid;
  846. $new_node->{$base_table_id} = $record->{$base_table_id};
  847. $new_node->$base_table = $record;
  848. $new_node->language = LANGUAGE_NONE;
  849. // TODO: should we get rid of this hook and use hook_node_presave() instead?
  850. // allow base module to set additional fields as needed
  851. $hook_create_new_node = $node_type . '_chado_node_sync_create_new_node';
  852. if (function_exists($hook_create_new_node)) {
  853. $new_node = call_user_func($hook_create_new_node, $new_node, $record);
  854. }
  855. // Validate and Save New Node
  856. $form = array();
  857. $form_state = array();
  858. node_validate($new_node, $form, $form_state);
  859. if (!form_get_errors()) {
  860. $node = node_submit($new_node);
  861. // If there are memory leaks on the node_save it is probably
  862. // caused by the hook_node_insert() function.
  863. node_save($node);
  864. }
  865. else {
  866. throw new Exception(t("Failed to insert $base_table: %title", array('%title' => $new_node->title)));
  867. }
  868. }
  869. $i++;
  870. }
  871. print "\n\nComplete!\n";
  872. }
  873. catch (Exception $e) {
  874. $transaction->rollback();
  875. print "\n"; // make sure we start errors on new line
  876. watchdog_exception('trp-fsync', $e);
  877. print "FAILED: Rolling back database changes...\n";
  878. }
  879. }
  880. /**
  881. * This function is a wrapper for the chado_cleanup_orphaned_nodes function.
  882. * It breaks up the work of chado_cleanup_orphaned_nodes into smaller pieces
  883. * that are more managable for servers that may have low php memory settings.
  884. *
  885. * @param $table
  886. * The name of the table that corresonds to the node type we want to clean up.
  887. * @param $nentries
  888. * Optional. The number of entries to parse at one time (ie: the batch size).
  889. * Set to zero if no limit is needed.
  890. * @param $linking_table
  891. * Optional. The name of the linking table that maps Drupal nodes to Chado
  892. * records. This is only required if the linking table name is not of the
  893. * form: chado_[table] where [table] is the value provided to the $table
  894. * argument.
  895. * @param $node_type
  896. * Optional. The name of the node type for the records. This is only
  897. * required if the node type is not of the form: chado_[table] where
  898. * [table] is the value provided to the $table.
  899. * @param $job_id
  900. * Optional. This should be the job id from the Tripal jobs system. Typically,
  901. * only the Tripal jobs system will use the argument.
  902. *
  903. * @ingroup tripal_chado_node_api
  904. */
  905. function chado_cleanup_orphaned_nodes($table, $nentries = 25000, $linking_table = NULL, $node_type = NULL, $job_id = NULL) {
  906. // The max number of records either as nodes or linked records.
  907. $count = 0;
  908. // Will hold the number of nodes of this type.
  909. $ncount = 0;
  910. // Will hold the number of linked records.
  911. $clcount = 0;
  912. if (!$node_type) {
  913. $node_type = 'chado_' . $table;
  914. }
  915. if (!$linking_table) {
  916. $linking_table = 'chado_' . $table;
  917. }
  918. // Find the number nodes of type chado_$table and find the number of entries
  919. // in chado_$table; keep the larger of the two numbers.
  920. $dsql = "SELECT COUNT(*) FROM {node} WHERE type = :node_type";
  921. $ndat = db_query($dsql, array(':node_type' => $node_type));
  922. $temp = $ndat->fetchObject();
  923. $ncount = $temp->count;
  924. $clsql= "SELECT COUNT(*) FROM {" . $linking_table . "}";
  925. $cdat = db_query($clsql);
  926. $clcount = $cdat->fetchObject();
  927. if ($ncount < $clcount) {
  928. $count = $clcount;
  929. }
  930. else {
  931. $count = $ncount;
  932. }
  933. $transaction = db_transaction();
  934. print "\nNOTE: This operation is performed using a database transaction. \n" .
  935. "If it fails or is terminated prematurely then the entire set of \n" .
  936. "changes is rolled back and will not be found in the database\n\n";
  937. try {
  938. $m = ceil($count / $nentries);
  939. for ($i = 0; $i < $m; $i++) {
  940. $offset = ($nentries * $i);
  941. chado_cleanup_orphaned_nodes_part($table, $job_id, $nentries, $offset, $linking_table, $node_type);
  942. }
  943. }
  944. catch (Exception $e) {
  945. $transaction->rollback();
  946. print "\n"; // make sure we start errors on new line
  947. watchdog_exception('trp-fsync', $e);
  948. print "FAILED: Rolling back database changes...\n";
  949. }
  950. return '';
  951. }
  952. /**
  953. * This function will delete Drupal nodes for any sync'ed table (e.g.
  954. * feature, organism, analysis, stock, library) if the chado record has been
  955. * deleted or the entry in the chado_[table] table has been removed.
  956. *
  957. * @param $table
  958. * The name of the table that corresonds to the node type we want to clean up.
  959. * @param $job_id
  960. * This should be the job id from the Tripal jobs system. This function
  961. * will update the job status using the provided job ID.
  962. *
  963. * @ingroup tripal_chado_node_api
  964. */
  965. function chado_cleanup_orphaned_nodes_part($table, $job_id = NULL, $nentries,
  966. $offset, $linking_table, $node_type) {
  967. $count = 0;
  968. // Retrieve all of the entries in the linker table for a given node type
  969. // and place into an array.
  970. print "Verifying $linking_table records...\n";
  971. $cnodes = array();
  972. $clsql= "
  973. SELECT *
  974. FROM {" . $linking_table . "} LT
  975. ORDER BY LT.nid LIMIT $nentries OFFSET $offset";
  976. $res = db_query($clsql);
  977. foreach ($res as $node) {
  978. $cnodes[$count] = $node;
  979. $count++;
  980. }
  981. // Iterate through all of the $linking_table entries and remove those
  982. // that don't have a node or don't have a $table record.
  983. $deleted = 0;
  984. if ($count > 0) {
  985. $i = 0;
  986. $interval = intval($count * 0.01);
  987. if ($interval < 1) {
  988. $interval = 1;
  989. }
  990. foreach ($cnodes as $linker) {
  991. // Update the job status every 1% analyses
  992. if ($job_id and $i % $interval == 0) {
  993. $percent = sprintf("%.2f", ($i / $count) * 100);
  994. tripal_set_job_progress($job_id, intval($percent));
  995. print "Percent complete: $percent%. Memory: " . number_format(memory_get_usage()) . " bytes.\n";
  996. }
  997. // See if the node exits, if not remove the entry from linking table table.
  998. $nsql = "SELECT * FROM {node} WHERE nid = :nid AND type = :node_type";
  999. $results = db_query($nsql, array(':nid' => $linker->nid, ':node_type' => $node_type));
  1000. $node = $results->fetchObject();
  1001. if (!$node) {
  1002. $deleted++;
  1003. db_query("DELETE FROM {" . $linking_table . "} WHERE nid = :nid", array(':nid' => $linker->nid));
  1004. //print "$linking_table missing node.... DELETING where nid=".$linker->nid." $linking_table entry.\n";
  1005. }
  1006. // Does record in chado exists, if not remove entry from $linking_table.
  1007. $table_id = $table . "_id";
  1008. $lsql = "SELECT * FROM {" . $table . "} where " . $table_id . " = :chado_id";
  1009. $results = chado_query($lsql, array(":chado_id" => $linker->$table_id));
  1010. $record = $results->fetchObject();
  1011. if (!$record) {
  1012. $deleted++;
  1013. $sql = "DELETE FROM {" . $linking_table . "} WHERE " . $table_id . " = :chado_id";
  1014. db_query($sql, array(":chado_id" => $linker->$table_id));
  1015. //print "$linking_table missing $table.... DELETING where $table_id=".$linker->$table_id." $linking_table entry.\n";
  1016. }
  1017. $i++;
  1018. }
  1019. $percent = sprintf("%.2f", ($i / $count) * 100);
  1020. tripal_set_job_progress($job_id, intval($percent));
  1021. print "Percent complete: $percent%. Memory: " . number_format(memory_get_usage()) . " bytes.\n";
  1022. }
  1023. print "\nDeleted $deleted record(s) from $linking_table missing either a node or chado entry.\n";
  1024. // Build the SQL statements needed to check if nodes point to valid record.
  1025. print "Verifying nodes...\n";
  1026. $dsql = "
  1027. SELECT *
  1028. FROM {node}
  1029. WHERE type = :node_type
  1030. ORDER BY nid
  1031. LIMIT $nentries OFFSET $offset
  1032. ";
  1033. $dsql_args = array(':node_type' => $node_type);
  1034. $nodes = array();
  1035. $res = db_query($dsql, $dsql_args);
  1036. $count = 0;
  1037. foreach ($res as $node) {
  1038. $nodes[$count] = $node;
  1039. $count++;
  1040. }
  1041. // Iterate through all of the nodes and delete those that don't
  1042. // have a corresponding entry in the linking table.
  1043. $deleted = 0;
  1044. if ($count > 0) {
  1045. $i = 0;
  1046. $interval = intval($count * 0.01);
  1047. if ($interval < 1) {
  1048. $interval = 1;
  1049. }
  1050. foreach ($nodes as $node) {
  1051. // update the job status every 1%
  1052. if ($job_id and $i % $interval == 0) {
  1053. $percent = sprintf("%.2f", ($i / $count) * 100);
  1054. tripal_set_job_progress($job_id, intval($percent));
  1055. print "Percent complete: $percent%. Memory: " . number_format(memory_get_usage()) . " bytes.\r";
  1056. }
  1057. // check to see if the node has a corresponding entry
  1058. // in the $linking_table table. If not then delete the node.
  1059. $csql = "SELECT * FROM {" . $linking_table . "} WHERE nid = :nid ";
  1060. $results = db_query($csql, array(':nid' => $node->nid));
  1061. $link = $results->fetchObject();
  1062. if (!$link) {
  1063. // Checking node_access creates a memory leak. Commenting out for now
  1064. // assuming that this code can only be run by a site administrator
  1065. // anyway.
  1066. // if (node_access('delete', $node)) {
  1067. $deleted++;
  1068. node_delete($node->nid);
  1069. // }
  1070. // else {
  1071. // print "\nNode missing in $linking_table table.... but cannot delete due to improper permissions (node $node->nid)\n";
  1072. // }
  1073. }
  1074. $i++;
  1075. }
  1076. $percent = sprintf("%.2f", ($i / $count) * 100);
  1077. tripal_set_job_progress($job_id, intval($percent));
  1078. print "Percent complete: $percent%. Memory: " . number_format(memory_get_usage()) . " bytes.\r";
  1079. print "\nDeleted $deleted node(s) that did not have corresponding $linking_table entries.\n";
  1080. }
  1081. return '';
  1082. }
  1083. /**
  1084. * Create New Node
  1085. *
  1086. * Note: For your own module, replace hook in the function name with the
  1087. * machine-name of your chado node type (ie: chado_feature).
  1088. *
  1089. * @param $new_node:
  1090. * a basic new node object
  1091. * @param $record:
  1092. * the record object from chado specifying the biological data for this node
  1093. *
  1094. * @return
  1095. * A node object containing all the fields necessary to create a new node
  1096. * during sync
  1097. *
  1098. * @ingroup tripal_chado_node_api
  1099. */
  1100. function hook_chado_node_sync_create_new_node($new_node, $record) {
  1101. // Add relevant chado details to the new node object. This really only
  1102. // needs to be the fields from the node used during node creation
  1103. // including values used to generate the title, etc. All additional chado
  1104. // data will be added via nodetype_load when the node is later used
  1105. $new_node->uniquename = $record->uniquename;
  1106. return $new_node;
  1107. }
  1108. /**
  1109. * Alter the Chado node sync form.
  1110. *
  1111. * This might be necessary if you need additional filtering options for
  1112. * choosing which chado records to sync or even if you just want to further
  1113. * customize the help text provided by the form.
  1114. *
  1115. * Note: For your own module, replace hook in the function name with the
  1116. * machine-name of your chado node type (ie: chado_feature).
  1117. *
  1118. * @ingroup tripal_chado_node_api
  1119. */
  1120. function hook_chado_node_sync_form($form, &$form_state) {
  1121. // Change or add to the form array as needed.
  1122. // Any changes should be made in accordance with the Drupal Form API.
  1123. return $form;
  1124. }
  1125. /**
  1126. * Bypass chado node api sync form submit.
  1127. *
  1128. * Allows you to use this function as your own submit.
  1129. *
  1130. * This might be necessary if you want to add additional arguments to the
  1131. * tripal job or to call your own sync'ing function if the generic
  1132. * chado_node_sync_records() is not sufficient.
  1133. *
  1134. * Note: For your own module, replace hook in the function name with the
  1135. * machine-name of your chado node type (ie: chado_feature).
  1136. *
  1137. * @ingroup tripal_chado_node_api
  1138. */
  1139. function hook_chado_node_sync_form_submit ($form, $form_state) {
  1140. global $user;
  1141. $job_args = array(
  1142. // The base chado table (ie: feature).
  1143. $base_table,
  1144. // The maximum number of records to sync or FALSE for sync all that match.
  1145. $max_sync,
  1146. // The organism_id to restrict records to or FALSE if not to restrict by organism_id.
  1147. $organism_id,
  1148. // A string with the cvterm.name of the types to restrict to separated by |||
  1149. $types
  1150. );
  1151. // You should register a tripal job
  1152. tripal_add_job(
  1153. // The title of the job -be descriptive.
  1154. $title,
  1155. // The name of your module.
  1156. $module,
  1157. // The chado node api sync function.
  1158. 'chado_node_sync_records',
  1159. // An array with the arguments to pass to the above function.
  1160. $job_args,
  1161. // The user who submitted the job.
  1162. $user->uid
  1163. );
  1164. }
  1165. /**
  1166. * Alter the query that retrieves records to be sync'd (optional)
  1167. *
  1168. * This might be necessary if you need fields from other chado tables to
  1169. * create your node or if your chado node type only supports a subset of a
  1170. * given table (ie: a germplasm node type might only support node creation for
  1171. * cerain types of stock records in which case you would need to filter the
  1172. * results to only those types).
  1173. *
  1174. * Note: For your own module, replace hook in the function name with the
  1175. * machine-name of your chado node type (ie: chado_feature).
  1176. *
  1177. * @param $query
  1178. * An array containing the following:
  1179. * 'select': An array of select clauses
  1180. * 'joins: An array of joins (ie: a single join could be
  1181. * 'LEFT JOIN {chadotable} alias ON base.id=alias.id')
  1182. * 'where_clauses: An array of where clauses which will all be AND'ed
  1183. * together. Use :placeholders for values.
  1184. * 'where_args: An associative array of arguments to be subbed in to the
  1185. * where clause where the
  1186. *
  1187. * @ingroup tripal_chado_node_api
  1188. */
  1189. function hook_chado_node_sync_select_query($query) {
  1190. // You can add fields to be selected. Be sure to prefix each field with the
  1191. // tale name.
  1192. $query['select'][] = 'example.myfavfield';
  1193. // Provide any join you may need to the joins array. Be sure to wrap the
  1194. // table name in curly brackets.
  1195. $query['joins'][] = 'LEFT JOIN {exampleprop} PROP ON PROP.example_id=EXAMPLE.example_id';
  1196. // The category should be a unique id for a group of items that will be
  1197. // concatenated together via an SQL 'OR'. By default the $where_clases
  1198. // variable will come with categories of 'id', 'organism' and 'type'.
  1199. // you can add your own unique category or alter the contents of the existing
  1200. // categories. Be sure to make sure the category doesn't already exist
  1201. // in the $query['where_clauses']
  1202. $category = 'my_category';
  1203. // Provide any aditionall where clauses and their necessary arguments.
  1204. // Be sure to prefix the field with the table name. Be sure that the
  1205. // placeholder is unique across all categories (perhaps add a unique
  1206. // prefix/suffix).
  1207. $query['where_clauses'][$category][] = 'example.myfavfield = :favvalue';
  1208. $query['where_args'][$category][':favvalue'] = 'awesome-ness';
  1209. // Must return the updated query
  1210. return $query;
  1211. }