constructor(queue, type, workerFn, opts) {
if (typeof type !== 'string') throw new Error('type must be a string');
if (typeof workerFn !== 'function') throw new Error('workerFn must be a function');
if (typeof opts !== 'object') throw new Error('opts must be an object');
if (typeof opts.interval !== 'number') throw new Error('opts.interval must be a number');
if (typeof opts.intervalErrorMultiplier !== 'number') throw new Error('opts.intervalErrorMultiplier must be a number');
super();
this.id = puid.generate();
this.kibanaId = opts.kibanaId;
this.kibanaName = opts.kibanaName;
this.queue = queue;
this._client = this.queue.client;
this.jobtype = type;
this.workerFn = workerFn;
this.checkSize = opts.size || 10;
this.debug = getLogger(opts, this.id, 'debug');
this.warn = getLogger(opts, this.id, 'warn');
this._running = true;
this.debug(`Created worker for ${this.jobtype} jobs`);
this._poller = new Poller({
functionToPoll: () => {
return this._processPendingJobs();
},
pollFrequencyInMillis: opts.interval,
trailing: true,
continuePollingOnError: true,
pollFrequencyErrorMultiplier: opts.intervalErrorMultiplier,
});
this._startJobPolling();
}
client.addListener('nick', function (oldnick, newnick, channels, raw) {
var debug = require('debug')('AUTH:NICK:');
var reqId = puid.generate();
var cmd = {};
cmd.oldnick = oldnick ? oldnick.toLowerCase() : false;
cmd.newnick = newnick ? newnick.toLowerCase() : false;
cmd.isAdmin = cmd.oldnick ? config.admins[cmd.oldnick] : false;
if (!cmd.oldnick || !cmd.newnick || !cmd.isAdmin) {
debug(reqId, 'DISCARDED', 'cmd=', cmd);
return;
}
debug(reqId, 'cmd=', cmd.oldnick);
deauthAdmin(reqId, config, cmd.oldnick);
config.admins[cmd.newnick] = true;
debug(reqId, 'ADMIN:RIGHTS:ADDED:' + cmd.newnick.toUpperCase());
});
client.addListener('notice', function (nick, to, message, raw) {
var debug = require('debug')('AUTH:NOTICE:');
var reqId = puid.generate();
var cmdline = utils.filterCommands(message);
var cmd = {};
cmd.mode = '+o';
cmd.cmdlineLength = cmdline.length;
cmd.nick = nick ? nick.toLowerCase() : false;
// early return
if (cmd.cmdlineLength > 4 || !cmd.nick) {
debug(reqId, 'DISCARDED', 'cmd=', cmd, 'cmdline=', cmdline);
return;
}
cmd.user = cmd.receiver = cmd.cmdlineLength && cmdline[0] ? cmdline[0].toLowerCase() : false;
cmd.isAdmin = config.admins.hasOwnProperty(cmd.nick) && config.admins[cmd.nick];
cmd.hasAdmin = config.admins.hasOwnProperty(cmd.user);
cmd.nickservAcc = 'ACC';
cmd.nickservStatus = 3;
cmd.nickserv = 'nickserv';
debug(reqId, 'cmdline=', cmdline, 'cmd=', cmd);
if (
cmd.hasAdmin &&
cmd.cmdlineLength === 3 || cmd.cmdlineLength === 4 &&
utils.isBotMessage(to, config) &&
cmd.nick === cmd.nickserv &&
cmd.nickservAcc === cmdline[1].toUpperCase() &&
cmd.nickservStatus === parseInt(cmdline[2], 10) &&
!cmd.isAdmin &&
cmd.user
) {
config.admins[cmd.user] = true;
config.irc.options.channels.forEach(function(channel){
if(cmd.user !== cmd.nick && !utils.isBotMessage(cmd.user, config)) {
client.send('MODE', channel, cmd.mode, cmd.user);
}
});
if (config.plugins && config.plugins.auth && config.plugins.auth.notify) {
debug(reqId, 'SEND:NOTIFY:TRUE', cmd.user);
sendMessage(reqId, client, cmd.user, 'AUTH: changed role to admin');
} else {
debug(reqId, 'SEND:NOTIFY:FALSE', cmd.user);
}
}
});
insert: function(collection, item){
if(!(collection in db))
db[collection] = [];
item._id = puid.generate();
db[collection].push(item);
return item;
},
client.addListener('quit', function (nick, reason, channels, raw) {
var debug = require('debug')('AUTH:QUIT:');
var reqId = puid.generate();
debug(reqId, 'nick=', nick);
deauthAdmin(reqId, config, nick);
});
client.addListener('join', function (channel, nick, raw) {
var debug = require('debug')('AUTH:JOIN:');
var reqId = puid.generate();
debug(reqId, channel.toUpperCase() + ':' + nick.toUpperCase());
client.say('NickServ', 'ACC' + ' ' + nick);
});
User.findOne({username: username, password: password}, function(err, user) {
if(err)
res.send(err);
else {
var token = {"access_token": puid.generate(),
"refresh_token": puid.generate(),
"expires_in": 3600,
"token_type": "bearer"
};
user.access_token = token["acess_token"];
user.refresh_token = token["refresh_token"];
user.token_createAt = Date.now();
user.save(function(err, result) {
if(err)
res.send(err);
else
res.send(token);
});
}
})
client.addListener('names', function (channel, nicks) {
var debug = require('debug')('AUTH:NAMES:');
var reqId = puid.generate();
debug(reqId, nicks);
Object.keys(nicks).forEach(function (nick) {
debug(reqId, 'SEND:ACC:REQUEST:' + nick.toUpperCase());
client.say('NickServ', 'ACC' + ' ' + nick);
});
});
exports.post = function(req, res) {
// //edit by 차슬기 2014.05.22 세션 체크 추가
// var regID = req.session.regID;
// if(req.session.regID === undefined || req.session.regID == '') { //세션에 아이디가 존재하지 않을 경우
// res.json({isSuccess:"Session has expired."});
// return;
// }
//edit by 차슬기 2014.05.22 세션쪽 안되서 일단 주석처리하고 파라미터로 처리하게 해놓음
var regID;
try {
regID = req.body.regID;
} catch(err) {
regID = '';
}
var puid = new Puid(false);
var cmtID = puid.generate();
var mstrID = req.body.mstrID;
var ctt = req.body.ctt;
var divVal = req.body.divVal;
pool.post(divVal, cmtID, mstrID, regID, ctt, function(err, result, pushFlag, regName, pushTarget) {
if(err) console.error('err', err);
try {
if(result === undefined) {
res.json({});//res.json({isSuccess: 'undefined',error:err});
} else if(result.affectedRows == 1) {
//pushFlag(0:비활성화, 1:활성화)에 따른 push처리
if(pushFlag) {
var pushMessage = {
divVal : divVal,
mstrID : mstrID,
regName : regName[0].nickName
};
// global.sendPush(res, pushTarget, pushMessage);
sendPush(res, pushTarget, pushMessage);
}
res.json({isSuccess:"success","aceptedData":{"divVal":divVal,"mstrID":mstrID,"ctt":ctt}});
} else {
res.json({});//res.json({isSuccess: 'fail',error:err});
}
} catch(error) {
console.error('catch', error);
res.json({error:error});
}
});
};
exports.post = function(req, res){
// //edit by 차슬기 2014.05.22 세션 체크 추가
// var regID = req.session.regID;
// if(req.session.regID === undefined || req.session.regID == '') { //세션에 아이디가 존재하지 않을 경우
// res.json({isSuccess:"Session has expired."});
// return;
// }
//edit by 차슬기 2014.05.22 세션쪽 안되서 일단 주석처리하고 파라미터로 처리하게 해놓음
var regID;
try {
regID = req.body.regID;
} catch(err) {
regID = '';
}
var puid = new Puid(false);
var curaID = puid.generate();
var title = req.body.title;
var bookIDs = req.body.bookIDs;
pool.post(curaID, regID, title, bookIDs, function(err, result, pushFlag, regName, pushTarget) {
if(err) console.error('err', err);
try {
if(result === undefined) {
res.json({});//res.json({isSuccess: 'undefined',error:err});
} else if(result.affectedRows == 1) {
//pushFlag(0:비활성화, 1:활성화)에 따른 push처리
if(pushFlag) {
var pushMessage = {
divVal : '1',
mstrID : curaID,
regName : regName[0].nickName
};
// global.sendPush(res, pushTarget, pushMessage);
sendPush(res, pushTarget, pushMessage);
}
res.json({isSuccess: 'success', aceptedData: {curaID: curaID, title: title, bookIDs: bookIDs}});
} else {
res.json({});//res.json({isSuccess: 'fail',error:err});
}
} catch(error) {
console.error('catch', error);
res.json({error:error});
}
});
};
function Handle(workerFilePath, payload) {
Emitter.call(this);
var self = this;
this.id = puid.generate();
this.payload = payload;
var setupData = JSON.stringify({
id: this.id,
payload: payload
})
this.worker = fork(workerFilePath, [setupData]);
this.worker.on('message', function (data) {
var obj = JSON.parse(data.toString());
if (typeof obj.event == 'string') {
self.emit(obj.event, obj.data);
}
});
}
constructor(queue, type, workerFn, opts) {
if (typeof type !== 'string') throw new Error('type must be a string');
if (typeof workerFn !== 'function') throw new Error('workerFn must be a function');
if (typeof opts !== 'object') throw new Error('opts must be an object');
if (typeof opts.interval !== 'number') throw new Error('opts.interval must be a number');
if (typeof opts.intervalErrorMultiplier !== 'number') throw new Error('opts.intervalErrorMultiplier must be a number');
super();
this.id = puid.generate();
this.queue = queue;
this.client = opts.client || this.queue.client;
this.jobtype = type;
this.workerFn = workerFn;
this.checkSize = opts.size || 10;
this.doctype = opts.doctype || constants.DEFAULT_SETTING_DOCTYPE;
this.debug = (msg, err) => {
const logger = opts.logger || function () {};
const message = `${this.id} - ${msg}`;
const tags = ['worker', 'debug'];
if (err) {
logger(`${message}: ${err.stack ? err.stack : err }`, tags);
return;
}
logger(message, tags);
};
this._running = true;
this.debug(`Created worker for job type ${this.jobtype}`);
this._poller = new Poller({
functionToPoll: () => {
return this._processPendingJobs();
},
pollFrequencyInMillis: opts.interval,
trailing: true,
continuePollingOnError: true,
pollFrequencyErrorMultiplier: opts.intervalErrorMultiplier,
});
this._startJobPolling();
}
User.findOne({refresh_token: refresh_token}, function(err, user) {
if(err)
response.send(err);
else {
var token = {"access_token": puid.generate(),
"expires_in": 3600,
"token_type": "bearer"
};
user.access_token = token["access_token"];
user.refresh_token = null;
user.token_createAt = Date.now();
user.save(function(err, result) {
if(err)
response.send(err);
else
response.send(token);
});
}
});
resetpass: function(req, res){
puid = new Puid(true);
var email = req.param('email'),
newPass = puid.generate();
User.findOneByEmail(email, function( err, user ){
console.log(user);
console.log(newPass);
crypto.generate({saltComplexity: 10}, newPass, function(err, hash){
if(err){
return cb(err);
}else{
var emailTemplate = res.render('email/reset.ejs', function(err){
nodemailer.send({
name: user.firstName + ' ' + user.lastName,
from: sails.config.nodemailer.from,
to: email,
subject: 'Peices pass Reset',
messageHtml: 'Your new password for peices.co ' + newPass
}, function(err, response){
sails.log.debug('nodemailer sent', err, response);
});
res.redirect('/login');
});
console.log(user.firstName + user.lastName);
console.log(user.email);
console.log('original user pass '+ user.password);
newPass = hash;
console.log('hashed pass: '******'Updated user to have pass ' + newPass);
});
}
});
});
}
Handle.prototype.call = function (method) {
var self = this;
var args = [];
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
var callId = puid.generate();
this.send({
'__': true,
method: method,
args: args,
callId: callId
});
return {
response: function (callback) {
self.once('__' + callId, function (result) {
callback.apply(self, result);
});
}
};
};
var p = new Promise(function(resolve, reject){
var id = puid.generate();
var dest = path.join(pasta, '');
var writeStream = fs.createWriteStream(dest);
// Avisando a promise que acabamos por aqui
writeStream.on('finish', function(){
resolve(id);
if(success)
success();
});
// Capturando erros da write stream
writeStream.on('error', function(err){
fs.unlink(dest, reject.bind(null, err));
});
var readStream = request.get(arquivo);
// Capturando erros da request stream
readStream.on('error', function(err){
fs.unlink(dest, reject.bind(null, err));
});
// Iniciando a transferência de dados
readStream.pipe(writeStream);
});
const getRandomScrollId = () => {
return puid.generate();
};
client.addListener('message', function (nick, to, message, raw) {
var debug = require('debug')('AUTH:MESSAGE:');
var reqId = puid.generate();
var cmdline = utils.filterCommands(message);
var cmd = {};
cmd.cmdlineLength = cmdline.length;
// early return
if (!utils.isCmd('!auth', cmdline) || cmd.cmdlineLength > 3) {
debug(reqId, 'DISCARDED');
return;
}
cmd.nick = nick ? nick.toLowerCase() : false;
cmd.to = to ? to.toLowerCase() : false;
cmd.isAdmin = config.admins.hasOwnProperty(cmd.nick) && config.admins[cmd.nick];
debug(reqId, 'cmdline=', cmdline, 'cmd=', cmd);
if (cmd.cmdlineLength === 1) {
debug(reqId, 'SEND:ACC:REQUEST:' + cmd.nick.toUpperCase());
client.say('NickServ', 'ACC' + ' ' + cmd.nick);
return;
}
if (utils.isBotMessage(cmd.to, config)) {
debug(reqId, 'SET:PRIVMSG:' + cmd.nick.toUpperCase() + ':ON');
cmd.to = cmd.nick;
}
cmd.command = cmd.cmdlineLength > 1 && cmdline[1] ? cmdline[1].toLowerCase() : false;
cmd.user = cmd.cmdlineLength > 2 && cmdline[2] ? cmdline[2].toLowerCase() : false;
debug(reqId, 'COMMAND:RECOGNIZED:' + cmd.command.toUpperCase());
switch (cmd.command) {
case 'list':
debug = require('debug')('AUTH:MESSAGE:COMMAND:LIST:');
debug(reqId);
cmd.admins = [];
Object.keys(config.admins).forEach(function (admin) {
var name = admin.toLowerCase();
if (config.admins[name]) {
cmd.admins.push(name);
}
});
debug(reqId, 'SEND:MSG:ADMINS', 'cmd.admins=', cmd.admins);
sendMessage(reqId,
client,
cmd.to,
'ADMINS: ' +
(cmd.admins.length ? cmd.admins.join(', ') : 'tortelini')
);
break;
case 'add':
debug = require('debug')('AUTH:MESSAGE:COMMAND:ADD:');
debug(reqId);
if (cmd.isAdmin && cmd.user) {
config.admins[cmd.user] = true;
debug(reqId, cmd.nick.toUpperCase());
}
debug(reqId, 'ADMINS:', config.admins);
break;
case 'remove':
debug = require('debug')('AUTH:MESSAGE:COMMAND:REMOVE:');
debug(reqId);
if (cmd.isAdmin && cmd.user) {
delete(config.admins[cmd.user]);
debug(reqId, cmd.nick.toUpperCase());
}
debug(reqId, 'ADMINS:', config.admins);
break;
default:
debug(reqId, 'DEFAULT:' + cmd.command.toUpperCase() + ':' + cmd.nick.toUpperCase());
break;
}
});
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var Puid = require('puid');
var puid = new Puid();
var Client = new Schema({
name: {type: String, default: puid.generate()},
secret: {type: String, default: puid.generate()},
});
Client.methods.verifyClientSecret = function(secret, callback) {
if(secret !== this.secret)
return callback("Password is not match: " + secret + " vs " + this.secret);
return callback(null, true);
}
module.exports = mongoose.model('Client', Client);
'use strict';
var mongoose = require('mongoose'),
Schema = mongoose.Schema;
var crypto = require('crypto');
var Puid = require('puid');
var puid = new Puid();
var UserSchema = new Schema({
name: { type: String, required: true },
email: { type: String, required: true, index: { unique: true }},
password: { type: String, required: true },
department: { type : String, required: true },
sex: { type: String, required: true },
occupation: { type: String, required: true },
uuid: { type: String, required: true, default: puid.generate() },
created_at: { type: Date, required: true, default: Date.now },
updated_at: { type: Date, required: true, default: Date.now },
disabled: { type: Boolean, required: true, default: false }
});
UserSchema.static('createHash', function(password) {
if (!password) { return ''; }
var planeText = 'Plane Text';
var cipher = crypto.createCipher('aes192', password);
cipher.update(planeText, 'utf8', 'hex');
return cipher.final('hex');
});
UserSchema.pre('save', function(next) {
var now = new Date();
id: function(){
return puid.generate();
}
constructor(queue, index, jobtype, payload, options = {}) {
if (typeof jobtype !== 'string') throw new Error('Jobtype must be a string');
if (!isPlainObject(payload)) throw new Error('Payload must be a plain object');
super();
this.queue = queue;
this._client = this.queue.client;
this.id = puid.generate();
this.index = index;
this.jobtype = jobtype;
this.payload = payload;
this.created_by = options.created_by || false;
this.timeout = options.timeout || 10000;
this.maxAttempts = options.max_attempts || 3;
this.priority = Math.max(Math.min(options.priority || 10, 20), -20);
this.indexSettings = options.indexSettings || {};
this.browser_type = options.browser_type;
this.debug = (msg, err) => {
const logger = options.logger || function () {};
const message = `${this.id} - ${msg}`;
const tags = ['job', 'debug'];
if (err) {
logger(`${message}: ${err}`, tags);
return;
}
logger(message, tags);
};
const indexParams = {
index: this.index,
id: this.id,
body: {
jobtype: this.jobtype,
meta: {
// We are copying these values out of payload because these fields are indexed and can be aggregated on
// for tracking stats, while payload contents are not.
objectType: payload.type,
layout: payload.layout ? payload.layout.id : 'none',
},
payload: this.payload,
priority: this.priority,
created_by: this.created_by,
timeout: this.timeout,
process_expiration: new Date(0), // use epoch so the job query works
created_at: new Date(),
attempts: 0,
max_attempts: this.maxAttempts,
status: constants.JOB_STATUS_PENDING,
browser_type: this.browser_type,
}
};
if (options.headers) {
indexParams.headers = options.headers;
}
this.ready = createIndex(this._client, this.index, this.indexSettings)
.then(() => this._client.callWithInternalUser('index', indexParams))
.then((doc) => {
this.document = {
id: doc._id,
index: doc._index,
_seq_no: doc._seq_no,
_primary_term: doc._primary_term,
};
this.debug(`Job created in index ${this.index}`);
return this._client.callWithInternalUser('indices.refresh', {
index: this.index
}).then(() => {
this.debug(`Job index refreshed ${this.index}`);
this.emit(constants.EVENT_JOB_CREATED, this.document);
});
})
.catch((err) => {
this.debug('Job creation failed', err);
this.emit(constants.EVENT_JOB_CREATE_ERROR, err);
});
}
client.addListener('message', function (nick, to, message, raw) {
var debug = require('debug')('CMD:MESSAGE:');
var reqId = puid.generate();
var cmdline = utils.filterCommands(message);
var cmd = {};
cmd.cmdlineLength = cmdline.length;
if (!utils.isCmd('!cmd', cmdline) || cmd.cmdlineLength < 2) {
debug(reqId, 'DISCARDED');
return;
}
debug(reqId, 'nick', nick, 'to=', to, 'message=', message);
cmd.nick = nick ? nick.toLowerCase() : false;
cmd.to = to ? to.toLowerCase() : false;
cmd.isAdmin = config.admins.hasOwnProperty(cmd.nick) && config.admins[cmd.nick];
debug(reqId, 'cmd=', cmd, 'cmdline=', cmdline);
if (!cmd.isAdmin) {
debug(reqId, 'DISCARDED:NO_AUTH');
return;
}
debug = require('debug')('CMD:MESSAGE:COMMAND:');
cmd.command = cmd.cmdlineLength > 1 && cmdline[1] ? cmdline[1].toLowerCase() : false;
// cmd params
// ==========
cmd.param1 = cmd.receiver = cmd.cmdlineLength > 2 && cmdline[2] ? cmdline[2].toLowerCase() : false;
cmd.param2 = cmd.nickname = cmd.cmdlineLength > 3 && cmdline[3] ? cmdline[3].toLowerCase() : false;
cmd.msgMessage = cmd.cmdlineLength > 3 ? cmdline.slice(3).join(' ') : false;
debug(reqId,
'cmd=', cmd
);
switch (cmd.command) {
case 'msg':
debug = require('debug')('CMD:MESSAGE:COMMAND:MSG:');
debug(reqId);
if (
cmd.cmdlineLength > 3 &&
cmd.receiver.indexOf('#') === 0) {
client.say(cmd.receiver, cmd.msgMessage + ' (@' + nick + ')');
debug(
reqId,
'SEND:MESSAGE:CHANNEL:' + cmd.receiver.toUpperCase(),
'from=', cmd.nick,
'message=', cmd.msgMessage
);
} else {
debug(reqId, 'ABORTED');
}
break;
case 'op':
case '+op':
case '-op':
// !cmd op #channel nickname
if (cmd.command.indexOf('-') === 0) {
cmd.mode = '-o';
} else {
cmd.mode = '+o';
}
debug = require('debug')('CMD:MESSAGE:COMMAND:OP:' + cmd.mode.toUpperCase() + ':');
// !cmd op
if (cmd.cmdlineLength === 2) {
cmd.nickname = cmd.nick;
cmd.receiver = cmd.to;
}
// !cmd op nickname
if (cmd.cmdlineLength === 3) {
cmd.nickname = cmd.receiver;
cmd.receiver = cmd.to;
}
// !cmd op #channel
if (cmd.cmdlineLength === 3 && cmd.param1.indexOf('#') === 0) {
cmd.nickname = cmd.nick;
cmd.receiver = cmd.param1;
}
debug(reqId, cmd);
if (cmd.receiver.indexOf('#') === 0) {
client.send('MODE', cmd.receiver, cmd.mode, cmd.nickname);
debug(
reqId,
cmd.nick.toUpperCase() + ':' + cmd.receiver.toUpperCase() + ':' + cmd.receiver.toUpperCase()
);
} else {
debug(reqId, 'ABORTED');
}
break;
default:
debug(reqId, 'DEFAULT:' + cmd.command.toUpperCase() + ':' + cmd.nick.toUpperCase());
break;
}
});