227 lines
10 KiB
JavaScript
227 lines
10 KiB
JavaScript
var fs = require('fs')
|
|
var execSync = require('child_process').execSync
|
|
module.exports = function(s,config,lang,app,io){
|
|
if(config.dropInEventServer === true){
|
|
if(config.dropInEventDeleteFileAfterTrigger === undefined)config.dropInEventDeleteFileAfterTrigger = true
|
|
var beforeMonitorsLoadedOnStartup = function(){
|
|
if(!config.dropInEventsDir){
|
|
config.dropInEventsDir = s.dir.streams + 'dropInEvents/'
|
|
}
|
|
s.dir.dropInEvents = s.checkCorrectPathEnding(config.dropInEventsDir)
|
|
//dropInEvents dir
|
|
if(!fs.existsSync(s.dir.dropInEvents)){
|
|
fs.mkdirSync(s.dir.dropInEvents)
|
|
}
|
|
}
|
|
var getDropInEventDir = function(monitorConfig){
|
|
var ke = monitorConfig.ke
|
|
var mid = monitorConfig.mid
|
|
var groupEventDropDir = s.dir.dropInEvents + ke
|
|
var monitorEventDropDir = groupEventDropDir + '/' + mid + '/'
|
|
return monitorEventDropDir
|
|
}
|
|
var onMonitorStop = function(monitorConfig){
|
|
var ke = monitorConfig.ke
|
|
var mid = monitorConfig.mid
|
|
if(s.group[monitorConfig.ke].activeMonitors[monitorConfig.mid].dropInEventWatcher){
|
|
s.group[monitorConfig.ke].activeMonitors[monitorConfig.mid].dropInEventWatcher.close()
|
|
delete(s.group[monitorConfig.ke].activeMonitors[monitorConfig.mid].dropInEventWatcher)
|
|
}
|
|
var monitorEventDropDir = getDropInEventDir(monitorConfig)
|
|
if(fs.existsSync(monitorEventDropDir))execSync('rm -rf ' + monitorEventDropDir)
|
|
}
|
|
var onMonitorInit = function(monitorConfig){
|
|
onMonitorStop(monitorConfig)
|
|
var ke = monitorConfig.ke
|
|
var mid = monitorConfig.mid
|
|
var monitorEventDropDir = getDropInEventDir(monitorConfig)
|
|
var groupEventDropDir = s.dir.dropInEvents + ke
|
|
if(!fs.existsSync(groupEventDropDir)){
|
|
fs.mkdirSync(groupEventDropDir)
|
|
}
|
|
var monitorEventDropDir = groupEventDropDir + '/' + mid + '/'
|
|
if(!fs.existsSync(monitorEventDropDir)){
|
|
fs.mkdirSync(monitorEventDropDir)
|
|
}
|
|
var fileQueue = {}
|
|
s.group[monitorConfig.ke].activeMonitors[monitorConfig.mid].dropInEventFileQueue = fileQueue
|
|
var search = function(searchIn,searchFor){
|
|
return searchIn.indexOf(searchFor) > -1
|
|
}
|
|
var processFile = function(filename){
|
|
var filePath = monitorEventDropDir + filename
|
|
if(search(filename,'.jpg') || search(filename,'.jpeg')){
|
|
var snapPath = s.dir.streams + ke + '/' + mid + '/s.jpg'
|
|
fs.unlink(snapPath,function(err){
|
|
fs.createReadStream(filePath).pipe(fs.createWriteStream(snapPath))
|
|
s.triggerEvent({
|
|
id: mid,
|
|
ke: ke,
|
|
details: {
|
|
confidence: 100,
|
|
name: filename,
|
|
plug: "dropInEvent",
|
|
reason: "ftpServer"
|
|
}
|
|
})
|
|
})
|
|
}else{
|
|
if(search(filename,'.mp4')){
|
|
fs.stat(filePath,function(err,stats){
|
|
var startTime = stats.ctime
|
|
var endTime = stats.mtime
|
|
var shinobiFilename = s.formattedTime(startTime) + '.mp4'
|
|
var recordingPath = s.getVideoDirectory(monitorConfig) + shinobiFilename
|
|
var writeStream = fs.createWriteStream(recordingPath)
|
|
fs.createReadStream(filePath).pipe(writeStream)
|
|
writeStream.on('finish', () => {
|
|
s.insertCompletedVideo(s.group[monitorConfig.ke].rawMonitorConfigurations[monitorConfig.mid],{
|
|
file : shinobiFilename
|
|
},function(){
|
|
})
|
|
})
|
|
})
|
|
}
|
|
s.triggerEvent({
|
|
id: mid,
|
|
ke: ke,
|
|
details: {
|
|
confidence: 100,
|
|
name: filename,
|
|
plug: "dropInEvent",
|
|
reason: "ftpServer"
|
|
}
|
|
})
|
|
}
|
|
if(config.dropInEventDeleteFileAfterTrigger){
|
|
setTimeout(function(){
|
|
fs.unlink(filePath,function(err){
|
|
|
|
})
|
|
},1000 * 60 * 5)
|
|
}
|
|
}
|
|
var eventTrigger = function(eventType,filename,stats){
|
|
if(stats.isDirectory()){
|
|
fs.readdir(monitorEventDropDir + filename,function(err,files){
|
|
if(files){
|
|
files.forEach(function(filename){
|
|
processFile(filename)
|
|
})
|
|
}else if(err){
|
|
console.log(err)
|
|
}
|
|
})
|
|
}else{
|
|
processFile(filename)
|
|
}
|
|
}
|
|
var directoryWatch = fs.watch(monitorEventDropDir,function(eventType,filename){
|
|
fs.stat(monitorEventDropDir + filename,function(err,stats){
|
|
if(!err){
|
|
clearTimeout(fileQueue[filename])
|
|
fileQueue[filename] = setTimeout(function(){
|
|
eventTrigger(eventType,filename,stats)
|
|
},10000)
|
|
}
|
|
})
|
|
})
|
|
s.group[monitorConfig.ke].activeMonitors[monitorConfig.mid].dropInEventWatcher = directoryWatch
|
|
}
|
|
// FTP Server
|
|
if(config.ftpServer === true){
|
|
if(!config.ftpServerPort)config.ftpServerPort = 21
|
|
if(!config.ftpServerUrl)config.ftpServerUrl = `ftp://0.0.0.0:${config.ftpServerPort}`
|
|
config.ftpServerUrl = config.ftpServerUrl.replace('{{PORT}}',config.ftpServerPort)
|
|
const FtpSrv = require('ftp-srv')
|
|
const ftpServer = new FtpSrv({
|
|
// log: {
|
|
// warn: function(){},
|
|
// info: function(){},
|
|
// child: function(){},
|
|
// error: function(){},
|
|
// trace: function(){},
|
|
// },
|
|
url: config.ftpServerUrl,
|
|
// log:{trace:function(){},error:function(){},child:function(){},info:function(){},warn:function(){}
|
|
})
|
|
|
|
ftpServer.on('login', (data, resolve, reject) => {
|
|
var username = data.username
|
|
var password = data.password
|
|
s.basicOrApiAuthentication(username,password,function(err,user){
|
|
if(user){
|
|
resolve({root: s.dir.dropInEvents + user.ke})
|
|
}else{
|
|
// reject(new Error('Failed Authorization'))
|
|
}
|
|
})
|
|
})
|
|
ftpServer.on('client-error', ({connection, context, error}) => {
|
|
console.log('error')
|
|
})
|
|
ftpServer.listen().then(() => {
|
|
s.systemLog(`FTP Server running on port ${config.ftpServerPort}...`)
|
|
}).catch(function(err){
|
|
s.systemLog(err)
|
|
})
|
|
}
|
|
//add extensions
|
|
s.beforeMonitorsLoadedOnStartup(beforeMonitorsLoadedOnStartup)
|
|
s.onMonitorInit(onMonitorInit)
|
|
s.onMonitorStop(onMonitorStop)
|
|
}
|
|
// SMTP Server
|
|
// allow starting SMTP server without dropInEventServer
|
|
if(config.smtpServer === true){
|
|
var SMTPServer = require("smtp-server").SMTPServer;
|
|
if(!config.smtpServerPort && (config.smtpServerSsl && config.smtpServerSsl.enabled !== false || config.ssl)){config.smtpServerPort = 465}else if(!config.smtpServerPort){config.smtpServerPort = 25}
|
|
var smtpOptions = {
|
|
onAuth(auth, session, callback) {
|
|
var username = auth.username
|
|
var password = auth.password
|
|
s.basicOrApiAuthentication(username,password,function(err,user){
|
|
if(user){
|
|
callback(null, {user: user.ke})
|
|
}else{
|
|
callback(new Error(lang.failedLoginText2))
|
|
}
|
|
})
|
|
},
|
|
onRcptTo(address, session, callback) {
|
|
var split = address.address.split('@')
|
|
var monitorId = split[0]
|
|
var ke = session.user
|
|
if(s.group[ke].rawMonitorConfigurations[monitorId] && s.group[ke].activeMonitors[monitorId].isStarted === true){
|
|
s.triggerEvent({
|
|
id: monitorId,
|
|
ke: ke,
|
|
details: {
|
|
confidence: 100,
|
|
name: address.address,
|
|
plug: "dropInEvent",
|
|
reason: "smtpServer"
|
|
}
|
|
})
|
|
}else{
|
|
return callback(new Error(lang['No Monitor Exists with this ID.']))
|
|
}
|
|
callback()
|
|
}
|
|
}
|
|
if(config.smtpServerSsl && config.smtpServerSsl.enabled !== false || config.ssl && config.ssl.cert && config.ssl.key){
|
|
var key = config.ssl.key || fs.readFileSync(config.smtpServerSsl.key)
|
|
var cert = config.ssl.cert || fs.readFileSync(config.smtpServerSsl.cert)
|
|
smtpOptions = Object.assign(smtpOptions,{
|
|
secure: true,
|
|
key: config.ssl.key,
|
|
cert: config.ssl.cert
|
|
})
|
|
}
|
|
var server = new SMTPServer(smtpOptions)
|
|
server.listen(config.smtpServerPort,function(){
|
|
s.systemLog(`SMTP Server running on port ${config.smtpServerPort}...`)
|
|
})
|
|
}
|
|
}
|