pao-aop-server
Version:
基于pao-aop的服务端框架
324 lines (322 loc) • 13.4 kB
JavaScript
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
}
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
(function (factory) {
if (typeof module === "object" && typeof module.exports === "object") {
var v = factory(require, exports);
if (v !== undefined) module.exports = v;
}
else if (typeof define === "function" && define.amd) {
define(["require", "exports", "pao-aop", "../buffer/index", "../net/socket", "../base/index"], factory);
}
})(function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var pao_aop_1 = require("pao-aop");
var index_1 = require("../buffer/index");
var socket_1 = require("../net/socket");
var index_2 = require("../base/index");
/**
* TCP设备
* @description 支持TCP/IP的设备
*/
var SocketDevice = /** @class */ (function (_super) {
__extends(SocketDevice, _super);
function SocketDevice() {
var _this = _super !== null && _super.apply(this, arguments) || this;
/** 回调函数列表 */
_this.recallFunctionList = new pao_aop_1.RecallFunctionList();
return _this;
}
/**
* 发送消息
* @param message 消息
* @param returnFunctionID 消息命令
* @param timeout 超时
* @param checkToSend 发送前的检查函数
* @returns 命令返回Promise
*/
SocketDevice.prototype.sendMessage = function (message, returnFunctionID, timeout, timeoutCheckBreak) {
if (returnFunctionID === void 0) { returnFunctionID = undefined; }
if (timeout === void 0) { timeout = 3000; }
if (timeoutCheckBreak === void 0) { timeoutCheckBreak = 100; }
this.sendDataToSocket(message);
return this.recallFunctionList.createRecallFunction(returnFunctionID, timeout, timeoutCheckBreak);
};
/**
* 发送数据
* @param deviceID 设备ID
* @param data 数据
*/
SocketDevice.prototype.sendDataToSocket = function (data) {
if (typeof (data) === 'string') {
this.socket.write(Buffer.from(data));
}
else {
this.socket.write(data);
}
if (typeof (data) === 'string') {
pao_aop_1.log('netThing', "\u53D1\u9001\u6570\u636E, \u8BBE\u5907ID=" + this.deviceID + ", \u6570\u636E=" + data);
}
else {
pao_aop_1.log('netThing', "\u53D1\u9001\u6570\u636E, \u8BBE\u5907ID=" + this.deviceID + ", \u6570\u636E=" + index_1.bufferToBase64(data).substr(0, 20));
}
};
/**
* 处理接收数据
* @param data 数据
*/
SocketDevice.prototype.onReceivedData = function (data) {
};
/**
* 处理错误
* @param error 错误
*/
SocketDevice.prototype.onError = function (error) {
/**
* 返回错误给客户端
*/
this.recallFunctionList.rejectAll(error);
};
SocketDevice = __decorate([
pao_aop_1.addon('SocketDevice', 'TCP设备', '支持TCP/IP的设备')
], SocketDevice);
return SocketDevice;
}(pao_aop_1.BaseAddon));
exports.SocketDevice = SocketDevice;
/**
* Socket设备服务
* @description 提供Socket设备与云端通讯的服务
* @author pao
*/
var SocketDeviceServer = /** @class */ (function (_super) {
__extends(SocketDeviceServer, _super);
function SocketDeviceServer() {
var _this = _super !== null && _super.apply(this, arguments) || this;
/** 命令超时时间，默认为30秒 */
_this.commandTimeout = 30000;
return _this;
}
SocketDeviceServer.prototype.start = function () {
_super.prototype.start.call(this);
};
SocketDeviceServer.prototype.setDeviceService = function (deviceServices) {
this.deviceServices = deviceServices;
};
/**
* 连接建立
* @param socket 套接
*/
SocketDeviceServer.prototype.onConnected = function (socket) {
var _this = this;
var device = this.onCreateDevice();
// 首先获取设备ID
device.socket = socket;
socket.on('error', function (error) {
pao_aop_1.log('netThing', new Error("\u8FDE\u63A5" + device.socket.remoteAddress + " : " + device.socket.remotePort + "\u5F02\u5E38: " + error));
});
socket.on('timeout', function () {
pao_aop_1.log('netThing', new Error("\u8FDE\u63A5" + device.socket.remoteAddress + " : " + device.socket.remotePort + "\u8D85\u65F6"));
});
socket.on('close', function (had_error) {
pao_aop_1.log('netThing', "\u8FDE\u63A5" + device.socket.remoteAddress + " : " + device.socket.remotePort + "\u5173\u95ED");
});
socket.on('data', function (data) {
try {
pao_aop_1.log('netThing', "\u6536\u5230\u6765\u81EA" + device.socket.remoteAddress + " : " + device.socket.remotePort + "\u7684\u6570\u636E: " + data);
_this.onReceivedData(device, data);
}
catch (error) {
pao_aop_1.log('netThing', new Error("\u8FDE\u63A5" + device.socket.remoteAddress + " : " + device.socket.remotePort + "\u65F6\u53D1\u751F\u5F02\u5E38: " + error));
}
});
this.onDeviceStart(device, socket);
};
/**
* 接收数据处理事件
* @param device 设备ID
* @param data 数据
*/
SocketDeviceServer.prototype.onReceivedData = function (device, data) {
return device.onReceivedData(data);
};
/**
* 异常时的处理
* @param device 设备ID
* @param error 错误
*/
SocketDeviceServer.prototype.onError = function (device, error) {
return device.onError(error);
};
SocketDeviceServer.prototype.getDeviceByName = function (deviceName) {
if (!this.deviceServices) {
return undefined;
}
return this.deviceServices.find(function (service) {
return service.serviceName === deviceName;
});
};
SocketDeviceServer = __decorate([
pao_aop_1.addon('SocketDeviceServer', 'Socket设备服务', '提供Socket设备与云端通讯的服务')
], SocketDeviceServer);
return SocketDeviceServer;
}(socket_1.SocketServer));
exports.SocketDeviceServer = SocketDeviceServer;
/**
* 基础设备服务
* @description 所有设备服务的基类，实现了物联网设备服务接口
* @author pao
*/
var BaseDeviceService = /** @class */ (function (_super) {
__extends(BaseDeviceService, _super);
function BaseDeviceService() {
var _this = _super !== null && _super.apply(this, arguments) || this;
/** 设备列表 */
_this.deviceList = new Map();
return _this;
}
/**
* 连接设备
* @param deviceID 设备ID
*/
BaseDeviceService.prototype.connectDevice = function (newDevice) {
var deviceID = newDevice.deviceID;
this.deviceList.set(deviceID, newDevice);
this.onDeviceConnected(deviceID);
};
/**
* 断开设备
* @param had_error 是否有错误
*/
BaseDeviceService.prototype.disconnectDevice = function (deviceID, had_error) {
var _this = this;
return new Promise(function (executor, reject) {
try {
if (had_error) {
_this.setErrorToDevice(deviceID, new Error('连接异常关闭'));
}
_this.onDeviceDisconnected(deviceID);
_this.deviceList.delete(deviceID);
}
catch (err) {
reject(err);
}
});
};
/**
* 事件: 有错误发生
* @param error 错误
*/
BaseDeviceService.prototype.setErrorToDevice = function (deviceID, error) {
this.onDeviceError(deviceID, error);
this.getDevice(deviceID).recallFunctionList.rejectAll(error);
};
/**
* 发送服务消息
* @param message 消息
* @param returnFunctionID 返回消息ID
* @param timeout 超时（单位：毫秒，如果小于或等于0，表示不设置超时）
* @param timeoutCheckBreak 超时检查时间间隔（单位：毫秒）
*/
BaseDeviceService.prototype.sendMessage = function (deviceID, message, returnFunctionID, timeout, timeoutCheckBreak) {
if (returnFunctionID === void 0) { returnFunctionID = undefined; }
if (timeout === void 0) { timeout = -1; }
if (timeoutCheckBreak === void 0) { timeoutCheckBreak = 100; }
var device = this.getDevice(deviceID);
if (!device) {
throw new Error("\u627E\u4E0D\u5230\u8BBE\u5907:" + deviceID);
}
return device.sendMessage(message, returnFunctionID, timeout, timeoutCheckBreak);
};
/**
* 根据设备ID获取设备
* @param deviceID 设备ID
*/
BaseDeviceService.prototype.getDevice = function (deviceID) {
return this.deviceList.get(deviceID);
};
/**
* 回调函数列表是否为空
* @param deviceID 设备ID
*/
BaseDeviceService.prototype.isRecallFunctionEmpty = function (deviceID) {
return this.getDevice(deviceID).recallFunctionList.isEmpty();
};
/**
* 获取回调函数
* @param deviceID 设备ID
* @param functionID 命令ID
*/
BaseDeviceService.prototype.getRecallFunction = function (deviceID, functionID) {
return this.getDevice(deviceID).recallFunctionList.getRecallFunction(functionID);
};
/**
* 回调函数
* @param deviceID 设备ID
* @param functionID 命令ID
* @param returnData 返回数据
*/
BaseDeviceService.prototype.recallFunction = function (deviceID, functionID, returnData) {
if (returnData === void 0) { returnData = undefined; }
this.getDevice(deviceID).recallFunctionList.recallFunction(functionID, returnData);
};
/**
* 接收数据
* @param deviceID 设备ID
* @param data 数据
*/
BaseDeviceService.prototype.receiveData = function (deviceID, data) {
this.onDataReceived(deviceID, data);
};
/**
* AT命令到达
* @param deviceID 设备ID
* @param data 数据
*/
BaseDeviceService.prototype.onCommandReceived = function (deviceID, data) { };
/**
* 数据到达
* @param deviceID 设备ID
* @param data 数据
*/
BaseDeviceService.prototype.onDataReceived = function (deviceID, data) { };
/**
* 设备错误
* @param deviceID 设备ID
* @param data 数据
*/
BaseDeviceService.prototype.onDeviceError = function (deviceID, error) { };
/**
* 事件: 设备连接
* @param deviceID 设备ID
*/
BaseDeviceService.prototype.onDeviceConnected = function (deviceID) { };
/**
* 事件: 设备断开
* @param deviceID 设备ID
*/
BaseDeviceService.prototype.onDeviceDisconnected = function (deviceID) { };
BaseDeviceService = __decorate([
pao_aop_1.addon('BaseDeviceService', '基础设备服务', '所有设备服务的基类')
], BaseDeviceService);
return BaseDeviceService;
}(index_2.BaseService));
exports.BaseDeviceService = BaseDeviceService;
});
//# sourceMappingURL=index.js.map