@abi-software/flatmapvuer 1.5.4 → 1.5.6-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abi-software/flatmapvuer",
-  "version": "1.5.4",
+  "version": "1.5.6-beta.0",
   "license": "Apache-2.0",
   "files": [
     "dist/*",
@@ -43,8 +43,8 @@
     "./src/*": "./src/*"
   },
   "dependencies": {
-    "@abi-software/flatmap-viewer": "3.1.9",
-    "@abi-software/map-utilities": "^1.1.1",
+    "@abi-software/flatmap-viewer": "3.2.0",
+    "@abi-software/map-utilities": "^1.1.2",
     "@abi-software/sparc-annotation": "0.3.1",
     "@abi-software/svg-sprite": "^1.0.1",
     "@element-plus/icons-vue": "^2.3.1",

package/src/App.vue

@@ -195,8 +195,12 @@ export default {
         .getCurrentFlatmap()
         .searchAndShowResult(this.searchText, true)
     },
-    onFlatmapChanged: function () {
+    onFlatmapChanged: function (activeSpecies) {
       this.helpMode = false;
+      // Update current flatmapImp after changing species
+      if (this.$refs.multi.$refs[activeSpecies][0].mapImp) {
+        window.flatmapImp = this.$refs.multi.$refs[activeSpecies][0].mapImp;
+      }
     },
     onHelpModeShowNext: function () {
       this.helpModeActiveItem += 1;

package/src/components/FlatmapVuer.vue

@@ -658,7 +658,7 @@ import {
 import flatmapMarker from '../icons/flatmap-marker'
 import {
   FlatmapQueries,
-  findTaxonomyLabel,
+  findTaxonomyLabels,
 } from '../services/flatmapQueries.js'
 import yellowstar from '../icons/yellowstar'
 import ResizeSensor from 'css-element-queries/src/ResizeSensor'
@@ -1179,12 +1179,13 @@ export default {
      */
     processTaxon: function (flatmapAPI, taxonIdentifiers) {
       this.taxonConnectivity.length = 0
-      taxonIdentifiers.forEach((taxon) => {
-        findTaxonomyLabel(flatmapAPI, taxon).then((value) => {
-          const item = { taxon, label: value }
-          this.taxonConnectivity.push(item)
-        })
-      })
+      findTaxonomyLabels(this.mapImp, taxonIdentifiers).then((entityLabels) => {
+        if (entityLabels.length) {
+          entityLabels.forEach((entityLabel) => {
+            this.taxonConnectivity.push(entityLabel);
+          });
+        }
+      });
     },
     /**
      * @public
@@ -1270,7 +1271,7 @@ export default {
      * @arg {Object} `payload`
      */
     centreLinesSelected: function (payload) {
-      if (this.mapImp) {
+      if (this.mapImp && this.mapImp.enableCentrelines) {
         this.mapImp.enableCentrelines(payload.value)
       }
     },
@@ -1314,7 +1315,7 @@ export default {
         let pathFeatures = paths.map((p) => this.mapImp.featureProperties(p))
 
         // Query the flatmap knowledge graph for connectivity, we use this to grab the origins
-        let connectivity = await this.flatmapQueries.queryForConnectivity(payload)
+        let connectivity = await this.flatmapQueries.queryForConnectivityNew(this.mapImp, payload)
 
         // Check and flatten the origins node graph
         let originsFlat = connectivity?.ids?.dendrites?.flat().flat()
@@ -1758,7 +1759,7 @@ export default {
         }
       } else {
         let results =
-          await this.flatmapQueries.retrieveFlatmapKnowledgeForEvent(data)
+          await this.flatmapQueries.retrieveFlatmapKnowledgeForEvent(this.mapImp, data)
         // The line below only creates the tooltip if some data was found on the path
         // result 0 is the connection, result 1 is the pubmed results from flatmap
         if (
@@ -1807,7 +1808,7 @@ export default {
      * @arg {Object} `data`
      */
     createTooltipFromNeuronCuration: async function (data) {
-      this.tooltipEntry = await this.flatmapQueries.createTooltipData(data)
+      this.tooltipEntry = await this.flatmapQueries.createTooltipData(this.mapImp, data)
       this.displayTooltip(data.resource[0])
     },
     /**
@@ -2352,7 +2353,7 @@ export default {
       this.mapImp.setBackgroundOpacity(1)
       this.backgroundChangeCallback(this.currentBackground)
       this.pathways = this.mapImp.pathTypes()
-      if (!this.isCentreLine) {
+      if (!this.isCentreLine && this.mapImp.enableCentrelines) {
         this.mapImp.enableCentrelines(false)
       }
       //Disable layers for now

package/src/services/flatmapQueries.js

@@ -8,6 +8,7 @@ const removeDuplicates = function (arrayOfAnything) {
 }
 
 const cachedLabels = {}
+const cachedTaxonLabels = [];
 
 const findTaxonomyLabel = async function (flatmapAPI, taxonomy) {
   if (cachedLabels && cachedLabels.hasOwnProperty(taxonomy)) {
@@ -35,6 +36,38 @@ const findTaxonomyLabel = async function (flatmapAPI, taxonomy) {
   })
 }
 
+const findTaxonomyLabels = async function (mapImp, taxonomies) {
+  const intersectionTaxonomies = taxonomies.filter((taxonomy) =>
+    cachedTaxonLabels.some((obj) => obj.taxon === taxonomy)
+  );
+
+  const foundCachedTaxonLabels = cachedTaxonLabels.filter((obj) =>
+    intersectionTaxonomies.includes(obj.taxon)
+  );
+
+  const leftoverTaxonomies = taxonomies.filter((taxonomy) =>
+    !intersectionTaxonomies.includes(taxonomy)
+  );
+
+  if (!leftoverTaxonomies.length) {
+    return foundCachedTaxonLabels;
+  } else {
+    const entityLabels = await mapImp.queryLabels(leftoverTaxonomies);
+    if (entityLabels.length) {
+      entityLabels.forEach((entityLabel) => {
+        let { entity: taxon, label } = entityLabel;
+        if (label === 'Mammalia') {
+          label = 'Mammalia not otherwise specified'
+        }
+        const item = { taxon, label };
+        foundCachedTaxonLabels.push(item);
+        cachedTaxonLabels.push(item);
+      });
+      return foundCachedTaxonLabels;
+    }
+  }
+}
+
 const inArray = function (ar1, ar2) {
   if (!ar1 || !ar2) return false
   let as1 = JSON.stringify(ar1)
@@ -54,7 +87,7 @@ let FlatmapQueries = function () {
     this.lookUp = []
   }
 
-  this.createTooltipData = async function (eventData) {
+  this.createTooltipData = async function (mapImp, eventData) {
     let hyperlinks = []
     if (
       eventData.feature.hyperlinks &&
@@ -67,13 +100,12 @@ let FlatmapQueries = function () {
     let taxonomyLabel = undefined
     if (eventData.provenanceTaxonomy) {
       taxonomyLabel = []
-      for (let i = 0; eventData.provenanceTaxonomy.length > i; i++) {
-        taxonomyLabel.push(
-          await findTaxonomyLabel(
-            this.flatmapAPI,
-            eventData.provenanceTaxonomy[i]
-          )
-        )
+      const entityLabels = await findTaxonomyLabels(mapImp, eventData.provenanceTaxonomy);
+      if (entityLabels.length) {
+        entityLabels.forEach((entityLabel) => {
+          const { label } = entityLabel;
+          taxonomyLabel.push(label);
+        });
       }
     }
 
@@ -104,33 +136,22 @@ let FlatmapQueries = function () {
     return labelList
   }
 
-  this.createLabelLookup = function (uberons) {
-    return new Promise((resolve) => {
+  this.createLabelLookup = function (mapImp, uberons) {
+    return new Promise(async (resolve) => {
       let uberonMap = {}
       this.uberons = []
-      const data = { sql: this.buildLabelSqlStatement(uberons) }
-      fetch(`${this.flatmapApi}knowledge/query/`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(data),
-      })
-        .then((response) => response.json())
-        .then((payload) => {
-          const entity = payload.keys.indexOf('entity')
-          const label = payload.keys.indexOf('label')
-          if (entity > -1 && label > -1) {
-            payload.values.forEach((pair) => {
-              uberonMap[pair[entity]] = pair[label]
-              this.uberons.push({
-                id: pair[entity],
-                name: pair[label],
-              })
-            })
-          }
-          resolve(uberonMap)
-        })
+      const entityLabels = await findTaxonomyLabels(mapImp, uberons);
+      if (entityLabels.length) {
+        entityLabels.forEach((entityLabel) => {
+          const { taxon: entity, label } = entityLabel;
+          uberonMap[entity] = label;
+          this.uberons.push({
+            id: entity,
+            name: label,
+          })
+        });
+        resolve(uberonMap)
+      }
     })
   }
 
@@ -209,7 +230,7 @@ let FlatmapQueries = function () {
     return found
   }
 
-  this.retrieveFlatmapKnowledgeForEvent = async function (eventData) {
+  this.retrieveFlatmapKnowledgeForEvent = async function (mapImp, eventData) {
     // check if there is an existing query
     if (this.controller) this.controller.abort()
 
@@ -221,15 +242,59 @@ let FlatmapQueries = function () {
     this.destinations = []
     this.origins = []
     this.components = []
+    this.urls = []
     if (!keastIds || keastIds.length == 0) return
 
-    let prom1 = this.queryForConnectivity(keastIds, signal) // This on returns a promise so dont need 'await'
-    let prom2 = await this.pubmedQueryOnIds(eventData)
-    let results = await Promise.all([prom1, prom2])
+    let prom1 = this.queryForConnectivityNew(mapImp, keastIds, signal) // This on returns a promise so dont need 'await'
+    // let prom2 = await this.pubmedQueryOnIds(eventData)
+    let results = await Promise.all([prom1])
     return results
   }
 
-  this.queryForConnectivity = function (keastIds, signal, processConnectivity=true) {
+  this.queryForConnectivityNew = function (mapImp, keastIds, signal, processConnectivity=true) {
+    return new Promise((resolve) => {
+      mapImp.queryKnowledge(keastIds[0])
+        .then((response) => {
+          if (this.checkConnectivityExists(response)) {
+            let connectivity = response;
+            if (processConnectivity) {
+              this.processConnectivity(mapImp, connectivity).then((processedConnectivity) => {
+                // response.references is publication urls
+                // same data as mapImp.queryPublications(keastIds[0]) method
+                if (response.references) {
+                  // with publications
+                  this.getURLsForPubMed(response.references).then((urls) => {
+                    // TODO: if empty urls array is returned,
+                    // the urls are not on PubMed.
+                    // Those urls, response.references, will be shown in another way.
+                    this.urls = urls;
+                    resolve(processedConnectivity)
+                  })
+                } else {
+                  // without publications
+                  resolve(processedConnectivity)
+                }
+              })
+            }
+            else resolve(connectivity)
+          } else {
+            resolve(false)
+          }
+        })
+        .catch((error) => {
+          if (error.name === 'AbortError') {
+            // This error is from AbortController's abort method.
+          } else {
+            // console.error('Error:', error)
+            // TODO: to update after queryKnowledge method update
+            console.warn(`Unable to get the knowledge for the entity ${keastIds[0]}.`)
+          }
+          resolve(false)
+        })
+    })
+  }
+
+  this.queryForConnectivity = function (mapImp, keastIds, signal, processConnectivity=true) {
     const data = { sql: this.buildConnectivitySqlStatement(keastIds) }
     const headers = {
       method: 'POST',
@@ -246,7 +311,7 @@ let FlatmapQueries = function () {
           if (this.connectivityExists(data)) {
             let connectivity = JSON.parse(data.values[0][0])
             if (processConnectivity) {
-              this.processConnectivity(connectivity).then((processedConnectivity) => {
+              this.processConnectivity(mapImp, connectivity).then((processedConnectivity) => {
                 resolve(processedConnectivity)
               })
             }
@@ -266,6 +331,10 @@ let FlatmapQueries = function () {
     })
   }
 
+  this.checkConnectivityExists = function (data) {
+    return data && data.connectivity?.length;
+  };
+
   this.connectivityExists = function (data) {
     if (
       data.values &&
@@ -336,7 +405,7 @@ let FlatmapQueries = function () {
     )
   }
 
-  this.processConnectivity = function (connectivity) {
+  this.processConnectivity = function (mapImp, connectivity) {
     return new Promise((resolve) => {
       // Filter the origin and destinations from components
       let components = this.findComponents(connectivity)
@@ -349,7 +418,7 @@ let FlatmapQueries = function () {
       let conIds = this.findAllIdsFromConnectivity(connectivity)
 
       // Create readable labels from the nodes. Setting this to 'this.origins' updates the display
-      this.createLabelLookup(conIds).then((lookUp) => {
+      this.createLabelLookup(mapImp, conIds).then((lookUp) => {
         this.destinations = axons.map((a) =>
           this.createLabelFromNeuralNode(a, lookUp)
         )
@@ -393,7 +462,7 @@ let FlatmapQueries = function () {
   this.stripPMIDPrefix = function (pubmedId) {
     return pubmedId.split(':')[1]
   }
-  
+
   this.getPMID = function(idsList) {
     return new Promise((resolve) => {
       if (idsList.length > 0) {
@@ -419,7 +488,7 @@ let FlatmapQueries = function () {
           })
           promises.push(promise)
         })
-        
+
         Promise.all(promises).then(() => {
           resolve(results)
         }).catch(() => {
@@ -450,7 +519,7 @@ let FlatmapQueries = function () {
         resolve(pmids)
       })
     })
-  } 
+  }
 
   this.extractPublicationIdFromURLString = function (urlStr) {
     if (!urlStr) return
@@ -500,11 +569,18 @@ let FlatmapQueries = function () {
 
   this.getURLsForPubMed = function (data) {
     return new Promise((resolve) => {
-      const ids = data.values.map((id) => this.extractPublicationIdFromURLString(id[0]))
+      const ids = data.map((id) =>
+        (typeof id === 'object') ?
+        this.extractPublicationIdFromURLString(id[0]) :
+        this.extractPublicationIdFromURLString(id)
+      )
       this.convertPublicationIds(ids).then((pmids) => {
         if (pmids.length > 0) {
           const transformedIDs = pmids.join()
           resolve([this.pubmedSearchUrl(transformedIDs)])
+        } else {
+          // return empty array for non-pubmed urls
+          resolve(pmids)
         }
       })
     })
@@ -550,7 +626,7 @@ let FlatmapQueries = function () {
       this.flatmapQuery(sql).then((data) => {
         // Create pubmed url on paths if we have them
         if (data.values.length > 0) {
-           this.getURLsForPubMed(data).then((urls) => {
+           this.getURLsForPubMed(data.values).then((urls) => {
             this.urls = urls
             resolve(true)
           })
@@ -573,7 +649,7 @@ let FlatmapQueries = function () {
       this.buildPubmedSqlStatementForModels(source)
     ).then((data) => {
       if (Array.isArray(data.values) && data.values.length > 0) {
-        this.getURLsForPubMed(data).then((urls) => {
+        this.getURLsForPubMed(data.values).then((urls) => {
           this.urls = urls
           return true
         })
@@ -596,4 +672,4 @@ let FlatmapQueries = function () {
   }
 }
 
-export { FlatmapQueries, findTaxonomyLabel }
+export { FlatmapQueries, findTaxonomyLabel, findTaxonomyLabels }