ff-attic/xnode
3
Fork 0
Code Activity

Added project

Browse source
This commit is contained in:
Willem Cazander 2022-11-13 01:46:38 +01:00
parent fe9aa14dfd
commit 2d73cc8845
186 changed files with 21174 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

75
lib-build/debug-server/node_lib/model/xnode-base-command.js Normal file
View file

@ -0,0 +1,75 @@
var logger = require('winston').loggers.get('main');
var mongoose = require('mongoose');
var tmongoose = require('../lib/node-ff-tcrud').build.backend.mongoose;
var modelName = __filename.split('/').pop().split('.')[0];
var modelBackend = modelName.split('-').join('_');
var modelMeta = {
net_id: {
type: String,
index: { unique: false },
tfield: {
tvalidate: { io: 'string' },
},
},
command: {
type: String,
tfield: {
tvalidate: { io: 'string' },
},
},
insert_ip: {
type: String,
tfield: {
tvalidate: { io: 'string' },
},
},
insert_date: {
type: Date,
default: Date.now,
tfield: {
tlist: { tenable: false },
},
},
send_date: {
type: Date
},
done_date: {
type: Date
}
};
var modelSchema = new mongoose.Schema(modelMeta);
modelSchema.statics = tmongoose.buildStaticsModelValidated(modelMeta,modelSchema, {
findByNetIdLimit10: function (net_id, callback) {
logger.debug(modelBackend+'.findByNetId net_id='+net_id);
this.find({net_id:net_id}).sort('-insert_date').limit(10).exec(callback);
},
findOpenByNetId: function (net_id, callback) {
logger.debug(modelBackend+'.findOpenByNetId net_id='+net_id);
this.find({net_id:net_id}).where('send_date',null).sort('insert_date').limit(1).exec(callback);
},
findOpenCommandLimit5: function (callback) {
logger.debug(modelBackend+'.findOpenCommands');
var dateLastHour = new Date(new Date().getTime() - 30*60*1000); // soft limit on long open errors.
this.find({insert_date: { $gt: dateLastHour}}).where('send_date',null).sort('insert_date').limit(5).exec(callback);
},
findSendCommandLimit5: function (callback) {
logger.debug(modelBackend+'.findSendCommands');
var dateLastHour = new Date(new Date().getTime() - 60*60*1000);
this.find({send_date: { $gt: dateLastHour}}).sort('-insert_date').limit(5).exec(callback);
},
insert: function (net_id,command,insert_ip, next) {
var xcmd = new this();
xcmd.net_id = net_id;
xcmd.command = command;
xcmd.insert_ip = insert_ip;
xcmd.save(function(err,xcmd) {
if (err) { return next(err); }
logger.debug(modelBackend+'.insert _id='+xcmd._id+' net_id='+xcmd.net_id);
});
}
});
module.exports = mongoose.model(modelName, modelSchema, modelBackend);

98
lib-build/debug-server/node_lib/model/xnode-base.js Normal file
View file

@ -0,0 +1,98 @@
var logger = require('winston').loggers.get('main');
var mongoose = require('mongoose');
var tmongoose = require('../lib/node-ff-tcrud').build.backend.mongoose;
var modelName = __filename.split('/').pop().split('.')[0];
var modelBackend = modelName.split('-').join('_');
var modelMeta = {
net_id: {
type: String,
index: { unique: true },
tfield: {
tvalidate: { io: 'string' },
},
},
net_key: {
type: String,
tfield: {
tvalidate: { io: 'string' },
tlist: { tenable: false },
},
},
net_mac: {
type: String,
tcrud: {
tname: 'Net MAC',
tlist: { tenable: false },
}
},
rf_key: {
type: String,
tfield: {
tname: 'RF Key',
tlist: { tenable: false },
}
},
init_index: {
type: Number,
tfield: {
tlist: { tenable: false },
}
},
ping_counter: {
type: Number,
default: 0,
tfield: {
tname: 'Ping #'
}
},
ping_last_date: {
type: Date,
index: { unique: true, sparse: true }
},
ping_rtt: {
type: Number,
default: 0,
tfield: {
tname: 'Ping RTT'
}
},
changed_date: {
type: Date,
default: Date.now,
tfield: {
tlist: { tenable: false },
}
},
created_date: {
type: Date,
default: Date.now,
tfield: {
tlist: { tenable: false },
}
},
created_ip: {
type: String,
tfield: {
tvalidate: { io: 'string' },
},
}
};
var modelSchema = new mongoose.Schema(modelMeta);
modelSchema.statics = tmongoose.buildStaticsModelValidated(modelMeta,modelSchema, {
findOneByNetId: function (net_id, callback) {
logger.debug(modelBackend+'.findByNetId net_id='+net_id);
this.findOne({net_id:net_id}).exec(callback);
},
findLastPingLimit5: function (callback) {
var dateLastHour = new Date(new Date().getTime() - 60*60*1000);
logger.debug(modelBackend+'.findLastPinged lastDate: '+dateLastHour);
this.find({}).where('ping_last_date').gt(dateLastHour).sort('-ping_last_date').limit(5).exec(callback);
}
});
module.exports = mongoose.model(modelName, modelSchema, modelBackend);

59
lib-build/debug-server/node_lib/model/xnode-data-value.js Normal file
View file

@ -0,0 +1,59 @@
var logger = require('winston').loggers.get('main');
var mongoose = require('mongoose');
var tmongoose = require('../lib/node-ff-tcrud').build.backend.mongoose;
var modelName = __filename.split('/').pop().split('.')[0];
var modelBackend = modelName.split('-').join('_');
var modelMeta = {
/*
uuid: {
type: String,
index: { unique: true },
tfield: {
tvalidate: { io: 'string' },
},
},
*/
node_id: {
type: Number,
index: { unique: false },
tfield: {
tvalidate: { io: 'number' },
},
},
insert_date: {
type: Date,
index: { unique: false },
default: Date.now,
},
name: {
type: String,
index: { unique: false },
tfield: {
tvalidate: { io: 'string' },
},
},
value: {
type: String,
}
};
var modelSchema = new mongoose.Schema(modelMeta);
modelSchema.statics = tmongoose.buildStaticsModelValidated(modelMeta,modelSchema, {
findLastAddedLimit5: function (callback) {
logger.debug(modelBackend+'.findLastAddedLimit5');
this.find({}).sort('-insert_date').limit(5).exec(callback);
},
findByNetIdAndNodeId: function (net_id,node_id, callback) {
logger.debug(modelBackend+'.findByNetIdAndNodeId net_id='+net_id+' node_id='+node_id);
this
.aggregate({ $match: { net_id:net_id ,node_id:node_id }})
.group({ _id: "$name", value: { $min : "$value" } })
.sort("_id")
.exec(callback);
//this.find({net_id:net_id,node_id:node_id}).sort('insert_date').exec(callback);
}
});
module.exports = mongoose.model(modelName, modelSchema, modelBackend);

53
lib-build/debug-server/node_lib/model/xnode-data.js Normal file
View file

@ -0,0 +1,53 @@
var logger = require('winston').loggers.get('main');
var mongoose = require('mongoose');
var tmongoose = require('../lib/node-ff-tcrud').build.backend.mongoose;
var modelName = __filename.split('/').pop().split('.')[0];
var modelBackend = modelName.split('-').join('_');
var modelMeta = {
//node : {type : Schema.ObjectId, ref : 'XNode'}
node_id: {
type: Number,
index: { unique: false },
tfield: {
tvalidate: { io: 'number' },
},
},
data_raw: {
type: String,
tfield: {
ttype: 'textarea',
tvalidate: { io: 'string' },
tlist: { tenable: false },
}
},
data_text: {
type: String,
tfield: {
tvalidate: { io: 'number' },
ttype: 'textarea',
}
},
remote_ip: {
type: String,
tfield: {
tname: 'Remote IP',
tvalidate: { io: 'ip_address' },
tlist: { tenable: false },
}
},
insert_date: {
type: Date, default: Date.now,
}
};
var modelSchema = new mongoose.Schema(modelMeta);
modelSchema.statics = tmongoose.buildStaticsModelValidated(modelMeta,modelSchema, {
findLastLimit5: function (callback) {
logger.debug(modelBackend+'.findLastLimit5');
this.find({}).sort('-insert_date').limit(5).exec(callback);
}
});
module.exports = mongoose.model(modelName, modelSchema, modelBackend);

98
lib-build/debug-server/node_lib/model/xnode.js Normal file
View file

@ -0,0 +1,98 @@
var logger = require('winston').loggers.get('main');
var mongoose = require('mongoose');
var tmongoose = require('../lib/node-ff-tcrud').build.backend.mongoose;
var modelName = __filename.split('/').pop().split('.')[0];
var modelBackend = modelName.split('-').join('_');
var modelMeta = {
net_id: {
type: String,
index: { unique: false },
tfield: {
tvalidate: { io: 'string' },
},
},
node_id: {
type: Number,
index: { unique: false },
tfield: {
tvalidate: { io: 'number' },
},
},
insert_date: {
type: Date,
index: { unique: false },
default: Date.now,
tfield: {
tlist: { tenable: false },
}
},
info_date: {
type: Date,
tfield: {
tlist: { tenable: false },
}
},
name: {
type: String,
},
description: {
type: String,
tfield: {
tlist: { tenable: false },
}
},
gps_latitude: {
type: Number,
tfield: {
tname: 'Latitude',
tlist: { tenable: false },
}
},
gps_longitude: {
type: Number,
tfield: {
tname: 'Longitude',
tlist: { tenable: false },
}
},
rx_bytes: {
type: Number,
default: 0,
tfield: {
tname: 'RX bytes'
}
},
rx_requests: {
type: Number,
default: 0,
tfield: {
tname: 'RX req#'
}
},
rx_date: {
type: Date,
index: { unique: false },
default: Date.now,
tfield: {
tname: 'RX Date'
}
}
};
var modelSchema = new mongoose.Schema(modelMeta);
modelSchema.statics = tmongoose.buildStaticsModelValidated(modelMeta,modelSchema, {
findByNetId: function (net_id, callback) {
logger.debug(modelBackend+'.findByNetId net_id='+net_id+"");
this.find({net_id:net_id}).sort('insert_date').exec(callback);
},
findByNetIdAndNodeId: function (net_id,node_id, callback) {
logger.debug(modelBackend+'.findByNetIdAndNodeId net_id='+net_id+' node_id='+node_id);
this.findOne({net_id:net_id,node_id:node_id}).sort('insert_date').exec(callback);
}
});
module.exports = mongoose.model(modelName, modelSchema, modelBackend);

35
lib-build/debug-server/node_lib/model/xsystem-session.js Normal file
View file

@ -0,0 +1,35 @@
var logger = require('winston').loggers.get('main');
var mongoose = require('mongoose');
var tmongoose = require('../lib/node-ff-tcrud').build.backend.mongoose;
var modelName = __filename.split('/').pop().split('.')[0];
var modelBackend = modelName.split('-').join('_');
var modelMeta = {
_id: {
type: String,
tfield: {
tname: 'SID',
ttype: 'textarea'
}
},
session: {
type: String,
tfield: {
ttype: 'textarea'
}
},
expires: {
type: Date,
},
};
var modelSchema = new mongoose.Schema(modelMeta);
modelSchema.statics = tmongoose.buildStaticsModelValidated(modelMeta,modelSchema, {
findLastChangedLimit5: function (callback) {
logger.debug(modelBackend+'.findLastChangedLimit5');
this.find({}).sort('-changed_date').limit(5).exec(callback);
},
});
module.exports = mongoose.model(modelName, modelSchema, modelBackend);

146
lib-build/debug-server/node_lib/model/xsystem-state.js Normal file
View file

@ -0,0 +1,146 @@
var logger = require('winston').loggers.get('main');
var mongoose = require('mongoose');
var tmongoose = require('../lib/node-ff-tcrud').build.backend.mongoose;
var modelName = __filename.split('/').pop().split('.')[0];
var modelBackend = modelName.split('-').join('_');
var modelMeta = {
name: {
type: String,
trim: true,
index: { unique: true },
tfield: {
tvalidate: { io: 'string' },
},
},
type: {
type: String,
trim: true,
index: { unique: false },
tfield: {
tvalidate: { io: 'string' },
},
},
value: {
type: String,
trim: true,
tfield: {
xtype: 'textarea',
tvalidate: { io: 'string' },
},
},
description: {
type: String,
trim: true,
tfield: {
ttype: 'textarea',
tvalidate: { io: 'string' },
},
},
changed_date: {
type: Date,
default: Date.now,
tfield: {
tlist: { tenable: false },
},
},
created_date: {
type: Date,
default: Date.now,
tfield: {
tlist: { tenable: false },
},
}
};
var modelSchema = new mongoose.Schema(modelMeta);
modelSchema.statics = tmongoose.buildStaticsModelValidated(modelMeta,modelSchema, {
findLastChangedLimit5: function (callback) {
logger.debug(modelBackend+'.findLastChangedLimit5');
this.find({}).sort('-changed_date').limit(5).exec(callback);
},
findOneByName: function (name, callback) {
logger.debug(modelBackend+'.findByName name='+name);
this.findOne({name:name}).exec(callback);
},
ensureExcists: function (name, type, defaultValue, description, callback) {
this.findOneByName(name, function(err, xprop) {
if (err) {
callback(err);
return;
}
if (xprop == null) {
logger.debug(modelBackend+'.getByName create name='+name+' defaultValue='+defaultValue);
var model = mongoose.model(modelName);
xprop = new model();
xprop.name = name;
xprop.type = type;
xprop.value = defaultValue;
xprop.description = description;
xprop.save(function(err,xprop) {
if (callback) {
callback(err, xprop);
}
});
} else {
logger.debug(modelBackend+'.getByName fetched name='+name);
if (callback) {
callback(null, xprop);
}
}
});
},
setByName: function (name, value, callback) {
this.findOneByName(name, function(err, xprop) {
if (err) { throw err }
logger.debug(modelBackend+'.setByName name='+name+' valueNew='+value+' valueOld='+xprop.value);
xprop.value = value;
xprop.save(function(err) {
callback(err, xprop);
});
});
},
incByName: function (name, callback) {
this.findOneByName(name, function(err, xprop) {
if (err) { throw err }
xprop.value++;
logger.debug(modelBackend+'.incByName name='+name+' value='+xprop.value);
xprop.save(function(err) {
callback(err, xprop);
});
});
},
incHexByName: function (name, callback) {
this.findOneByName(name, function(err, xprop) {
// DIY inc per 8 chars as JS goes to ~14chars before zering the rest.
var v = xprop.value;
var r = '';
var inc = true;
for (var i=0;i<v.length/8;i++) {
var sv = v.substring(v.length-(i*8)-8,v.length-(i*8));
var svNum = parseInt(sv, 16);
if (inc) {
svNum++;
inc = false;
}
if (svNum == (1+0xFFFFFFFF)) {
svNum = 0;
inc = true;
}
sv = svNum.toString(16).toUpperCase();
while (i<((v.length/8)-1) && sv.length < 8) {
sv = '0' + sv;
}
r = sv + r;
}
xprop.value = r; ///(parseInt(xprop.value, 16)+1).toString(16).toUpperCase();
logger.debug(modelBackend+'.incHexByName name='+name+' value='+xprop.value);
xprop.save(function(err) {
callback(err, xprop);
});
});
}
});
module.exports = mongoose.model(modelName, modelSchema, modelBackend);

46
lib-build/debug-server/node_lib/model/xsystem-user.js Normal file
View file

@ -0,0 +1,46 @@
var logger = require('winston').loggers.get('main');
var mongoose = require('mongoose');
var tmongoose = require('../lib/node-ff-tcrud').build.backend.mongoose;
var modelName = __filename.split('/').pop().split('.')[0];
var modelBackend = modelName.split('-').join('_');
var modelMeta = {
username: {
type: String,
trim: true,
index: { unique: true },
tfield: {
tvalidate: { io: 'string' },
},
},
password: {
type: String
},
active: {
type: Boolean,
default: true
},
changed_date: {
type: Date,
default: Date.now
},
created_date: {
type: Date,
default: Date.now
}
};
var modelSchema = new mongoose.Schema(modelMeta);
modelSchema.statics = tmongoose.buildStaticsModelValidated(modelMeta,modelSchema, {
findLastChangedLimit5: function (callback) {
logger.debug(modelBackend+'.findLastChangedLimit5');
this.find({}).sort('-changed_date').limit(5).exec(callback);
},
findOneByUsername: function (username, callback) {
logger.debug(modelBackend+'.findByName username='+username);
this.findOne({username:username}).exec(callback);
}
});
module.exports = mongoose.model(modelName, modelSchema, modelBackend);