@igea/oac_backend 1.0.74 → 1.0.76

package/package.json

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

package/src/controllers/ontology.js

@@ -7,6 +7,8 @@ const Converter = require('../models/converter');
 const Validator = require('../models/validator');
 const tmp = require('tmp');
 const Investigations = require('../models/investigations');
+const EditLocks = require('../models/editLocks');
+
 const {
     fusekiUrlDataset,
     fusekiUrl,
@@ -149,7 +151,7 @@ router.post('/form/save', (req, res) => {
         let updateQuery = Converter.turtle2Sparql(dataset, {processQuad, processRoot});
         Investigations.save({
             id, uuid, dataset, format: 'turtle'
-        }).then( () => {
+        }).then( (dbResponse) => {
             axios.post(fusekiUrlUpdate, updateQuery, {
                 headers: {
                     'Content-Type': 'application/sparql-update',
@@ -158,7 +160,7 @@ router.post('/form/save', (req, res) => {
             }).then(response => {
                 console.log(response.data);
                 res.status(200).json({
-                    success: true
+                    success: true, data: dbResponse.data
                 });
             }).catch(error => {
                 //TODO: rollback investigation save
@@ -223,7 +225,69 @@ router.post('/form/search', (req, res) => {
     })
     
 })
+//-----------------------------------------------------------------
+
+router.get('/form/lock/:row_id/:client_uuid', (req, res) => {
+    const row_id = parseInt(req.params.row_id)
+    const client_uuid = req.params.client_uuid
+    EditLocks.lock('investigation', row_id, client_uuid).then((success)=>{
+        res.status(200).json({
+            success,
+            message: success ? null : 'Record is locked by another user'
+        });
+    }).catch((err)=>{
+        res.status(500).json({
+            success: false,
+            data: null,
+            message: `Error locking record: ${row_id}`   
+        });
+    })
+})
+
+router.get('/form/lock-keep/:row_id/:client_uuid', (req, res) => {
+    const row_id = parseInt(req.params.row_id)
+    const client_uuid = req.params.client_uuid
+    EditLocks.extendLock('investigation', row_id, client_uuid).then((success)=>{
+        res.status(200).json({
+            success,
+            message: success ? null : 'Lock not owned or expired'
+        });
+    }).catch((err)=>{
+        res.status(500).json({
+            success: false,
+            data: null,
+            message: `Error keeping lock on record: ${row_id}`   
+        });
+    })
+})
+
+function _unlock(req, res){
+    const row_id = parseInt(req.params.row_id)
+    const client_uuid = req.params.client_uuid
+    EditLocks.delete('investigation', row_id, client_uuid).then((success)=>{
+        res.status(200).json({
+            success
+        });
+    }).catch((err)=>{
+        res.status(500).json({
+            success: false,
+            data: null,
+            message: `Error unlocking record ${row_id}: ${err}`   
+        });
+    })
+}
+
+router.get('/form/unlock/:row_id/:client_uuid', (req, res) => {
+    _unlock(req, res)
+})
+
+router.post('/form/unlock/:row_id/:client_uuid', (req, res) => {
+    _unlock(req, res)
+})
+
+
 
+//-----------------------------------------------------------------
 router.get('/schema/:type/:what', (req, res) => {
     console.log(`Requesting SHACL schema in format: ${req.params.type}`); 
     let type = req.params.type || 'config';

package/src/models/editLocks.js

@@ -0,0 +1,78 @@
+const {db, schema } = require('./db')
+const table = `${schema}.edit_locks`
+const expiration_seconds = 300 // 5 mjinutes
+
+
+class EditLocks {
+
+    static lock(table_name, row_id, client_uuid){
+        return new Promise(async (resolve, reject) => {
+            try{
+                let start_ts = Math.ceil(new Date().getTime()/1000)
+                let end_ts = start_ts + expiration_seconds
+                let sql = `INSERT INTO ${table}(
+                    table_name, row_id, client_uuid,
+                    locked_at_ts, expires_at_ts
+                )VALUES(?, ?, ?, ?, ?)
+                ON CONFLICT (table_name, row_id)
+                DO UPDATE
+                    SET client_uuid = EXCLUDED.client_uuid,
+                    locked_at_ts = ?, expires_at_ts = ?
+                WHERE ${table}.table_name = ?
+                    AND ${table}.row_id = ?
+                    AND ${table}.expires_at_ts < ?   
+                RETURNING client_uuid  
+                `
+                const result = await db.raw(sql, [
+                    table_name, row_id, client_uuid, start_ts, end_ts,
+                    start_ts, end_ts,
+                    table_name, row_id, start_ts
+                ])
+                let reserver_uuid = null
+                if(result.rows.length){
+                    reserver_uuid = result.rows[0]["client_uuid"]
+                }
+                console.log(reserver_uuid)
+                resolve(reserver_uuid == client_uuid)
+            }catch(e){
+                reject(e)
+            }
+        }); 
+    }
+
+    static extendLock(table_name, row_id, client_uuid){
+        return new Promise(async (resolve, reject) => {
+            try{
+                const cur_ts = Math.ceil((new Date()).getTime()/1000)
+                const updated = await db(table).
+                    where({ table_name, row_id, client_uuid })
+                    .andWhere('expires_at_ts', '>', cur_ts)
+                    .update({
+                        expires_at_ts: cur_ts + expiration_seconds
+                    })
+                if(updated == 0)    
+                    resolve(false)
+                else
+                    resolve(true)
+            }catch(e){
+                reject(e)
+            }
+        }); 
+    }
+
+    static delete(table_name, row_id, client_uuid){
+        return new Promise(async (resolve, reject) => {
+            try {
+                await db(table).where(
+                    {table_name, row_id, client_uuid}
+                ).delete()
+                resolve(true)
+            }catch(e){
+                reject(e)
+            }
+        }); 
+    }
+
+}
+
+module.exports = EditLocks

package/src/models/investigations.js

@@ -19,10 +19,13 @@ class Investigations {
             try{
                 const sql = `SELECT 
                     id, uuid,
-                    array_to_string(
-                        regexp_split_to_array(?,'[^[:alnum:]_/:]+')
-                        ,','
-                    ) as label
+                    array_to_string(ARRAY(
+                        SELECT token
+                            FROM unnest(
+                                regexp_split_to_array(dataset, '[^[:alnum:]_/:]+')
+                            ) AS token
+                        WHERE token ILIKE ?
+                    ), ',') AS label
                 FROM investigations
                 WHERE dataset_search @@ plainto_tsquery('simple', ?)
                     OR dataset ILIKE ?
@@ -31,7 +34,7 @@ class Investigations {
                 const tsQuery = `${text}:*`;
                 const ilikeQuery = `%${text}%`;
                 const result = await db.raw(sql, 
-                    [txtQuery, tsQuery, ilikeQuery, limit, offset]
+                    [ilikeQuery, tsQuery, ilikeQuery, limit, offset]
                 );
                 resolve(result.rows)
             }catch(e){
@@ -58,19 +61,22 @@ class Investigations {
         item.format = item.format || 'turtle'
         return new Promise(async (resolve, reject) => {
             try {
+                let _id = null
                 const existing = await db(table)
                     .where({uuid: item.uuid})
                     .first();
                 let operation = existing ? 'UPDATE' : 'INSERT';
                 if(existing){
+                    delete item["id"]
                     await db(table)
                         .where({uuid: item.uuid})
                         .update(item);
                 }else{
-                    await db(table).insert(item);
+                    const [{id}] = await db(table).insert(item).returning('id');
+                    _id = id;
                 }    
                 resolve({
-                    success: true, operation
+                    success: true, operation, data: _id
                 })
             }catch(e){
                 reject(e)