1367 lines
38 KiB
CoffeeScript
1367 lines
38 KiB
CoffeeScript
fileLocation = '/mnt/usb'
|
|
dbFile = '/mnt/usb/data.db'
|
|
|
|
# HELPER FUNCTIONS
|
|
pad = (num) ->
|
|
('0' + num.toString()).slice(-2)
|
|
|
|
pocDateFormat = (dtime) ->
|
|
# returns the date in the format YYYYMMDD from a date Object
|
|
regexString = /(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2}).(\d*)/
|
|
dateParts = regexString.exec(dtime)
|
|
dateParts[1] + dateParts[2] + dateParts[3]
|
|
|
|
pocDateTimeFormat = (dtime) ->
|
|
# returns the datetime in the format YYYYMMDD_hhmmss from a date Object
|
|
regexString = /(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2}).(\d*)/
|
|
dateParts = regexString.exec(dtime)
|
|
dateParts[1] + dateParts[2] + dateParts[3] + "_" + dateParts[4] + dateParts[5] + dateParts[6]
|
|
|
|
createFilenameFromCardObject = (c) ->
|
|
# requires Card_ID, Stroke_Time, Card_Type, and Fillage_Percent columns.
|
|
dtPart = pocDateTimeFormat(c.Stroke_Time)
|
|
(dtPart + "_" + c.Card_ID.toString() + "_" + c.Card_Type)
|
|
|
|
|
|
mysqlDateFormat = (dString) ->
|
|
# converts a pocDateFormat string to YYYY-MM-DD for use in MySQL
|
|
regexString = /(\d{4})(\d{2})(\d{2})/
|
|
mysqlDate = regexString.exec(dString)
|
|
(mysqlDate[1] + "-" + mysqlDate[2] + "-" + mysqlDate[3])
|
|
|
|
mysqlDateTimeFormat = (dString) ->
|
|
# converts a pocDateTimeFormat string to a full-blown date object
|
|
regexString = /(\d{4})(\d{2})(\d{2})_(\d{2})(\d{2})(\d{2})/
|
|
m = regexString.exec(dString)
|
|
(new Date(m[1], m[2], m[3], m[4], m[5], m[6], 0))
|
|
|
|
splitDateIntoObj = (dString) ->
|
|
regexString = /(\d{4})(\d{2})(\d{2})/
|
|
dList = regexString.exec(dString)
|
|
d =
|
|
year: dList[1]
|
|
month: dList[2]
|
|
day: dList[3]
|
|
d
|
|
|
|
getTime = (inp) ->
|
|
[parseFloat(inp.split("_")[1]), inp]
|
|
|
|
# DATA FUNCTIONS
|
|
exports.allDates = (req, res) ->
|
|
# returns all dates with cards stored in the database
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
query = "SELECT * FROM card_history_dates"
|
|
db.serialize () ->
|
|
db.all query, (err, rows) ->
|
|
db.close()
|
|
if err
|
|
console.log(err)
|
|
res.json
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
dates: rows.map (x) ->
|
|
x.year.toString() + pad(x.month) + pad(x.day)
|
|
undefined
|
|
|
|
|
|
exports.allCards = (req, res) ->
|
|
# returns all cards for a given date
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
fdate = req.params.date.toString()
|
|
startDate = splitDateIntoObj(fdate)
|
|
db.serialize () ->
|
|
startIDquery = db.prepare "SELECT id, first_id FROM card_history_dates WHERE year = ? AND month = ? AND day = ?"
|
|
startIDquery.all startDate.year, startDate.month, startDate.day, (err, rows) ->
|
|
startIDquery.finalize()
|
|
if err
|
|
db.close()
|
|
console.log err
|
|
res.json
|
|
status:"error"
|
|
message:err
|
|
else
|
|
first_id = rows[0].first_id
|
|
found_id = rows[0].id
|
|
lastIDquery = db.prepare "SELECT first_id FROM card_history_dates WHERE id = (SELECT MIN(id) FROM card_history_dates WHERE id > ?)"
|
|
lastIDquery.all found_id, (lerr, lrows) ->
|
|
lastIDquery.finalize()
|
|
if lerr
|
|
db.close()
|
|
console.log lerr
|
|
res.json
|
|
status:'error'
|
|
message:lerr
|
|
else
|
|
# var cardQuery
|
|
if lrows.length > 0
|
|
# We are not being asked for the current day
|
|
last_id = lrows[0].first_id
|
|
cardQuery = db.prepare("SELECT id, Card_ID, Stroke_Time, Card_Type FROM card_history WHERE id > ? AND id <= ? ORDER BY id DESC")
|
|
cardQuery.all first_id, last_id, (cerr, crows) ->
|
|
cardQuery.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status:"error"
|
|
message:cerr
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
date:fdate
|
|
cards:crows
|
|
else
|
|
# We are being asked for the current day
|
|
cardQuery = db.prepare("SELECT id, Card_ID, Stroke_Time, Card_Type FROM card_history WHERE id > ? ORDER BY id DESC")
|
|
cardQuery.all first_id, (cerr, crows) ->
|
|
cardQuery.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status:"error"
|
|
message:cerr
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
date:fdate
|
|
cards:crows
|
|
undefined
|
|
|
|
|
|
exports.filePage = (req,res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
date = mysqlDateFormat req.params.date.toString()
|
|
page = req.params.page.toString()
|
|
numPerPage = req.params.numPerPage.toString()
|
|
|
|
db.serialize () ->
|
|
query = db.prepare "SELECT id, Card_ID, Stroke_Time, Card_Type FROM card_history WHERE id <= (SELECT id FROM card_history WHERE DATE(Stroke_Time) = ? ORDER BY id DESC LIMIT 1) - (? * (? - 1)) and id > ((SELECT id FROM card_history WHERE DATE(Stroke_Time) = ? ORDER BY id DESC LIMIT 1) - (? * (? - 1)) - ?) ORDER BY id DESC"
|
|
query.all date, numPerPage, page, date, numPerPage, page, numPerPage, (err, rows) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
date: req.params.date.toString()
|
|
cards:rows
|
|
undefined
|
|
|
|
exports.countDateFiles = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
date = mysqlDateFormat req.params.date.toString()
|
|
db.serialize () ->
|
|
query = db.prepare "SELECT COUNT(id) as cnt FROM card_history WHERE DATE(Stroke_Time) = ?"
|
|
query.all date, (err, rows) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status:'error'
|
|
message:err
|
|
query:query
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
date: req.params.date.toString()
|
|
count:rows[0].cnt
|
|
undefined
|
|
|
|
exports.cardLatestX = (req,res) ->
|
|
# attempts to find the filenames of the latest X cards. If there are less than X cards, returns as many as possible.
|
|
# if no number of cards is supplied, returns the latest card
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
numCards = 1
|
|
if req.params.num > 1
|
|
numCards = parseInt(req.params.num)
|
|
|
|
db.serialize () ->
|
|
query = db.prepare "SELECT id, Card_ID, Stroke_Time, Card_Type FROM card_history WHERE id > ((SELECT MAX(id) FROM card_history) - ?)"
|
|
query.all numCards, (err, rows) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status:'error'
|
|
message:err
|
|
query:query
|
|
else
|
|
filenames = rows.map createFilenameFromCardObject
|
|
ids = rows.map (x) ->
|
|
x.id
|
|
res.json
|
|
status:"OK"
|
|
file: filenames[0]
|
|
folder:pocDateFormat(rows[0].Stroke_Time)
|
|
numCards: rows.length
|
|
cards:filenames.reverse()
|
|
ids: ids.reverse()
|
|
undefined
|
|
|
|
stringToFloatArray = (stringArray) ->
|
|
spl = stringArray.toString().split(',')
|
|
spl.map (x) ->
|
|
parseFloat(x)
|
|
|
|
exports.latestCardData = (req, res) ->
|
|
# Gets right to the point and returns the data for the latest x cards
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
numCards = 1
|
|
if req.params.num > 1
|
|
numCards = parseInt req.params.num
|
|
|
|
db.serialize () ->
|
|
query = db.prepare "SELECT * FROM card_history WHERE id > ((SELECT MAX(id) FROM card_history) - ?)"
|
|
query.all numCards, (err, rows) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status:'error'
|
|
message:err
|
|
query:query
|
|
else
|
|
card_data_ret = rows.map (r) ->
|
|
Surface_Position: stringToFloatArray r.Surface_Position
|
|
Surface_Load: stringToFloatArray r.Surface_Load
|
|
Downhole_Position: stringToFloatArray r.Downhole_Position
|
|
Downhole_Load: stringToFloatArray r.Downhole_Load
|
|
Stroke_Time: r.Stroke_Time
|
|
id: r.id
|
|
Card_ID: r.Card_ID
|
|
Card_Type: r.Card_Type
|
|
|
|
res.json
|
|
status:"OK"
|
|
date: pocDateFormat rows[0].Stroke_Time
|
|
card_data: card_data_ret
|
|
undefined
|
|
|
|
exports.findBetweenDateTime = (req, res) ->
|
|
# returns all filenames between a given start and end time
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
mStart = mysqlDateTimeFormat req.params.start
|
|
mEnd = mysqlDateTimeFormat req.params.end
|
|
db.serialize () ->
|
|
query = db.prepare "SELECT id, Stroke_Time, Card_ID, Card_Type FROM card_history WHERE Stroke_Time < ? AND Stroke_Time >= ? ORDER BY Stroke_Time DESC"
|
|
query.all mEnd, mStart, (err, rows) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
error:err
|
|
query:query
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
files:rows.map createFilenameFromCardObject
|
|
undefined
|
|
|
|
exports.singleCard = (req, res) ->
|
|
# returns all the data for a single card given it's id (db id)
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
id = req.params.id
|
|
db.serialize () ->
|
|
query = db.prepare "SELECT * FROM card_history WHERE id = ?"
|
|
query.all id, (err, rows) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status:'error'
|
|
message:err
|
|
query:query
|
|
else if (rows.length > 0)
|
|
card_data_ret = rows.map (r) ->
|
|
Surface_Position: stringToFloatArray r.Surface_Position
|
|
Surface_Load: stringToFloatArray r.Surface_Load
|
|
Downhole_Position: stringToFloatArray r.Downhole_Position
|
|
Downhole_Load: stringToFloatArray r.Downhole_Load
|
|
Stroke_Time: r.Stroke_Time
|
|
id: r.id
|
|
Card_ID: r.Card_ID
|
|
Card_Type: r.Card_Type
|
|
|
|
res.json
|
|
status:"OK"
|
|
date: pocDateFormat rows[0].Stroke_Time
|
|
card_data: card_data_ret[0]
|
|
# else
|
|
# res.json
|
|
# status:'error'
|
|
# message:"no cards found with that id"
|
|
undefined
|
|
|
|
exports.singleCardOldway = (req, res) ->
|
|
# returns all the data for a single card given its folder(date) and filename
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
date = mysqlDateFormat(req.params.folder)
|
|
card_id = parseInt(req.params.file.split("_")[2])
|
|
db.serialize () ->
|
|
query = db.prepare "SELECT * FROM card_history WHERE DATE(Stroke_Time) = ? AND Card_ID = ?"
|
|
query.all date, card_id, (err, rows) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
else
|
|
card_data_ret = rows.map (r) ->
|
|
Surface_Position: stringToFloatArray r.Surface_Position
|
|
Surface_Load: stringToFloatArray r.Surface_Load
|
|
Downhole_Position: stringToFloatArray r.Downhole_Position
|
|
Downhole_Load: stringToFloatArray r.Downhole_Load
|
|
Stroke_Time: r.Stroke_Time
|
|
id: r.id
|
|
Card_ID: r.Card_ID
|
|
Card_Type: r.Card_Type
|
|
|
|
res.json
|
|
status:"OK"
|
|
date: pocDateFormat card_data_ret[0].Stroke_Time
|
|
card_data: card_data_ret[0]
|
|
|
|
exports.getCardByCardID = (req, res) ->
|
|
# returns all the data for a card given its date and Card_ID
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
cardID = req.params.card_id
|
|
fdate = req.params.date
|
|
|
|
db.serialize () ->
|
|
query = db.prepare "SELECT * FROM card_history WHERE DATE(Stroke_Time) = ? AND Card_ID = ? ORDER BY Stroke_Time DESC"
|
|
query.all mysqlDateFormat fdate , cardID, (err, rows) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
else
|
|
if rows.length > 0
|
|
card_data_ret = rows.map (r) ->
|
|
Surface_Position: stringToFloatArray r.Surface_Position
|
|
Surface_Load: stringToFloatArray r.Surface_Load
|
|
Downhole_Position: stringToFloatArray r.Downhole_Position
|
|
Downhole_Load: stringToFloatArray r.Downhole_Load
|
|
Stroke_Time: r.Stroke_Time
|
|
id: r.id
|
|
Card_ID: r.Card_ID
|
|
Card_Type: r.Card_Type
|
|
|
|
res.json
|
|
status:"OK"
|
|
date: card_data_ret[0].Stroke_Time.getFullYear().toString() + pad(card_data_ret[0].Stroke_Time.getMonth()+1) + pad(card_data_ret[0].Stroke_Time.getDate())
|
|
card_data: card_data_ret[0]
|
|
else
|
|
res.json
|
|
status:"error"
|
|
message:"No cards found for those parameters."
|
|
undefined
|
|
|
|
exports.multipleCards = (req, res) ->
|
|
# Returns all the data for multiple cards
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database dbFile
|
|
ids = req.body.ids
|
|
idString = ids.join()
|
|
db.serialize () ->
|
|
query = db.prepare "SELECT * FROM card_history WHERE id IN (?)"
|
|
query.all idString, (err, rows) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status: 'error'
|
|
message: err
|
|
|
|
else
|
|
if rows.length > 0
|
|
res.json
|
|
status:"OK",
|
|
cards: rows.map (r) ->
|
|
Surface_Position: stringToFloatArray r.Surface_Position
|
|
Surface_Load: stringToFloatArray r.Surface_Load
|
|
Downhole_Position: stringToFloatArray r.Downhole_Position
|
|
Downhole_Load: stringToFloatArray r.Downhole_Load
|
|
Stroke_Time: r.Stroke_Time
|
|
id: r.id
|
|
Card_ID: r.Card_ID
|
|
Card_Type: r.Card_Type
|
|
else
|
|
res.json
|
|
status:"error"
|
|
message:"No cards found for those parameters."
|
|
undefined
|
|
|
|
exports.cardCSV = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
dbid = req.params.id
|
|
db.serialize () ->
|
|
query = db.prepare "SELECT * FROM card_history WHERE id = ?"
|
|
csvString = ""
|
|
query.all dbid, (err, rows) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
filenamecsv = createFilenameFromCardObject rows[0]
|
|
for key in rows[0]
|
|
if rows[0].hasOwnProperty key
|
|
csvString += key + "," + rows[0][key] + "\n"
|
|
res.set 'Content-Type', 'text/csv'
|
|
res.set 'Content-Disposition', "attachment;filename="+filenamecsv + ".csv"
|
|
res.send csvString
|
|
undefined
|
|
|
|
|
|
# TODO CREATE A DB TABLE FOR TAPER DATA
|
|
exports.taper = (req, res) ->
|
|
undefined
|
|
|
|
exports.status = (req, res) ->
|
|
# returns the current run status
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
db.serialize () ->
|
|
query = db.prepare "SELECT * FROM run_status WHERE id = (SELECT MAX(id) FROM run_status)"
|
|
query.all (err, rows) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
console.log err
|
|
res.json
|
|
status:'error'
|
|
message:err
|
|
query:query
|
|
else
|
|
if rows.length > 0
|
|
res.json
|
|
status:"OK"
|
|
datetime: rows[0].dtime
|
|
run_status: rows[0].status
|
|
else
|
|
res.json
|
|
status:'error'
|
|
message:"no statuses in db"
|
|
undefined
|
|
|
|
exports.historyLatest = (req, res) ->
|
|
# returns the latest gauge off data recorded
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
query = 'SELECT * FROM Hist_Day ORDER BY id DESC LIMIT 1'
|
|
db.serialize () ->
|
|
db.all query, (err, rows) ->
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
hist:rows[0]
|
|
|
|
exports.wellTestLatest = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
query = 'SELECT * FROM Well_Test ORDER BY id DESC LIMIT 1'
|
|
db.serialize () ->
|
|
db.all query, (err, rows) ->
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
wellTest:rows[0]
|
|
|
|
|
|
exports.eventList = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
numEvents = 10
|
|
if req.params.numEvents
|
|
numEvents = req.params.numEvents
|
|
db.serialize () ->
|
|
query = db.prepare 'SELECT * FROM Event_List ORDER BY id DESC LIMIT ?'
|
|
query.all numEvents, (err, rows) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
events:rows
|
|
|
|
exports.eventListAll = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
query = 'SELECT * FROM Event_List ORDER BY id DESC'
|
|
db.serialize () ->
|
|
db.all query, (err, rows) ->
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
events:rows
|
|
|
|
exports.historyAll = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
query = 'SELECT * FROM Hist_Day ORDER BY id DESC'
|
|
db.serialize () ->
|
|
db.all query, (err, rows) ->
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
hist:rows
|
|
|
|
exports.wellTestAll = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
query = 'SELECT * FROM Well_Test ORDER BY id DESC'
|
|
db.serialize () ->
|
|
db.all query, (err, rows) ->
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
wellTest:rows
|
|
|
|
exports.getSetup = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
query = 'SELECT * FROM config ORDER BY dateChanged DESC LIMIT 1'
|
|
db.serialize () ->
|
|
db.all query, (err, rows) ->
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
setup:rows[0]
|
|
|
|
exports.updateSetup = (req, res) ->
|
|
exec = require('child_process').exec
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
console.log req.body.ip_address, req.body.device_type
|
|
a =
|
|
ip_address: req.body.ip_address,
|
|
device_type: req.body.device_type
|
|
|
|
db.serialize () ->
|
|
query = db.prepare('INSERT INTO config (ip_address, device_type) VALUES (?, ?)')
|
|
query.run req.body.ip_address, req.body.device_type, (err) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.redirect "/#/setup"
|
|
exec '/etc/init.d/loggers stop', (error, stdout, stderr) ->
|
|
if execError
|
|
errMsg =
|
|
status:"error"
|
|
message:execError
|
|
console.log errMsg
|
|
res.json errMsg
|
|
setTimeout () ->
|
|
exec '/etc/init.d/loggers start', (error, stdout, stderr) ->
|
|
if execError
|
|
errMsg =
|
|
status:"error"
|
|
message:execError
|
|
console.log errMsg
|
|
,5000
|
|
undefined
|
|
|
|
|
|
|
|
|
|
exports.checkPythonScripts = (req, res) ->
|
|
fs = require('fs')
|
|
running = require("is-running")
|
|
|
|
alarmPID = 0
|
|
dataPID = 0
|
|
programStatus =
|
|
alarmLogger:false
|
|
dataLogger:false
|
|
fs.readFile '/root/alarmLogger.pid', (aerr,adata) ->
|
|
if aerr
|
|
console.log "Problem getting PID of alarmLogger"
|
|
else
|
|
programStatus.alarmLogger = running adata
|
|
|
|
fs.readFile '/root/dataLogger.pid', (derr,ddata) ->
|
|
if derr
|
|
console.log "Problem getting PID of dataLogger"
|
|
else
|
|
programStatus.dataLogger = running ddata
|
|
|
|
setTimeout ()->
|
|
res.json
|
|
status: programStatus
|
|
, 1000
|
|
undefined
|
|
|
|
exports.restartPythonScripts = (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"
|
|
|
|
|
|
tagsAllowedToWrite = [
|
|
{name:"Stop Command", tag:"Pump.Stop", units:""},
|
|
{name:"Speed Setpoint (SPM)", tag:"Pump.Speed_Setpoint_SPM", units:"SPM"},
|
|
{name:"Max Speed", tag:"Pump.Speed_Max", units:"RPM"},
|
|
{name:"Min Speed", tag:"Pump.Speed_Min", units:"RPM"},
|
|
{name:"Speed Increase Setpoint", tag:"Pump.Auto_Percentage_RampUp", units:"%"},
|
|
{name:"Speed Decrease Setpoint", tag:"Pump.Auto_Percentage_RampDown", units:"%"},
|
|
{name:"Pump-Off Setpoint", tag:"Pump.POC_Percentage_Off", units:"%"},
|
|
]
|
|
|
|
|
|
# TODO FIX THIS FUNCTION
|
|
exports.statusTagData = (req, res) ->
|
|
# async = require('async')
|
|
# async.map(tagsAllowedToWrite, (tag, tagcb) ->
|
|
# readTag tag.tag, (retObj) ->
|
|
# console.log retObj
|
|
# if retObj.status == 'success'
|
|
# tagcb
|
|
# tag:tag.tag
|
|
# value:retObj.value
|
|
# type:retObj.type
|
|
# units:tag.units
|
|
# else
|
|
# tagcb
|
|
# error:retObj.error
|
|
#
|
|
# (tagerr, tagresult) ->
|
|
# res.json
|
|
# status:"OK"
|
|
# tags:tagresult
|
|
undefined
|
|
|
|
|
|
readTag = (tagName, cb) ->
|
|
exec = require('child_process').exec
|
|
exec 'python /home/poconsole/src/datalogger/readTag.py ' + tagName, (error, stdout, stderr) ->
|
|
if error
|
|
cb
|
|
error:error
|
|
else
|
|
readReturned = JSON.parse stdout.replace /'/g, '"'
|
|
if readReturned.status == "error"
|
|
cb
|
|
error:readReturned.message
|
|
else if readReturned.status == "success"
|
|
cb readReturned
|
|
undefined
|
|
|
|
writeTag = (tagName, value, godMode, cb) ->
|
|
exec = require('child_process').exec
|
|
allowedTags = tagsAllowedToWrite.map (x) ->
|
|
x.tag
|
|
inAllowedTags = false
|
|
if allowedTags.indexOf(tagName) > 0
|
|
inAllowedTags = true
|
|
if inAllowedTags || godMode
|
|
exec 'python /home/poconsole/src/datalogger/writeTag.py ' + tagName + " " + value, (error, stdout, stderr) ->
|
|
if error
|
|
cb
|
|
error:error
|
|
else
|
|
readReturned = JSON.parse stdout.replace /'/g, '"'
|
|
if readReturned.status == "error"
|
|
cb
|
|
error:readReturned.message
|
|
else if readReturned.status == "success"
|
|
cb readReturned
|
|
else
|
|
cb
|
|
error:"Not in allowed tags"
|
|
|
|
|
|
exports.setTagValue = (req, res) ->
|
|
tagName = req.params.tagName
|
|
value = req.params.value
|
|
godMode = req.params.mode == "I_AM_PATRICK"
|
|
|
|
writeTag tagName, value, godMode, (newValue) ->
|
|
res.json newValue
|
|
undefined
|
|
|
|
exports.getTagValue = (req, res) ->
|
|
readTag req.params.tagName, (retObj) ->
|
|
res.json retObj
|
|
undefined
|
|
|
|
exports.getWellBackups = (req, res) ->
|
|
fs = require('fs')
|
|
backupDir = fileLocation
|
|
fs.readdir backupDir, (err, files) ->
|
|
if err
|
|
res.json
|
|
status:"error"
|
|
message:err
|
|
else
|
|
backups = files.filter (x)->
|
|
x.slice(0,6) == "backup"
|
|
.map (y) ->
|
|
y.split(".")[0]
|
|
.sort().reverse()
|
|
res.json
|
|
status:"OK"
|
|
backups:backups
|
|
undefined
|
|
|
|
exports.parseWellBackup = (req, res) ->
|
|
# fs = require('fs');
|
|
# csv = require('ya-csv');
|
|
# path = require('path');
|
|
#
|
|
# backup = {}
|
|
# backup.unitConfig = {}
|
|
# backup.unitConfig.motorNameplate = {}
|
|
# backup.taper = []
|
|
# for (var i = 0; i<11; i ++){
|
|
# backup.taper.push({setup:{}});
|
|
# }
|
|
#
|
|
# var backupDir = fileLocation;
|
|
# var reader = new csv.createCsvFileReader(path.join(backupDir,req.params.file) + ".csv", {
|
|
# 'separator': ',',
|
|
# 'quote': '"',
|
|
# 'escape': '"',
|
|
# 'comment': '',
|
|
# });
|
|
# var writer = new csv.CsvWriter(process.stdout);
|
|
# reader.addListener('data', function(data) {
|
|
# var splitTagName = data[0].split(".");
|
|
# if (splitTagName[0] == "UnitConfig"){
|
|
# if (splitTagName[1] == "MotorNameplate"){
|
|
# backup.unitConfig.motorNameplate[splitTagName[2]] = data[1];
|
|
# else
|
|
# backup.unitConfig[splitTagName[1]] = data[1];
|
|
# }
|
|
# } else if (splitTagName[0] == "Taper"){
|
|
# var re = /Taper\[(\d*)\]/;
|
|
# var taperNum = parseInt(re.exec(splitTagName[1])[1]);
|
|
# backup.taper[taperNum].setup[splitTagName[3]] = data[1];
|
|
# else
|
|
# if (splitTagName[0] != "TAPER"){
|
|
# backup[data[0]] = data[1];
|
|
# }
|
|
# }
|
|
# });
|
|
# reader.on("end", function(){
|
|
# res.json({status:"OK", backupData:backup});
|
|
# });
|
|
undefined
|
|
|
|
exports.getCurrentTotals = (req, res) ->
|
|
exec = require('child_process').exec
|
|
script = 'python /home/poconsole/src/datalogger/getTodaysTotals.py'
|
|
exec script, (error, stdout, stderr) ->
|
|
if error
|
|
res.json
|
|
status:'error'
|
|
message:error
|
|
else
|
|
console.log
|
|
stdout:stdout
|
|
res.json
|
|
status:"OK"
|
|
totals:JSON.parse stdout.replace /'/g, '"'
|
|
undefined
|
|
|
|
### NOTES ###
|
|
exports.getNotes = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
query = "SELECT notes.id as id, notes.author as author, notes.note as note, types.type as ntype, notes.type as ntypeval, notes.associated_stroke as stroke, notes.datetime as date_time FROM Notes notes LEFT JOIN note_types types ON notes.type = types.id WHERE notes.deleted=0"
|
|
db.serialize () ->
|
|
db.all query, (err, rows) ->
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
notes:rows.reverse()
|
|
undefined
|
|
|
|
exports.postNote = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
post =
|
|
author: req.body.author,
|
|
note: req.body.note,
|
|
type: req.body.type,
|
|
associated_stroke: req.body.stroke_associated
|
|
|
|
query = db.prepare "INSERT INTO Notes (author, note, type, associated_stroke) VALUES (?, ?, ?, ?)"
|
|
db.serialize () ->
|
|
query.run req.body.author, req.body.note, req.body.type, req.body.associated_stroke, (err) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
undefined
|
|
|
|
exports.getNoteTypes = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
query = "SELECT * FROM note_types WHERE deleted=0"
|
|
db.serialize () ->
|
|
db.all query, (err, rows) ->
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK", types:rows
|
|
undefined
|
|
|
|
exports.updateNote = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
id = parseInt(req.body.id)
|
|
db.serialize () ->
|
|
query = db.prepare "UPDATE Notes SET note = ?, author= ?, type = ? , associated_stroke = ? WHERE id = ?"
|
|
query.run req.body.note, req.body.author, req.body.type, req.body.stroke_associated, id, (err) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
undefined
|
|
|
|
exports.deleteNote = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
id = parseInt req.body.id
|
|
db.serialize () ->
|
|
query = db.prepare "UPDATE Notes SET deleted=1 WHERE id = ?"
|
|
query.run id, (err) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
undefined
|
|
|
|
exports.undeleteNote = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
id = parseInt req.body.id
|
|
db.serialize () ->
|
|
query = db.prepare 'UPDATE Notes SET deleted=0 WHERE id = ?'
|
|
query.run id, (err) ->
|
|
db.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
undefined
|
|
|
|
exports.getDeletedNotes = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
query = "SELECT notes.id as id, notes.author as author, notes.note as note, types.type as ntype, notes.type as ntypeval, notes.associated_stroke as stroke, notes.datetime as date_time FROM Notes notes LEFT JOIN note_types types ON notes.type = types.id WHERE notes.deleted=1"
|
|
db.serialize () ->
|
|
db.all query, (err, rows) ->
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
notes:rows.reverse()
|
|
undefined
|
|
|
|
|
|
### FLUID LEVEL SHOT ###
|
|
exports.getFluidShots = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
query = "SELECT * FROM fluid_shot WHERE deleted=0"
|
|
db.serialize () ->
|
|
db.all query, (err, rows, fields) ->
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
fluid_shots: rows.reverse()
|
|
undefined
|
|
|
|
exports.postFluidShot = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
p =
|
|
shot_datetime: req.body.shot_datetime,
|
|
pump_intake_pressure: req.body.pump_intake_pressure,
|
|
fluid_gradient: req.body.fluid_gradient,
|
|
friction: req.body.friction,
|
|
taken_by: req.body.taken_by
|
|
|
|
db.serialize () ->
|
|
query = db.prepare "INSERT INTO fluid_shot (shot_datetime, pump_intake_pressure, fluid_gradient, friction, taken_by) VALUES (?, ?, ?, ?, ?)"
|
|
query.run p.shot_datetime, p.pump_intake_pressure, p.fluid_gradient, p.friction, p.taken_by, (err) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
undefined
|
|
|
|
exports.updateFluidShot = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
id = parseInt req.body.id
|
|
db.serialize () ->
|
|
query = db.prepare "UPDATE fluid_shot SET shot_datetime = ?, pump_intake_pressure= ?, fluid_gradient = ? , friction = ?, taken_by = ? WHERE id = ?"
|
|
query.run req.body.shot_datetime, req.body.pump_intake_pressure, req.body.fluid_gradient, req.body.friction, req.body.taken_by, id, (err) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
undefined
|
|
|
|
exports.deleteFluidShot = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
id = parseInt(req.body.id)
|
|
db.serialize () ->
|
|
query = db.prepare "UPDATE fluid_shot SET deleted=1 WHERE id = ?"
|
|
query.run id, (err) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
undefined
|
|
|
|
exports.undeleteFluidShot = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
id = parseInt req.body.id
|
|
db.serialize () ->
|
|
query = db.prepare "UPDATE fluid_shot SET deleted=0 WHERE id = ?"
|
|
query.run id, (err) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
undefined
|
|
|
|
exports.getDeletedFluidShots = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
query = "SELECT * FROM fluid_shot WHERE deleted=1"
|
|
db.serialize () ->
|
|
db.all query, (err, rows) ->
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
fluid_shots:rows.reverse()
|
|
undefined
|
|
|
|
### WELL TESTS ###
|
|
exports.getWellTests = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
query = "SELECT * FROM Well_Test WHERE deleted=0"
|
|
db.serialize () ->
|
|
db.all query, (err, rows, fields) ->
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK", well_tests: rows.reverse()
|
|
undefined
|
|
|
|
exports.postWellTest = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
p =
|
|
test_date: req.body.test_date,
|
|
test_volume_oil: req.body.test_volume_oil,
|
|
test_volume_water: req.body.test_volume_water,
|
|
test_volume_gas: req.body.test_volume_gas,
|
|
api_gravity_oil: req.body.api_gravity_oil,
|
|
sg_oil:req.body.sg_oil,
|
|
sg_water: req.body.sg_water,
|
|
test_hours: req.body.test_hours
|
|
|
|
db.serialize () ->
|
|
query = db.prepare "INSERT INTO Well_Test SET (test_date, test_volume_oil, test_volume_water, test_volume_gas, api_gravity_oil, sg_oil, sg_water, test_hours) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
|
|
query.run p.test_date, p.test_volume_oil, p.test_volume_water, p.test_volume_gas, p.api_gravity_oil, p.sg_oil, p.sg_water, p.test_hours, (err) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
undefined
|
|
|
|
exports.updateWellTest = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
id = parseInt req.body.id
|
|
db.serialize () ->
|
|
query = db.prepare "UPDATE Well_Test SET test_date = ?, test_volume_oil= ?, test_volume_water = ? , test_volume_gas = ?, api_gravity_oil = ?, sg_oil = ?, sg_water = ?, test_hours = ?, WHERE id = ?"
|
|
query.run req.body.test_date, req.body.test_volume_oil, req.body.test_volume_Water, req.body.test_volume_gas, req.body.api_gravity_oil, req.body.sg_oil, req.body.sg_water, req.body.test_hours, id, (err, rows, fields) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
undefined
|
|
|
|
exports.deleteWellTest = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
id = parseInt req.body.id
|
|
db.serialize () ->
|
|
query = db.prepare "UPDATE Well_Test SET deleted=1 WHERE id = ?"
|
|
query.run id, (err) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status: "OK"
|
|
undefined
|
|
|
|
exports.undeleteWellTest = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
id = parseInt req.body.id
|
|
db.serialize () ->
|
|
query = db.prepare "UPDATE Well_Test SET deleted=0 WHERE id = ?"
|
|
query.run id, (err) ->
|
|
query.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
undefined
|
|
|
|
exports.getDeletedWellTests = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
query = "SELECT * FROM Well_Test WHERE deleted=1"
|
|
db.serialize () ->
|
|
db.all query, (err, rows) ->
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
well_tests:rows.reverse()
|
|
undefined
|
|
|
|
exports.getTagValues = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
|
|
db.serialize () ->
|
|
query = "SELECT name, dtime, val FROM tag_vals GROUP BY name"
|
|
prepQuery = db.prepare query
|
|
prepQuery.all req.params.id, (err, rows) ->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status:"OK"
|
|
vals:rows
|
|
undefined
|
|
|
|
|
|
exports.getValuesClosestTo = (req, res) ->
|
|
sqlite3 = require('sqlite3').verbose()
|
|
db = new sqlite3.Database(dbFile)
|
|
db.serialize ()->
|
|
query = 'SELECT *, MIN(ABS(dtime - ?)) as dist FROM tag_vals GROUP BY name ORDER BY abs(dtime - ?);'
|
|
prepQuery = db.prepare query
|
|
prepQuery.all req.params.unixTS, (err, rows)->
|
|
prepQuery.finalize()
|
|
db.close()
|
|
if err
|
|
errMsg =
|
|
status:"error"
|
|
message:err
|
|
query:query
|
|
console.log errMsg
|
|
res.json errMsg
|
|
else
|
|
res.json
|
|
status: "OK"
|
|
vals: rows
|
|
undefined
|