tqxz-sn-message-platform/app/controller/home.js

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 model = decryptRequest(body.model);
      const password = decryptRequest(body.password);
      const requestMsg = body.userMsg;
      const result = await ctx.service.home.unBindingSN(uid, model, password, requestMsg);
      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;