557 lines
22 KiB
JavaScript
557 lines
22 KiB
JavaScript
var fs = require('fs');
|
|
module.exports = (s,config,lang) => {
|
|
const deleteSetOfVideos = function(options,callback){
|
|
const groupKey = options.groupKey
|
|
const err = options.err
|
|
const videos = options.videos
|
|
const storageIndex = options.storageIndex
|
|
const reRunCheck = options.reRunCheck
|
|
var completedCheck = 0
|
|
var whereGroup = []
|
|
var whereQuery = [
|
|
['ke','=',groupKey],
|
|
]
|
|
if(videos){
|
|
videos.forEach(function(video){
|
|
video.dir = s.getVideoDirectory(video) + s.formattedTime(video.time) + '.' + video.ext
|
|
const queryGroup = {
|
|
mid: video.mid,
|
|
time: video.time,
|
|
}
|
|
if(whereGroup.length > 0)queryGroup.__separator = 'or'
|
|
whereGroup.push(queryGroup)
|
|
fs.rm(video.dir,function(err){
|
|
++completedCheck
|
|
if(err){
|
|
fs.stat(video.dir,function(err){
|
|
if(!err){
|
|
fs.unlink(video.dir)
|
|
}
|
|
})
|
|
}
|
|
const whereGroupLength = whereGroup.length
|
|
if(whereGroupLength > 0 && whereGroupLength === completedCheck){
|
|
whereQuery[1] = whereGroup
|
|
s.knexQuery({
|
|
action: "delete",
|
|
table: "Videos",
|
|
where: whereQuery
|
|
},(err,info) => {
|
|
setTimeout(reRunCheck,1000)
|
|
})
|
|
}
|
|
})
|
|
if(storageIndex){
|
|
s.setDiskUsedForGroupAddStorage(groupKey,{
|
|
size: -(video.size/1048576),
|
|
storageIndex: storageIndex
|
|
})
|
|
}else{
|
|
s.setDiskUsedForGroup(groupKey,-(video.size/1048576))
|
|
}
|
|
s.tx({
|
|
f: 'video_delete',
|
|
ff: 'over_max',
|
|
filename: s.formattedTime(video.time)+'.'+video.ext,
|
|
mid: video.mid,
|
|
ke: video.ke,
|
|
time: video.time,
|
|
end: s.formattedTime(new Date,'YYYY-MM-DD HH:mm:ss')
|
|
},'GRP_'+groupKey)
|
|
})
|
|
}else{
|
|
console.log(err)
|
|
}
|
|
if(whereGroup.length === 0){
|
|
if(callback)callback()
|
|
}
|
|
}
|
|
const deleteSetOfTimelapseFrames = function(options,callback){
|
|
const groupKey = options.groupKey
|
|
const err = options.err
|
|
const frames = options.frames
|
|
const storageIndex = options.storageIndex
|
|
var whereGroup = []
|
|
var whereQuery = [
|
|
['ke','=',groupKey],
|
|
[]
|
|
]
|
|
var completedCheck = 0
|
|
if(frames){
|
|
frames.forEach(function(frame){
|
|
const details = s.parseJSON(frame.details)
|
|
var selectedDate = frame.filename.split('T')[0]
|
|
var dir = s.getTimelapseFrameDirectory(frame)
|
|
var timeFolder = s.formattedTime(new Date(frame.time),'YYYY-MM-DD')
|
|
var fileLocationMid = `${dir}${timeFolder}/` + frame.filename
|
|
const queryGroup = {
|
|
mid: frame.mid,
|
|
time: frame.time,
|
|
}
|
|
if(whereGroup.length > 0)queryGroup.__separator = 'or'
|
|
whereGroup.push(queryGroup)
|
|
fs.rm(fileLocationMid,function(err){
|
|
++completedCheck
|
|
const whereGroupLength = whereGroup.length
|
|
if(whereGroupLength > 0 && whereGroupLength === completedCheck){
|
|
whereQuery[1] = whereGroup
|
|
s.knexQuery({
|
|
action: "delete",
|
|
table: "Timelapse Frames",
|
|
where: whereQuery
|
|
},() => {
|
|
deleteTimelapseFrames(groupKey,callback)
|
|
})
|
|
}
|
|
})
|
|
if(storageIndex){
|
|
s.setDiskUsedForGroupAddStorage(groupKey,{
|
|
size: -(frame.size/1048576),
|
|
storageIndex: storageIndex
|
|
},'timelapseFrames')
|
|
}else{
|
|
s.setDiskUsedForGroup(groupKey,-(frame.size/1048576),'timelapseFrames')
|
|
}
|
|
// s.tx({
|
|
// f: 'timelapse_frame_delete',
|
|
// ff: 'over_max',
|
|
// filename: s.formattedTime(video.time)+'.'+video.ext,
|
|
// mid: video.mid,
|
|
// ke: video.ke,
|
|
// time: video.time,
|
|
// end: s.formattedTime(new Date,'YYYY-MM-DD HH:mm:ss')
|
|
// },'GRP_'+groupKey)
|
|
})
|
|
}else{
|
|
console.log(err)
|
|
}
|
|
if(whereGroup.length === 0){
|
|
if(callback)callback()
|
|
}
|
|
}
|
|
const deleteSetOfFileBinFiles = function(options,callback){
|
|
const groupKey = options.groupKey
|
|
const err = options.err
|
|
const files = options.files
|
|
var whereGroup = []
|
|
var whereQuery = [
|
|
['ke','=',groupKey],
|
|
[]
|
|
]
|
|
var completedCheck = 0
|
|
if(files){
|
|
files.forEach(function(file){
|
|
var dir = s.getFileBinDirectory(file)
|
|
s.debugLog(`deleting FileBin File`,`${file}`,dir)
|
|
var fileLocationMid = `${dir}` + file.name
|
|
const queryGroup = {
|
|
mid: file.mid,
|
|
name: file.name,
|
|
}
|
|
if(whereGroup.length > 0)queryGroup.__separator = 'or'
|
|
whereGroup.push(queryGroup)
|
|
fs.rm(fileLocationMid,function(err){
|
|
++completedCheck
|
|
if(err){
|
|
fs.stat(fileLocationMid,function(err){
|
|
if(!err){
|
|
fs.unlink(fileLocationMid)
|
|
}
|
|
})
|
|
}
|
|
const whereGroupLength = whereGroup.length
|
|
if(whereGroupLength > 0 && whereGroupLength === completedCheck){
|
|
whereQuery[1] = whereGroup
|
|
s.knexQuery({
|
|
action: "delete",
|
|
table: "Files",
|
|
where: whereQuery
|
|
},() => {
|
|
deleteFileBinFiles(groupKey,callback)
|
|
})
|
|
}
|
|
})
|
|
s.setDiskUsedForGroup(groupKey,-(file.size/1048576),'fileBin')
|
|
})
|
|
}else{
|
|
console.log(err)
|
|
}
|
|
if(whereGroup.length === 0){
|
|
if(callback)callback()
|
|
}
|
|
}
|
|
const deleteAddStorageVideos = function(groupKey,callback){
|
|
reRunCheck = function(){
|
|
s.debugLog('deleteAddStorageVideos')
|
|
return deleteAddStorageVideos(groupKey,callback)
|
|
}
|
|
var currentStorageNumber = 0
|
|
function readStorageArray(){
|
|
const theGroup = s.group[groupKey]
|
|
setTimeout(function(){
|
|
reRunCheck = readStorageArray
|
|
var storage = s.listOfStorage[currentStorageNumber]
|
|
if(!storage){
|
|
//done all checks, move on to next user
|
|
callback()
|
|
return
|
|
}
|
|
var storageId = storage.value
|
|
if(storageId === '' || !theGroup.addStorageUse[storageId]){
|
|
++currentStorageNumber
|
|
readStorageArray()
|
|
return
|
|
}
|
|
var storageIndex = theGroup.addStorageUse[storageId]
|
|
//run purge command
|
|
const maxSize = (storageIndex.sizeLimit * (storageIndex.videoPercent / 100) * config.cron.deleteOverMaxOffset);
|
|
if(storageIndex.usedSpaceVideos > maxSize){
|
|
s.knexQuery({
|
|
action: "select",
|
|
columns: "*",
|
|
table: "Videos",
|
|
where: [
|
|
['ke','=',groupKey],
|
|
['status','!=','0'],
|
|
['archive','!=',`1`],
|
|
['details','LIKE',`%"dir":"${storage.value}"%`],
|
|
],
|
|
orderBy: ['time','asc'],
|
|
limit: 3
|
|
},(err,rows) => {
|
|
deleteSetOfVideos({
|
|
groupKey: groupKey,
|
|
err: err,
|
|
videos: rows,
|
|
storageIndex: storageIndex,
|
|
reRunCheck: () => {
|
|
return readStorageArray()
|
|
}
|
|
},callback)
|
|
})
|
|
}else{
|
|
++currentStorageNumber
|
|
readStorageArray()
|
|
}
|
|
})
|
|
}
|
|
readStorageArray()
|
|
}
|
|
const deleteAddStorageTimelapseFrames = function(groupKey,callback){
|
|
const theGroup = s.group[groupKey]
|
|
reRunCheck = function(){
|
|
s.debugLog('deleteAddStorageTimelapseFrames')
|
|
return deleteAddStorageTimelapseFrames(groupKey,callback)
|
|
}
|
|
var currentStorageNumber = 0
|
|
function readStorageArray(){
|
|
setTimeout(function(){
|
|
reRunCheck = readStorageArray
|
|
var storage = s.listOfStorage[currentStorageNumber]
|
|
if(!storage){
|
|
//done all checks, move on to next user
|
|
callback()
|
|
return
|
|
}
|
|
var storageId = storage.value
|
|
if(storageId === '' || !theGroup.addStorageUse[storageId]){
|
|
++currentStorageNumber
|
|
readStorageArray()
|
|
return
|
|
}
|
|
var storageIndex = theGroup.addStorageUse[storageId]
|
|
//run purge command
|
|
const maxSize = (storageIndex.sizeLimit * (storageIndex.timelapsePercent / 100) * config.cron.deleteOverMaxOffset);
|
|
if(storageIndex.usedSpaceTimelapseFrames > maxSize){
|
|
s.knexQuery({
|
|
action: "select",
|
|
columns: "*",
|
|
table: "Timelapse Frames",
|
|
where: [
|
|
['ke','=',groupKey],
|
|
['details','LIKE',`%"dir":"${storage.value}"%`],
|
|
],
|
|
orderBy: ['time','asc'],
|
|
limit: 3
|
|
},(err,frames) => {
|
|
deleteSetOfTimelapseFrames({
|
|
groupKey: groupKey,
|
|
err: err,
|
|
frames: frames,
|
|
storageIndex: storageIndex,
|
|
reRunCheck: () => {
|
|
return readStorageArray()
|
|
}
|
|
},callback)
|
|
})
|
|
}else{
|
|
++currentStorageNumber
|
|
readStorageArray()
|
|
}
|
|
})
|
|
}
|
|
readStorageArray()
|
|
}
|
|
const deleteMainVideos = function(groupKey,callback){
|
|
if(s.group[groupKey].usedSpaceVideos > (s.group[groupKey].sizeLimit * (s.group[groupKey].sizeLimitVideoPercent / 100) * config.cron.deleteOverMaxOffset)){
|
|
s.knexQuery({
|
|
action: "select",
|
|
columns: "*",
|
|
table: "Videos",
|
|
where: [
|
|
['ke','=',groupKey],
|
|
['status','!=','0'],
|
|
['archive','!=',`1`],
|
|
['details','NOT LIKE',`%"dir"%`],
|
|
],
|
|
orderBy: ['time','asc'],
|
|
limit: 3
|
|
},(err,rows) => {
|
|
deleteSetOfVideos({
|
|
groupKey: groupKey,
|
|
err: err,
|
|
videos: rows,
|
|
storageIndex: null,
|
|
reRunCheck: () => {
|
|
return deleteMainVideos(groupKey,callback)
|
|
}
|
|
},callback)
|
|
})
|
|
}else{
|
|
callback()
|
|
}
|
|
}
|
|
const deleteTimelapseFrames = function(groupKey,callback){
|
|
//run purge command
|
|
const maxSize = (s.group[groupKey].sizeLimit * (s.group[groupKey].sizeLimitTimelapseFramesPercent / 100) * config.cron.deleteOverMaxOffset);
|
|
const currentlyUsedSize = s.group[groupKey].usedSpaceTimelapseFrames
|
|
s.debugLog(`deleteTimelapseFrames`,`${currentlyUsedSize}/${maxSize}`)
|
|
if(currentlyUsedSize > maxSize){
|
|
s.knexQuery({
|
|
action: "select",
|
|
columns: "*",
|
|
table: "Timelapse Frames",
|
|
where: [
|
|
['ke','=',groupKey],
|
|
['details','NOT LIKE',`%"dir"%`],
|
|
],
|
|
orderBy: ['time','asc'],
|
|
limit: 3
|
|
},(err,frames) => {
|
|
deleteSetOfTimelapseFrames({
|
|
groupKey: groupKey,
|
|
err: err,
|
|
frames: frames,
|
|
storageIndex: null
|
|
},callback)
|
|
})
|
|
}else{
|
|
callback()
|
|
}
|
|
}
|
|
const deleteFileBinFiles = function(groupKey,callback){
|
|
if(config.deleteFileBinsOverMax === true){
|
|
const maxSize = (s.group[groupKey].sizeLimit * (s.group[groupKey].sizeLimitFileBinPercent / 100) * config.cron.deleteOverMaxOffset);
|
|
const currentlyUsedSize = s.group[groupKey].usedSpaceFilebin
|
|
s.debugLog(`deleteFileBinFiles`,`${currentlyUsedSize}/${maxSize}`)
|
|
if(currentlyUsedSize > maxSize){
|
|
s.knexQuery({
|
|
action: "select",
|
|
columns: "*",
|
|
table: "Files",
|
|
where: [
|
|
['ke','=',groupKey],
|
|
['archive','!=',`1`],
|
|
],
|
|
orderBy: ['time','asc'],
|
|
limit: 1
|
|
},(err,files) => {
|
|
deleteSetOfFileBinFiles({
|
|
groupKey: groupKey,
|
|
err: err,
|
|
files: files,
|
|
},callback)
|
|
})
|
|
}else{
|
|
callback()
|
|
}
|
|
}else{
|
|
callback()
|
|
}
|
|
}
|
|
const deleteCloudVideos = function(groupKey,storageType,storagePoint,callback){
|
|
const whereGroup = []
|
|
const cloudDisk = s.group[groupKey].cloudDiskUse[storageType]
|
|
//run purge command
|
|
if(cloudDisk.sizeLimitCheck && cloudDisk.usedSpace > (cloudDisk.sizeLimit * config.cron.deleteOverMaxOffset)){
|
|
s.knexQuery({
|
|
action: "select",
|
|
columns: "*",
|
|
table: "Cloud Videos",
|
|
where: [
|
|
['status','!=','0'],
|
|
['ke','=',groupKey],
|
|
['details','LIKE',`%"type":"${storageType}"%`],
|
|
],
|
|
orderBy: ['time','asc'],
|
|
limit: 2
|
|
},function(err,videos) {
|
|
if(!videos)return console.log(err)
|
|
var whereQuery = [
|
|
['ke','=',groupKey],
|
|
]
|
|
var didOne = false
|
|
videos.forEach(function(video){
|
|
video.dir = s.getVideoDirectory(video) + s.formattedTime(video.time) + '.' + video.ext
|
|
const queryGroup = {
|
|
mid: video.mid,
|
|
time: video.time,
|
|
}
|
|
if(whereGroup.length > 0)queryGroup.__separator = 'or'
|
|
whereGroup.push(queryGroup)
|
|
s.setCloudDiskUsedForGroup(groupKey,{
|
|
amount : -(video.size/1048576),
|
|
storageType : storageType
|
|
})
|
|
s.deleteVideoFromCloudExtensionsRunner(groupKey,storageType,video)
|
|
})
|
|
const whereGroupLength = whereGroup.length
|
|
if(whereGroupLength > 0){
|
|
whereQuery[1] = whereGroup
|
|
s.knexQuery({
|
|
action: "delete",
|
|
table: "Cloud Videos",
|
|
where: whereQuery
|
|
},() => {
|
|
deleteCloudVideos(groupKey,storageType,storagePoint,callback)
|
|
})
|
|
}else{
|
|
callback()
|
|
}
|
|
})
|
|
}else{
|
|
callback()
|
|
}
|
|
}
|
|
const deleteCloudTimelapseFrames = function(groupKey,storageType,storagePoint,callback){
|
|
const whereGroup = []
|
|
var cloudDisk = s.group[groupKey].cloudDiskUse[storageType]
|
|
//run purge command
|
|
if(cloudDisk.usedSpaceTimelapseFrames > (cloudDisk.sizeLimit * (s.group[groupKey].sizeLimitTimelapseFramesPercent / 100) * config.cron.deleteOverMaxOffset)){
|
|
s.knexQuery({
|
|
action: "select",
|
|
columns: "*",
|
|
table: "Cloud Timelapse Frames",
|
|
where: [
|
|
['ke','=',groupKey],
|
|
],
|
|
orderBy: ['time','asc'],
|
|
limit: 3
|
|
},(err,frames) => {
|
|
if(!frames)return console.log(err)
|
|
var whereQuery = [
|
|
['ke','=',groupKey],
|
|
]
|
|
frames.forEach(function(frame){
|
|
frame.dir = s.getVideoDirectory(frame) + s.formattedTime(frame.time) + '.' + frame.ext
|
|
const queryGroup = {
|
|
mid: frame.mid,
|
|
time: frame.time,
|
|
}
|
|
if(whereGroup.length > 0)queryGroup.__separator = 'or'
|
|
whereGroup.push(queryGroup)
|
|
s.setCloudDiskUsedForGroup(groupKey,{
|
|
amount : -(frame.size/1048576),
|
|
storageType : storageType
|
|
})
|
|
// s.deleteVideoFromCloudExtensionsRunner(groupKey,storageType,frame)
|
|
})
|
|
const whereGroupLength = whereGroup.length
|
|
if(whereGroupLength > 0){
|
|
whereQuery[1] = whereGroup
|
|
s.knexQuery({
|
|
action: "delete",
|
|
table: "Cloud Timelapse Frames",
|
|
where: whereQuery
|
|
},() => {
|
|
deleteCloudTimelapseFrames(groupKey,storageType,storagePoint,callback)
|
|
})
|
|
}else{
|
|
callback()
|
|
}
|
|
})
|
|
}else{
|
|
callback()
|
|
}
|
|
}
|
|
function resetAllStorageCounters(groupKey){
|
|
var storageIndexes = Object.keys(s.group[groupKey].addStorageUse)
|
|
storageIndexes.forEach((storageIndex) => {
|
|
s.setDiskUsedForGroupAddStorage(groupKey,{
|
|
size: 0,
|
|
storageIndex: storageIndex
|
|
})
|
|
})
|
|
s.setDiskUsedForGroup(groupKey,0)
|
|
}
|
|
function createAdminUser(user){
|
|
return new Promise((resolve,reject) => {
|
|
const detailsColumn = Object.assign({
|
|
"factorAuth":"0",
|
|
"size": user.diskLimit || user.size || '',
|
|
"days":"",
|
|
"event_days":"",
|
|
"log_days":"",
|
|
"max_camera": user.cameraLimit || user.max_camera || '',
|
|
"permissions":"all",
|
|
"edit_size":"1",
|
|
"edit_days":"1",
|
|
"edit_event_days":"1",
|
|
"edit_log_days":"1",
|
|
"use_admin":"1",
|
|
"use_aws_s3":"1",
|
|
"use_whcs":"1",
|
|
"use_sftp":"1",
|
|
"use_webdav":"1",
|
|
"use_discordbot":"1",
|
|
"use_ldap":"1",
|
|
"aws_use_global":"0",
|
|
"b2_use_global":"0",
|
|
"webdav_use_global":"0"
|
|
},s.parseJSON(user.details) || {});
|
|
const insertQuery = {
|
|
ke: user.ke || s.gid(7),
|
|
uid: user.uid || s.gid(6),
|
|
mail: user.mail,
|
|
pass: s.createHash(user.initialPassword || user.pass || s.gid()),
|
|
details: JSON.stringify(detailsColumn)
|
|
}
|
|
s.knexQuery({
|
|
action: "insert",
|
|
table: "Users",
|
|
insert: insertQuery
|
|
},function(err,users) {
|
|
resolve({
|
|
ok: !err,
|
|
inserted: !err ? insertQuery : undefined,
|
|
err: err
|
|
})
|
|
})
|
|
})
|
|
}
|
|
return {
|
|
deleteSetOfVideos: deleteSetOfVideos,
|
|
deleteSetOfTimelapseFrames: deleteSetOfTimelapseFrames,
|
|
deleteSetOfFileBinFiles: deleteSetOfFileBinFiles,
|
|
deleteAddStorageVideos: deleteAddStorageVideos,
|
|
deleteMainVideos: deleteMainVideos,
|
|
deleteTimelapseFrames: deleteTimelapseFrames,
|
|
deleteAddStorageTimelapseFrames,
|
|
deleteFileBinFiles: deleteFileBinFiles,
|
|
deleteCloudVideos: deleteCloudVideos,
|
|
deleteCloudTimelapseFrames: deleteCloudTimelapseFrames,
|
|
resetAllStorageCounters: resetAllStorageCounters,
|
|
createAdminUser: createAdminUser,
|
|
}
|
|
}
|