zhywpt-plug/wxminipro/plugin/utils/active-tools/active-device-tools.js

import {
  configBlueStateMsg,
  decode,
  hex2int
} from '../etc-sdk-tool/gbk-tool'
import {
  jsonToString
} from '../obj-tools'
import {

  connectAndInit,
  disconnect,
  transCmd,
  getIccFile15,
  getObuSystemInfo,

  activeObu,
  getDeviceCustomizedInfo,
} from '../etc-sdk-tool/etc-sdk-tool'
import activeCode from './active-device-code'
import {
  API
} from '../../network/etcApi'

const network = require('../../network/index')
const DevResult = {
  code: 0,
  msg: '', //信息
  data: []
}


let issueResult = {
  cmd: '',
  cmdType: '',
  stepNo: '',
  transOrderId: '',
  OrderNo: '',
  isOnline: '',
}

let _checkStatusCallback = Function()
let _isDeviceEnd = false
let _disConnectCallback = Function()
/// -------------------- 公开方法 ----------------------- ///


// 激活设备
export async function ActiveDevice({
  device,
  params,
  isNeedShowLoad = true,
  isNeedContect = true,
  disconnectCallback = Function(),
} = {}) {
  _disConnectCallback = disconnectCallback
  activeCode.params = params
  activeCode.isNeedShowLoad = isNeedShowLoad || true
  if (isNeedContect) {
    _configNormalActiveCode()
    return await _connectDevice(device, 1)
  } else {
    return await _configIssueApply()
  }
}


// 重新激活
export async function ActiveAgainDevice({
  device,
  params,
  isNeedShowLoad = true,
  disconnectCallback = Function(),
} = {}) {
  activeCode.bussType = 4
  return await _againObuIssueCheck()

}

// 设备校验
export async function EquipmentDetection({
  device,
  params,
  isNeedShowLoad = true,
  checkStatusCallback = Function(),
} = {}) {
  _disConnectCallback = checkStatusCallback
  _configNormalActiveCode()
  activeCode.params = params
  activeCode.isNeedShowLoad = isNeedShowLoad || true
  return await _connectDevice(device, 11)
}



/**
 * 卡片检测 
 *
 * @param device 设备对象
 * @param params 检测参数，默认为空对象，可包含 OrderId 和 PlateNumber 属性
 * @param isNeedShowLoad 是否需要显示加载动画，默认为 true
 * @param checkStatusCallback 检测状态回调函数，默认为 null
 * @returns 返回连接设备的 Promise 对象
 */
export async function CardDetection({
  device,
  params,
  isNeedShowLoad = true,
  disconnectCallback = Function(),
} = {}) {
  _disConnectCallback = disconnectCallback
  _configNormalActiveCode()
  activeCode.params = params
  activeCode.isNeedShowLoad = isNeedShowLoad || true
  return await _connectDevice(device, 2)
}

/**
 * 重新激活设备
 *
 * @async
 * @returns {Promise<any>} 返回一个Promise对象，表示设备连接的结果
 */
export async function Reactivate() {
  const {
    device,
    params,
    isNeedShowLoad,
    disconnectCallback
  } = arguments[0]
  _disConnectCallback = disconnectCallback
  _configNormalActiveCode()
  activeCode.params = params
  activeCode.isNeedShowLoad = isNeedShowLoad || true
  return await _connectDevice(device, 4)
}
/**
 * 断开与设备的连接
 *
 * @returns 返回断开连接的结果
 */
export async function DisConnectDevice() {
  _isDeviceEnd = true
  const res = await disconnect()
  console.log(jsonToString(res))
  return res
}
/**
 * 重新读取设备信息
 * 
 * @param {*} device 
 * @param {*} bussType 
 */
export async function ObuSystemInfo() {
  return await _obuSystemInfo()
}

/// -------------------- 私有方法 ----------------------- ///

/// -------------------- 设备相关

async function _connectDevice(device, bussType) {
  console.log('准备连接设备')
  const deviceName = device.name
  activeCode.deviceName = deviceName
  activeCode.bussType = bussType
  console.log('设备名称:' + deviceName)
  if (!device || !device.name) {
    return {
      code: 251,
      msg: "设备名称为空"
    }
  }
  _conFigCurrentCallBack(200, deviceName)
  const res = await connectAndInit(device, () => {
    if (!_isDeviceEnd) {
      if (activeCode.isNeedShowLoad) {
        console.log('连接断开隐藏加载框')
        wx.hideLoading()
      }
      console.log('设备连接断开')
      typeof _disConnectCallback === 'function' && _disConnectCallback()
    }
  })
  if (res.code == 0) {
    if (bussType == 1) {
      return await _configIssueApply()
    } else {
      return await _obuSystemInfo()
    }
  }
  _conFigCurrentCallBack(250, deviceName)
  res.code = 250
  return res
}



/// -------------------- OBU相关

/// -------------------- OBU信息读取相关
/**
 * 获取系统信息并进行处理
 *
 * @param type 类型，默认为0
 * @returns 返回处理结果
 */
async function _obuSystemInfo(type = 0) {
  _conFigCurrentCallBack(300)
  const res = await getObuSystemInfo()
  console.log('获取系统信息结果：' + jsonToString(res))
  if (res.code == 0) {
    console.log('获取系统信息成功')
    const sytem = res.data
    if (sytem) {
      console.log('OBU系统信息：' + sytem)
      const contractType = sytem.substr(16, 2)
      const contractVersion = sytem.substr(18, 2)
      const serialNumber = sytem.substr(20, 16)
      const star = sytem.substr(36, 8)
      const end = sytem.substr(44, 8)
      const activeState = sytem.substr(52, 2)
      const lssuer = sytem.substr(8, 8)
      activeCode.contractType = contractType
      activeCode.contractVersion = contractVersion
      activeCode.serialNumber = serialNumber
      activeCode.startTime = star
      activeCode.expireTime = end
      activeCode.acState = activeState == '01' ? true : false
      activeCode.lssuer = lssuer
      console.log('协约类型' + contractType)
      console.log('合同版本' + contractVersion)
      console.log('合同序列号' + serialNumber)
      console.log('开始时间' + star)
      console.log('结束时间' + end)
      console.log('激活状态' + activeState)
      console.log('发行方' + lssuer)

      if (type == 0) {
        if (
          activeCode.bussType == 2 ||
          activeCode.bussType == 11 ||
          activeCode.bussType == 4 ||
          activeCode.bussType == 12
        ) {
          return _iccFile15Info()
        } else if (activeCode.bussType == 1) {
          return _configIssueApply()
        }
      } else {
        if (activeCode.bussType == 1) {
          if (activeCode.acState == true) {
            return _iccFile15Info(1)

          } else {
            return _configFailCallBack({
              msg: '标签位激活失败',
            })
          }
        } else if (activeCode.bussType == 4) {
          if (activeCode.acState == true) {
            activeCode.vehiclePlate = activeCode.cardPlateNumber
            activeCode.vehiclePlateColor = activeCode.cardPlateColor
            return _configSuccessCallBack("重新激活成功")
          } else {
            return {
              code: -1,
              msg: '重新激活失败',
            }
          }
        } else if (activeCode.bussType == 2) {
          return _configSuccessCallBack('卡签检测成功')
        }
      }
    }
  }
  _conFigCurrentCallBack(350)
  return res
}



/// -------------------- OBU信息写入相关

/// -------------------- ICC相关

async function _iccFile15Info(type = 0) {
  _conFigCurrentCallBack(304)
  const res = await getIccFile15()
  if (res.code == 0) {
    let data = res.data
    console.log('读取CPU 0015文件：' + data)
    let sytem = data
    /// 卡片类型
    let cardType = sytem.substr(16, 2)
    /// 卡片版本号
    let cardVersion = sytem.substr(18, 2)
    /// 卡片网络编号 + 用户卡片内部编号
    let cardNumber = sytem.substr(20, 20)
    activeCode.cardVersionHex = cardVersion;
    activeCode.cardVersion = hex2int(cardVersion)
    activeCode.cardType = hex2int(cardType)
    activeCode.faceCardNum = cardNumber
    /// 卡片内部编号
    activeCode.cardUid = sytem.substr(24, 16)
    console.log('卡片类型' + activeCode.cardType)
    console.log('卡号' + activeCode.faceCardNum)
    console.log('卡版本' + activeCode.cardVersion)
    if (sytem.length > 84) {
      /// 启用时间
      let cardStar = sytem.substring(40, 48)
      /// 到期时间
      let cardEnd = sytem.substring(48, 56)
      /// 车牌号码
      let plateNo = sytem.substring(56, 80)
      /// 车牌颜色
      let plateColor = hex2int(sytem.substring(82, 84))
      if (
        plateNo == '000000000000000000000000' ||
        plateNo == 'ffffffffffffffffffffffff' ||
        plateNo == 'FFFFFFFFFFFFFFFFFFFFFFFF'
      ) {
        console.log('车牌号为空')
        activeCode.cardPlateNumber = '未知车牌'
        activeCode.cardPlateColor = '-1'
        activeCode.vehiclePlate = '未知车牌'
        activeCode.vehiclePlateColor = '-1'
      } else {
        activeCode.cardPlateCode = plateNo
        activeCode.cardPlateColor = plateColor
        activeCode.cardPlateNumber = decode(plateNo)
      }
      activeCode.plateNumber = activeCode.cardPlateNumber
      activeCode.cardStar = cardStar
      activeCode.cardEnd = cardEnd
      activeCode.cardVehicleType = hex2int(sytem.substring(84, 86))
      console.log('卡开始时间' + cardStar)
      console.log('卡结束时间' + cardEnd)
      console.log('车牌号十六进制' + plateNo)
      console.log('车牌颜色' + plateColor)
      console.log('车型' + activeCode.cardVehicleType)
    }
    if (activeCode.bussType == 1) {
      if (type == 0) {
        return _cardIssueCheck()
      } else {
        return _configSuccessCallBack('激活成功')
      }

    } else if (activeCode.bussType == 2 || activeCode.bussType == 12) {
      if (activeCode.cardPlateNumber == '未知车牌' && activeCode.bussType == 12) {
        activeCode.plateNumber = '未知车牌'
        activeCode.vehiclePlate = '未知车牌'
        activeCode.vehiclePlateColor = '-1'
        activeCode.catInfo = {
          licensePlate: '未知车牌',
        }
        return _configSuccessCallBack('检测成功')
      } else {
        if (activeCode.bussType == 2) {
          if (activeCode.cardPlateNumber == '未知车牌') {
            return _configSuccessCallBack('检测成功')
          }
          return _obuVehicleInfo()
        } else if (activeCode.bussType == 12) {
          activeCode.vehiclePlate = activeCode.cardPlateNumber
          activeCode.vehiclePlateColor = activeCode.cardPlateColor
          return _configSuccessCallBack('检测成功')
        }
      }
    } else if (activeCode.bussType == 11) {
      return _getDeviceCustomizedInfo()
    } else if (activeCode.bussType == 4) {
      if (activeCode.cardPlateNumber == '未知车牌') {
        return _configFailCallBack({
          msg: '设备未激活,请先激活设备',
        })
      } else {
        return _againObuIssueCheck()
      }
    }
  } else {
    _conFigCurrentCallBack(354)
  }

  return res
}

async function _getDeviceCustomizedInfo() {
  console.log("获取设备定制化信息")
  const res = await getDeviceCustomizedInfo();
  console.log(res)
  if (res.code == 0) {
    activeCode.devInfoCustom.pillar = res.data
    if (res.data) {
      return _configSuccessCallBack('校验信息获取成功')
    } else {
      return _configFailCallBack({
        code: 257
      })
    }
  } else {
    activeCode.devInfoCustom.pillar = true
  }
  return _configSuccessCallBack('校验信息获取成功')
}


async function _againObuIssueCheck() {
  _conFigCurrentCallBack(402)
  const res = await activeObu(_getAgainObuMac)
  if (res.code == 0) {
    return _obuSystemInfo(1);
  } else {
    _conFigCurrentCallBack(352);
  }
  return res;
}




/// -------------------- 网络相关 ---------------------- ///


// 重新激活

async function _getAgainObuMac(randNum, callback) {
  console.log("获取随机数", randNum)
  let params = {
    // Flag: '0001',
    // ContractSN: activeCode.serialNumber,
    // Random: randNum
    cardId: activeCode.cardId,
    obuId: activeCode.obuId,
    vehiclePlate: activeCode.vehiclePlate,
    vehiclePlateColor: activeCode.vehiclePlateColor,
    vehicleType: activeCode.vehicleType,
    random: cmdRandNum
  }
  console.log(params)
  let resData = await API.ETC.getVFJObuActive(params)
  console.log(resData);
  const {
    code,
    data
  } = resData;

  if (code == 0) {
    DevResult.code = 0;
    DevResult.data = data.APDU;
  } else {
    DevResult.code = 3;
  }
  typeof callback === 'function' && callback(DevResult)
}

// 新版激活接口

async function _instApply() {
  _conFigCurrentCallBack(750, "正在激活,请等待")
  let params = {}

  params.orderNo = activeCode.params.orderNo;
  params.cardId = activeCode.faceCardNum;
  params.obuId = activeCode.serialNumber;
  params.cardVersion = activeCode.cardVersionHex
  params.obuVersion = activeCode.contractVersion
  const res = await network.etc.instApply(
    params.orderNo,
    params.cardId,
    params.obuId,
    params.cardVersion,
    params.obuVersion,
  );
  console.log(res)
  if (res.code == 0) {
    return _configIssueNetWorkData(res.data)
  } else {
    return _configFailCallBack({
      msg: (res.message || '发行指令申请失败,请稍后重试') + res.code
    })
  }
}


async function _instCallBack(cmdResult) {
  const res = await network.etc.instCallBack(
    issueResult.transOrderId,
    issueResult.cmd,
    cmdResult,
    issueResult.stepNo,
  )
  if (res.code == 0) {
    return _configIssueNetWorkData(res.data)
  } else {
    return _configFailCallBack({
      msg: (res.message || '发行指令回传失败,请稍后重试') + res.code
    })
  }
}





// 老版本




/// 配置发行指令申请
/// issueType - 指令类型 1-卡 2-签
async function _configIssueApply() {
  return await _instApply()
  // const params = {
  // 	...activeCode.params,
  // };
  // _conFigCurrentCallBack(750, "正在激活,请等待")
  // const res = await apiIssueApply(params)
  // console.log(res)
  // if (res.code == 0) {
  // 	return _configIssueNetWorkData(res.data)
  // } else {
  // 	return _configFailCallBack({
  // 		msg: (res.message || '发行指令申请失败,请稍后重试') + res.code
  // 	})
  // }
}
/// 配置发行指令回传
async function _configIssueCallback(cmdResult) {
  return await _instCallBack(cmdResult);
  // const params = {
  // 	openId: activeCode.params.openId,
  // 	transOrderId: issueResult.transOrderId,
  // 	cmd: issueResult.cmd,
  // 	cmdResult,
  // 	stepNo: issueResult.stepNo,
  // };
  // const res = await apiIssueCallback(params)
  // if (res.code == 0) {
  // 	return _configIssueNetWorkData(res.data)
  // } else {
  // 	return _configFailCallBack({
  // 		msg: (res.message || '发行指令回传失败,请稍后重试') + res.code
  // 	})
  // }
}


async function _configIssueNetWorkData(data) {
  issueResult = data;
  const cmdArr = data.cmd.split(',')
  const cmdType = data.cmdType == "CARD" ? '10' : '20'

  if (issueResult.stepNo == 100) {
    return _obuSystemInfo(1)
  } else {
    const res = await transCmd(cmdArr, cmdType)
    if (res.code == 0) {
      return await _configIssueCallback(res.cmdResult)
    } else {
      return _configFailCallBack({
        msg: res.msg || "激活失败"
      })
    }
  }
}













/**
 * 配置成功回调函数
 *
 * @param msg 成功消息内容
 * @returns 配置成功后的返回对象
 */
function _configSuccessCallBack(msg) {
  _conFigCurrentCallBack(500)
  return {
    code: 0,
    data: activeCode,
    msg: msg,
  }
}
/**
 * 处理网络请求失败的情况
 *
 * @param data 任意类型的数据，表示请求返回的数据
 * @param msg 错误信息字符串
 * @returns 返回包含错误码、数据和错误信息的对象
 */
function _configFailCallBack({
  data = activeCode,
  msg = '网络请求失败',
  code = -1
} = {}) {
  _conFigCurrentCallBack(550, msg)
  return {
    code,
    data: data,
    msg: msg,
  }
}
/**
 * 回调方法
 */
function _conFigCurrentCallBack(code, name) {
  const {
    type,
    msg
  } = configBlueStateMsg(code, name)

  if (type == 1) {
    typeof _checkStatusCallback === 'function' && _checkStatusCallback(msg)
    if (activeCode.isNeedShowLoad) {
      wx.showLoading({
        title: msg,
      })
    }
  } else {
    _isDeviceEnd = true
    if (activeCode.isNeedDisConnect) {
      console.log("_conFigCurrentCallBack")
      console.log("执行断开连接设备")
      DisConnectDevice()
    }

    if (activeCode.isNeedShowLoad && activeCode.isNeedDisConnect) {
      wx.hideLoading()
    }
  }
  return type
}

/**
 * 配置普通激活码的属性
 */
function _configNormalActiveCode() {
  _isDeviceEnd = false
  activeCode.params = {
    OrderId: '',
    PlateNumber: '',
  }
  /// 卡片版本号
  activeCode.cardVersion = ''
  // 卡片类型
  activeCode.cardType = ''
  /// 卡片里 车型 1 客车、2 货车
  activeCode.cardVehicleType = '1'
  /// 合同类型
  activeCode.contractType = ''
  /// 合同版本
  activeCode.contractVersion = ''
  /// 卡表面号, 网络编号的20位表面号
  activeCode.faceCardNum = ''
  /// 卡表面号,不带网络编号的16位表面号
  activeCode.cardUid = ''
  /// 车牌号编码
  activeCode.vehiclePlateCode = ''
  /// 车牌号
  activeCode.vehiclePlate = ''
  /// 车牌号
  activeCode.plateNumber = ''
  /// OBU 车型 1 客车、2 货车
  activeCode.vehicleType = '1'
  /// 车牌颜色
  activeCode.vehiclePlateColor = '0'
  /// 卡片车牌号码
  activeCode.cardPlateNumber = ''
  /// 卡片车牌颜色
  activeCode.cardPlateColor = '-1'
  /// 办理状态
  /// 0、开始发行
  /// 10、上传图片成功、
  /// 20、写Obu成功
  /// 30、写卡成功
  /// 40、激活成功
  /// 50、二次已激活
  activeCode.issueState = 10

  /// OBU序列号,16位合同序列号
  activeCode.serialNumber = ''
  /// 服务供应商
  activeCode.supplier = '贵州'
  /// 订单号
  activeCode.OrderNo = ''
  /// 开始时间
  activeCode.startTime = ''
  /// 结束时间
  activeCode.expireTime = ''
  /// 业务类型 1 激活 4 二次激活 2 卡签检测
  activeCode.bussType = 1
  /// 激活状态
  activeCode.acState = false
  /// obu mac 地址
  activeCode.obuId = 'FFFFFFFF'
  /// 发行方标识
  activeCode.lssuer = ''
  /// 卡片激活开始时间
  activeCode.cardStar = ''
  /// 卡片激活结束时间
  activeCode.cardEnd = ''
  /// 电量
  activeCode.electricity = '40'
  ///  true 天线关闭 false 天线打开
  activeCode.equipmentState = false
  /// 是否支持 打开 和 关闭 天线
  activeCode.isShowEquipment = false
  activeCode.content = ''
  /// 换卡换签 网络返回数据
  activeCode.netData = {}
  /// 车辆解密信息
  activeCode.catInfo = {
    licensePlate: '未知车牌',
  }
  /// 1 换卡 2 换签 3 全套
  activeCode.afterType = '1'
  /// 设备名字
  activeCode.deviceName = ''
  /// 0 支持 1 不支持
  activeCode.supportLock = '0'
  /// 回调
  activeCode.callBack = ''
  /// 是否显示默认加载 动画
  activeCode.isNeedShowLoad = true
  /// 是否需要校验设备名字
  activeCode.isNeedCheckName = true
  activeCode.isNeedDisConnect = false
}