Adding HGNC API call

Author: pnrobinson

src-tauri/src/lib.rs

@@ -15,7 +15,7 @@ use std::{collections::HashMap, fs, sync::{Arc, Mutex}};
 use tauri_plugin_fs::{init};
 
 
-use crate::{dto::{pmid_dto::PmidDto, status_dto::{ProgressDto, StatusDto}, text_annotation_dto::{HpoAnnotationDto, ParentChildDto, TextAnnotationDto}}, hpo::{MinedCell, MiningConcept, ontology_loader}, phenoboard::HpoMatch};
+use crate::{dto::{pmid_dto::PmidDto, status_dto::{ProgressDto, StatusDto}, text_annotation_dto::{HpoAnnotationDto, ParentChildDto, TextAnnotationDto}}, hpo::{MinedCell, MiningConcept, ontology_loader}, phenoboard::HpoMatch, util::HgncBundle};
 
 struct AppState {
     phenoboard: Mutex<PhenoboardSingleton>,
@@ -80,7 +80,8 @@ pub fn run() {
             create_cell_mappings,
             get_multi_hpo_strings,
             get_cohort_age_strings,
-            get_status_dto
+            get_status_dto,
+            fetch_hgnc_data
         ])
         .setup(|app| {
             let win = app.get_webview_window("main").unwrap();
@@ -1022,3 +1023,13 @@ async fn get_cohort_age_strings(
         .map_err(|_| "Failed to acquire lock on HPO State".to_string())?;
     singleton.get_all_cohort_age_strings(dto)
 }
+
+
+/// Get HGNC data related to a gene symbol
+#[tauri::command]
+async fn fetch_hgnc_data(
+    symbol: String
+) -> Result<HgncBundle, String> {
+    util::fetch_hgnc_data(&symbol).await
+}
+

src-tauri/src/util/hgnc_rest.rs

@@ -0,0 +1,83 @@
+
+
+use crate::util::HgncBundle;
+
+
+
+pub async fn fetch_gene_data(symbol: &str) -> Result<HgncBundle, Box<dyn std::error::Error>> {
+    let url = format!("https://rest.genenames.org/fetch/symbol/{}", symbol);
+    println!("{}", url);
+    let client = reqwest::Client::new();
+
+    let res = client
+        .get(&url)
+        .header(reqwest::header::ACCEPT, "application/json")
+        .send()
+        .await?;
+    let body = res.text().await?;
+    let bundle = parse_hgnc_json(&body)?;
+    Ok(bundle)
+}
+
+fn parse_hgnc_json(json_str: &str) -> Result<HgncBundle, Box<dyn std::error::Error>> {
+    let v: serde_json::Value = serde_json::from_str(json_str)?;
+    let num_found = v["response"]["numFound"]
+        .as_u64()
+        .ok_or("Could not find 'numFound' in response")?;
+
+    if num_found != 1 {
+        return Err(format!("Expected 1 gene, found {}", num_found).into());
+    }
+    let doc = &v["response"]["docs"][0];
+    if doc.is_null() {
+        return Err("Response docs array is empty".into());
+    }
+    let hgnc_id = doc["hgnc_id"]
+        .as_str()
+        .ok_or("hgnc_id missing or not a string")?
+        .to_string();
+    let mane_select_array = doc["mane_select"]
+        .as_array()
+        .ok_or("mane_select missing or not an array")?;
+
+    let mane_select = mane_select_array
+        .iter()
+        .filter_map(|val| val.as_str())
+        .find(|s| s.starts_with("NM_"))
+        .ok_or("No RefSeq (NM_...) entry found in mane_select")?
+        .to_string();
+
+    Ok(HgncBundle{ hgnc_id, mane_select})
+}
+
+
+
+#[cfg(test)]
+mod tests {
+    use super::*; // Assumes your logic is in the same crate
+   
+
+ 
+    #[tokio::test]
+    #[ignore = "API call"]
+    async fn test_fetch_gene_data() {
+        let symbol = "BRAF";
+        let expected_hgnc = "HGNC:1097";
+        let expected_mane = "NM_004333.6";
+        let bundle = fetch_gene_data(symbol).await.expect("API call failed");
+        assert_eq!(expected_hgnc, bundle.hgnc_id);
+        assert_eq!(expected_mane, bundle.mane_select);
+        
+        
+    }
+
+    #[test]
+    fn test_parsing_logic() {
+        let raw_json = r#"{"response":{"numFound":1,"docs":[{"hgnc_id":"HGNC:1097","mane_select":["ENST00000646891.2","NM_004333.6"]}]}}"#;
+        let bundle = parse_hgnc_json(raw_json).unwrap();
+        assert_eq!(bundle.hgnc_id, "HGNC:1097");
+        assert_eq!(bundle.mane_select, "NM_004333.6");
+    }
+
+
+}

src-tauri/src/util/mod.rs

@@ -1,3 +1,21 @@
+use serde::{Deserialize, Serialize};
+
+
 pub mod io_util;
 pub mod pubmed_retrieval;
-pub mod text_to_annotation;
+pub mod text_to_annotation;
+mod hgnc_rest;
+
+#[derive(Deserialize, Debug, Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct HgncBundle {
+    hgnc_id: String,
+    mane_select: String,
+}
+
+pub async fn fetch_hgnc_data(symbol: &str) -> Result<HgncBundle, String> {
+    let bundle = hgnc_rest::fetch_gene_data(symbol)
+        .await
+        .map_err(|e| e.to_string())?;
+    Ok(bundle)
+}

src/app/cohortdialog/cohortdialog.component.html

@@ -59,9 +59,26 @@ <h3>Gene Info</h3>
         <p class="error-text">Valid HGNC ID required (e.g., HGNC:1234)</p>
       }
     </div>
-
+    
     <div class="form-field">
-      <input placeholder="Gene symbol (e.g. CFTR)" formControlName="symbol" class="form-input" />
+    <div class="form-field flex gap-2">
+      <input 
+      placeholder="Gene symbol (e.g. CFTR)" 
+      formControlName="symbol" 
+      class="form-input flex-1" />
+      <button
+        type="button"
+        [disabled]="!canFetch() || isLoading()"
+        (click)="fetchAndFillHgnc()"
+        class="px-3 py-1 bg-blue-50 text-blue-600 border border-blue-200 rounded hover:bg-blue-100 disabled:opacity-50 transition-all flex items-center gap-2"
+        >
+        @if (isLoading()) {
+          <span class="animate-spin">⏳</span>
+        } @else {
+          🔍 Fetch info
+        }
+        </button>
+    </div>
       @if (form.get('symbol')?.invalid && form.get('symbol')?.touched) {
         <p class="error-text">Gene symbol is required.</p>
       }

src/app/cohortdialog/cohortdialog.component.ts

@@ -1,11 +1,13 @@
-import { Component, inject,  signal } from '@angular/core';
+import { Component, computed, inject,  signal } from '@angular/core';
 import { FormBuilder, FormGroup, Validators, ReactiveFormsModule } from '@angular/forms';
 import { MatDialogRef, MAT_DIALOG_DATA, MatDialogModule } from '@angular/material/dialog';
 import { CommonModule } from '@angular/common';
 import { FormsModule } from '@angular/forms';
 import { noWhitespaceValidator, noLeadingTrailingSpacesValidator } from '../validators/validators';
 import { MatMenuModule } from "@angular/material/menu";
 import { HelpButtonComponent } from "../util/helpbutton/help-button.component";
+import { ConfigService } from '../services/config.service';
+import { toSignal } from '@angular/core/rxjs-interop';
 
 
 @Component({
@@ -23,25 +25,28 @@ import { HelpButtonComponent } from "../util/helpbutton/help-button.component";
   styleUrls: ['./cohortdialog.component.css'],
 })
 export class CohortDialogComponent {
-  form: FormGroup;
-
+  
   showPasteArea = signal(false);
   pastedText = signal<string | null>(null);
   private fb = inject(FormBuilder);
   public dialogRef = inject(MatDialogRef<CohortDialogComponent>);
-public data = inject(MAT_DIALOG_DATA) as { title: string };
-  constructor(
-  ) {
-    this.form = this.fb.group({
+  public data = inject(MAT_DIALOG_DATA) as { title: string };
+  private configService = inject(ConfigService);
+ 
+  form: FormGroup = this.fb.group({
       diseaseId: ['', [Validators.required, Validators.pattern(/^OMIM:\d{6}$/)]],
       diseaseLabel: ['', [Validators.required, noLeadingTrailingSpacesValidator]],
       cohortAcronym: ['', [Validators.required, noWhitespaceValidator]],
       hgnc: ['', [Validators.required, Validators.pattern(/^HGNC:\d+$/)]],
       symbol: ['', [Validators.required, noWhitespaceValidator]],
       transcript: ['', [Validators.required, Validators.pattern(/^[\w]+\.\d+$/)]],
     });
-  }
-
+  symbolValue = toSignal(this.form.get('symbol')!.valueChanges, { initialValue: '' });
+  canFetch = computed(() => {
+    const s = this.symbolValue();
+    return s && s.trim().length > 0;
+  });
+  isLoading = signal(false);
 
   cancel() {
     this.dialogRef.close(null);
@@ -85,4 +90,32 @@ public data = inject(MAT_DIALOG_DATA) as { title: string };
   togglePaste() {
     this.showPasteArea.update(v => !v);
   }
+
+  async fetchHgncData(symbol: string): Promise<{ hgncId: string, maneSelect: string } | null> {
+    try {
+      return await this.configService.fetchHgncData(symbol);
+    } catch (error) {
+      console.error(`Error fetching gene ${symbol}: ${error}`);
+      return null; // Return null so your UI can show a "Gene not found" message
+    }
+  }
+
+  async fetchAndFillHgnc() {
+    const symbol = this.symbolValue();
+    if (!symbol) return;
+
+    this.isLoading.set(true);
+    const result = await this.fetchHgncData(symbol);
+    this.isLoading.set(false);
+
+    if (result) {
+      this.form.patchValue({
+        hgnc: result.hgncId,
+        transcript: result.maneSelect
+      });
+    } else {
+      // Optional: Toast or specific error handling if gene not found
+      alert(`Could not find data for symbol: ${symbol}`);
+    }
+  }
 }

src/app/hpopolishing/hpopolishing.component.ts

@@ -11,15 +11,14 @@ import { AddageComponent } from '../addages/addage.component';
 import { MatDialog } from '@angular/material/dialog';
 import { NotificationService } from '../services/notification.service';
 import { HpoMatch } from '../models/hpo_mapping_result';
-import { MatIcon } from "@angular/material/icon";
 
 /** This component takes the results of the raw text mining (fenominal) and allows the user to revise them and add new terms */
 @Component({
   selector: 'app-hpopolishing',
   templateUrl: './hpopolishing.component.html',
   styleUrls: ['./hpopolishing.component.scss'],
   standalone: true,
-  imports: [CommonModule, FormsModule, HpoAutocompleteComponent, MatIcon]
+  imports: [CommonModule, FormsModule, HpoAutocompleteComponent]
 })
 export class HpoPolishingComponent implements OnInit {
 

src/app/services/config.service.ts

@@ -374,6 +374,10 @@ export class ConfigService {
      return await invoke<string[]>('get_all_cohort_age_strings', {dto: dto});
   }
 
+  async fetchHgncData(symbol: string): Promise<{ hgncId: string, maneSelect: string}> {
+    return await invoke<{ hgncId: string, maneSelect: string}>('fetch_hgnc_data', {symbol: symbol});
+  }
+
   /**
  * Adjusts x and y coordinates to ensure a menu stays within the viewport.
  */