Client.prototype.sendIq = function (data, cb) {
var result, respEvent, allowed, dest;
var self = this;
data = data || {};
if (!data.id) {
data.id = this.nextId();
}
var iq = (!data.toJSON) ? new Iq(data) : data;
if (data.type === 'error' || data.type === 'result') {
this.send(iq);
return;
}
dest = new JID(data.to);
allowed = {};
allowed[''] = true;
allowed[dest.full] = true;
allowed[dest.bare] = true;
allowed[dest.domain] = true;
allowed[self.jid.bare] = true;
allowed[self.jid.domain] = true;
respEvent = 'id:' + data.id;
result = new Promise(function (resolve, reject) {
var handler = function (res) {
if (!allowed[res.from.full]) {
return;
}
self.off(respEvent, handler);
if (!res.error) {
resolve(res);
} else {
reject(res);
}
};
self.on(respEvent, 'session', handler);
});
this.send(iq);
return result.timeout(self.config.timeout * 1000 || 15000)
.catch(Promise.TimeoutError, function () {
throw {type: 'error', error: {condition: 'timeout'}};
})
.nodeify(cb);
};
Client.prototype.sendIq = function (data, cb) {
var result, respEvent, allowed, dest;
var self = this;
data = data || {};
if (!data.id) {
data.id = this.nextId();
}
var Iq = this.stanzas.getIq();
var iq = (!data.toJSON) ? new Iq(data) : data;
if (data.type === 'error' || data.type === 'result') {
this.send(iq);
return;
}
dest = new JID(data.to);
allowed = {};
allowed[''] = true;
allowed[dest.full] = true;
allowed[dest.bare] = true;
allowed[dest.domain] = true;
allowed[self.jid.bare] = true;
allowed[self.jid.domain] = true;
respEvent = 'iq:id:' + data.id;
result = new BPromise(function (resolve, reject) {
var handler = function (res) {
// Only process result from the correct responder
if (!allowed[res.from.full]) {
return;
}
// Only process result or error responses, if the responder
// happened to send us a request using the same ID value at
// the same time.
if (res.type !== 'result' && res.type !== 'error') {
return;
}
self.off(respEvent, handler);
if (!res.error) {
resolve(res);
} else {
reject(res);
}
};
self.on(respEvent, 'session', handler);
});
this.send(iq);
return result.timeout(self.config.timeout * 1000 || 15000)
.catch(BPromise.TimeoutError, function () {
throw {
id: data.id,
type: 'error',
error: {
condition: 'timeout'
}
};
})
.nodeify(cb);
};
return new Promise(resolve=> {
let sendFun = new Promise(resolve => {
switch (type) {
case 0:
config = {
id: v.equip_id,
type: type,
openTime: req.body.openTime.split(','), //在这个地方处理 不然config有引用传值的问题，数据在initdata被改变
closeTime: req.body.closeTime.split(','),
btnState:req.body.btnState
};
config1 = {
id: v.equip_id,
type: type,
openTime: req.body.openTime.split(','),
closeTime: req.body.closeTime.split(','),
btnState:req.body.btnState
};
data = InitData.initTimeConfigData(config);
break;
case 1:
let startDay = req.body.startDay,
endDay = req.body.endDay;
btnState = req.body.btnState;
startDay = startDay.split(',');
endDay = endDay.split(',');
config = {
id: v.equip_id,
type: type,
startDay: startDay,
endDay: endDay,
openTime: req.body.openTime.split(','),
closeTime: req.body.closeTime.split(','),
btnState:req.body.btnState
};
config1 = {
id: v.equip_id,
type: type,
startDay: startDay,
endDay: endDay,
openTime: req.body.openTime.split(','),
closeTime: req.body.closeTime.split(','),
btnState:req.body.btnState
};
data = InitData.initDayTimeConfigData(config);
break;
case 2:
let switchStatus = req.body.switchStatus;
config = {
id: v.equip_id,
type: type,
switchStatus: switchStatus
};
data = InitData.initSwitchControlData(config);
break;
}
sendData(v.equip_id, data, function (result) {
resolve(result);
});
});
sendFun.timeout(15000).then(v=> {
logger.info(v.code == -1 ? 'equip_id:' + v.equip_id + ' 失败，不保存配置' : '');
if(v.code > -1 && type === 0){
config1.id = v.equip_id;
weekTimeServer.saveConfig(config1);
}else if(v.code > -1 && type === 1){
config1.id = v.equip_id;
dailyTimeServer.saveConfig(config1);
}
resolve(v);
}).catch(Promise.TimeoutError, function () {
resolve({code: -2, message: "could not get response data within 2000ms",equip_id:v.equip_id});//超时-2
});
});
}).post('/id/:id', function (req, res) {
let data,
id = req.params.id,
type = Number(req.body.type),
openTime = req.body.openTime,
closeTime = req.body.closeTime,
btnState = req.body.btnState,
code = 1,
message = 'success',
config,
config1;
if (openTime && closeTime) {
openTime = openTime.split(',');
closeTime = closeTime.split(',');
}
let sendData = require("../lib/socket/socketHandle").send;
switch (type){
case 0:
config = {
id: id,
type: type,
openTime: openTime,
closeTime: closeTime,
btnState: btnState
};
config1 = {
id: id,
type: type,
openTime: req.body.openTime.split(','),
closeTime: req.body.closeTime.split(','),
btnState: btnState
};
data = InitData.initTimeConfigData(config);
break;
case 1:
let startDay = req.body.startDay,
endDay = req.body.endDay;
startDay = startDay.split(',');
endDay = endDay.split(',');
config = {
id: id,
type: type,
startDay: startDay,
endDay: endDay,
openTime: openTime,
closeTime: closeTime,
btnState: btnState
};
config1 = {
id: id,
type: type,
startDay: startDay,
endDay: endDay,
openTime: req.body.openTime.split(','),
closeTime: req.body.closeTime.split(','),
btnState: btnState
};
data = InitData.initDayTimeConfigData(config);
break;
case 2:
let switchStatus = req.body.switchStatus;
config = {
id: id,
type: type,
switchStatus: switchStatus
};
data = InitData.initSwitchControlData(config);
break;
}
let sendFun = new Promise(function (resolve) {
sendData(id, data, function (result) {
resolve(result)
});
});
sendFun.timeout(15000).then(v=> {
// logger.info('config1::::::::::::::::::::::::::');
// logger.info(config1);
logger.info(v.code == -1 ? 'equip_id:' + v.equip_id + ' 失败，不保存配置' : '');
if(v.code > -1 && type===0){
weekTimeServer.saveConfig(config1);
}else if(v.code > -1 && type===1){
dailyTimeServer.saveConfig(config1);
}
res.send(v);
}).catch(Promise.TimeoutError, function () {
res.send({code: -2, message: "could not get response data within 2000ms",equip_id:id});//超时-2
});
});
.then((channel) => {
const settings = hoek.applyToDefaults(defaultRabbit, params);
const message = hoek.applyToDefaults(defaultMessage, params.message);
let rpcPromise = new Promise((resolve) => {
const correlationId = uuid.v1();
const replyFunc = (msg) => {
if (msg.properties.correlationId === correlationId) {
resolve(msg);
}
};
// declare anonyme queue for RPC answer
channel.assertQueue('', {
exclusive : true,
autoDelete : true,
})
.then(queueOk => queueOk.queue)
.then((answerQueue) => {
internals._consume({
channel,
queue : answerQueue,
options : {
exclusive : true,
},
receiveFunc : replyFunc,
});
return answerQueue;
})
.then((queue) => {
// sending the message with replyTo set with the anonymous queue
const msgOpt = _.extend({}, message.options, {
correlationId,
replyTo : queue,
});
return channel.assertQueue(settings.queue, _.pick(settings.options, queueOpt))
.then(queueOk => channel.publish('', queueOk.queue, new Buffer(message.content), _.pick(msgOpt, messageOpt)))
.then(() => queue);
});
});
if (!_.isUndefined(settings.RPCTimeout)) {
rpcPromise = rpcPromise.timeout(settings.RPCTimeout)
.catch((err) => {
channel.close();
return Promise.reject(err);
});
}
return rpcPromise
.then((msg) => {
channel.close();
return msg;
})
.then((msg) => {
settings.receiveFunc(msg);
return msg;
});
})