@igea/oac_backend 1.0.14 → 1.0.16

package/README.md

@@ -1,2 +1,8 @@
 # oac_backend
 Backend service for the OAC project
+
+## Required Ubuntu libraries
+### XSLT
+```console
+sudo apt install xsltproc
+```

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@igea/oac_backend",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "Backend service for the OAC project",
   "main": "src/index.js",
   "scripts": {
     "start": "cross-env NODE_ENV=production node src/index.js",
-    "dev": "cross-env NODE_ENV=development nodemon src/index.js"
+    "dev": "cross-env NODE_ENV=development nodemon src/index.js",
+    "test": "mocha \"test/**/*.js\""
   },
   "repository": {
     "type": "git",
@@ -24,10 +25,17 @@
     "express": "5.1.0",
     "get-port": "7.1.0",
     "knex": "3.1.0",
-    "pg": "8.16.3"
+    "libxmljs2": "0.37.0",
+    "pg": "8.16.3",
+    "strip-bom": "5.0.0",
+    "xslt-processor": "3.3.1"
   },
   "devDependencies": {
+    "chai": "5.2.1",
     "cross-env": "7.0.3",
-    "nodemon": "3.1.10"
+    "mocha": "11.7.1",
+    "nodemon": "3.1.10",
+    "sinon": "21.0.0",
+    "supertest": "7.1.3"
   }
 }

package/src/controllers/fuseki.js

@@ -9,6 +9,7 @@ const configFuseki = config.fuseki || {
 }
 const fusekiUrl = `${configFuseki.protocol}://${configFuseki.host}:${configFuseki.port}/${configFuseki.dataset}/sparql`;
 const axios = require('axios');
+const Fuseki = require('../models/fuseki');
 
 router.get('/count/entities', (req, res) => {
     const query = `
@@ -50,4 +51,49 @@ router.get('/count/entities', (req, res) => {
     
 });
 
+router.get('/export/:format/:entity/:id', (req, res) => {
+    let accept = 'application/rdf+xml'
+    let filename = `${req.params.entity}_${req.params.id}`;
+    switch(req.params.format){
+        case 'turtle':
+            accept='text/turtle'
+            filename += ".ttl"
+            break;
+        case 'json':
+            accept='application/ld+json'
+            filename += ".jsonld"
+            break;
+        case 'n-triples':
+            accept='application/n-triples'
+            filename += ".nt"
+            break;
+        case 'trig':
+            accept='application/trig'
+            filename += ".trig"
+            break;
+        default:
+            filename += ".rdf"  
+    }
+    const uri = 'http://diagnostica/campione/1'
+    const query = Fuseki.getQueryDownload2(uri, 4)
+    axios.post(fusekiUrl, `query=${encodeURIComponent(query)}`,{
+        headers: {
+            'Accept': `${accept}`,
+            'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        responseType: 'stream'
+    }).then(response => {
+        res.setHeader('Content-Disposition', `attachment; filename=${filename}`);
+        res.setHeader('Content-Type', response.headers['content-type'] || 'application/octet-stream');
+        response.data.pipe(res);
+    }).catch(err => {
+        res.status(500).json({
+            success: false,
+            data: null,
+            message: `Error: ${err}`
+        });
+    });
+    
+});
+
 module.exports = router

package/src/index.js

@@ -11,7 +11,11 @@ const jwtLib = jwtLibFactory({
         `/${serviceName}/auth/authenticate`,
         `/${serviceName}/auth/echo`,
         `/${serviceName}/health`,
-        `/${serviceName}/fuseki/count/entities`
+        
+        `/${serviceName}/fuseki/count/entities`,
+        `/${serviceName}/fuseki/export/rdf/campione/1`,
+        `/${serviceName}/fuseki/export/turtle/campione/1`
+        
     ],
     signOptions: { expiresIn: '15m' }
 });

package/src/models/fuseki.js

@@ -0,0 +1,89 @@
+class Fuseki {
+
+    /**
+     * Return the query to retrieve the definition of an entity
+     * @param {string} entityUrl 
+     * @returns 
+     */
+    static getQueryDownload(entityUrl){
+        //http://diagnostica/campione/1    
+        return `
+            PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+            PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+            PREFIX owl: <http://www.w3.org/2002/07/owl#>
+            PREFIX dcterms: <http://purl.org/dc/terms/>
+            PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+            PREFIX schema: <http://schema.org/>
+
+            CONSTRUCT {
+                <${entityUrl}> ?p1 ?o1 .
+                ?o1 ?p2 ?o2 .
+                ?o2 ?p3 ?o3 .
+                ?o3 ?p4 ?o4 .
+            }
+            WHERE {
+                <${entityUrl}> ?p1 ?o1 .
+                OPTIONAL {
+                    ?o1 ?p2 ?o2 .
+                    OPTIONAL {
+                        ?o2 ?p3 ?o3 .
+                        OPTIONAL {
+                            ?o3 ?p4 ?o4 .
+                        }
+                    }
+                }
+            }
+        `;
+    }
+
+    static getQueryDownload2(entityUrl, depth = 3) {
+        const prefixes = `
+            PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+            PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+            PREFIX owl: <http://www.w3.org/2002/07/owl#>
+            PREFIX dcterms: <http://purl.org/dc/terms/>
+            PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+            PREFIX schema: <http://schema.org/>
+        `;
+
+        // Generate CONSTRUCT triples
+        let constructTriples = [`<${entityUrl}> ?p1 ?o1 .`];
+        for (let i = 1; i <= depth; i++) {
+            const subject = i === 1 ? `?o1` : `?o${i}`;
+            const predicate = `?p${i + 1}`;
+            const object = `?o${i + 1}`;
+            constructTriples.push(`${subject} ${predicate} ${object} .`);
+        }
+
+        // Generate nested OPTIONAL blocks in WHERE
+        let where = `<${entityUrl}> ?p1 ?o1 .\n`;
+        let indent = '';
+        for (let i = 1; i <= depth; i++) {
+            const subject = i === 1 ? `?o1` : `?o${i}`;
+            const predicate = `?p${i + 1}`;
+            const object = `?o${i + 1}`;
+            where += `${indent}OPTIONAL {\n`;
+            indent += '  ';
+            where += `${indent}${subject} ${predicate} ${object} .\n`;
+        }
+        // Close all OPTIONALs
+        for (let i = 0; i < depth; i++) {
+            indent = indent.slice(0, -2);
+            where += `${indent}}\n`;
+        }
+
+        return `
+            ${prefixes}
+            CONSTRUCT {
+                ${constructTriples.join('\n    ')}
+            }
+            WHERE {
+                ${where}
+            }`;
+    }
+
+}
+
+module.exports = Fuseki;

package/src/models/vocabolaries/parser

@@ -0,0 +1,82 @@
+const fs = require('fs');
+const path = require('path');
+const XsltProcessor = require('xslt-processor');
+const {XmlParser, Xslt} = XsltProcessor;
+const libxmljs = require('libxmljs2');
+const { exec } = require('child_process');
+const stripBom = require('strip-bom').default;
+const xslt = new Xslt({
+    escape: false,
+    outputMethod: 'text'
+});
+const xmlParser = new XmlParser();
+
+
+class Parser{
+    
+    static _INSTANCE = null;
+
+    constructor(){
+        let xsdPath = path.join(__dirname, 'vocabolaries.xsd');
+        this.xsltPath = path.join(__dirname, 'vocabolaries.xslt');
+        this.xsdData = fs.readFileSync(xsdPath, 'utf8');
+        this.xsdDoc = libxmljs.parseXml(this.xsdData);
+        this.xsltData = fs.readFileSync(this.xsltPath, 'utf8');
+        //this.xslt = xmlParser.xmlParse(this.xsltData);
+        this.xsltDoc = libxmljs.parseXml(this.xsdData);
+    }
+
+    _getXmlData(xmlPath){
+        let _xmlData = fs.readFileSync(xmlPath, 'utf8');
+        let xmlData = stripBom(_xmlData);
+        return xmlData;
+    }
+
+    parse(xmlPath){
+        let xmlData = this._getXmlData(xmlPath);
+        let xmlDoc = libxmljs.parseXml(xmlData);
+        let validation = xmlDoc.validate(this.xsdDoc);
+        if (!validation) {
+            throw new Error(`XML validation failed: ${xmlDoc.validationErrors}`);
+        }
+        return xmlDoc;
+    }
+
+    transform(xmlPath){
+        return new Promise((resolve, reject) => {
+            try{
+                exec('xsltproc ' + this.xsltPath + ' ' + xmlPath, (err, stdout, stderr) => {
+                    if (err) {
+                        reject(err)
+                    }else{
+                        var terms = stdout.split('\n')
+                        resolve(terms.map(line => line.trim()).filter(line => line.length > 0));
+                    }
+                });                
+            }catch(e){
+                reject(e)        
+            }
+            
+            /*    
+            let xmlData = this._getXmlData(xmlPath);
+            const xml = xmlParser.xmlParse(xmlData);
+            xslt.xsltProcess(xml, this.xslt)
+            .then(result => {
+                var terms = result.split('
')
+                resolve(terms.map(line => line.trim()).filter(line => line.length > 0));
+            }).catch(err => {
+                reject(err)
+            });
+            */
+        });
+    }
+
+    static GET_INSTANCE(){
+        if (Parser._INSTANCE === null) {
+            Parser._INSTANCE = new Parser();
+        }
+        return Parser._INSTANCE;
+    }
+}
+
+module.exports = Parser

package/src/models/vocabolaries/vocabolaries.xsd

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+           elementFormDefault="qualified">
+
+  <!-- Radice -->
+  <xs:element name="vocabularies">
+    <xs:complexType>
+      <xs:sequence>
+        <!-- Required prefix element with a mandatory "value" attribute -->
+        <xs:element name="prefix">
+          <xs:complexType>
+            <xs:attribute name="value" type="xs:string" use="required"/>
+          </xs:complexType>
+        </xs:element>
+
+        <!-- Multiple vocabulary entries -->
+        <xs:element name="vocabulary" maxOccurs="unbounded">
+          <xs:complexType>
+            <xs:sequence>
+              <xs:element name="term" type="termType"/>
+            </xs:sequence>
+          </xs:complexType>
+        </xs:element>
+      </xs:sequence>
+    </xs:complexType>
+  </xs:element>
+
+  <!-- Tipo ricorsivo per ogni term -->
+  <xs:complexType name="termType">
+    <xs:sequence>
+      <xs:element name="name">
+        <xs:complexType>
+          <xs:simpleContent>
+            <xs:extension base="xs:string">
+              <xs:attribute name="lang" type="xs:string" use="required"/>
+            </xs:extension>
+          </xs:simpleContent>
+        </xs:complexType>
+      </xs:element>
+
+      <!-- Sub-terms ricorsivo -->
+      <xs:element name="sub-terms" minOccurs="0">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="term" type="termType" maxOccurs="unbounded"/>
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+    </xs:sequence>
+
+    <xs:attribute name="id" type="xs:string" use="required"/>
+  </xs:complexType>
+
+</xs:schema>

package/src/models/vocabolaries/vocabolaries.xslt

@@ -0,0 +1,50 @@
+<?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"/>
+
+  <!-- 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="$prefix"/>
+    </xsl:apply-templates>
+  </xsl:template>
+
+  <!-- Vocabolario -->
+  <xsl:template match="vocabulary">
+    <xsl:param name="prefix"/>
+    <xsl:variable name="vocab-id" select="@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="@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="$new-path"/>
+          <xsl:text> rdfs:label "</xsl:text>
+          <xsl:value-of select="."/>
+          <xsl:text>"@</xsl:text>
+          <xsl:value-of select="@lang"/>
+          <xsl:text>&#10;</xsl:text>
+        </xsl:for-each>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:apply-templates select="sub-terms/term">
+          <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

@@ -0,0 +1,34 @@
+const chai = require('chai');
+const expect = chai.expect;
+const request = require('supertest');
+const Parser = require('../../../src/models/vocabolaries/parser');
+
+
+describe('Vocabolaries.Parsers', () => {
+  
+  beforeEach(() => {
+    
+  });
+
+  it('should create a parser instance', () => {
+    const parser = Parser.GET_INSTANCE();
+    expect(parser).to.be.an.instanceof(Parser);
+  });
+
+  it('should parse the vocabolaries.xml file', () => {
+    const parser = Parser.GET_INSTANCE();
+    var xmlDoc = parser.parse(__dirname + '/vocabolaries.xml');
+    expect(xmlDoc).to.not.be.null;
+    let nodes = xmlDoc.find('//vocabulary');
+    expect(nodes.length).to.be.equal(10);
+  });
+
+  it('should transform the vocabolaries.xml file', async () => {
+    const parser = Parser.GET_INSTANCE();
+    var terms = await parser.transform(__dirname + '/vocabolaries.xml');
+    expect(terms.length).to.be.equal(193);
+    expect(terms[0]).to.be.equal('http://diagnostica/condizioni-ambientali/ambiente/buio rdfs:label "Buio"@it');
+    expect(terms[1]).to.be.equal('http://diagnostica/condizioni-ambientali/ambiente/illuminato rdfs:label "Illuminato"@it');
+  });
+    
+});