@igea/oac_backend 1.0.19 → 1.0.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@igea/oac_backend",
-  "version": "1.0.19",
+  "version": "1.0.20",
   "description": "Backend service for the OAC project",
   "main": "src/index.js",
   "scripts": {

package/src/controllers/fuseki.js

@@ -10,10 +10,13 @@ const configFuseki = config.fuseki || {
     "port": "3030",
     "dataset": "oac"
 }
-const fusekiUrl = `${configFuseki.protocol}://${configFuseki.host}:${configFuseki.port}/${configFuseki.dataset}/sparql`;
+const fusekiUrlDataset = `${configFuseki.protocol}://${configFuseki.host}:${configFuseki.port}/${configFuseki.dataset}`;
+const fusekiUrl = `${fusekiUrlDataset}/sparql`;
+const fusekiUrlUpdate = `${fusekiUrlDataset}/update`;
 const axios = require('axios');
 const Fuseki = require('../models/fuseki');
-const VocabParser = require('../models/vocabolaries/parser').GET_INSTANCE();
+const { Parser, transformMode } = require('../models/vocabolaries/parser');
+const VocabParser = Parser.GET_INSTANCE();
 
 //---------------------------------------------------------------
 const uploadFolder = path.join(__dirname, '../data/import');    
@@ -47,7 +50,7 @@ const deleteFiles = function(files){
  * @param {Array} files - Array of files to be uploaded
  * @returns {Object} - Response object with message and file details
  *
- * curl -X POST -F "files=@vocabolaries.xsd" http://localhost:5000/backend/fuseki/upload/vocabularies
+ * curl -X POST -F "files=@vocabolaries.xml" http://localhost:5000/backend/fuseki/upload/vocabularies
  * 
  * */
 router.post('/upload/vocabularies', upload.array('files'), (req, res) => {
@@ -68,13 +71,32 @@ router.post('/upload/vocabularies', upload.array('files'), (req, res) => {
 
   if(xmlFiles.length == 1) {
     let xmlFile = uploadedFiles[0];
-    VocabParser.transform(xmlFile.path).then(terms => {
-        console.log(terms)
+    VocabParser.insertQuery(xmlFile.path).then(query => {
+        console.log("Query to insert vocabularies: ", query);
+        
         deleteFiles(uploadedFiles)
-        res.json({
-            message: 'File correctly uploaded',
-            files: uploadedFiles
+        
+        
+        axios.post(fusekiUrlUpdate, query, {
+            headers: {
+                'Content-Type': 'application/sparql-update',
+                'Accept': 'application/sparql-results+json'
+            }
+        })
+        .then(response => {
+            res.json({
+                message: 'File correctly uploaded and vocabularies updated: ' + response.data,
+                files: uploadedFiles
+            });
+        }).catch(error => {
+            let message = (error.response?.status + error.response?.data) || error.message
+            res.status(500).json({ 
+                message: 'Error from SPARQL end-point: ' + message, 
+                files: uploadedFiles,
+                query
+            });
         });
+        
     }).catch(err => {
         deleteFiles(uploadedFiles)
         console.error('Error transforming XML:', err);

package/src/models/vocabolaries/parser

@@ -7,16 +7,24 @@ const config = require('../../config');
 const VocabPrefix = config.fuseki.vocabularies.prefix || 'diagnostica';
 
 
+const transformMode = {
+    default: 'default',
+    forInsert: 'forInsert'
+}
+
 class Parser{
     
     static _INSTANCE = null;
 
     constructor(){
         let xsdPath = path.join(__dirname, 'vocabolaries.xsd');
-        this.xsltPath = path.join(__dirname, 'vocabolaries.xslt');
+        this.xsltPath = {
+            default: path.join(__dirname, 'vocabolaries.xslt'),
+            forInsert: path.join(__dirname, 'vocabolaries_for_insert.xslt')
+        };
         this.xsdData = fs.readFileSync(xsdPath, 'utf8');
         this.xsdDoc = libxmljs.parseXml(this.xsdData);
-        this.xsltData = fs.readFileSync(this.xsltPath, 'utf8');
+        //this.xsltData = fs.readFileSync(this.xsltPath, 'utf8');
         //this.xslt = xmlParser.xmlParse(this.xsltData);
         this.xsltDoc = libxmljs.parseXml(this.xsdData);
     }
@@ -50,11 +58,12 @@ class Parser{
         return result
     }
 
-    transform(xmlPath){
+    transform(xmlPath, using=transformMode.default){
         return new Promise((resolve, reject) => {
+            let xsltPath = this.xsltPath[using] || this.xsltPath.default;
             try{
                 let command = 'xsltproc --stringparam prefix ' + VocabPrefix + ' ';
-                command += this.xsltPath + ' ' + xmlPath    
+                command += xsltPath + ' ' + xmlPath    
                 exec(command, (err, stdout, stderr) => {
                     if (err) {
                         reject(err)
@@ -81,6 +90,33 @@ class Parser{
         });
     }
 
+    insertQuery(xmlPath){
+        return new Promise((resolve, reject) => {
+            this.transform(xmlPath, transformMode.forInsert).then(terms => {
+                let query = `
+                PREFIX crm: <http://www.cidoc-crm.org/cidoc-crm/>
+                PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+
+                INSERT {
+                    ?term a crm:E55_Type ;
+                    rdfs:label ?label ;
+                    crm:P127_has_broader_term ?broader .
+                }
+                WHERE {
+                    VALUES (?term ?label ?broader) {
+                        ${terms.join(' \n')}
+                    }
+                    FILTER NOT EXISTS {
+                        ?term rdfs:label ?label .
+                    }
+                }`
+                resolve(query);
+            }).catch(err => {
+                reject(err);
+            });
+        })
+    }
+
     static GET_INSTANCE(){
         if (Parser._INSTANCE === null) {
             Parser._INSTANCE = new Parser();
@@ -89,4 +125,4 @@ class Parser{
     }
 }
 
-module.exports = Parser
+module.exports = { Parser, transformMode };

package/src/models/vocabolaries/vocabolaries.xslt

@@ -20,7 +20,7 @@
   <!-- Vocabolario -->
   <xsl:template match="vocabulary">
     <xsl:param name="prefix"/>
-    <xsl:variable name="vocab-id" select="@id"/>
+    <xsl:variable name="vocab-id" select="normalize-space(@id)"/>
     <xsl:apply-templates select="term">
       <xsl:with-param name="path" select="concat('http://', $prefix, $vocab-id)"/>
     </xsl:apply-templates>
@@ -29,7 +29,7 @@
   <!-- Term ricorsivo -->
   <xsl:template match="term">
     <xsl:param name="path"/>
-    <xsl:variable name="current-id" select="@id"/>
+    <xsl:variable name="current-id" select="normalize-space(@id)"/>
     <xsl:variable name="new-path" select="concat($path, '/', $current-id)"/>
 
     <xsl:choose>
@@ -48,7 +48,7 @@
       </xsl:when>
       <xsl:otherwise>
         
-        <xsl:variable name="cid" select="@id"/>
+        <xsl:variable name="cid" select="normalize-space(@id)"/>
         <xsl:variable name="npath" select="concat($path, '/', $current-id)"/>
 
         <xsl:for-each select="name">

package/src/models/vocabolaries/vocabolaries_for_insert.xslt

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                version="1.0">
+
+  <xsl:output method="text" encoding="UTF-8"/>
+
+  <xsl:param name="prefix"/>
+
+  <!-- Prendi il prefix e passa ai vocabolari -->
+  <xsl:template match="/vocabularies">
+    <!--
+    <xsl:variable name="prefix" select="prefix/@value"/>
+    -->
+    
+    <xsl:apply-templates select="vocabulary">
+      <xsl:with-param name="prefix" select="concat($prefix,'/vocabularies')"/>
+    </xsl:apply-templates>
+  </xsl:template>
+
+  <!-- Vocabolario -->
+  <xsl:template match="vocabulary">
+    <xsl:param name="prefix"/>
+    <xsl:variable name="vocab-id" select="normalize-space(@id)"/>
+    <xsl:apply-templates select="term">
+      <xsl:with-param name="path" select="concat('http://', $prefix, $vocab-id)"/>
+    </xsl:apply-templates>
+  </xsl:template>
+
+  <!-- Term ricorsivo -->
+  <xsl:template match="term">
+    <xsl:param name="path"/>
+    <xsl:variable name="current-id" select="normalize-space(@id)"/>
+    <xsl:variable name="new-path" select="concat($path, '/', $current-id)"/>
+
+    <xsl:choose>
+      <!-- Se NON ha sub-terms/term -->
+      <xsl:when test="not(sub-terms/term)">
+        <xsl:for-each select="name">
+          <xsl:value-of select="concat('(', '&lt;',$new-path,'&gt; ')"/>
+          <xsl:text>"</xsl:text>
+          <xsl:value-of select="."/>
+          <xsl:text>"@</xsl:text>
+          <xsl:value-of select="@lang"/>
+          <xsl:value-of select="concat(' &lt;',$path,'&gt;', ') ')"/>
+          <xsl:text>&#10;</xsl:text>
+        </xsl:for-each>
+      </xsl:when>
+      <xsl:otherwise>
+        
+        <xsl:variable name="cid" select="normalize-space(@id)"/>
+        <xsl:variable name="npath" select="concat($path, '/', $current-id)"/>
+
+        <xsl:for-each select="name">
+          <xsl:value-of select="concat('(','&lt;',$npath,'&gt; ')"/>
+          <xsl:text>"</xsl:text>
+          <xsl:value-of select="."/>
+          <xsl:text>"@</xsl:text>
+          <xsl:value-of select="@lang"/>
+          <xsl:value-of select="concat(' &lt;',$path,'&gt;',') ')"/>
+          <xsl:text>&#10;</xsl:text>
+        </xsl:for-each>
+
+        <xsl:apply-templates select="sub-terms/term">
+          <xsl:with-param name="prev-path" select="$path"/>
+          <xsl:with-param name="path" select="$new-path"/>
+        </xsl:apply-templates>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+</xsl:stylesheet>

package/test/models/vocabolaries/parser.test.js

@@ -1,7 +1,8 @@
 const chai = require('chai');
 const expect = chai.expect;
 const request = require('supertest');
-const Parser = require('../../../src/models/vocabolaries/parser');
+//const Parser = require('../../../src/models/vocabolaries/parser');
+const { Parser, transformMode } = require('../../../src/models/vocabolaries/parser');
 
 
 describe('Vocabolaries.Parsers', () => {
@@ -23,7 +24,7 @@ describe('Vocabolaries.Parsers', () => {
     expect(nodes.length).to.be.equal(10);
   });
 
-  it('should transform the vocabolaries.xml file', async () => {
+  it('should transform the vocabolaries.xml file (default)', async () => {
     const parser = Parser.GET_INSTANCE();
     var terms = await parser.transform(__dirname + '/vocabolaries.xml');
     console.log(terms.filter(n => n.indexOf('P127_has_broader_term') == -1))
@@ -31,5 +32,19 @@ describe('Vocabolaries.Parsers', () => {
     expect(terms[0]).to.be.equal('<http://diagnostica/vocabularies/condizioni-ambientali> a crm:E55_Type rdfs:label "Condizioni ambientali"@it ; crm:P127_has_broader_term <http://diagnostica/vocabularies> .');
     expect(terms[1]).to.be.equal('<http://diagnostica/vocabularies/condizioni-ambientali/ambiente> a crm:E55_Type rdfs:label "Ambiente"@it ; crm:P127_has_broader_term <http://diagnostica/vocabularies/condizioni-ambientali> .');
   });
+
+  it('should transform the vocabolaries.xml file (for insert)', async () => {
+    const parser = Parser.GET_INSTANCE();
+    var terms = await parser.transform(__dirname + '/vocabolaries.xml', transformMode.forInsert);
+    expect(terms.length).to.be.equal(246);
+    expect(terms[0]).to.be.equal('(<http://diagnostica/vocabularies/condizioni-ambientali> "Condizioni ambientali"@it <http://diagnostica/vocabularies>)');
+    expect(terms[1]).to.be.equal('(<http://diagnostica/vocabularies/condizioni-ambientali/ambiente> "Ambiente"@it <http://diagnostica/vocabularies/condizioni-ambientali>)');
+  });
     
+  it('should get the insert query for the vocabolaries.xml file', async () => {
+    const parser = Parser.GET_INSTANCE();
+    var query = await parser.insertQuery(__dirname + '/vocabolaries.xml');
+    expect(query.length).to.be.equal(40619);
+  });
+
 });