app.get('/ssh/host/:host?', function (req, res, next) {
res.sendFile(path.join(path.join(__dirname, 'public', (config.useminified)
? 'client-min.htm' : 'client-full.htm')))
// capture, assign, and validated variables
req.session.ssh = {
host: (validator.isIP(req.params.host + '') && req.params.host) ||
(validator.isFQDN(req.params.host) && req.params.host) ||
(/^(([a-z]|[A-Z]|[0-9]|[!^(){}\-_~])+)?\w$/.test(req.params.host) &&
req.params.host) || config.ssh.host,
port: (validator.isInt(req.query.port + '', {min: 1, max: 65535}) &&
req.query.port) || config.ssh.port,
header: {
name: req.query.header || config.header.text,
background: req.query.headerBackground || config.header.background
},
algorithms: config.algorithms,
term: (/^(([a-z]|[A-Z]|[0-9]|[!^(){}\-_~])+)?\w$/.test(req.query.sshterm) &&
req.query.sshterm) || config.ssh.term,
allowreplay: validator.isBoolean(req.headers.allowreplay + '') || false,
serverlog: {
client: config.serverlog.client || false,
server: config.serverlog.server || false
},
readyTimeout: (validator.isInt(req.query.readyTimeout + '', {min: 1, max: 300000}) &&
req.query.readyTimeout) || config.ssh.readyTimeout
}
req.session.ssh.header.name && validator.escape(req.session.ssh.header.name)
req.session.ssh.header.background &&
validator.escape(req.session.ssh.header.background)
})
minMaxChecker(value, rules) {
if (validator.isInt(value)) {
return validator.isInt(value, rules)
} else if (validator.isFloat(value)) {
return validator.isFloat(value, rules)
}
}
//Length of charachters
* between(field, value, args, message){
if(!Array.isArray(args) && args.length !== 2){
this.validator.addError(field, 'rule', 'between', 'The number of arguements in the field are invalid');
return false;
}else{
if(!v.isInt(args[0]) || !v.isInt(args[1])){
this.validator.addError(field, 'rule', 'between', 'The rule arguements for the field need to be integers');
return false;
}else if( parseInt(args[0]) >= parseInt(args[1]) ){
this.validator.addError(field, 'rule', 'between', 'The rule arguement for the min value cannot be greater than or equal to the max value');
return false;
}else if(value.toString().length < parseInt(args[0]) || value.toString().length > parseInt(args[1])){
if(message){
if(message){
message = message.replace(':minLength', args[0]).replace(':maxLength', args[1]);
}
}
this.validator.addError(field, 'rule', 'between', 'The size of the field is not within the specified range');
return false;
}
}
return true;
}
router.post('/find/:model/:number/:page/:order/:sort', passport.authenticate('jwt', {session: false}), routeRequirements, function(request, response) {
if (!validator.isInt(request.params.number, {gt: 0}) || !validator.isInt(request.params.page, {gt: 0}) || !validator.isAscii(request.params.model) || !validator.isAscii(request.params.sort) || !validator.isAscii(request.params.order))
response.status(400).json({"Mensaje":"Petición errónea."});
else {
if (!checkPrivileges(request, request.params.model))
response.status(401).json({"Mensaje":"No tienes privilegios para realizar esa búsqueda"});
else {
var body = filter(request.body);
finderModel.find(request.params.model, body, request.params.number, request.params.page, request.params.order, request.params.sort, function(error, data) {
if (error) {
if (error.errno == '1054')
response.status(400).json({"Mensaje":"Búsqueda de claves incorrecta."});
else if (error.errno == '1052')
response.status(400).json({"Mensaje":"Claves ambiguas"});
else if (error)
response.status(400).json({"Mensaje":"Error al buscar los datos: " + error.message});
}
else if (data){
response.status(200).json(data);
}else{
data = [];
response.status(200).json(data);
}
});
}
}
});
socket.on('heartbeat', function (data) {
var p = socket["player"];
if (p != null) {
var cur = new Date();
p.lastHeartBeat = cur.getTime();
if (typeof data != "undefined" && data != null) {
if ("likenews" in data && "wormholes" in data) {
if (!validator.isInt(data.likenews) || !validator.isInt(data.wormholes)) {
log.info("Troll detected: " + p.steamName);
}
else {
p.likenewCount = parseInt(data.likenews);
p.wormholeCount = parseInt(data.wormholes);
}
}
if (data.gameid !== "undefined") {
if (validator.isInt(data.gameid)) {
if (data.gameid == 0) {
p.playerLeavedGame();
}
else {
p.playerMadeIntoGame(parseInt(data.gameid));
}
}
}
}
p.sendHello();
}
});
Validation.validateData = function(data) {
var errors = [];
if (!validator.isInt(data.type) || _.parseInt(data.type) <= 0) {
errors.push(Validation.INVALID_DATA_TYPE_ID + data.type);
}
if (data.date && !validator.isDate(data.date)) {
errors.push(Validation.INVALID_DATE + data.date);
}
if (data.tags && !_.isArray(data.tags)) {
errors.push(Validation.INVALID_TAG + data.tags);
}
if (!data.metadata || _.isEmpty(data.metadata)) {
errors.push(Validation.MISSING_METADATA);
}
if (!validator.isJSON(JSON.stringify(data.metadata)) || !_.isObject(data.metadata)) {
errors.push(Validation.INVALID_METADATA + data.metadata);
}
if (data.parentSubject && !validator.isInt(data.parentSubject)) {
errors.push(Validation.INVALID_PARENT_SUBJECT_ID + data.parentSubject);
}
if (data.parentSample && !validator.isInt(data.parentSample)) {
errors.push(Validation.INVALID_PARENT_SAMPLE_ID + data.parentSample);
}
if (data.parentData && !validator.isInt(data.parentData)) {
errors.push(Validation.INVALID_PARENT_DATA_ID + data.parentData);
}
return errors.length ? errors : null;
};
Validation.validateSample = function(sample) {
var errors = [];
if (!validator.isInt(sample.type) || _.parseInt(sample.type) <= 0) {
errors.push(Validation.INVALID_DATA_TYPE_ID + sample.type);
}
/* //Biobank Code is autogenerate if missing??
*
if (!sample.biobankCode) {
errors.push(Validation.MISSING_BIOBANK_CODE);
} */
if (!sample.metadata || _.isEmpty(sample.metadata)) {
errors.push(Validation.MISSING_METADATA);
}
if (!validator.isJSON(JSON.stringify(sample.metadata)) || !_.isObject(sample.metadata)) {
errors.push(Validation.INVALID_METADATA + sample.metadata);
}
if (!sample.biobank) {
errors.push(Validation.MISSING_BIOBANK_ID);
}
if (sample.biobank && !validator.isInt(sample.biobank)) {
errors.push(Validation.INVALID_BIOBANK_ID + sample.biobank);
}
if (sample.donor && !validator.isInt(sample.donor)) {
errors.push(Validation.INVALID_DONOR_ID + sample.donor);
}
if (sample.parentSample && !validator.isInt(sample.parentSample)) {
errors.push(Validation.INVALID_PARENT_SAMPLE_ID + sample.parentSample);
}
return errors.length ? errors : null;
};
exports.addTask = function(req, res)
{
var self = this;
var newTask = new Task(
{
device: req.body.device,
action: req.body.action,
param: req.body.param,
dateRule: req.body.dateRule,
recurrenceRule: req.body.recurrenceRule
});
newTask.recurrenceRule.second = 0;
// Validation
if(typeof newTask.device !== 'string') return res.status(500).send("Bad device Id, should be a string");
if(!validator.isInt(newTask.action)) return res.status(500).send("Bad action, should be a number");
if(newTask.param && !validator.isInt(newTask.param)) return res.status(500).send("Bad param, should be a number or null");
if(newTask.dateRule && !(newTask.dateRule instanceof Date)) res.status(500).send("Bad dateRule, should be a Date or null");
// Check this
//if(newTask.recurrenceRule && !(newTask.recurrenceRule instanceof schedule.RecurrenceRule)) res.status(500).send("Bad recurrenceRule, should be a RecurrenceRule or null");
newTask.save(function(err)
{
if(err) return res.status(500).send(err.message);
// reload tasks
taskManager.reload();
// Send all tasks
exports.findAllTasks(req, res);
});
};
function validateInput(data) {
var resp = '';
if (typeof data.plant !== 'undefined' && !validator.isInt(data.plant)) resp += 'Planta no válida, ';
if (typeof data.treatment !== 'undefined' && !validator.isInt(data.treatment)) resp += 'Tratamiento no válida, ';
if (typeof data.product !== 'undefined' && !validator.isInt(data.product)) resp += 'Producto no válida, ';
if (resp) resp = resp.slice(0, -2);
return resp;
}
router.get('/admin/treatments/:number/:page/:sort', passport.authenticate('jwt', {session: false}), routeRequirements, function (request, response) {
if (!validator.isInt(request.params.number, {gt: 0}) || !validator.isInt(request.params.page, {gt: 0}) || !isASCII(request.params.sort))
response.status(400).json({"Mensaje":"Petición incorrecta"});
else {
treatmentModel.getTreatments(request.params.number, request.params.page, request.params.sort, function(error, data){
response.status(200).json(data);
});
}
});
var connection = new sql.Connection(config, function(err) {
if (err) {
console.dir(err);
res.send(401, 'DB Connection Error.');
return;
}
var request = new sql.Request(connection);
var VISN = req.param("VISN");
var STA3N = req.param("STA3N");
var whereClause = '';
var where = ' WHERE';
var and = ' AND';
if (VISN && validator.isInt(VISN)) {
request.input('VISN', sql.Int, VISN);
whereClause += where + ' v.VISN = @VISN ';
}
if (STA3N && validator.isInt(STA3N)) {
request.input('STA3N', sql.Int, STA3N);
if (VISN) {
whereClause += and;
} else {
whereClause += where;
}
whereClause += ' s.sta3N = @STA3N ';
}
console.log("MilitaryBranchAPI whereClause: ", whereClause);
// Configure Database Query
var query = '';
query += 'SELECT DISTINCT me.BranchDesc, r.RiskLevelDesc as RiskLevel, COUNT(DISTINCT p.ReachID) as Total FROM dbo.Patient p';
query += ' INNER JOIN dbo.Ref_RiskLevel r ON p.RiskLevel = r.RiskLevelID'
query += ' INNER JOIN dbo.Ref_MilitaryBranch me ON p.MilitaryBranch = me.BranchID';
query += ' INNER JOIN PatientStation s ON s.ReachID = p.ReachID';
query += ' INNER JOIN Ref_VAMC v ON s.sta3N = v.STA3N';
query += whereClause;
query += ' GROUP BY me.BranchDesc, r.RiskLevelDesc, p.MilitaryBranch';
// Query the database
request.query(query, function(err, recordset) {
if (err) {
connection.close();
console.dir(err);
praudit.auditlog('SQL ERROR',err);
res.send(401, 'Query Failed.');
return;
}
connection.close();
var jsonRecordSet = JSON.parse(JSON.stringify(recordset));
res.send(jsonRecordSet);
});
});
var connection = new sql.Connection(config, function(err) {
if (err) {
data = "Error: Database connection failed!";
return;
}
var request = new sql.Request(connection);
/*Configure database query */
var outreachStatus = req.param("outreachStatus");
outreachStatus = outreachStatus? outreachStatus:0;
var vetReachID = req.param("vetReachID");
var facilityID = req.param("facilityID");
var userID = req.param("UserID");
var query = '';
if (userID && validator.isInt(userID)) {
request.input('userID', sql.Int, userID);
}
if (facilityID && validator.isInt(facilityID)) {
request.input('facilityID', sql.Int, facilityID);
}
if (outreachStatus && validator.isInt(outreachStatus)) {
request.input('outreachStatus', sql.Int, outreachStatus);
}
if (vetReachID && validator.isInt(vetReachID)) {
request.input('vetReachID', sql.Int, vetReachID);
var value = '';
if (outreachStatus == null || outreachStatus.length == 0 || outreachStatus == 0)
value = undefined;
else
value = outreachStatus;
request.input('value', sql.Int, value);
query += "exec dbo.sp_SaveOutreachStatus @User=@userId, @ReachID=@vetReachID, @Status=@value, @sta3n_input=@facilityID";
}
else {
res.send("ERROR: vetReach ID is required.");
}
/*Query database */
request.query(query, function(err, recordset) {
if (err) {
connection.close();
console.dir(err);
praudit.auditlog('SQL ERROR',err);
res.send(401, 'Query Failed');
return;
}
var action = 'Outreach Status Updated for ReachID: ' + vetReachID;
var message = 'Updated by User ' + req.headers.prsessionkey.split('::')[0];
praudit.auditlog(action,message,'info');
connection.close();
/*Send the data */
data = "Save Completed Successfully!";
res.send(data);
});
});
tg.for('/random :start :end', ($) => {
var start = $.query.start;
var end = $.query.end;
if(validator.isInt(end) && validator.isInt(start)) {
$.sendMessage(getRandom(parseInt(start), parseInt(end)));
}
else {
$.sendMessage("Please enter two valid integers!");
}
});
nodeWeixinUser.profile(app, process.env.APP_OPENID, function (error, data) {
assert.equal(true, !error);
assert.equal(true, validator.isInt(data.subscribe));
assert.equal(true, data.openid === process.env.APP_OPENID);
assert.equal(true, typeof data.nickname === 'string');
assert.equal(true, validator.isInt(data.sex));
assert.equal(true, typeof data.language === 'string');
assert.equal(true, typeof data.city === 'string');
assert.equal(true, typeof data.country === 'string');
if (data.headimgurl) {
assert.equal(true, validator.isURL(data.headimgurl));
}
done();
});
function loadImagePath(params, callback) {
var savePath = Image.getSavePath(params.hashedId);
if(params.width || params.height) {
if(!(validator.isInt(params.width) && validator.isInt(params.height))) {
return cb({status: 400, message: '숫자만 넣어주세요.'});
}
imageMagick(savePath).size(function(err, size) {
_generateThumbnail(savePath, size, params, callback);
});
} else {
callback(null, savePath);
}
}
router.delete('/admin/productTreatment/:plant/:treatment/:product', passport.authenticate('jwt', {session: false}), routeRequirements, function(request, response) {
if (!validator.isInt(request.params.plant, {gt: 0}) || !validator.isInt(request.params.treatment, {gt: 0}) || !validator.isInt(request.params.product, {gt: 0}))
response.status(400).json({"Mensaje":"Petición incorrecta"});
else {
productTreatmentModel.deleteProductTreatment(request.params.plant, request.params.treatment, request.params.product, function(error, data) {
if (data == 1)
response.status(200).json({"Mensaje":"Borrado"});
else if (data == 0)
response.status(404).json({"Mensaje":"No existe"});
else
response.status(500).json({"Mensaje":error.message});
});
}
});
router.get('/productTreatmentPlant/:treatment/:plant/:number/:page/:sort', passport.authenticate('jwt', {session: false}), routeRequirements, function(request, response) {
if (!validator.isInt(request.params.plant, {gt: 0}) || !validator.isInt(request.params.treatment, {gt: 0}) || !validator.isInt(request.params.number, {gt: 0}) || !validator.isInt(request.params.page, {gt: 0}) || !validator.isAscii(request.params.sort))
response.status(400).json({"Mensaje":"Petición incorrecta"});
else {
productTreatmentModel.getProductsByTreatmentAndPlant(request.params.number, request.params.page, request.params.sort, request.params.treatment, request.params.plant, function(error, data) {
if (error)
response.status(400).json(error.message);
else if (typeof data !== 'undefined')
response.status(200).json(data);
else
response.status(404).json({"Mensaje":"No existe"});
});
}
});
_.each(columns, function (columnKey) {
var message = '';
// check nullable
if (model.hasOwnProperty(columnKey) && schema[tableName][columnKey].hasOwnProperty('nullable')
&& schema[tableName][columnKey].nullable !== true) {
if (validator.isNull(model[columnKey]) || validator.empty(model[columnKey])) {
message = 'Value in [' + tableName + '.' + columnKey + '] cannot be blank.';
validationErrors.push(new errors.ValidationError(message, tableName + '.' + columnKey));
}
}
// TODO: check if mandatory values should be enforced
if (model[columnKey]) {
// check length
if (schema[tableName][columnKey].hasOwnProperty('maxlength')) {
if (!validator.isLength(model[columnKey], 0, schema[tableName][columnKey].maxlength)) {
message = 'Value in [' + tableName + '.' + columnKey + '] exceeds maximum length of '
+ schema[tableName][columnKey].maxlength + ' characters.';
validationErrors.push(new errors.ValidationError(message, tableName + '.' + columnKey));
}
}
//check validations objects
if (schema[tableName][columnKey].hasOwnProperty('validations')) {
validationErrors = validationErrors.concat(validate(model[columnKey], columnKey, schema[tableName][columnKey].validations));
}
//check type
if (schema[tableName][columnKey].hasOwnProperty('type')) {
if (schema[tableName][columnKey].type === 'integer' && !validator.isInt(model[columnKey])) {
message = 'Value in [' + tableName + '.' + columnKey + '] is no valid integer.';
validationErrors.push(new errors.ValidationError(message, tableName + '.' + columnKey));
}
}
}
});
Validation.validateSubject = function(subject) {
var errors = [];
if (!validator.isInt(subject.type) || _.parseInt(subject.type) <= 0) {
errors.push(Validation.INVALID_DATA_TYPE_ID + subject.type);
}
if (subject.tags && !_.isArray(subject.tags)) {
errors.push(Validation.INVALID_TAG + subject.tags);
}
// silently fix sex errors
if (!subject.sex || !validator.isIn(subject.sex, ['M', 'F', 'N.D.', 'UNKNOWN', 'UNDIFFERENTIATED'])) {
subject.sex = 'N.D.';
}
/*
if (subject.personalInfo && !validator.isInt(subject.personalInfo)) {
errors.push(Validation.INVALID_PERSONAL_INFO_ID + subject.personalInfo);
} */
/* // is Metadata required for Subjects??
*
if (!data.metadata || _.isEmpty(data.metadata)) {
errors.push(Validation.MISSING_METADATA);
} */
if (!validator.isJSON(JSON.stringify(subject.metadata)) || !_.isObject(subject.metadata)) {
errors.push(Validation.INVALID_METADATA + subject.metadata);
}
errors.forEach(function(error) {
console.log(error);
});
return errors.length ? errors : null;
};
exports.isCIDR = function (str, paramName) {
paramName = paramName || '';
var isValid = true;
if (str.indexOf('/') === -1) {
isValid = false;
} else {
var parts = str.split('/');
if (parts.length !== 2) {
isValid = false;
} else {
var ip = parts[0];
if (!validator.isIP(ip)) {
isValid = false;
} else {
var cidr = parts[1];
if (!validator.isInt(cidr)) {
isValid = false;
}
}
}
}
if (isValid === true) {
return str;
} else {
throw new Error(util.format('Given %s "%s" is not valid CIDR', paramName, str));
}
};
BIGINT.prototype.validate = function(value) {
if (!Validator.isInt(value)) {
throw new sequelizeErrors.ValidationError(util.format('%j is not a valid bigint', value));
}
return true;
};
_.each(columns, function each(columnKey) {
var message = '',
strVal = _.toString(model[columnKey]);
// check nullable
if (model.hasOwnProperty(columnKey) && schema[tableName][columnKey].hasOwnProperty('nullable')
&& schema[tableName][columnKey].nullable !== true) {
if (validator.empty(strVal)) {
message = i18n.t('notices.data.validation.index.valueCannotBeBlank', {tableName: tableName, columnKey: columnKey});
validationErrors.push(new errors.ValidationError({message: message, context: tableName + '.' + columnKey}));
}
}
// validate boolean columns
if (model.hasOwnProperty(columnKey) && schema[tableName][columnKey].hasOwnProperty('type')
&& schema[tableName][columnKey].type === 'bool') {
if (!(validator.isBoolean(strVal) || validator.empty(strVal))) {
message = i18n.t('notices.data.validation.index.valueMustBeBoolean', {tableName: tableName, columnKey: columnKey});
validationErrors.push(new errors.ValidationError({message: message, context: tableName + '.' + columnKey}));
}
}
// TODO: check if mandatory values should be enforced
if (model[columnKey] !== null && model[columnKey] !== undefined) {
// check length
if (schema[tableName][columnKey].hasOwnProperty('maxlength')) {
if (!validator.isLength(strVal, 0, schema[tableName][columnKey].maxlength)) {
message = i18n.t('notices.data.validation.index.valueExceedsMaxLength',
{
tableName: tableName,
columnKey: columnKey,
maxlength: schema[tableName][columnKey].maxlength
});
validationErrors.push(new errors.ValidationError({
message: message,
context: tableName + '.' + columnKey
}));
}
}
// check validations objects
if (schema[tableName][columnKey].hasOwnProperty('validations')) {
validationErrors = validationErrors.concat(validate(strVal, columnKey, schema[tableName][columnKey].validations, tableName));
}
// check type
if (schema[tableName][columnKey].hasOwnProperty('type')) {
if (schema[tableName][columnKey].type === 'integer' && !validator.isInt(strVal)) {
message = i18n.t('notices.data.validation.index.valueIsNotInteger', {
tableName: tableName,
columnKey: columnKey
});
validationErrors.push(new errors.ValidationError({
message: message,
context: tableName + '.' + columnKey
}));
}
}
}
});
FileReadStream.prototype.destroy = function () {
if (this._destroyed) {
return;
}
var self = this;
this.readable = false;
function close(fd) {
fs.close(fd || self._fd, function(err) {
if (err) {
self.emit('error', err);
}
else {
self.emit('close');
}
});
self._fd = null;
self._destroyed = true;
}
// when the stream is closed immediately after creating it
if (!validator.isInt(this._fd)) {
this.once('open', close);
return;
}
close();
};
function runValidation(key, args, value) {
// currently only supports:
// is, isURL, isEmail, len, notEmpty, notIn
switch (key) {
case 'is':
if (!validator.matches(value, args.value)) return args.key;
break;
case 'isURL':
if (!validator.isURL(value) && !validator.isNull(value)) return args.key;
break;
case 'isEmail':
if (!validator.isEmail(value) && !validator.isNull(value)) return args.key;
break;
case 'len': {
const [min, max] = args.value;
if (!validator.isLength(value, min, max)) return args.key;
break;
}
case 'notEmpty':
if (validator.isNull(value)) return args.key;
break;
case 'notIn':
if (validator.isIn(value, args.value)) return args.key;
if (typeof value === 'string' &&
validator.isIn(value.toLowerCase(), args.value)) return args.key;
break;
case 'isInt':
if (!validator.isInt(value) && !validator.isNull(value)) return args.key;
}
return null;
}
bigAmount: function(amount, currency) {
// 2.33 -> 233
if (!validator.isFloat(amount) && !validator.isInt(amount)) {
return false;
}
return Math.round(amount * 100);
},
router.put('/admin/treatment/:id', passport.authenticate('jwt', {session: false}), routeRequirements, function(request, response) {
if (!validator.isInt(request.params.id, {gt: 0}))
response.status(400).json({"Mensaje":"Petición incorrecta"});
else {
var treatmentData = {
name: request.body.name,
description: request.body.description,
};
treatmentData = filter(treatmentData);
if (typeof treatmentData.name == 'undefined')
response.status(400).json({"Mensaje":"Faltan parámetros necesarios"});
else {
var validate = validateInput(treatmentData);
if (validate.length > 0)
response.status(400).json({"Mensaje": validate});
else {
treatmentModel.updateTreatment(treatmentData, request.params.id, function(error, data) {
if (data == 1)
response.status(200).json({"Mensaje":"Actualizado"});
else if (data == 0)
response.status(404).json({"Mensaje":"No existe"});
else if (error) {
if (error.errno == '1406')
response.status(500).json({"Mensaje":"Texto demasiado largo"});
else
response.status(500).json({"Mensaje":error.message});
}
});
}
}
}
});
exports.updatePrevMaintenance = function(req, res) {
if(!req.session.email || !req.session.siteid) {
return res.json(401, {message: 'Please sign in.'});
}
var eventID = req.body.id;
var maintenanceType = req.body.type;
var maintenanceDate = req.body.date;
var maintenanceDetails = req.body.details;
var email = req.session.email;
var siteid = req.session.siteid;
var maintenanceID = req.body.maintenanceID;
if(!validator.isEmail(email)) {
return res.json(400, {message: 'Invalid email.'});
}
if(!validator.isUUID(siteid, 4)) {
return res.json(400, {message: 'Invalid site id.'});
}
if(validator.isNull(maintenanceDetails) || !validator.isMaintenanceStatus(maintenanceType)) {
return res.json(400, {message: 'Missing maintenance elements.'});
}
if(!validator.isInt(maintenanceDate)) {
return res.json(400, {message: 'Invalid maintenance date.'});
}
if(!validator.isUUID(maintenanceID, 4)) {
return res.json(400, {message: 'Invalid maintenance id.'});
}
if(!validator.isUUID(eventID, 4)) {
return res.json(400, {message: 'Invalid event id.'});
}
sites.get(siteid, function (error, reply) {
if(error) {
console.log(error);
return res.json(500, {message: 'Problem getting maintenance requests.'});
}
var updated = false;
for(var maintenanceCounter = 0; maintenanceCounter < reply.maintenance.length; maintenanceCounter++) {
if(reply.maintenance[maintenanceCounter].id === maintenanceID) {
for(var eventCounter = 0; eventCounter < reply.maintenance[maintenanceCounter].events.length; eventCounter++) {
if(reply.maintenance[maintenanceCounter].events[eventCounter].id === eventID) {
reply.maintenance[maintenanceCounter].events[eventCounter].type = maintenanceType;
reply.maintenance[maintenanceCounter].events[eventCounter].date = maintenanceDate;
reply.maintenance[maintenanceCounter].events[eventCounter].details = maintenanceDetails;
reply.maintenance[maintenanceCounter].events[eventCounter].update = Date.now(Date.UTC());
updated = true;
}
}
}
}
if(!updated) {
return res.json(400, {message: 'Maintenance event does not exist.'});
}
sites.insert(reply, siteid, function (error) {
if(error) {
console.log(error);
return res.json(500, {message: 'Problem updating maintenance event.'});
}
return res.json({message: 'Maintenance event updated.'});
});
});
};
app.post('/hiscores', function(req, res){
var name = req.body.name,
score = req.body.score;
if (!name || name == '' || !score || score == '') {
res.status(400).write('name or score not given');
return res.end();
}
// validate score
if (!validator.isInt(score)) {
res.status(400).write('invalid score');
return res.end();
}
// sanitize html
name = sanitizer.sanitize(name);
if (name == '') {
res.status(400).write('invalid name');
return res.end();
}
pool.query(
"INSERT INTO `hiscores` (`name`, `score`) VALUES (?, ?) ON DUPLICATE KEY UPDATE `score`= IF(score > ?, score, ?)",
[name, score, score, score],
function(err, result) {
if (err) {
res.status(500).write('database error: ' + err.code);
return res.end();
}
res.status(201).end();
}
);
});
exports.updatePrevIncident = function(req, res) {
if(!req.session.email || !req.session.siteid) {
return res.json(401, {message: 'Please sign in.'});
}
var eventID = req.body.id;
var incidentType = req.body.type;
var incidentDate = req.body.date;
var incidentMessage = req.body.message;
var email = req.session.email;
var incidentID = req.body.incidentID;
var siteid = req.session.siteid;
if(!validator.isEmail(email)) {
return res.json(400, {message: 'Invalid email.'});
}
if(!validator.isUUID(siteid, 4)) {
return res.json(400, {message: 'Invalid site id.'});
}
if(validator.isNull(incidentMessage) || !validator.isInicidentType(incidentType)) {
return res.json(400, {message: 'Missing incident elements.'});
}
if(!validator.isInt(incidentDate)) {
return res.json(400, {message: 'Invalid incident date.'});
}
if(!validator.isUUID(incidentID, 4)) {
return res.json(400, {message: 'Invalid incident id.'});
}
if(!validator.isUUID(eventID, 4)) {
return res.json(400, {message: 'Invalid event id.'});
}
sites.get(siteid, function (error, reply) {
if(error) {
console.log(error);
return res.json(500, {message: 'Problem getting incidents.'});
}
var updated = false;
for(var incidentCounter = 0; incidentCounter < reply.incidents.length; incidentCounter++) {
if(reply.incidents[incidentCounter].id === incidentID) {
for(var eventCounter = 0; eventCounter < reply.incidents[incidentCounter].events.length; eventCounter++) {
if(reply.incidents[incidentCounter].events[eventCounter].id === eventID) {
reply.incidents[incidentCounter].events[eventCounter].type = incidentType;
reply.incidents[incidentCounter].events[eventCounter].date = incidentDate;
reply.incidents[incidentCounter].events[eventCounter].message = incidentMessage;
reply.incidents[incidentCounter].events[eventCounter].update = Date.now(Date.UTC());
updated = true;
}
}
}
}
if(!updated) {
return res.json(400, {message: 'Incident event does not exist.'});
}
sites.insert(reply, siteid, function (error) {
if(error) {
console.log(error);
return res.json(500, {message: 'Problem updating incident event.'});
}
return res.json({message: 'Incident event updated.'});
});
});
};
isInt: function() {
try {
this.success = stringValidator.isInt(this.val + '', this.filter || undefined);
transformErr.call(this);
} catch (e) {
transformErr.call(this);
throw e;
}
return this;
function transformErr() {
transformErrMessage.call(this, function(context) {
var messageType;
if ( _.isPlainObject(this.filter)
&& (this.filter.min || this.filter.max)
) {
messageType = minMaxOrBoth({
both: 'between.number',
min: 'min.number',
max: 'max.number',
}, this.filter, context);
} else {
messageType = 'isInt';
}
return this.message(messageType, context);
});
}
},