sd delete

src/controllers/file/recording_data_meta.js

@@ -1,7 +1,9 @@
 import RecordingDataMeta from '../../models/file/recording_data_meta'
 import * as auth from '../../controllers/auth'
+import RecordingMeta from '../../models/file/bps_recording_meta'
 
 const recordingDataMeta = new RecordingDataMeta()
+const recordingMeta = new RecordingMeta() // control system 3.0
 
 export const create = async (ctx, next) => {
   const data = ctx.request.body
@@ -120,3 +122,19 @@ export const getAll = async (ctx, next) => {
 
   next()
 }
+
+// control system 3.0
+export const getMetaByUUID = async (ctx, next) => {
+  const uuid = ctx.params.uuid
+  const result = await recordingMeta.getMetaByUUID(uuid)
+  ctx.body = result
+
+  next()
+}
+
+export const getMetaAll = async (ctx, next) => {
+  const result = await recordingMeta.getMetaAll()
+  ctx.body = result
+
+  next()
+}

src/controllers/file/recording_data_raw.js

@@ -80,10 +80,21 @@ export const getDataByID = async (ctx, next) => {
   next()
 }
 
-export const getSdDataByID = async (ctx, next) => {
-  const index = ctx.params.channel
-  const id = ctx.params.id
-  const result = await recordingDataRaw.getSdDataByID(id, index)
+export const getSdDataByUUID = async (ctx, next) => {
+  const uuid = ctx.params.uuid
+  const channel = ctx.params.channel
+  const startTime = ctx.params.startTime
+  const endTime = ctx.params.endTime
+  const result = await recordingDataRaw.getSdDataByUUID(uuid, channel, startTime, endTime)
+  ctx.body = result
+
+  next()
+}
+
+export const getSdDataAllTimeslotByUUID = async (ctx, next) => {
+  const uuid = ctx.params.uuid
+  const channel = ctx.params.channel
+  const result = await recordingDataRaw.getSdDataAllTimeslotByUUID(uuid, channel)
   ctx.body = result
 
   next()

src/controllers/file/sd_card/index.js

@@ -1,10 +1,12 @@
 import RecordingDataMeta from '../../../models/file/recording_data_meta'
+import RecordingDataRaw from '../../../models/file/recording_data_raw'
 import Controller from '../../../models/product/controller'
 import childProcess from 'child_process'
 import path from 'path'
 import { homedir } from 'os'
 
 const recordingDataMeta = new RecordingDataMeta()
+const recordingDataRaw = new RecordingDataRaw()
 const controller = new Controller()
 
 const sdPath = [homedir(), 'bioproanalysis', 'sdcard']
@@ -61,13 +63,11 @@ const getUuidPathStringPromise = async () => {
   })
 }
 
-function uploadPromise (uuidPath, uuid, ampGain) {
+function uploadPromise (uuid) {
   return new Promise((resolve, reject) => {
     const subprocess = childProcess.spawn('python3', [
       path.join(...sdUploadPath),
-      uuidPath,
       uuid,
-      ampGain
     ])
 
     let dataString = ''
@@ -130,8 +130,6 @@ export const uploadThenDelete = async (ctx, next) => {
   const controllerID = request.controllerID
   const metaID = request.metaID
   const uuid = request.uuid
-  const uuidPath = await getPath(uuid)
-  const ampGain = await getParameter(metaID, 'AMP_GAIN')
 
   // timeout defualt 120s to no-limit
   ctx.req.setTimeout(0)
@@ -141,14 +139,21 @@ export const uploadThenDelete = async (ctx, next) => {
     sd_uploading: true
   }, controllerID)
 
-  const uploadResult = await uploadPromise(uuidPath, uuid, ampGain)
-
+  let uploadResult = await uploadPromise(uuid)
   if (uploadResult === 'true') {
-    // meta sd_card_uploaded true
-    await recordingDataMeta.update({
-      sd_data_uploaded: true
-    }, metaID)
-    await deletePromise(uuidPath)
+    // [Region] then doubly check if sd raw data table actually has data
+    const meta = await recordingDataMeta.getByUUID(uuid)
+    const channel = JSON.parse(meta[0].channels)[0]
+    const sdDataRes = await recordingDataRaw.getSdDataAllTimeslotByUUID(uuid, channel)
+    if (sdDataRes.length > 0) {
+    // [EndRegion]
+      await recordingDataMeta.update({
+        sd_data_uploaded: true
+      }, metaID)
+      // await deletePromise(uuidPath)
+    } else {
+      uploadResult = 'false'
+    }
   }
 
   // controller column sd_uploading close

src/controllers/file/sd_raw_neulive.js

@@ -1,25 +1,25 @@
 import SDRawNeulive from '../../models/file/sd_raw_neulive'
 import * as auth from '../auth'
 
-const sd_raw_Neulive = new SDRawNeulive()
+const sdRawNeulive = new SDRawNeulive()
 
 export const create = async (ctx, next) => {
   const data = ctx.request.body
-  const result = await sd_raw_Neulive.create(data)
+  const result = await sdRawNeulive.create(data)
   ctx.body = result
   next()
 }
 
 export const getByParentUUID = async (ctx, next) => {
   const parent_uuid = ctx.params.parent_uuid
-  const result = await sd_raw_Neulive.getByParentUUID(parent_uuid)
+  const result = await sdRawNeulive.getByParentUUID(parent_uuid)
   ctx.body = result
   next()
 }
 
-export const deleteByParentUUID = async (ctx, next) => {
+export const clearDeleted = async (ctx, next) => {
   const parent_uuid = ctx.params.parent_uuid
-  const result = await sd_raw_Neulive.deleteByParentUUID(parent_uuid)
+  const result = await sdRawNeulive.clearDeleted(parent_uuid)
   ctx.body = result
   next()
-}
+}

src/controllers/file/trigger/index.js

@@ -0,0 +1,11 @@
+import RawTrigger from '../../../models/file/bps_raw_trigger'
+
+const rawTrigger = new RawTrigger()
+
+export const getRawTriggerByUUID = async (ctx, next) => {
+  const parent_uuid = ctx.params.parent_uuid
+  const result = await rawTrigger.getDataByUUID(parent_uuid)
+  ctx.body = result
+
+  next()
+}

src/controllers/index.js

@@ -10,6 +10,7 @@ import * as recordingDataRaw from './file/recording_data_raw'
 import * as recordingDataMini from './file/recording_data_mini'
 import * as analysis from './analysis'
 import * as sdCard from './file/sd_card'
+import * as trigger from './file/trigger'
 
 export default {
   upload,
@@ -23,5 +24,6 @@ export default {
   recordingDataRaw,
   recordingDataMini,
   analysis,
-  sdCard
+  sdCard,
+  trigger,
 }

src/db/database.js

@@ -40,6 +40,8 @@ for (let i = 256; i < 288; i++) {
 for (let i = 256; i < 288; i++) {
   db[i + '_recording_data_minis'] = require('./schema/recording_data_mini.model')(sequelize, Sequelize, i)
 }
+db.recording_meta = require('./schema/bps_recording_meta.model')(sequelize, Sequelize)
+db.raw_trigger = require('./schema/bps_raw_trigger.model')(sequelize, Sequelize)
 
 db.sd_raw_neulive = require('./schema/sd_raw_neulive.model')(sequelize, Sequelize)
 

src/db/schema/bps_raw_trigger.model.js

@@ -0,0 +1,34 @@
+module.exports = (sequelize, Sequelize) => {
+  const TriggerDataRaw = sequelize.define('bps_raw_trigger', {
+    channel: {
+      type: Sequelize.INTEGER,
+      defaultValue: -1
+    },
+    parent_uuid: {
+      type: Sequelize.STRING,
+      defaultValue: ''
+    },
+    data: {
+      type: Sequelize.TEXT,
+      defaultValue: ''
+    },
+    timestamp: {
+      type: Sequelize.TEXT,
+      defaultValue: ''
+    },
+    start_time: {
+      type: Sequelize.STRING,
+      defaultValue: '-1'
+    },
+    end_time: {
+      type: Sequelize.STRING,
+      defaultValue: '-1'
+    },
+  },
+  {
+    freezeTableName: true
+  }
+  )
+
+  return TriggerDataRaw
+}

src/db/schema/bps_recording_meta.model.js

@@ -0,0 +1,78 @@
+
+module.exports = (sequelize, Sequelize) => {
+  const RecordingMeta = sequelize.define('bps_recording_meta', {
+    uuid: {
+      type: Sequelize.STRING,
+      defaultValue: '',
+      primaryKey: true
+    },
+    name: {
+      type: Sequelize.STRING
+    },
+    series: {
+      type: Sequelize.STRING
+    },
+    folder_id: {
+      type: Sequelize.INTEGER,
+      defaultValue: -1
+    },
+    task_uuid: {
+      type: Sequelize.STRING,
+      defaultValue: ''
+    },
+    device: {
+      type: Sequelize.JSONB,
+      defaultValue: {}
+    },
+    description: {
+      type: Sequelize.STRING,
+      defaultValue: ''
+    },
+    size: {
+      type: Sequelize.INTEGER,
+      defaultValue: -1
+    },
+    sd_size: {
+      type: Sequelize.INTEGER,
+      defaultValue: -1
+    },
+    time_duration_sec: {
+      type: Sequelize.INTEGER,
+      defaultValue: 0
+    },
+    time_duration_micro: {
+      type: Sequelize.INTEGER,
+      defaultValue: 0
+    },
+    sample_rate: {
+      type: Sequelize.INTEGER,
+      defaultValue: -1
+    },
+    deleted: {
+      type: Sequelize.BOOLEAN,
+      defaultValue: false
+    },
+    tag: {
+      type: Sequelize.STRING,
+      defaultValue: '-1'
+    },
+    parameter_set: {
+      type: Sequelize.ARRAY(Sequelize.JSONB),
+      defaultValue: []
+    },
+    create_date: {
+      type: Sequelize.DATE,
+      defaultValue: Sequelize.literal('CURRENT_TIMESTAMP')
+    },
+    channel: {
+      type: Sequelize.ARRAY(Sequelize.INTEGER),
+      defaultValue: []
+    }
+  },
+  {
+    timestamps: false
+  }
+  )
+
+  return RecordingMeta
+}

src/db/schema/sd_raw_neulive.model.js

@@ -10,6 +10,10 @@ module.exports = (sequelize, Sequelize, i) => {
       type: Sequelize.TEXT,
       defaultValue: ''
     },
+    data_time: {
+      type: Sequelize.TEXT,
+      defaultValue: ''
+    },
     start_time_sec: {
       type: Sequelize.INTEGER,
       defaultValue: 0

src/models/file/bps_raw_trigger.js

@@ -0,0 +1,42 @@
+const db = require('../../db/database')
+const { Transform } = require("stream")
+
+class RawTrigger {
+  async getDataByUUID (parent_uuid) {
+    const ret = await db.raw_trigger.findAllWithStream(
+      {
+        where: {
+          parent_uuid: parent_uuid
+        },
+        attributes: [
+          'data'
+        ],
+      }
+    )
+    
+    const transformer = new Transform({
+      transform(chunk, encoding, callback) {
+        const chunkDataStr = chunk.toString('utf8')
+        // replace: ref https://dmitripavlutin.com/replace-all-string-occurrences-javascript/#2-replace-with-a-global-regular-expression
+        // slice: remove last ','
+        const transformDataArr = JSON.parse(chunkDataStr)[0].data.replace(/[@#$]/g, '').slice(0, -1).split(',')
+        const step = 3
+        let transformData = ''
+        for (let startPos = 0; startPos < transformDataArr.length; startPos += step) {
+          // array chunking algo. comparison: https://www.better.dev/javascript-algorithms-array-chunking
+          let temp = transformDataArr.slice(startPos, startPos + step)
+          const date = new Date(parseInt(temp[0]))
+          temp[0] = date
+          temp[1] = parseInt(temp[1]) + 1
+          temp.splice(1, 0, [date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()].join(':'))
+          transformData += (temp.join() + '\n') // join: https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/Array/join
+        }
+        callback(null, transformData)
+      },
+    })
+    
+    return ret.pipe(transformer)
+  }
+}
+
+export default RawTrigger

src/models/file/bps_recording_meta.js

@@ -0,0 +1,37 @@
+
+const db = require('../../db/database')
+
+class RecordingMeta {
+  async getMetaByUUID (uuid) {
+    const ret = await db.recording_meta.findAll(
+      {
+        where: {
+          uuid: uuid
+        }
+      }
+    )
+    return ret
+  }
+
+  async getMetaAll () {
+    const ret = await db.recording_meta.findAll({
+      order: [
+        ['create_date', 'DESC']
+      ]
+    })
+    return ret
+  }
+
+  async clearDeleted (uuid) {
+    const ret = await db.recording_meta.destroy(
+      {
+        where: {
+          uuid: uuid
+        }
+      }
+    )
+    return ret
+  }
+}
+
+export default RecordingMeta

src/models/file/recording_data_meta.js

@@ -1,10 +1,15 @@
 import RecordingDataRaw from './recording_data_raw'
 import RecordingDataMini from './recording_data_mini'
+import SDRawNeulive from './sd_raw_neulive'
+import RecordingMeta from '../../models/file/bps_recording_meta'
+
 const db = require('../../db/database')
 // const RecordingDataMini = require('./recording_data_mini')
 
 const recordingDataRaw = new RecordingDataRaw()
 const recordingDataMini = new RecordingDataMini()
+const sdRawNeulive = new SDRawNeulive()
+const recordingMeta = new RecordingMeta() // control system 3.0
 
 const Op = db.Sequelize.Op
 
@@ -47,7 +52,8 @@ class RecordingDataMeta {
         attributes: [
           'id',
           'raw_data',
-          'mini_data'
+          'mini_data',
+          'uuid'
         ],
         where: {
           deleted: true
@@ -68,6 +74,8 @@ class RecordingDataMeta {
           recordingDataMini.clearDeleted(channel)
         }
       }
+      recordingMeta.clearDeleted(meta.uuid) // control system 3.0
+      sdRawNeulive.clearDeleted(meta.uuid)
     }
     ret = await db.recording_data_metas.destroy(
       {
@@ -175,7 +183,8 @@ class RecordingDataMeta {
       {
         where: {
           uuid: uuid
-        }
+        },
+        raw: true
       }
     )
     return ret

src/models/file/recording_data_raw.js

@@ -103,21 +103,66 @@ class RecordingDataRaw {
     return ret
   }
 
-  async getSdDataByID (id, index) {
-    const ret = await db[index + '_recording_data_raws'].findAllWithStream(
+  // ref: https://stackoverflow.com/questions/47498083/find-the-closest-smaller-value-of-an-array
+  findClosestSmalllerValIndex (arr, val) {
+    const targetVal = arr.slice().reverse().find(e => e <= val) // why additionally use slice: see https://stackoverflow.com/questions/30610523/reverse-array-in-javascript-without-mutating-original-array
+    if (targetVal !== undefined) {
+      return arr.findIndex(e => e === targetVal)
+    } else {
+      return 0
+    }
+  }
+
+  async getSdDataByUUID (uuid, channel, startTime, endTime) {
+    const timeSlots = await this.getSdDataAllTimeslotByUUID(uuid, channel)
+    const startTimeArr = timeSlots.map(x => parseInt(x.start_time_sec) * 1e6 + parseInt(x.start_time_micro))
+    const endTimeArr = timeSlots.map(x => parseInt(x.end_time_sec) * 1e6 + parseInt(x.end_time_micro))
+
+    const startIndex = this.findClosestSmalllerValIndex(startTimeArr, parseInt(startTime))
+    let endIndex
+    const findEndIndex = endTimeArr.findIndex(el => el >= parseInt(endTime))
+    findEndIndex !== -1 ? endIndex = findEndIndex : endIndex = timeSlots.length - 1
+
+    const idList = timeSlots.slice(startIndex, endIndex + 1).map(x => x.id)
+
+    const ret = await db['sd_raw_neulive'].findAll(
       {
-        batchSize: 1000,
         where: {
-          id: id
+          id: idList
         },
-        attributes: [
-          'sd_data'
-        ]
+        order: [
+          ['start_time_sec', 'ASC'],
+          ['start_time_micro', 'ASC']
+        ],
+        raw: true,
       }
     )
     return ret
   }
 
+  async getSdDataAllTimeslotByUUID (uuid, channel) {
+    const ret = await db['sd_raw_neulive'].findAll(
+      {
+        where: {
+          parent_uuid: uuid,
+          channel: channel,
+        },
+        attributes: [
+          'id',
+          'start_time_sec',
+          'end_time_sec',
+          'start_time_micro',
+          'end_time_micro',
+        ],
+        order: [
+          ['start_time_sec', 'ASC'],
+          ['start_time_micro', 'ASC']
+        ],
+        raw: true,
+      }
+    )
+    return ret
+  }
 
   async getByAttrID (id, attr, index) {
     const attrList = attr.split('-')

src/models/file/sd_raw_neulive.js

@@ -27,7 +27,7 @@ class SDRawNeulive {
     return ret
   }
 
-  async deleteByParentUUID (parent_uuid) {
+  async clearDeleted (parent_uuid) {
     const ret = await db['sd_raw_neulive'].destroy(
       {
         where: {

src/routes/api/file/index.js

@@ -3,6 +3,7 @@ import meta from './meta'
 import mini from './mini'
 import raw from './raw'
 import sdcard from './sdcard'
+import trigger from './trigger'
 
 export default function (_prefix) {
   const prefix = _prefix + '/file'
@@ -11,6 +12,7 @@ export default function (_prefix) {
     ...meta(prefix),
     ...mini(prefix),
     ...raw(prefix),
-    ...sdcard(prefix)
+    ...sdcard(prefix),
+    ...trigger(prefix)
   ]
 }

src/routes/api/file/meta.js

@@ -17,6 +17,9 @@ export default function (_prefix) {
     ['GET', prefix + '/get_by_parent_with_limit/:type/:parent/:limit/:offset/:order', controllers.recordingDataMeta.getByParentWithLimit],
     ['GET', prefix + '/get_by_attr_parent_with_limit/:type/:parent/:limit/:offset/:order/:attr', controllers.recordingDataMeta.getByAttrsParentWithLimit],
     ['GET', prefix + '/get_or_create_by_path/:path', controllers.recordingDataMeta.getOrCreateByPath],
-    ['GET', prefix + '/get/all', controllers.recordingDataMeta.getAll]
+    ['GET', prefix + '/get/all', controllers.recordingDataMeta.getAll],
+    // control system 3.0
+    ['GET', prefix + '/get_meta_by_uuid/:uuid', controllers.recordingDataMeta.getMetaByUUID],
+    ['GET', prefix + '/get_meta_all', controllers.recordingDataMeta.getMetaAll],
   ]
 }

src/routes/api/file/raw.js

@@ -12,7 +12,8 @@ export default function (_prefix) {
     ['GET', prefix + '/get_by_id/:channel/:id', controllers.recordingDataRaw.getByID],
     ['GET', prefix + '/get_by_ids/:channel/:id', controllers.recordingDataRaw.getByIDs],
     ['GET', prefix + '/get_data_by_id/:channel/:id', controllers.recordingDataRaw.getDataByID],
-    ['GET', prefix + '/get_sd_data_by_id/:channel/:id', controllers.recordingDataRaw.getSdDataByID],
+    ['GET', prefix + '/get_sd_data_by_uuid/:uuid/:channel/:startTime/:endTime', controllers.recordingDataRaw.getSdDataByUUID],
+    ['GET', prefix + '/get_sd_data_all_timeslot_by_uuid/:uuid/:channel', controllers.recordingDataRaw.getSdDataAllTimeslotByUUID],
     ['GET', prefix + '/get_by_parent/:channel/:parent', controllers.recordingDataRaw.getByParent],
     ['GET', prefix + '/get_attr_by_id/:channel/:id/:attr', controllers.recordingDataRaw.getAttrByID],
     ['GET', prefix + '/get_attr_by_ids/:channel/:id/:attr', controllers.recordingDataRaw.getAttrByIDs],

src/routes/api/file/trigger.js

@@ -0,0 +1,10 @@
+import controllers from '../../../controllers'
+
+// '/api/file/trigger'
+
+export default function (_prefix) {
+  const prefix = _prefix + '/trigger'
+  return [
+    ['GET', prefix + '/get_raw_by_uuid/:parent_uuid', controllers.trigger.getRawTriggerByUUID],
+  ]
+}