卫星通信服务平台

This commit is contained in:
2026-03-27 17:57:44 +08:00
commit 21bcbf78f8
35 changed files with 1915 additions and 0 deletions

464
app/controller/home.js Normal file
View File

@@ -0,0 +1,464 @@
const { Controller } = require('egg');
const GBK = require("gbk.js");
const decode = (data) => {
let arr = [];
data.match(/..?/g).forEach((element) => {
arr.push(parseInt(element, 16));
});
return GBK.decode(arr);
}
const CryptoJS = require("crypto-js");
const KEY = CryptoJS.enc.Utf8.parse('BDQH');
const decryptRequest = (body) => {
return CryptoJS.AES.decrypt(body, KEY, {
mode: CryptoJS.mode.ECB,
padding: CryptoJS.pad.Pkcs7
}).toString(CryptoJS.enc.Utf8);
}
const checkUid = async (ctx) => {
const uid = ctx.request.body.uid;
const token = ctx.request.header.authorization;
const redis = ctx.app.redis;
let rdmcode;
if (!uid) {
const [buser, cuser, tuser] = await Promise.all([
redis.get('db0').get(token),
redis.get('db1').get(token),
redis.get('db5').get(token),
]);
rdmcode = buser || cuser || tuser;
} else {
let decryptUid = decryptRequest(uid).split('?')[0];
const redisType = {
"B": "db0",
"C": "db1",
"T": "db5",
};
const lastCode = decryptUid[decryptUid.length - 1];
rdmcode = await redis.get(redisType[lastCode]).get(token);
}
if (!rdmcode) {
return false;
}
return rdmcode;
};
const fileName = "home";
const setResponse = (ctx, code, msg, model, data = {}) => {
const modelType = {
"none": { code, msg },
"deconstruction": { code, msg, ...data },
"polymerization": { code, msg, data }
}
ctx.body = modelType[model];
}
class HomeController extends Controller {
// 获取SN号
async getSN() {
const ctx = this.ctx;
try {
let rdmcode = await checkUid(ctx);
if (!rdmcode) {
setResponse(ctx, 401, 'token过期或错误', "none");
return;
}
const uid = JSON.parse(rdmcode).uid;
const result = await ctx.service.home.getSN(uid);
if(result == "error") {
setResponse(ctx, 500, '服务器错误', "none");
return;
}
if (result) {
const data = { snNumber: result.dataValues.sn_number };
setResponse(ctx, 200, '获取SN号成功', "deconstruction", data);
} else {
setResponse(ctx, 404, '获取SN号失败', "none");
}
} catch (error) {
const blockName = fileName + "--" + "getSN";
ctx.app.middleware.utils.log('../../../controllerLog', blockName + ">>>>" + error);
setResponse(ctx, 500, '服务器错误', "none");
}
}
// 搜索SN号
async searchSN() {
const ctx = this.ctx;
try {
let rdmcode = await checkUid(ctx);
if (!rdmcode) {
setResponse(ctx, 401, 'token过期或错误', "none");
return;
}
const uid = JSON.parse(rdmcode).uid;
const { snNumber } = ctx.request.body;
const result = await ctx.service.home.searchSN(snNumber);
if(result == "error") {
setResponse(ctx, 500, '服务器错误', "none");
return;
}
if (result) {
if (result.dataValues.cuser == null) {
setResponse(ctx, 201, '此SN号未绑定', "deconstruction", result);
} else if (result.dataValues.cuser == uid) {
setResponse(ctx, 202, '此SN号已与当前账号绑定', "none");
} else {
setResponse(ctx, 203, '此SN号已绑定', "none");
}
} else {
setResponse(ctx, 404, '此SN号未注册', "none");
}
} catch (error) {
const blockName = fileName + "--" + "searchSN";
ctx.app.middleware.utils.log('../../../controllerLog', blockName + ">>>>" + error);
setResponse(ctx, 500, '服务器错误', "none");
}
}
// 搜索可绑定的SN号
async searchBindSN() {
const ctx = this.ctx;
try {
let rdmcode = await checkUid(ctx);
if (!rdmcode) {
setResponse(ctx, 401, 'token过期或错误', "none");
return;
}
const uid = JSON.parse(rdmcode).uid;
const result = await ctx.service.home.searchBindSN(uid);
if(result == "error") {
setResponse(ctx, 500, '服务器错误', "none");
return;
}
if (result) {
const data = {
result
}
setResponse(ctx, 200, '获取可绑定的SN号成功', "deconstruction", data);
} else {
setResponse(ctx, 404, '获取可绑定的SN号失败', "none");
}
} catch (error) {
const blockName = fileName + "--" + "searchBindSN";
ctx.app.middleware.utils.log('../../../controllerLog', blockName + ">>>>" + error);
setResponse(ctx, 500, '服务器错误', "none");
}
}
// 搜索可绑定的单位用户
async searchBindUser() {
const ctx = this.ctx;
try {
let rdmcode = await checkUid(ctx);
if (!rdmcode) {
setResponse(ctx, 401, 'token过期或错误', "none");
return;
}
const uid = JSON.parse(rdmcode).uid;
const result = await ctx.service.home.searchBindUser(uid);
if(result == "error") {
setResponse(ctx, 500, '服务器错误', "none");
return;
}
if (result) {
const data = {
result
}
setResponse(ctx, 200, '获取可绑定的单位用户成功', "deconstruction", data);
} else {
setResponse(ctx, 404, '获取可绑定的单位用户失败', "none");
}
} catch (error) {
const blockName = fileName + "--" + "searchBindUser";
ctx.app.middleware.utils.log('../../../controllerLog', blockName + ">>>>" + error);
setResponse(ctx, 500, '服务器错误', "none");
}
}
// 绑定SN号
async bindSN() {
const ctx = this.ctx;
try {
let rdmcode = await checkUid(ctx);
if (!rdmcode) {
setResponse(ctx, 401, 'token过期或错误', "none");
return;
}
const uid = JSON.parse(rdmcode).uid;
const body = ctx.request.body;
const result = await ctx.service.home.bindSN(uid, body);
if(result == "error") {
setResponse(ctx, 500, '服务器错误', "none");
return;
}
if (result) {
setResponse(ctx, 200, '绑卡成功', "none");
} else {
setResponse(ctx, 404, '绑卡失败', "none");
}
} catch (error) {
const blockName = fileName + "--" + "bindSN";
ctx.app.middleware.utils.log('../../../controllerLog', blockName + ">>>>" + error);
setResponse(ctx, 500, '服务器错误', "none");
}
}
// 解绑SN号
async unBindingSN() {
const ctx = this.ctx;
try {
let rdmcode = await checkUid(ctx);
if (!rdmcode) {
setResponse(ctx, 401, 'token过期或错误', "none");
return;
}
const uid = JSON.parse(rdmcode).uid;
const body = ctx.request.body;
const result = await ctx.service.home.unBindingSN(uid, body);
if(result == "error") {
setResponse(ctx, 500, '服务器错误', "none");
return;
}
if (result) {
setResponse(ctx, 200, '解绑成功', "none");
} else {
setResponse(ctx, 404, '解绑失败', "none");
}
} catch (error) {
const blockName = fileName + "--" + "unBindingSN";
ctx.app.middleware.utils.log('../../../controllerLog', blockName + ">>>>" + error);
setResponse(ctx, 500, '服务器错误', "none");
}
}
// 获取绑定记录
async getRecord() {
const ctx = this.ctx;
try {
let rdmcode = await checkUid(ctx);
if (!rdmcode) {
setResponse(ctx, 401, 'token过期或错误', "none");
return;
}
const uid = JSON.parse(rdmcode).uid;
const body = ctx.request.body;
const result = await ctx.service.home.getRecord(uid, body);
if(result == "error") {
setResponse(ctx, 500, '服务器错误', "none");
return;
}
if (result) {
let recordMsg = [];
result.rows.forEach(element => {
recordMsg.push(element.dataValues);
});
const data = {
recordMsg: recordMsg,
count: result.count
};
setResponse(ctx, 200, '绑定记录查询成功', "deconstruction", data);
} else {
setResponse(ctx, 404, '绑定记录查询失败', "none");
}
} catch (error) {
const blockName = fileName + "--" + "getRecord";
ctx.app.middleware.utils.log('../../../controllerLog', blockName + ">>>>" + error);
setResponse(ctx, 500, '服务器错误', "none");
}
}
// 存储消息记录
async shortMsg() {
const ctx = this.ctx;
try {
const body = ctx.request.body;
console.log(body)
const { sn_number, original_msg, msg_data, created_at } = body;
const form = {
sn_number: sn_number,
original_msg: original_msg,
msg_data: msg_data,
created_at: created_at
};
const result = await ctx.service.home.shortMsg(form);
if(result == "error") {
setResponse(ctx, 500, '服务器错误', "none");
return;
}
if (result) {
setResponse(ctx, 200, '消息记录存储成功', "none");
} else {
setResponse(ctx, 404, '消息记录存储失败', "none");
}
} catch (error) {
const blockName = fileName + "--" + "shortMsg";
ctx.app.middleware.utils.log('../../../controllerLog', blockName + ">>>>" + error);
setResponse(ctx, 500, '服务器错误', "none");
}
}
// 获取历史消息
async getHistoryMsg() {
const ctx = this.ctx;
try {
let rdmcode = await checkUid(ctx);
if (!rdmcode) {
setResponse(ctx, 401, 'token过期或错误', "none");
return;
}
const uid = JSON.parse(rdmcode).uid;
const body = ctx.request.body;
const result = await ctx.service.home.getHistoryMsg(uid, body);
if(result == "error") {
setResponse(ctx, 500, '服务器错误', "none");
return;
}
if (result) {
let historyMsg = [];
result.rows.forEach(element => {
historyMsg.push(element.dataValues);
});
const data = {
historyMsg: historyMsg,
count: result.count
};
setResponse(ctx, 200, '历史消息查找成功', "deconstruction", data);
} else {
setResponse(ctx, 404, '历史消息查找失败', "none");
}
} catch (error) {
const blockName = fileName + "--" + "getHistoryMsg";
ctx.app.middleware.utils.log('../../../controllerLog', blockName + ">>>>" + error);
setResponse(ctx, 500, '服务器错误', "none");
}
}
// 删除历史消息
async delHistoryMsg() {
const ctx = this.ctx;
try {
let rdmcode = await checkUid(ctx);
if (!rdmcode) {
setResponse(ctx, 401, 'token过期或错误', "none");
return;
}
const uid = JSON.parse(rdmcode).uid;
const body = ctx.request.body;
const model = decryptRequest(body.model);
const password = decryptRequest(body.password);
const requestMsg = body.userMsg;
const resetList = await ctx.service.home.delHistoryMsg(uid, model, password, requestMsg);
if(resetList == "error") {
setResponse(ctx, 500, '服务器错误', "none");
return;
}
if (resetList) {
setResponse(ctx, 200, '删除历史消息成功', "none");
} else {
setResponse(ctx, 404, '删除历史消息失败', "none");
}
} catch (error) {
const blockName = fileName + "--" + "delHistoryMsg";
ctx.app.middleware.utils.log('../../../controllerLog', blockName + ">>>>" + error);
setResponse(ctx, 500, '服务器错误', "none");
}
}
/**
* 将sequelize查询结果转换为普通对象数组
* @param {Array} rows - sequelize查询结果行
* @returns {Array} 转换后的普通对象数组
*/
transformBsideUsers(rows) {
let bsideUsers = [];
rows.forEach(element => {
bsideUsers.push(element.dataValues);
});
return bsideUsers;
}
// 获取单位用户
async bsideUserManager() {
const ctx = this.ctx;
try {
let rdmcode = await checkUid(ctx);
if (!rdmcode) {
setResponse(ctx, 401, 'token过期或错误', "none");
return;
}
const uid = JSON.parse(rdmcode).uid;
let result;
if(uid[uid.length - 1] == 'B') {
const body = ctx.request.body;
result = await ctx.service.home.bsideUserManager(uid, body);
}
if(result == "error") {
setResponse(ctx, 500, '服务器错误', "none");
return;
}
if (result) {
const bsideUsers = this.transformBsideUsers(result.rows);
const data = {
bsideUsers: bsideUsers,
count: result.count
};
setResponse(ctx, 200, '获取单位用户成功', "deconstruction", data);
} else {
setResponse(ctx, 404, '获取单位用户失败', "none");
}
} catch (error) {
const blockName = fileName + "--" + "bsideUserManager";
ctx.app.middleware.utils.log('../../../controllerLog', blockName + ">>>>" + error);
setResponse(ctx, 500, '服务器错误', "none");
}
}
// 获取可管理的SN号
async bsideSNManager() {
const ctx = this.ctx;
try {
let rdmcode = await checkUid(ctx);
if (!rdmcode) {
setResponse(ctx, 401, 'token过期或错误', "none");
return;
}
const uid = JSON.parse(rdmcode).uid;
let result;
if(uid[uid.length - 1] == 'B') {
const body = ctx.request.body;
result = await ctx.service.home.bsideSNManager(uid, body);
}
if(result == "error") {
setResponse(ctx, 500, '服务器错误', "none");
return;
}
if (result) {
let snArr = [];
result.forEach(element => {
snArr.push(element.dataValues);
});
const data = {
count: result.length,
bsideSN: snArr,
};
setResponse(ctx, 200, '获取可管理的SN号成功', "deconstruction", data);
} else {
setResponse(ctx, 404, '获取可管理的SN号失败', "none");
}
} catch (error) {
const blockName = fileName + "--" + "bsideSNManager";
ctx.app.middleware.utils.log('../../../controllerLog', blockName + ">>>>" + error);
setResponse(ctx, 500, '服务器错误', "none");
}
}
}
module.exports = HomeController;