tripal/tripal_analysis_blast/tripal_analysis_blast.module

<?php

require_once "parse_blast_XML.inc";


/*******************************************************************************
 * Tripal Blast Result lets users show/hide blast results associated
 * with a tripal feature
 ******************************************************************************/
function tripal_analysis_blast_init(){
	// Add javascript and style sheet
	drupal_add_css(drupal_get_path('theme', 'tripal').'/css/tripal_analysis_blast.css');
	drupal_add_js(drupal_get_path('theme', 'tripal').'/js/tripal_analysis_blast.js');
}

/*******************************************************************************
 * tripal_analysis_blast_menu()
 * HOOK: Implementation of hook_menu()
 * Entry points and paths of the module
 */
function tripal_analysis_blast_menu() {
	// Show top 10/25/all blast results for ajax calls
	$items['tripal_top_blast'] = array(
      'path' => 'top_blast',
      'title' => t('Blast Hits'),
      'page callback' => 'tripal_get_feature_blast_results_ajax',
      'page arguments' => array(1,2,3),
      'access arguments' => array('access content'),
      'type' => MENU_CALLBACK
	);
	// Show regular expressions for selected database in Blast admin page
	$items['admin/tripal/tripal_analysis/tripal_blast_regex/%'] = array(
      'title' => t('Blast Regex'),
      'page callback' => 'tripal_get_blast_regex',
      'page arguments' => array(4),
      'access arguments' => array('administer site configuration'),
      'type' => MENU_CALLBACK
	);
	$items['tripal_blast_report'] = array(
      'title' => t('Homology Report'),
      'page callback' => 'tripal_get_blast_report',
      'page arguments' => array(1,2,3,4,5),
      'access arguments' => array('access chado_analysis_blast content'),
      'type' => MENU_CALLBACK,
	   'file' => 'tripal_analysis_blast_htmlreport.inc'
	);
	return $items;
}


/*******************************************************************************
 * tripal_analysis_blast_nodeapi()
 * HOOK: Implementation of hook_nodeapi()
 * Display blast results for allowed node types
 */
function tripal_analysis_blast_nodeapi(&$node, $op, $teaser, $page) {

	switch ($op) {
		case 'view':
			// Find out which node types for showing the blast
			$types_to_show = variable_get('tripal_analysis_blast_setting',
			array('chado_feature'));

			// Abort if this node is not one of the types we should show.
			if (!in_array($node->type, $types_to_show, TRUE)) {
				break;
			}
			// Add blast to the content item if it's not a teaser
			if (!$teaser && $node->feature->feature_id) {
				if($node->build_mode == NODE_BUILD_SEARCH_INDEX){
					$node->content['tripal_analysis_blast_index_version'] = array(
                  '#value' => theme('tripal_analysis_blast_results_index_version',$node),
                  '#weight' => 8,
					);
				} else {
               if(strcmp($node->type,'chado_feature')==0){
					   // Show blast result if not at teaser view
					   $node->content['tripal_feature_blast_results'] = array(
                     '#value' => theme('tripal_feature_blast_results', $node),
                     '#weight' => 8
					   );
               }
				}
			}
	}
}
/************************************************************************
 *  We need to let drupal know about our theme functions and their arguments.
 *  We create theme functions to allow users of the module to customize the
 *  look and feel of the output generated in this module
 */
function tripal_analysis_blast_theme () {
	return array(
      'tripal_analysis_blast_results_index_version' => array (
         'arguments' => array('node'),
		),
		'tripal_feature_blast_results' => array(
			'arguments' =>  array('node'=> null),
		   'template' => 'tripal_feature_blast_results',
		)
	);
}
/*******************************************************************************
 *  
 */
function tripal_get_feature_blast_results_ajax($feature_id, $db_id, $max){
   $sql = "SELECT nid FROM {chado_feature} WHERE feature_id = %d";
   $nid = db_fetch_object(db_query($sql,$feature_id));
   $node = node_load($nid->nid);

   // add the additional variables that the theme needs to generate the output
   $node->db_id = $db_id;
   $node->max = $max;
   // call the theme to rebuild the blast results
   drupal_json(array('update' => theme('tripal_feature_blast_results',$node)));
}
/*******************************************************************************
 *  
 */
function tripal_analysis_blast_preprocess_tripal_feature_blast_results(&$variables){
   $feature = $variables['node']->feature;
   $db_id = $variables['node']->db_id;
  
   $max = 10;
   if(isset($variables['node']->max)){
      $max = $variables['node']->max;
   }
   $blast_results = tripal_get_feature_blast_results($feature->feature_id, $db_id, $max);
   $variables['tripal_analysis_blast']['blast_results_list'] = $blast_results;
}
/*******************************************************************************
 * Prepare blast result for the feature shown on the page
 */
function theme_tripal_analysis_blast_results_index_version ($node) {
	$feature = $node->feature;
	$content = tripal_get_blast_results_index_version($feature->feature_id);
	return $content;
}

/*******************************************************************************
 * tripal_get_feature_blast_results()
 * Get blast result from featureprop table for the feature
 */
function tripal_get_feature_blast_results($feature_id, $db_id, $max){

	// Get the blast results stored as XML from the analysisfeatureprop table
   // the type for the property is named 'analysis_blast_output_iteration_hits'
   // and is found in the 'tripal' controlled vocabulary.  This CV term was
   // added by this module.
	$sql = "SELECT AP.value AS apvalue, AFP.value AS afpvalue, AF.analysis_id AS aid
	        FROM {analysisfeatureprop} AFP
	          INNER JOIN {analysisfeature} AF ON AF.analysisfeature_id = AFP.analysisfeature_id
	          INNER JOIN {analysisprop} AP ON AP.analysis_id = AF.analysis_id
             INNER JOIN {cvterm} CVT on AFP.type_id = CVT.cvterm_id
             INNER JOIN {cv} CV on CVT.cv_id = CV.cv_id
	        WHERE AF.feature_id = %d AND CV.name = '%s' AND
                 CVT.name = '%s' AND AP.value like '%|%' ";
	$previous_db = tripal_db_set_active('chado');
	$result = db_query($sql, $feature_id,'tripal','analysis_blast_output_iteration_hits');
	tripal_db_set_active($previous_db);

	// get the HTML content for viewing each of the XML file
	$blast_obj_array = array ();
	$blast_obj_counter = 0;
	while ($analysisfeatureprop = db_fetch_object($result)) {

      // the database db_id is stored in the value field of the table
      // along with the XML.  The two are separated by a bar.  We
      // will separate these two:
		$blastsettings = explode("|", $analysisfeatureprop->apvalue);

      // if we don't have the proper number of fields in the value column then
      // skip this entry
      if(count($blastsettings) != 3){
        continue;
      }
      if(!$blastsettings[0]){
        continue;
      }
		$att_db_id = $blastsettings[0];

		// get analysis name and date
		$previous_db = tripal_db_set_active('chado');
		$sql = "SELECT analysis_id AS aid, name, to_char(timeexecuted, 'MM-DD-YYYY') AS time
		        FROM {analysis}
 		        WHERE analysis_id = %d";
		$analysis = db_fetch_object(db_query($sql, $analysisfeatureprop->aid));
		tripal_db_set_active($previous_db);

		// Get db object using the db_id
		$previous_db = tripal_db_set_active('chado');
		$sql = "SELECT * FROM {db} WHERE db_id=%d";
		$db = db_fetch_object(db_query($sql, $att_db_id));
		tripal_db_set_active($previous_db);

      // we want to add this blast result to our list if a database id has
      // not been specified or if it has been specified and the database id
      // for this analysis matches that of the one requested
      if(!$db_id or ($db_id and $att_db_id == $db_id)) {
			$blast_obj = tripal_analysis_blast_get_result_object($analysisfeatureprop->afpvalue,$db,$max,$feature_id, $analysis);
         $blast_obj->analysis = $analysis;
			$blast_obj_array [$blast_obj_counter] = $blast_obj;
			$blast_obj_counter ++;
      }
	}
   return $blast_obj_array;
}
/*******************************************************************************
 * Scanning the file folder for blast results and prepare content for indexing
 */
function tripal_get_blast_results_index_version ($feature_id){

	// Get cvterm_id for 'analysis_blast_output_iteration_hits' which is required
	// for inserting into the analysisfeatureprop table
	$previous_db = tripal_db_set_active('chado');
	$sql = "SELECT CVT.cvterm_id FROM {cvterm} CVT ".
          "INNER JOIN cv ON cv.cv_id = CVT.cv_id ".
          "WHERE CVT.name = 'analysis_blast_output_iteration_hits' ".
          "AND CV.name = 'tripal'";
	$type_id = db_result(db_query($sql));

	// Get xml string from analysisfeatureprop value column, get db_id from analysisprop value column
	// , and get analysis_id from analysisfeature table
	$sql = "SELECT AP.value AS apvalue, AFP.value AS afpvalue, AF.analysis_id AS aid
           FROM {analysisfeatureprop} AFP
           INNER JOIN analysisfeature AF ON AF.analysisfeature_id = AFP.analysisfeature_id
           INNER JOIN analysisprop AP ON AP.analysis_id = AF.analysis_id
           WHERE feature_id = %d
           AND AFP.type_id = %d ";
	$result = db_query($sql, $feature_id, $type_id);
	tripal_db_set_active($previous_db);

	// get the HTML content for viewing each of the XML file
	while ($analysisfeatureprop = db_fetch_object($result)) {
		// get analysis name and date
		$previous_db = tripal_db_set_active('chado');
		$sql = "SELECT analysis_id AS aid, name, to_char(timeexecuted, 'MM-DD-YYYY') AS time
              FROM {analysis}               WHERE analysis_id = %d";
		$analysis = db_fetch_object(db_query($sql, $analysisfeatureprop->aid));
		tripal_db_set_active($previous_db);

		$blastsettings = explode("|", $analysisfeatureprop->apvalue);
		$att_db_id = $blastsettings [0];

		// Get db object using the db_id
		$previous_db = tripal_db_set_active('chado');
		$sql = "SELECT * FROM {db} WHERE db_id=%d";
		$db = db_fetch_object(db_query($sql, $att_db_id));
		tripal_db_set_active($previous_db);
		// Only index best 10 hits because the default page only shows 10 blast results
		$max = 10;
		$content .= parse_NCBI_Blast_XML_index_version($analysisfeatureprop->afpvalue,$db,$max,$feature_id,$ajax, $analysis);
			
	}
	return $content;

}


/*******************************************************************************
 * Tripal Blast administrative setting form. This function is called by
 * tripal_analysis module which asks for an admin form to show on the page
 */
function tripal_analysis_blast_get_settings() {
	// Get an array of node types with internal names as keys
	$options = node_get_types('names');
	// Add 'chado_feature' to allowed content types for showing blast results
	$allowedoptions ['chado_feature'] = "Show blast results on feature pages";

	$form['description'] = array(
       '#type' => 'item',
       '#value' => t("Most chado features were analyzed by blast against major sequence databases. This option allows user to display the blast analysis results. Please read user manual for storage and display of blast files. Check the box to enable the analysis results. Uncheck to disable it."),
		 '#weight' => 0,
	);

	$form['tripal_analysis_blast_setting'] = array(
      '#type' => 'checkboxes',
      '#options' => $allowedoptions,
      '#default_value' => variable_get('tripal_analysis_blast_setting',
	array('chado_feature')),
	);
	$form['blast_parser'] = array(
      '#title' => t('Blast Parser Settings'),
      '#type' => 'fieldset',
      '#description' => t('Configure parsers for showing blast results. Each database is '.
                          'allowed to have one xml parser.'),
      '#weight' => 10
	);

	$previous_db = tripal_db_set_active('chado');  // use chado database
	// get a list of db from chado for user to choose
	$sql = 'SELECT db_id, name FROM {db} ORDER BY lower(name)';
	$results = db_query ($sql);
	$blastdbs = array();
	while ($db = db_fetch_object($results)){
		$blastdbs[$db->db_id] = $db->name;
	}
	$form['db_options'] = array(
      '#type' => 'value',
      '#value' => $blastdbs
	);
	$form['blast_parser']['blastdb'] = array(
      '#title' => t('Database'),
      '#type' => 'select',
      '#description' => t('The database used for the blast analysis.'),
      '#options' => $form['db_options']['#value'],
      '#attributes' => array(
         'onChange' => "return tripal_update_regex(this)",
	    )
	);
	$form['blast_parser']['displayname'] = array(
      '#title' => t('Title for the blast analysis'),
      '#type' => 'textfield',
	);
	$form['blast_parser']['gb_style_parser'] = array(
      '#title' => t('Use Genebank style parser. This will clear all regular expression settings for the selected database.'),
	   '#type' => 'checkbox',
	   '#attributes' => array(
         'onClick' => "return tripal_set_genbank_style(this)",
	    )
	);
	$form['blast_parser']['hit_id'] = array(
      '#title' => t('Regular expression for Hit Name'),
      '#type' => 'textfield',
	);
	$form['blast_parser']['hit_def'] = array(
      '#title' => t('Regular expression for Hit Description'),
      '#type' => 'textfield',
	);
	$form['blast_parser']['hit_accession'] = array(
      '#title' => t('Regular expression for Hit Accession'),
      '#type' => 'textfield',
	);
	$form['blast_parser']['button'] = array(
      '#type' => 'submit',
      '#value' => t('Save settings')
	);
	tripal_db_set_active($previous_db); // use drupal database

	$settings->form = $form;
	$settings->title = "Tripal Blast";
	return $settings;
}



/*******************************************************************************
 * This function is only called by ajax to get regular expressions for blast
 * admin page
 */
function tripal_get_blast_regex ($db_id) {
	$sql = "SELECT * FROM {tripal_analysis_blast} WHERE db_id = %d";
	$blast_regexs = db_fetch_object(db_query($sql, $db_id));
	drupal_json(array(
	     'name' => $blast_regexs->displayname,
	     'genbank_style' => $blast_regexs->genbank_style,
	     'reg1' => $blast_regexs->regex_hit_id,
	     'reg2' => $blast_regexs->regex_hit_def,
	     'reg3' => $blast_regexs->regex_hit_accession)
	);
}

/*******************************************************************************
 *  Provide information to drupal about the node types that we're creating
 *  in this module
 */
function tripal_analysis_blast_node_info() {
	$nodes = array();
	$nodes['chado_analysis_blast'] = array(
      'name' => t('Analysis: Blast'),
      'module' => 'chado_analysis_blast',
      'description' => t('A blast analysis from the chado database'),
      'has_title' => FALSE,
      'title_label' => t('Analysis: Blast'),
      'has_body' => FALSE,
      'body_label' => t('Blast Analysis Description'),
      'locked' => TRUE
	);
	return $nodes;
}


/*******************************************************************************
 *  Provide a Blast Analysis form
 */
function chado_analysis_blast_form ($node){
    //dprint_r($node);

   // add in the default fields
   $form = chado_analysis_form($node);

   // set the default values
   $blast = $node->analysis->tripal_analysis_blast;
   $blastdb = $blast->blastdb;
   $blastfile    = $blast->blastfile;
   $blastparameters = $blast->blastparameters;

   $query_re = $blast->query_re;
   $query_type = $blast->query_type;
   $query_uniquename = $blast->query_uniquename;

		
	$form['blast'] = array(
      '#title' => t('Blast Settings'),
      '#type' => 'fieldset',
      '#description' => t('Specific Settings for Blast Analysis.'),
      '#collapsible' => TRUE,
      '#attributes' => array('id' => 'blast-extra-settings'),
      '#weight' => 11
	);

	$previous_db = tripal_db_set_active('chado');  // use chado database
	// get a list of db from chado for user to choose
	$sql = 'SELECT db_id, name FROM {db} ORDER BY lower(name)';
	$results = db_query ($sql);
	tripal_db_set_active($previous_db);
	$blastdbs = array();
	while ($db = db_fetch_object($results)){
		$blastdbs[$db->db_id] = $db->name;
	}
	$form['db_options'] = array(
      '#type' => 'value',
      '#value' => $blastdbs
	);
	$form['blast']['blastdb'] = array(
      '#title' => t('Database'),
      '#type' => 'select',
      '#description' => t('The database used for the blast analysis. If the database does not appear in this list, please add it.'),
      '#options' => $form['db_options']['#value'],
      '#default_value' => $blastdb,
	);

	$form['blast']['blastfile'] = array(
      '#title' => t('Blast XML File/Directory: (if you input a directory without the tailing slash, all xml files in the directory will be loaded)'),
      '#type' => 'textfield',
      '#description' => t('The xml output file generated by blast in full path.'),
      '#default_value' => $blastfile,
	); 
   $form['blast']['blastfile_ext'] = array(
      '#title' => t('Blast XML file extension'),
      '#type' => 'textfield',
      '#description' => t('If a directory is provide for the blast file setting above, then a file extension can be provided here. Files with this extension in the directory will be parsed.  If no extension is provided then files with a .xml extension will be parsed within the directory. Please provide the extension without the preceeding period (e.g. "out" rather than ".out"'),
      '#default_value' => $blastfile_ext,
	);
	$form['blast']['no_parsed'] = array(
	  '#title' => t('Number of hits to be parsed'),
      '#type' => 'textfield',
      '#description' => t("The number of hits to be parsed. Tripal will parse only top 10 hits if you input '10'' in this field."),
      '#default_value' => 'all',
	);

	$form['blast']['query_re'] = array(
      '#title' => t('Query Name RE'),
      '#type' => 'textfield',
      '#description' => t('Enter the regular expression that will extract the '.
         'feature name from the query line in the blast results. This should be '.
         'the same as the definition line in the query FASTA file.  This option is '.
         'is only required when the query does not identically match a feature '.
         'in the database.'),
      '#default_value' => $query_re,
	);

	$form['blast']['query_type'] = array(
      '#title' => t('Query Type'),
      '#type' => 'textfield',
      '#description' => t('Please enter the Sequence Ontology term that describes '.
         'the query sequences used for blasting.  This is only necessary if two '.
         'or more sequences have the same name.'),
      '#default_value' => $query_type,
	);

	$form['blast']['query_uniquename'] = array(
      '#title' => t('Use Unique Name'),
      '#type' => 'checkbox',
      '#description' => t('Select this checboxk if the query name in the blast file '.
        'matches the uniquename of the feature.  By default, the blast results will '.
        'mapped to the "name" of the feature.'),
      '#default_value' => $query_uniquename,
	);

	$form['blast']['blastparameters'] = array(
      '#title' => t('Parameters'),
      '#type' => 'textfield',
      '#description' => t('The parameters for running the blast analysis.'),
      '#default_value' => $blastparameters,
	);
	
	$form['blast']['blastjob'] = array(
      '#type' => 'checkbox',
      '#title' => t('Submit a job to parse the xml output into analysisfeatureprop table'),
      '#description' => t('Note: features associated with the blast results must '.
                          'exist in chado before parsing the file. Otherwise, blast '.
                          'results that cannot be linked to a feature will be '.
                          'discarded. '),
      '#default_value' => $blastjob
	);
	
	$form['blast']['blastbesthit'] = array(
      '#type' => 'checkbox',
      '#title' => t('Submit a job to generate a "best hits" report.'),
      '#description' => t('Note: the checkbox above must also be selected.'),
      '#default_value' => $blastbesthit
	);
	
	return $form;
}

function chado_analysis_blast_validate($node, &$form){
    ##dprint_r($node);

    // This validation is being used for three activities:
    // CASE A: Update a node that exists in both drupal and chado
    // CASE B: Synchronizing a node from chado to drupal
    // CASE C: Inserting a new node that exists in niether drupal nor chado

    // Only nodes being updated will have an nid already
    if($node->nid){
        //---------------------------------------------------
        // CASE A: We are validating a form for updating an existing node
        //---------------------------------------------------

        // TO DO: check that the new fields don't yield a non-unique primary key in chado
    }
    else{
        // To differentiate if we are syncing or creating a new analysis altogther, see if an
        // analysis_id already exists

        if($node->analysis_id){

            //---------------------------------------------------
            // CASE B: Synchronizing a node from chado to drupal
            //---------------------------------------------------

        }
        else{

            //---------------------------------------------------
            // CASE C: We are validating a form for inserting a new node
            //---------------------------------------------------
            // The primary key for the chado analysis table is 
            // program, programversion, sourcename
            // Check to see if this analysis really is new -ie, it doesn't have the same
            // primary key as any other analysis 
	        $sql = "SELECT analysis_id ".
                "FROM {analysis} ".
                "WHERE program='%s'".
                "AND programversion='%s'".
                "AND sourcename='%s'";
	        $previous_db = tripal_db_set_active('chado');
	        $analysis_id = db_result(db_query($sql, $node->program, $node->programversion, $node->sourcename));
            tripal_db_set_active($previous_db);
        
            if($analysis_id){
                //---------------------------------------------------
                // this primary key already exists in chado analysis table!
                //---------------------------------------------------
        
                // check to see if it has also been synced with drupal
	            $sql = "SELECT nid FROM {chado_analysis} ".
                                "WHERE analysis_id = %d";
	            $node_id = db_result(db_query($sql, $analysis_id));
	            if($node_id){
                    //---------------------------------------------------
                    // the analysis has already been synced with drupal, redirect the user
                    // to modify that node or start over
                    //---------------------------------------------------
                    $error = 'This analysis already exists in the chado database (analysis id ';
                    $error .= $analysis_id.') and has been synchronized ';
                        $error .= 'with drupal. See node '.$node_id.' if you wish to update that analysis.  ';
                    $error .= ' For a new analysis, please select a unique primary key ';
                    $error .= '(primary key consists of sourcename, program and programversion).';
                    form_set_error('sourcename', t($error));
                }
        
                else{
                    //---------------------------------------------------
                    // the analysis does not exist in drupal - tell the user 
                    // to sync from chado or create a new unique primary key
                    //---------------------------------------------------
                    $error = 'This analysis already exists in the chado database (analysis id ';
                    $error .= $analysis_id.') but has not been synchronized ';
                    $error .= 'with drupal. See the tripal admin pages to synchronize. ';
                    $error .= ' For a new analysis, please select a unique primary key ';
                    $error .= '(primary key consists of sourcename, program and programversion).';
                    form_set_error('sourcename', t($error));
                }
            }
        }
    }
}

/*******************************************************************************
 *  When a node is requested by the user this function is called to allow us
 *  to add auxiliary data to the node object.
 */
function chado_analysis_blast_load($node){

   // load the default set of analysis fields
	$additions = chado_analysis_load($node);

   // create some variables for easier lookup
   $analysis = $additions->analysis;
   $analysis_id = $analysis->analysis_id;

   $blast_settings  = tripal_analysis_get_property($analysis->analysis_id,'analysis_blast_settings');	
   $blastdb         = tripal_analysis_get_property($analysis->analysis_id,'analysis_blast_blastdb');
   $blastfile       = tripal_analysis_get_property($analysis->analysis_id,'analysis_blast_blastfile');	
   $blastparameters = tripal_analysis_get_property($analysis->analysis_id,'analysis_blast_blastparameters');
   $no_parsed       = tripal_analysis_get_property($analysis->analysis_id,'analysis_blast_no_parsed');	
   $query_re        = tripal_analysis_get_property($analysis->analysis_id,'analysis_blast_query_re');	
   $query_type      = tripal_analysis_get_property($analysis->analysis_id,'analysis_blast_query_type');	
   $query_uniquename= tripal_analysis_get_property($analysis->analysis_id,'analysis_blast_query_uniquename');	
   $blastfile_ext   = tripal_analysis_get_property($analysis->analysis_id,'analysis_blast_blastfile_ext');	


   $analysis->tripal_analysis_blast->blastdb         = $blastdb->value;
   $analysis->tripal_analysis_blast->blastfile       = $blastfile->value;	
   $analysis->tripal_analysis_blast->blastparameters = $blastparameters->value;
   $analysis->tripal_analysis_blast->no_parsed       = $no_parsed->value;	
   $analysis->tripal_analysis_blast->query_re        = $query_re->value;	
   $analysis->tripal_analysis_blast->query_type      = $query_type->value;	
   $analysis->tripal_analysis_blast->query_uniquename= $query_uniquename->value;	
   $analysis->tripal_analysis_blast->blastfile_ext   = $blastfile_ext->value;	

   // get the database information so that we don't have to require callers
   // to do the lookup
   $select = array('db_id' => $blastdb->value);
   $analysis->tripal_analysis_blast->db = tripal_core_generate_chado_var('db',$select);

   // if there is an old style 'blast_settings' array, then break these out for
   // use in the new format
   if(count($blast_settings)>0){
	   $prop_values = explode ("|", $blast_settings->value);
      $analysis->tripal_analysis_blast->blastdb = $prop_values[0];
      $analysis->tripal_analysis_blast->blastfile = $prop_values[1];
      $analysis->tripal_analysis_blast->blastparameters = $prop_values[2];
   }
	return $additions;
}
/**
*
*/
function chado_analysis_blast_insert($node){

   // insert the analysis
   chado_analysis_insert($node);

   // set the type for this analysis
   tripal_analysis_insert_property($node->analysis->analysis_id,'analysis_type','tripal_analysis_blast');

   // now add in the remaining settings as a single property but separated by bars
   tripal_analysis_insert_property($node->analysis_id,'analysis_blast_blastdb',$node->blastdb);
   tripal_analysis_insert_property($node->analysis_id,'analysis_blast_blastfile',$node->blastfile);	
   tripal_analysis_insert_property($node->analysis_id,'analysis_blast_blastparameters',$node->blastparameters);	
   tripal_analysis_insert_property($node->analysis_id,'analysis_blast_no_parsed',$node->no_parsed);	
   tripal_analysis_insert_property($node->analysis_id,'analysis_blast_query_re',$node->query_re);	
   tripal_analysis_insert_property($node->analysis_id,'analysis_blast_query_type',$node->query_type);	
   tripal_analysis_insert_property($node->analysis_id,'analysis_blast_query_uniquename',$node->query_uniquename);	
   tripal_analysis_insert_property($node->analysis_id,'analysis_blast_blastfile_ext',$node->blastfile_ext);	
  
   // submit the parsing jobs
   chado_analysis_blast_submit_jobs($node);
}
/**
 * 
 */
function chado_analysis_blast_update($node){

   // update the anlaysis
   chado_analysis_update($node); 

   // add the blast settings
   tripal_analysis_update_property($node->analysis_id,'analysis_type','tripal_analysis_blast',1);	
   tripal_analysis_update_property($node->analysis_id,'analysis_blast_blastdb',$node->blastdb,1);
   tripal_analysis_update_property($node->analysis_id,'analysis_blast_blastfile',$node->blastfile,1);	
   tripal_analysis_update_property($node->analysis_id,'analysis_blast_blastparameters',$node->blastparameters,1);	
   tripal_analysis_update_property($node->analysis_id,'analysis_blast_no_parsed',$node->no_parsed,1);	
   tripal_analysis_update_property($node->analysis_id,'analysis_blast_query_re',$node->query_re,1);	
   tripal_analysis_update_property($node->analysis_id,'analysis_blast_query_type',$node->query_type,1);	
   tripal_analysis_update_property($node->analysis_id,'analysis_blast_query_uniquename',$node->query_uniquename,1);	
   tripal_analysis_update_property($node->analysis_id,'analysis_blast_blastfile_ext',$node->blastfile_ext,1);	

   // if this analysis uses the old style blast settings cvterm then remove that term
   $old = tripal_analysis_get_property($node->analysis_id,'analysis_blast_settings');
   if(count($old) > 0){
      tripal_analysis_delete_property($node->analysis_id,'analysis_blast_settings');
   }

   // submit the parsing jobs
   chado_analysis_blast_submit_jobs($node);
}
/**
*
*/
function chado_analysis_blast_submit_jobs($node){
   global $user;

   // add a job if the user wants to parse the XML	    	
	if($node->blastjob) {
      $job_args = array($analysis_id,
          $node->blastdb,
          $node->blastfile,
          $node->no_parsed,
          $node->blastfile_ext,
          $node->query_re,
		    $node->query_type, 
          $node->query_uniquename
      );

		if (is_readable($node->blastfile)) {
			tripal_add_job("Parse blast: $node->blastfile",'tripal_analysis_blast',
                          'tripal_analysis_blast_parseXMLFile', $job_args, $user->uid);
		} else {
			drupal_set_message("Can not open blast output file. Job not scheduled.");
		}
	}
   // add a job if the user wants to create a best hits report.
	if($node->blastbesthit) {
      $j_args[0] = $analysis_id;	
		tripal_add_job("Parse best hit: $node->blastfile",'tripal_analysis_blast',
                     'tripal_analysis_blast_parse_best_hit', $j_args, $user->uid);			
   }
		
}
/*******************************************************************************
 * Delete blast anlysis
 */
function chado_analysis_blast_delete($node){
	// Before removing, get analysis_id so we can remove it from chado database
	// later
	$sql_drupal = "SELECT analysis_id ".
                 "FROM {chado_analysis} ".
                 "WHERE nid = %d ".
                 "AND vid = %d";
	$analysis_id = db_result(db_query($sql_drupal, $node->nid, $node->vid));

	// Remove data from the {chado_analysis}, {node}, and {node_revisions} tables
	$sql_del = "DELETE FROM {chado_analysis} ".
              "WHERE nid = %d ".
              "AND vid = %d";
	db_query($sql_del, $node->nid, $node->vid);
	$sql_del = "DELETE FROM {node} ".
              "WHERE nid = %d ".
              "AND vid = %d";
	db_query($sql_del, $node->nid, $node->vid);
	$sql_del = "DELETE FROM {node_revisions} ".
              "WHERE nid = %d ".
              "AND vid = %d";
	db_query($sql_del, $node->nid, $node->vid);

	//Remove from analysisfeatureprop, analysisfeature, analysis, and analysisprop tables
	$previous_db = tripal_db_set_active('chado');
	$sql = "SELECT analysisfeature_id FROM {analysisfeature} WHERE analysis_id=%d";
	$results = db_query($sql, $analysis_id);
	while ($af = db_fetch_object($results)) {
		db_query("DELETE FROM {analysisfeatureprop} WHERE analysisfeature_id = %d", $af->analysisfeature_id);
	}
	db_query("DELETE FROM {analysisfeature} WHERE analysis_id = %d", $analysis_id);
	db_query("DELETE FROM {analysisprop} WHERE analysis_id = %d", $analysis_id);
	db_query("DELETE FROM {analysis} WHERE analysis_id = %d", $analysis_id);
	tripal_db_set_active($previous_db);
}




/*******************************************************************************
 *  This function customizes the view of the chado_analysis node.  It allows
 *  us to generate the markup.
 */
function chado_analysis_blast_view ($node, $teaser = FALSE, $page = FALSE) {
	// use drupal's default node view:
    //dprint_r($node);
	if (!$teaser) {
		$node = node_prepare($node, $teaser);
		// When previewing a node submitting form, it shows 'Array' instead of
		// correct date format. We need to format the date here
		$time = $node->timeexecuted;
		if(is_array($time)){
			$month = $time['month'];
			$day = $time['day'];
			$year = $time['year'];
			$timestamp = $year.'-'.$month.'-'.$day;
			$node->timeexecuted = $timestamp;
		}
		// When viewing a node, we need to reformat the analysisprop since we
		// separate each value with a bar |
		if (preg_match("/.*\|.*\|.*/",$node->blastdb)) {
			$prop_values = explode("|", $node->blastdb);
			$node->blastdb = $prop_values[0];
			$node->blastfile = $prop_values[1];
			$node->blastparameters = $prop_values[2];
		}
	}
	return $node;
}

/*******************************************************************************
 * Set the permission types that the chado module uses.  Essentially we
 * want permissionis that protect creation, editing and deleting of chado
 * data objects
 */
function tripal_analysis_blast_perm(){
	return array(
      'access chado_analysis_blast content',
      'create chado_analysis_blast content',
      'delete chado_analysis_blast content',
      'edit chado_analysis_blast content',
	);
}

/*******************************************************************************
 *  The following function proves access control for users trying to
 *  perform actions on data managed by this module
 */
function chado_analysis_blast_access($op, $node, $account){
	if ($op == 'create') {
		return user_access('create chado_analysis_blast content', $account);
	}

	if ($op == 'update') {
		if (user_access('edit chado_analysis_blast content', $account)) {
			return TRUE;
		}
	}
	if ($op == 'delete') {
		if (user_access('delete chado_analysis_blast content', $account)) {
			return TRUE;
		}
	}
	if ($op == 'view') {
		if (user_access('access chado_analysis_blast content', $account)) {
			return TRUE;
		}
	}
	return FALSE;
}