zhywpt-plug/wxminipro/plugin/etc/pages/activeAgainStep/activeAgainStep.js

// plugin/etc/pages/activeDes/activeDes.js


import {
  configPluginData,
  failPluginData
} from "../../../config.js"
import {
  ActiveDevice,
  DisConnectDevice,
  EquipmentDetection,
  ObuSystemInfo
} from "../../../utils/active-tools/active-device-tools.js"
import {
  starSearch,
  stopSearch
} from "../../../utils/blue-related-tools/blue_tool.js"
import {
  formatCardNumber
} from "../../../utils/obj-tools.js"

import {
  HOME_DIRECTORY,
  OBU_SYSTEM_FILE,
  RANDOM_NUMBER,
  APPLICATION_DIRECTORY,
  CMD_READBINARY,
  CMD_GETBALANCE
} from '../../../utils/cmdConfig'
import {
  transCmd,
  transCmdArrAfter,
  transCmdAfter
} from '../../../utils/etc-sdk-tool/etc-sdk-tool'
import {
  API
} from '../../../network/etcApi'

Page({

  /**
   * 页面的初始数据
   */
  data: {
    orderNo: "",
    type: 1,
    devList: [],
    showPopDevice: false,
    obuIdStr: "xxxx xxxx xxxx xxxx",
    cardIdStr: "xxxx xxxx xxxx xxxx",
    searchFailMsg: "请检查手机蓝牙、ETC蓝牙是否均已打开，连接过程中将手机和ETC设备尽量靠近",
    searchFailTitle: "未检测到ETC设备",
    activeFail: false,
    activeFailMsg: "不可发行/设备未入库",
    showType: 1,
    obuInfo: {
      version: '',
      obuId: '',
      chipSn: ''
    },
    cardInfo: {
      version: '',
      cardId: ''
    },
    plateNum: '', // 车牌号
    cardId: '',
    obuId: '',
    vehPosImgUrl: '',
    vehNegImgUrl: '',
    vehBodyUrl: '',
    installImgUrl: ''
  },
  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    this.configData(options)
  },
  onUnload() {
    this.configStop()
  },

  /// -------------- 工具类型 ---------------- ///
  // 配置默认参数
  configData(options) {
    configPluginData()
    const plateNum = options.plateNum ? options.plateNum : ''
    const cardId = options.cardId ? options.cardId : ''
    const obuId = options.obuId ? options.obuId : ''
    const vehPosImgUrl = options.vehPosImgUrl ? options.vehPosImgUrl : ''
    const vehNegImgUrl = options.vehNegImgUrl ? options.vehNegImgUrl : ''
    const vehBodyUrl = options.vehBodyUrl ? options.vehBodyUrl : ''
    const installImgUrl = options.installImgUrl ? options.installImgUrl : ''
    this.setData({
      plateNum,
      cardId,
      obuId,
      vehPosImgUrl,
      vehNegImgUrl,
      vehBodyUrl,
      installImgUrl
    })
  },

  /// 新版激活 -------- 触发方法
  /// 停止一切与设备相关的操作
  async configStop(isStop = true) {
    console.log('configStop')
    console.log("这个方法里执行断开设备")
    await DisConnectDevice()
    stopSearch(isStop)
  },

  // 点击开始搜索
  tapStar() {

    this.configNavTitle()
    this.setData({
      showPopDevice: false,
      devList: [],
      showType: 1,
    })
    wx.showLoading({
      title: '正在搜索设备...',
    })
    let self = this;
    starSearch((DevResult) => {
      console.log(DevResult);
      wx.hideLoading()
      if (DevResult.code == 0) {
        self.configNavTitle("验证设备")
        self.setData({
          devList: DevResult.data,
          showPopDevice: true,
        });
      } else {
        self.configSearchFail(DevResult.code)
      }
    }, false, "", false);
  },
  /// 配置导航栏标题
  configNavTitle(title = "设备搜索") {
    wx.setNavigationBarTitle({
      title: title,
    })
  },
  async tapOwner(e) {
    console.log(e)
    stopSearch(false);
    let device = e.detail;
    const res = await this.configActive(device);
    await DisConnectDevice()
    wx.hideLoading()
    if (res.code == 0) {
      this.configActiveSuccess();
    } else if (res.code == 250) {
      this.configSearchFail(res.code)
    } else {
      this.setData({
        activeFail: true,
        devName: device.name || "",
        activeFailMsg: res.msg || '请检查ETC硬件是否处于通电并开启蓝牙的状态'
      })
    }
  },

  // 连接设备
  async configActive(device) {
    const that = this;
    const rt = await EquipmentDetection({
      device,
      disconnectCallback: () => {
        that.configSearchFail(250)
      },
    })
    if (rt.code !== 0) {
      return rt
    } else {
      this.configEtcNumber(rt.data);

      // 激活前先查看是否需要升级设备
      await this.getObjDetail()
      await this.getCardId()

      if (this.data.obuInfo.version == '48' || this.data.obuInfo.version == '49' || this.data.cardInfo.version == '48' || this.data.cardInfo.version == '49') {
        await this.devideUpgrade()

        // 升级以后需要重新更新一下设备信息
        await ObuSystemInfo()
      }

      let cmdRandNum = await this.getVFJObuActive()

      let vFJObuInfo = await this.getObuActivation(cmdRandNum);

      return vFJObuInfo

      // 激活逻辑
      // const res = await ActiveDevice({
      //   device,
      //   params: {
      //     orderNo: this.data.orderNo,
      //   },
      //   disconnectCallback: () => {
      //     that.configSearchFail(250)
      //   },
      //   isNeedContect: false,
      //   isNeedReadDevice: false
      // })
      // return res
    }
  },

  // 获取激活指令
  async getVFJObuActive() {
    let cmdArr = [HOME_DIRECTORY, RANDOM_NUMBER];
    let res = await transCmd(cmdArr, '20')

    let cmdResult = res.cmdResult ? res.cmdResult.split(',') : []

    var status = cmdResult[1].substring(cmdResult[1].length - 4, cmdResult[1].length);

    if (status == "9000") {
      let cmdRandNum = cmdResult[1].substring(0, cmdResult[1].length - 4);
      return cmdRandNum
    } else {
      wx.showToast("RANDOM_NUMBER指令长度不符" + cmdResult[1]);
    }

  },

  async getObuActivation(cmdRandNum) {
    let vehicleArr = this.data.plateNum.split('_')

    let params = {
      // Flag: '0001',
      // ContractSN: this.data.obuId,
      // Random: cmdRandNum,
      cardId: this.data.cardId,
      obuId: this.data.obuId,
      vehiclePlate: vehicleArr[0],
      vehiclePlateColor: vehicleArr[1],
      vehicleType: this.data.vehicleType,
      random: cmdRandNum
    }

    let resData = await API.ETC.getVFJObuActive(params)

    let APDUInfo = resData.data

    let cmdArr = APDUInfo.APDU.split(',')

    let res = await transCmd(cmdArr, '20')

    let cmdResult = res.cmdResult ? res.cmdResult.split(',') : []

    if (cmdResult && cmdResult.length) {
      if (cmdResult[0] === '9000') {

        await this.activeSaveRecords()
        wx.showLoading({
          title: '激活成功'
        })
        return {
          code: 0,
          msg: "激活成功"
        }
      } else {
        wx.showToast('获取设备信息错误！')
      }
    } else {
      wx.showToast('获取设备信息错误！')
    }

  },

  // 二次设备激活保存记录
  async activeSaveRecords() {
    let data = this.data
    let vehicleArr = data.plateNum.split('_')
    let params = {
      vehicleId: data.plateNum,
      vehiclePlate: vehicleArr[0],
      vehiclePlateColor: vehicleArr[1],
      cardId: data.cardId,
      obuId: data.obuId,
      vehPosImgUrl: data.vehPosImgUrl,
      vehNegImgUrl: data.vehNegImgUrl,
      vehBodyUrl: data.vehBodyUrl,
      installImgUrl: data.installImgUrl,
      type: 2,
      activeType: 2,
      sourceType: "CHANNEL"
    }
    await API.ETC.activeSaveRecords(params).then(res => {
      // wx.navigateBack()
    })
  },

  configActiveSuccess() {
    wx.redirectTo({
      url: 'plugin://issuer-plugin/activeStatus' + "?obu=" + this.data.obuIdStr + "&card=" + this.data.cardIdStr + "&type=1",
    })
  },
  // 格式化obu号
  configEtcNumber(data) {
    this.setData({
      obuIdStr: formatCardNumber(data.serialNumber),
      cardIdStr: formatCardNumber(data.faceCardNum),
    })
  },
  // 配置搜索失败
  configSearchFail(code) {
    let failMsg = "请检查手机蓝牙、ETC蓝牙是否均已打开，连接过程中将手机和ETC设备尽量靠近"
    let failTitle = "未检测到ETC设备"
    if (code == -111 || code == -112) {
      failMsg = code == -111 ? "手机蓝牙权限未授权，无法读取蓝牙是否开启状态，请打开蓝牙" : "手机定位权限获取失败,请前往手机系统设置开启手机定位服务"
      failTitle = "蓝牙状态异常"
    }
    this.setData({
      showType: 2,
      searchFailMsg: failMsg,
      searchFailTitle: failTitle,
    })
  },
  tapActiveFailSure() {
    failPluginData(this.data.activeFailMsg);
    this.setData({
      activeFail: false,
    });
    wx.navigateBack()
  },

  // 获取Obu设备详情
  async getObjDetail() {
    let cmdArr = [HOME_DIRECTORY, OBU_SYSTEM_FILE, RANDOM_NUMBER]
    let res = await transCmd(cmdArr, '20')
    console.log('设备卡签信息：1111')
    console.log(res)
    let cmdResult = res.cmdResult ? res.cmdResult.split(',') : []
    if (cmdResult && cmdResult.length) {

      var status = cmdResult[1].substring(cmdResult[1].length - 4, cmdResult[1].length);
      //第一次获取随机数
      if (status == "9000") {
        this.data.obuInfo.obuId = cmdResult[1].substring(20, 36);
        this.data.obuInfo.version = cmdResult[1].substring(18, 20);
        this.data.obuInfo.chipSn = cmdResult[1].substring(0, 8)
        console.log(this.data.obuInfo)

      } else {
        wx.showToast('获取设备信息错误！')
      }
    } else {
      wx.showToast('获取设备信息错误！')
    }
    return true
  },

  // 获取卡信息
  async getCardId() {
    let cmdArr = [HOME_DIRECTORY, APPLICATION_DIRECTORY, CMD_READBINARY, CMD_GETBALANCE];

    let res = await transCmd(cmdArr, '10')

    let cmdResult = res.cmdResult ? res.cmdResult.split(',') : []

    let str = cmdResult[2].substring(cmdResult[2].length - 4, cmdResult[2].length); //判断是否为9000
    let str3 = cmdResult[3].substring(cmdResult[3].length - 4, cmdResult[3].length); //判断是否为9000
    if (str == "9000" || str3 == "9000") {
      if (cmdResult[2].length > 86 || cmdResult[3] >= 12) {
        this.data.cardInfo.cardId = cmdResult[2].substring(20, 40);
        this.data.cardInfo.version = cmdResult[2].substring(18, 20)
        console.log(this.data.cardInfo)

      } else {
        wx.showModal({
          title: '提示',
          content: "CMD_READBINARY指令长度不符" + cmdResult
        })
      }
      return;
    } else {
      return true
    }
    return true
  },

  // 设备升级
  async devideUpgrade() {
    return new Promise(async resolve => {
      let params = {
        contractSN: this.data.obuInfo.obuId, //OBU合同序列号 16位
        chipSn: this.data.obuInfo.chipSn, //OBU晶片序列号 8位
        issueMode: 'UPG', //发行模式
        issueType: 'SCOBU', //发行发行类型
        cardVersion: this.data.cardInfo.version, //卡版本号
        obuVersion: this.data.obuInfo.version //OBU版本号
      }

      let applyData = await API.ETC.getVfjApply4Upgrade(params)

      console.log('9999 获取设备升级指令')
      console.log(applyData)

      if (!applyData || (applyData && applyData.code !== 0)) {
        // this.showModals('获取升级指令失败')
        return false
      }

      let applyDataRes = applyData.data

      if (this.data.obuInfo.version == '48' || this.data.obuInfo.version == '49') {
        const updateEsDat = await this.updateEs('GEN_OBEIC_UPG', applyDataRes);
        if (!updateEsDat) return false;
      }

      if (this.data.cardInfo.version == '48' || this.data.cardInfo.version == '49') {
        const updateEsDatTwo = await this.updateEs('GEN_OBESAM_UPG', applyDataRes);
        if (!updateEsDatTwo) return false;
      }

      const upgradeDoneData = await API.ETC.vfjUpgradeDone({
        issueSerialNo: applyDataRes.issueSerialNo, //发行订单号
      });
      if (!upgradeDoneData || (upgradeDoneData && upgradeDoneData.code !== 0)) return false;

      // 升级完成后完成后重新写入
      const cardres = await this.getCardIdAfter();
      if (!cardres) return false;
      const obures = await this.getObuIdAfter();
      if (!obures) return false;

      resolve(true)
    })

    // wx.showModal({
    //   title: '提示',
    //   content: '设备升级完成',
    //   showCancel: false,
    //   complete: (res) => {
    //     if (res.confirm) {
    //       wx.navigateBack()
    //     }
    //   }
    // })
  },

  // 获取发行指令脚本
  async updateEs(type, applyData) {
    wx.showLoading({
      title: '设备升级中'
    })

    let getCommanData = await API.ETC.getVfjGetCommands({
      cardNo: applyData.cardNo, //卡片序列号
      wareId: type, //OBU的物料代码 OBE-SAM通道 GEN_OBESAM_UPG     OBE-IC通道 GEN_OBEIC_UPG
      issueSerialNo: applyData.issueSerialNo, //发行订单号
    })

    if (!getCommanData || (getCommanData && getCommanData.code !== 0)) {
      // this.showModals('获取发行脚本指令失败')
      return false
    };
    let getCommanDataRes = getCommanData.data
    //指令解析
    const result = getCommanDataRes.commands;
    const array = result.split('~');
    let cmdType = type == 'GEN_OBESAM_UPG' ? '20' : '10';
    for (const element of array) {
      console.log('updateEs', element, cmdType);
      // 让出主线程，确保UI更新
      await new Promise(resolve => setTimeout(resolve, 0));
      console.log("进来了", element.charAt(0), )
      if (element.charAt(0) === 'D' || element.charAt(0) === 'R') {
        await this.processDirectCommand(element, cmdType);
      } else if (element.charAt(0) === 'K') {
        await this.processKeyExchange(element, cmdType, applyData);
      } else if (element.charAt(0) === 'E') {
        await this.processExtAuth(element, cmdType, applyData);
      } else if (element === 'SESAM') {
        cmdType = '20';
      } else {
        cmdType = '10';
      }
    }
    return true;
  },

  processDirectCommand(element, cmdType) {
    // 添加随机延迟，避免连续请求
    return transCmdArrAfter(element.substring(1), cmdType);
  },


  async processKeyExchange(element, cmdType, applyData) {
    const ranData = await transCmdArrAfter('0084000004', cmdType);
    console.log("ranData", ranData)
    const exchangeKeyData = await API.ETC.vfjExchangeKey({
      key: element.substring(1),
      random: ranData['0084000004'][0].substring(0, 8),
      issueSerialNo: applyData.issueSerialNo
    });
    if (!exchangeKeyData) throw new Error('密钥置换失败');
    console.log("exchangeKeyData", exchangeKeyData)
    let exchangeKeyDataRes = exchangeKeyData.data
    return transCmdArrAfter(exchangeKeyDataRes.apdu, cmdType);
  },

  async processExtAuth(element, cmdType, applyData) {
    const ranData = await transCmdArrAfter('0084000004', cmdType);

    const extAuth4IssData = await API.ETC.vfjExtAuth4Iss({
      keyType: element.substring(1),
      random: ranData['0084000004'][0].substring(0, 8),
      issueSerialNo: applyData.issueSerialNo,
    });
    console.log("extAuth4IssData", extAuth4IssData)
    if (!extAuth4IssData) throw new Error('外部认证失败');
    let extAuth4IssDataRes = extAuth4IssData.data
    return transCmdArrAfter(extAuth4IssDataRes.apdu, cmdType);
  },

  // 读卡
  async getCardIdAfter() {
    return new Promise(async (resolve, reject) => {
      try {
        let cmdArr = [HOME_DIRECTORY, APPLICATION_DIRECTORY, CMD_READBINARY, CMD_GETBALANCE];
        const res = await transCmdAfter(cmdArr, "10");

        let cmdResult = res.cmdResult ? res.cmdResult.split(',') : []

        let str = cmdResult[2].substring(cmdResult[2].length - 4, cmdResult[2].length); //判断是否为9000
        let str3 = cmdResult[3].substring(cmdResult[3].length - 4, cmdResult[3].length); //判断是否为9000
        if (str == "9000" || str3 == "9000") {
          if (cmdResult[2].length > 86 || cmdResult[3] >= 12) {
            // card.cardId = cmdResult[2].substring(20, 40);
            // card.cardId = '52012511110201724155';
            this.data.cardInfo.cardId = cmdResult[2].substring(20, 40);
            this.data.cardInfo.version = cmdResult[2].substring(18, 20);
            console.log(9999999)
            console.log(this.data.cardInfo)
            wx.hideLoading()
            resolve(true);
            return
          } else {
            console.log("CMD_READBINARY指令长度不符" + cmdResult[2]);
            this.showModals("CMD_READBINARY指令长度不符" + cmdResult[2])
            resolve(false);
            return
          }
        }
        console.log("CMD_READBINARY指令长度不符" + cmdResult[2]);
        this.showModals("CMD_READBINARY指令长度不符" + cmdResult[2])
        resolve(false);
        return
      } catch (e) {
        //TODO handle the exception
        console.log('错误错误', e);
        reject(e);
      }
    })
  },

  // 读取签
  getObuIdAfter() {
    return new Promise(async (resolve, reject) => {
      try {
        let cmdArray = [HOME_DIRECTORY, OBU_SYSTEM_FILE, RANDOM_NUMBER];
        const res = await transCmdAfter(cmdArray, "20");
        let cmdResult = res.cmdResult ? res.cmdResult.split(',') : []
        var status = cmdResult[1].substring(cmdResult[1].length - 4, cmdResult[1].length);
        console.log('获取OBU号执行结果' + status, cmdResult)
        //第一次获取随机数
        if (status == "9000") {
          this.data.obuInfo.obuId = cmdResult[1].substring(20, 36);
          this.data.obuInfo.version = cmdResult[1].substring(18, 20);
          this.data.obuInfo.chipSn = cmdResult[1].substring(0, 8)
          resolve(true);
          console.log("success")
          return
        } else {
          this.showModals('获取设备信息错误！')
          resolve(false);
          return
        }
      } catch (e) {
        //TODO handle the exception
        console.log('错误错误', e);
        reject(e);
      }
    })
  },

  showModals(content) {
    wx.showModal({
      title: '提示',
      content: content,
      showCancel: false
    })
  },
})