518 lines
17 KiB
CoffeeScript
518 lines
17 KiB
CoffeeScript
# var dbFile = "/usr/db/data.db";
|
|
dbFile = '/mnt/usb/data.db'
|
|
# var dbFile = '/Users/patrickjmcd/data.db';
|
|
|
|
|
|
dString_to_sqlite = (dString) ->
|
|
###*
|
|
* Takes a date string in the form YYYYMMDD_HHmmSS and returns it in SQLite format (YYYY-MM-DD HH:mm:SS)
|
|
* @param {String} dString
|
|
* @return {String} sqliteString
|
|
###
|
|
|
|
re = /(\d{4})(\d{2})(\d{2})_(\d{2})(\d{2})(\d{2})/
|
|
fd = re.exec(dString)
|
|
if fd
|
|
sqliteString = ''
|
|
sqliteString.concat fd[1], '-', fd[2], '-', fd[3], ' ', fd[4], ':', fd[5], ':', fd[6]
|
|
else
|
|
null
|
|
|
|
|
|
sqlite_to_dString = (sqliteDate) ->
|
|
###*
|
|
* Takes a sqlite date string in the form YYYY-MM-DD HH:mm:SS and returns it in format YYYYMMDD_HHmmSS
|
|
* @param {String} sqliteDate
|
|
* @return {String} dString
|
|
###
|
|
|
|
re = /(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/
|
|
fd = re.exec(sqliteDate)
|
|
if fd
|
|
dString = ''
|
|
dString.concat fd[1], fd[2], fd[3], '_', fd[4], fd[5], fd[6]
|
|
else
|
|
null
|
|
|
|
|
|
getAllTags = (callback) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
db.serialize ->
|
|
query = 'SELECT * FROM tags WHERE deleted = 0'
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.all (err, rows) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
return callback(err, null)
|
|
console.log err
|
|
else
|
|
return callback(null, rows)
|
|
return
|
|
return
|
|
return
|
|
|
|
|
|
exports.getAllTags = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
db.serialize ->
|
|
query = 'SELECT * FROM tags WHERE deleted = 0'
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.all (err, rows) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
console.log err
|
|
else
|
|
res.json
|
|
status: 'OK'
|
|
tags: rows
|
|
return
|
|
return
|
|
return
|
|
|
|
|
|
exports.createTag = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
db.serialize ->
|
|
query = 'INSERT INTO tags (tag, units, minExpected, maxExpected, name, description, class, guarantee_sec, change_threshold, data_type) VALUES (?, ?, ?, ?, ?, ?, 5, ?, ?, ?)'
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.run req.body.tag, req.body.units, req.body.minExpected, req.body.maxExpected, req.body.name, req.body.description, req.body.guarantee_sec, req.body.change_threshold, req.body.data_type, (err) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
console.log err
|
|
else
|
|
res.json status: 'OK'
|
|
return
|
|
return
|
|
return
|
|
|
|
|
|
exports.getTag = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
db.serialize ->
|
|
query = 'SELECT * FROM tags WHERE id = ?'
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.all req.params.id, (err, rows) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
console.log err
|
|
else
|
|
res.json
|
|
status: 'OK'
|
|
tags: rows
|
|
return
|
|
return
|
|
return
|
|
|
|
|
|
exports.updateTag = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
db.serialize ->
|
|
query = 'UPDATE tags set tag = ?, units = ?, minExpected = ?, maxExpected = ?, name = ?, description = ?, guarantee_sec = ?, change_threshold = ?, data_type = ? WHERE id = ?'
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.run req.body.tag, req.body.units, req.body.minExpected, req.body.maxExpected, req.body.name, req.body.description, req.body.guarantee_sec, req.body.change_threshold, req.body.data_type, req.body.id, (err) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
console.log err
|
|
else
|
|
res.json
|
|
status: 'OK'
|
|
return
|
|
return
|
|
return
|
|
|
|
exports.deleteTag = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
db.serialize ->
|
|
query = 'UPDATE tags SET deleted = 1 WHERE id = ?'
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.run req.params.tag, (err) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
console.log err
|
|
else
|
|
res.json
|
|
status: 'OK'
|
|
return
|
|
return
|
|
return
|
|
|
|
exports.seriesTagValues = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
db.serialize ->
|
|
query = 'SELECT * FROM tag_vals WHERE tagID = ? AND dtime > DATETIME(\'now\', \'-1 HOUR\')'
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.all parseInt(req.params.tag), (err, rows) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
query: query
|
|
else
|
|
res.json
|
|
status: 'OK'
|
|
tag: req.params.tag
|
|
vals: rows
|
|
return
|
|
return
|
|
return
|
|
|
|
exports.seriesTagValuesBetween = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
db.serialize ->
|
|
query = 'SELECT * FROM tag_vals WHERE tagID = ? AND dtime >= DATETIME(?) AND dtime <= DATETIME(?)'
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.all parseInt(req.params.tag), dString_to_sqlite(req.params.startDatetime), dString_to_sqlite(req.params.endDatetime), (err, rows) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
query: query
|
|
else
|
|
res.json
|
|
status: 'OK'
|
|
tag: req.params.tag
|
|
startDatetime: dString_to_sqlite(req.params.startDatetime)
|
|
endDatetime: dString_to_sqlite(req.params.endDatetime)
|
|
vals: rows
|
|
return
|
|
return
|
|
return
|
|
|
|
createCSVrow = (header, dataRow) ->
|
|
i = header.indexOf(dataRow.name)
|
|
csvRow = dataRow.id.toString() + ',' + dataRow.dtime + ','
|
|
if i >= 0
|
|
j = 2
|
|
while j < header.length
|
|
if j == i
|
|
csvRow = csvRow + dataRow.val.toString() + ','
|
|
else
|
|
csvRow = csvRow + ','
|
|
j++
|
|
csvRow = csvRow.slice(0, -1) + '\u000d'
|
|
return csvRow
|
|
return
|
|
|
|
exports.allDataCSV = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
db.serialize ->
|
|
query = 'SELECT v.id, t.name, v.val, v.dtime FROM tags t JOIN tag_vals v ON t.id = v.tagID'
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.all (err, rows) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
query: query
|
|
else
|
|
getAllTags (err, tags) ->
|
|
if err
|
|
console.log err
|
|
else
|
|
csvString = ''
|
|
da = [
|
|
'id'
|
|
'dtime'
|
|
]
|
|
tagnames = tags.map((t) ->
|
|
t.name
|
|
)
|
|
h = da.concat(tagnames)
|
|
console.log h
|
|
csvString = csvString + h.join(',') + '\u000d'
|
|
i = 0
|
|
while i < rows.length
|
|
csvString = csvString + createCSVrow(h, rows[i])
|
|
i++
|
|
res.set 'Content-Type', 'text/csv'
|
|
res.set 'Content-Disposition', 'attachment;filename=tagdata.csv'
|
|
res.send csvString
|
|
return
|
|
return
|
|
return
|
|
return
|
|
|
|
exports.seriesCSV = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
db.serialize ->
|
|
query = 'SELECT v.id, t.name, v.val, v.dtime FROM tags t JOIN tag_vals v ON t.id = v.tagID WHERE tagID = ? AND v.dtime > DATETIME(\'now\', \'-1 HOUR\')'
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.all parseInt(req.params.tag), (err, rows) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
query: query
|
|
else
|
|
csvString = ''
|
|
h = [
|
|
'id'
|
|
'dtime'
|
|
rows[0].name
|
|
]
|
|
csvString = csvString + h.join(',') + '\u000d'
|
|
i = 0
|
|
while i < rows.length
|
|
csvString = csvString + [
|
|
rows[i].id
|
|
rows[i].dtime
|
|
rows[i].val
|
|
].join(',') + '\u000d'
|
|
i++
|
|
res.set 'Content-Type', 'text/csv'
|
|
res.set 'Content-Disposition', 'attachment;filename=tagdata.csv'
|
|
res.send csvString
|
|
return
|
|
return
|
|
return
|
|
|
|
exports.seriesCSVBetween = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
db.serialize ->
|
|
query = 'SELECT v.id, t.name, v.val, v.dtime FROM tags t JOIN tag_vals v ON t.id = v.tagID WHERE tagID = ? AND dtime >= DATETIME(?) AND dtime <= DATETIME(?)'
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.all parseInt(req.params.tag), dString_to_sqlite(req.params.startDatetime), dString_to_sqlite(req.params.endDatetime), (err, rows) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
query: query
|
|
else
|
|
csvString = ''
|
|
h = [
|
|
'id'
|
|
'dtime'
|
|
rows[0].name
|
|
]
|
|
csvString = csvString + h.join(',') + '\u000d'
|
|
i = 0
|
|
while i < rows.length
|
|
csvString = csvString + [
|
|
rows[i].id
|
|
rows[i].dtime
|
|
rows[i].val
|
|
].join(',') + '\u000d'
|
|
i++
|
|
res.set 'Content-Type', 'text/csv'
|
|
res.set 'Content-Disposition', 'attachment;filename=tagdata.csv'
|
|
res.send csvString
|
|
return
|
|
return
|
|
return
|
|
|
|
exports.latestValueSingleTag = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
db.serialize ->
|
|
query = 'SELECT * FROM tag_vals WHERE id = (SELECT MAX(id) FROM tag_vals WHERE tagID = ?)'
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.all req.params.tag, (err, rows) ->
|
|
console.log rows
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
console.log err
|
|
else
|
|
res.json
|
|
status: 'OK'
|
|
tag_val: rows[0]
|
|
return
|
|
return
|
|
return
|
|
|
|
exports.latestValueAllTags = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
db.serialize ->
|
|
query = 'SELECT t.tag as tag, t.name as name, t.description as description, t.units as units, t.id as t_id, t.minExpected as min, t.maxExpected as max, MAX(v.id) as v_id, v.val as val, v.dtime as dtime FROM tag_vals v JOIN tags t ON v.tagID = t.id WHERE t.deleted = 0 GROUP BY v.tagID'
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.all req.params.id, (err, rows) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
console.log err
|
|
else
|
|
res.json
|
|
status: 'OK'
|
|
vals: rows
|
|
return
|
|
return
|
|
return
|
|
|
|
exports.checkLoggerStatus = (req, res) ->
|
|
fs = require('fs')
|
|
# var ps = require("ps-node");
|
|
running = require('is-running')
|
|
fs.readFile '/root/tagserver.pid', (derr, ddata) ->
|
|
if derr
|
|
console.log 'Problem getting PID of tagserver'
|
|
res.json
|
|
status: 'error'
|
|
message: 'Problem getting PID of tagserver'
|
|
else
|
|
res.json
|
|
status: 'OK'
|
|
running: running(ddata)
|
|
return
|
|
return
|
|
|
|
exports.restartLogger = (req, res) ->
|
|
exec = require('child_process').exec
|
|
exec '/etc/init.d/loggers start', (error, stdout, stderr) ->
|
|
if error
|
|
res.json
|
|
status: 'error'
|
|
message: error
|
|
else
|
|
res.json
|
|
status: 'OK'
|
|
return
|
|
return
|
|
|
|
exports.getSetup = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
query = 'SELECT parameter, val, dateAdded FROM config GROUP BY parameter;'
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.all req.params.id, (err, rows) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
console.log err
|
|
else
|
|
res.json
|
|
status: 'OK'
|
|
config: rows
|
|
return
|
|
return
|
|
|
|
exports.updateSetup = (req, res) ->
|
|
exec = require('child_process').exec
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
console.log req.body.parameter, req.body.val
|
|
db.serialize ->
|
|
query = db.prepare('INSERT INTO config (parameter, val) VALUES (?, ?)')
|
|
query.run req.body.parameter, req.body.val, (err) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
console.log runErr: err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
query: query
|
|
else
|
|
res.redirect '/#/setup'
|
|
exec '/etc/init.d/loggers stop', (error, stdout, stderr) ->
|
|
if error
|
|
console.log
|
|
status: 'error'
|
|
message: error
|
|
query: query
|
|
setTimeout (->
|
|
exec '/etc/init.d/loggers start', (error, stdout, stderr) ->
|
|
if error
|
|
console.log
|
|
status: 'error'
|
|
message: error
|
|
query: query
|
|
return
|
|
return
|
|
), 5000
|
|
return
|
|
return
|
|
return
|
|
return
|
|
|
|
exports.clearValues = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new (sqlite3.Database)(dbFile)
|
|
if req.params.id
|
|
db.serialize () ->
|
|
query = 'DELETE FROM tag_vals WHERE tagID = ?;';
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.run req.params.id, (err) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
console.log err
|
|
else
|
|
res.json
|
|
status: 'OK'
|
|
else
|
|
db.serialize () ->
|
|
query = 'DELETE FROM tag_vals WHERE id >= 0;';
|
|
prepQuery = db.prepare(query)
|
|
prepQuery.run req.params.id, (err) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
console.log err
|
|
else
|
|
res.json
|
|
status: 'OK'
|
|
undefined
|