subject-two/entry/src/main/ets/common/service/initable.ts

// @ts-nocheck
import { initCenterCache, initCenterCacheByKSPT, initEsModel, initialization } from '../../api/index';
import { dateFormat } from '../utils/tools';
import AccountTable from '../database/tables/AccountTable';
import MA_MARKRULE from '../constants/MA_MARKRULE';
import MA_SYSTEMPARM from '../constants/MA_SYSTEMPARM';
import MA_MAP_COLLECT from '../constants/MA_MAP_COLLECT';
import MA_MAP_COLLECT_SHAPE from '../constants/MA_MAP_COLLECT_SHAPE';
import MA_MAP_ITEMCLASS from '../constants/MA_MAP_ITEMCLASS';
import MA_MAP_POINT from '../constants/MA_MAP_POINT';
import MA_MAP_POINT_ITEM from '../constants/MA_MAP_POINT_ITEM';
import MA_MAP_ROAD from '../constants/MA_MAP_ROAD';
import MA_MAP_ROAD_LANE from '../constants/MA_MAP_ROAD_LANE';
import MA_MAP_SUBITEM from '../constants/MA_MAP_SUBITEM';
import MA_SYSSET from '../constants/MA_SYSSET';
import ES_CARINFO from '../constants/ES_CARINFO';
import ES_EXAMPOINTDETAIL from '../constants/ES_EXAMPOINTDETAIL';
import MA_MARKRULESET from '../constants/MA_MARKRULESET';
import MA_CDSBINFO from '../constants/MA_CDSBINFO';
import MA_ITEMINFO from '../constants/MA_ITEMINFO';
import MA_T_CARPARMSET from '../constants/MA_T_CARPARMSET';
import ES_CAR_VIDEO_PARAMETER from '../constants/ES_CAR_VIDEO_PARAMETER';
import IpConfigTable from '../constants/IpConfigTable';
import CommonConstants from '../constants/CommonConstants';
import DeviceInfoTable from '../constants/DeviceInfoTable';
import USER from '../constants/USER';
import USERLIST from '../constants/USERLIST';
import util from '@ohos.util';
import FileModel from '../../pages/judgeSDK/utils/fileModel';
import FileUtil from '../../common/utils/File';
import { GlobalConfig } from '../../config/index';
import prompt from '@ohos.promptAction'

// @ts-nocheck
//读表
//参数平台
const map = {
  'MA_MARKRULE': MA_MARKRULE,
  'MA_SYSTEMPARM': MA_SYSTEMPARM,
  'MA_MAP_COLLECT': MA_MAP_COLLECT,
  'MA_MAP_COLLECT_SHAPE': MA_MAP_COLLECT_SHAPE,
  'MA_MAP_ITEMCLASS': MA_MAP_ITEMCLASS,
  'MA_MAP_POINT': MA_MAP_POINT,
  'MA_MAP_POINT_ITEM': MA_MAP_POINT_ITEM,
  'MA_MAP_ROAD': MA_MAP_ROAD,
  'MA_MAP_ROAD_LANE': MA_MAP_ROAD_LANE,
  'MAP_SUBITEM': MA_MAP_SUBITEM,
  'MA_SYSSET': MA_SYSSET,
  'ES_CARINFO': ES_CARINFO,
  'ES_EXAMPOINTDETAIL': ES_EXAMPOINTDETAIL,
  'MA_MARKRULESET': MA_MARKRULESET,
  'MA_CDSBINFO': MA_CDSBINFO,
  'MA_ITEMINFO': MA_ITEMINFO,
  'MA_T_CARPARMSET': MA_T_CARPARMSET,
  'ES_CAR_VIDEO_PARAMETER': ES_CAR_VIDEO_PARAMETER,
  'USER': USER,
  'USERLIST': USERLIST,
  'IpConfigTable': IpConfigTable,
  'DeviceInfoTable': DeviceInfoTable,
  'CommonConstants': CommonConstants
}
const centerToMap = {
  'ItemInfo': MA_ITEMINFO,
  'MarkRule': MA_MARKRULE,
  'SystemParm': MA_SYSTEMPARM,
  'mapCollectList': MA_MAP_COLLECT,
  'mapCollectshapeList': MA_MAP_COLLECT_SHAPE,
  'Map_Collect': MA_MAP_COLLECT,
  'Map_Collect_Shape': MA_MAP_COLLECT_SHAPE,
  'Map_ItemClass': MA_MAP_ITEMCLASS,
  'Map_Point': MA_MAP_POINT,
  'Map_Point_Item': MA_MAP_POINT_ITEM,
  'Map_Road': MA_MAP_ROAD,
  'Map_Road_Lane': MA_MAP_ROAD_LANE,
  'Map_SubItem': MA_MAP_SUBITEM,
  'Sysset': MA_SYSSET,
  'CarInfo': ES_CARINFO,
  // 'ES_EXAMPOINTDETAIL':ES_EXAMPOINTDETAIL,
  'MarkRuleSet': MA_MARKRULE,
  'Cdsbinfo': MA_CDSBINFO,
  'T_CarParmSet': MA_T_CARPARMSET,
  // 'ES_CAR_VIDEO_PARAMETER':ES_CAR_VIDE0pO_PARAMETER
}

function sqlInsertCommonFn(tableName, resultArr, context?, delFlag = true) {
  return new Promise((resolve, reject) => {
    const accountTable = new AccountTable(() => {
    }, map[tableName], context);
    accountTable.getRdbStore(() => {
      accountTable.query('0', async (result) => {
        console.log('teststet3',)

        // console.log('表长度',result.length,tableName)
        if (result.length == 0) {
          console.log('sqlsqlinsert',resultArr.length)
          if(resultArr.length==0){
            resolve(false)
            return
          }
          let INSERT_SQL = "INSERT INTO " + tableName
            + " (" + map[tableName].ACCOUNT_TABLE.columns.toString() + ") VALUES "

          resultArr.map((data, i) => {
            data.id = `${i}`
            let str = '('
            map[tableName].ACCOUNT_TABLE.columns.map((res, index) => {
              if (map[tableName].ACCOUNT_TABLE.columns.length - 1 == index) {
                str += data[res] ? `'${data[res]}'` : 'NULL'
              } else {
                str += (data[res] ? `'${data[res]}'` : 'NULL') + ','
              }
            })
            if (i == resultArr.length - 1) {
              str += ')'
            } else {
              str += '),'
            }
            INSERT_SQL += str
          })
          console.log('sqlsINSERT_SQLINSERT_SQL', INSERT_SQL)
          accountTable.sqlOperate(INSERT_SQL, tableName, (val) => {
            console.log('teststet3',val,tableName)

            console.log('sqlsqlinsert,', val, 'tableName', tableName)
            resolve(val)
          })
        }
        else {
          if (delFlag) {
            await delSyncTable(tableName, context)
            const result = await sqlInsertCommonFn(tableName, resultArr, context)
            resolve(result)
            return
          }
          const result = await sqlInsertCommonFn(tableName, resultArr, context)
          resolve(result)
        }
      }, true);
    }, context);
  })
}

//参数平台
export async function getDataBaseTable(params, reqParam) {
  return new Promise(async (resolve, reject) => {
    const date = new Date()
    if (!reqParam?.paraKdid) {
      prompt.showToast({
        message: 'paraKdid获取失败',
        duration: 3000
      });
      return
    }
    const str = { "head": { "time": dateFormat(date) },
      "body":
      { "tableName": params.tableName, // 表名
        "paraKdid": reqParam.paraKdid, //参数平台kdid
        "examinationRoomId": reqParam.examinationRoomId, //考试平台kdid
        "typeRsp": "0" // 赋默认值0，无需改变
      }
    }
    let res: any = await initCenterCache(str, reqParam.centerHost)
    if (res.body[params.tableName].length == 0) {
      resolve();
      return
    }
    if (params.tableName == 'MA_SYSSET') {
      res.body[params.tableName] = res.body[params.tableName].filter(res => {
        return res['v_no'] >= 300 && res['v_no'] <= 700
      })
    }
    sqlInsertCommonFn(param.tableName, res.body[params.tableName]).then((val) => {
      reslove(val)
    })
  })
}

//依据数组和表名更新sql表
export async function upDateTableByArray(tableName, arr) {
  return new Promise(async (reslove, reject) => {
    const data = await sqlInsertCommonFn(tableName, arr)
    reslove(data)
  })
}

//更新双中心表
export async function upDateTable(params, reqParam) {
  return new Promise((resolve, reject) => {
    const date = new Date()
    let paraKdid = reqParam?.paraKdid || ''
    let examinationRoomId = reqParam?.examinationRoomId || ''
    if (!paraKdid || !examinationRoomId) {
      resolve(false)
      return
    }

    const str = { "head": { "time": dateFormat(date) },
      "body":
      { "tableName": params.tableName, // 表名
        "paraKdid": paraKdid, //参数平台kdid
        "examinationRoomId": examinationRoomId, //考试平台kdid
        "typeRsp": "0" // 赋默认值0，无需改变
      }
    }
    const url = globalThis.timeInfo.url

    initCenterCache(str, url).then(async (res) => {
      if (!res || res == undefined || res == '') {
        resolve(false)
        return
      }
      try {
        const result = await sqlInsertCommonFn(params.tableName, res.body[params.tableName], reqParam.context)
        resolve(result)
      } catch (error) {
        console.log(error)
      }
    })
  });
}

//考试平台
export async function getMySystemSetTable(params, reqParam) {
  return new Promise((resolve, reject) => {
    const date = new Date()
    if (!reqParam.paraKdid) {
      prompt.showToast({
        message: 'paraKdid获取失败',
        duration: 3000
      });
      return
    }
    const str = { "head": { "time": dateFormat(date) },
      "body":
      { "tableName": params.tableName, // 表名
        "paraKdid": reqParam?.kdid, //考试平台kdid
        "examinationRoomId": reqParam?.kdid, //考试平台kdid
        "typeRsp": "0" // 赋默认值0，无需改变
      }
    }
    initCenterCacheByKSPT(str, reqParam.url).then((res) => {
      if (res.body[params.tableName].length == 0) {
        resolve();
        return
      }
      if (params.tableName == 'MA_SYSSET') {
        res.body[params.tableName] = res.body[params.tableName].filter(res => {
          return res['v_no'] < 300 || res['v_no'] > 700
        })
      }
      sqlInsertCommonFn(params.tableName, res.body[params.tableName], reqParam.context, false).then((result) => {
        resolve(result)
      })
    })


  })

}

//依据表名同步获取数据
export async function getSyncData(tableName, context?) {
  return new Promise((resolve, reject) => {
    const accountTable = new AccountTable(() => {
    }, map[tableName], context);
    accountTable.getRdbStore(() => {
      accountTable.query('0', async (result) => {
        resolve(result)
      }, true);
    });
  })

}

export async function delSyncTable(tableName, context?) {
  return new Promise((resolve, reject) => {
    const accountTable = new AccountTable(() => {
    }, map[tableName], context);
    accountTable.deleteTableData((ret) => {
      console.log('删除成功')
      resolve(true)
    }, tableName, context)

  })
}

//获取车模、场地模型
export async function getEsCarModel(context) {
  const date = new Date()
  if (!globalThis.timeInfo?.paraKdid) {
    prompt.showToast({
      message: 'paraKdid获取失败',
      duration: 3000
    });
    return
  }
  const carStr = { "head": { "time": dateFormat(date) },
    "body":
    {
      "rtkType": "1", //1:车模 2:场地模型
      "rspType": "0", //返回类型
      "paraKdid": globalThis.timeInfo.paraKdid, //参数平台kdid
      "examinationRoomId": globalThis.timeInfo.kdid, //考试平台kdid
      // "carMac":"MAC-HCPAD-210",
      "carMac": globalThis.deviceNo
    }
  }
  const venueStr = { "head": { "time": dateFormat(date) },
    "body":
    {
      "rtkType": "2", //1:车模 2:场地模型
      "rspType": "0", //返回类型
      "paraKdid": globalThis.timeInfo.paraKdid, //参数平台kdid
      "examinationRoomId": globalThis.timeInfo.kdid, //考试平台kdid
      // "carMac":"MAC-HCPAD-210",
      "carMac": globalThis.deviceNo
    }
  }


  let carRes: any = await initEsModel(carStr);
  let venueRes: any = await initEsModel(venueStr);

  const carModel = carRes.body.ES_MODEL[0][1];
  const venueModel = venueRes.body.ES_MODEL[0][2];

  let tmpBase64Array = carModel.split("\r\n")
  let newBase64Str: string = '';
  for (let i = 0; i < tmpBase64Array.length; ++i) {
    newBase64Str += tmpBase64Array[i];
  }
  const base64 = new util.Base64();
  let result = base64.decodeSync(newBase64Str);
  const fileModel = new FileModel(context);
  await fileModel.initFolder()
  await fileModel.storingFiles(result.buffer)
}

export async function upDataZhongxinginitialization(param) {
  return new Promise(async(resolve, reject) => {
    if (!param.carId) {
      resolve(false)
      return
    }
    let flag=true
    if (param.singlePlay) {
      console.log('teststet0',JSON.stringify(param))
      const fileUtil = new FileUtil(param.context)
      const tableList = ['MA_SYSSET', 'MA_SYSTEMPARM', 'MA_MARKRULE', 'MA_MARKRULESET','ES_CARINFO','MA_MAP_ROAD','MA_MAP_ROAD_LANE','MAP_SUBITEM','MA_T_CARPARMSET','MA_MAP_ITEMCLASS','MA_MAP_POINT','MA_MAP_POINT_ITEM'];
     for(let i=0;i<=tableList.length-1;i++){
       const data = await fileUtil.readFile(GlobalConfig.comoonfileWriteAddress + `/config/tableList/${tableList[i]}.txt`);
       const result=await sqlInsertCommonFn(tableList[i], JSON.parse(data) || [], param.context)
       result?(flag=true):(flag=false)
     }
      if(!flag){
        prompt.showToast({
          message: '本地文件初始化数据库失败',
          duration: 3000
        });
      }

      resolve(flag)
      return
    }
    try{
      const str = {
        "carId": param.carId, // 表名
        "examinationRoomId": param.examinationRoomId, //考试平台kdid
        videoVersion: '1.0',
        judgeVersion: param.judgeVersion,
        shellVersion: param.shellVersion,
        host: param.host
      }
      console.log('daihai2', JSON.stringify(str))

      initialization(str).then(async (res) => {
        console.log('daihai3', JSON.stringify(res))
        if (!res||res.initializationRsp.head.resultCode==1) {
          console.log('daihai34', JSON.stringify(res))
          resolve(false)
          return
        }
        let flag
        console.log('resposestart')

        for (let key in res.initializationRsp.body) {
          if (!centerToMap[key]) {
            continue
          }
          const data = await setSyncCenterSqlData(key, res, param)
          if (!data) {
            resolve(false)
          }
        }
        resolve(true)


        console.log('resposestart')

      }).catch((Error) => {
        resolve(false)
      })
    }catch (error){
      resolve(false)
    }
  })
}

function setSyncCenterSqlData(key, res, param) {
  return new Promise(async (resolve, reject) => {
    const mapName = {
      'ItemInfo': 'MA_ITEMINFO',
      'MarkRule': 'MA_MARKRULE',
      'SystemParm': 'MA_SYSTEMPARM',
      'Map_Collect': 'MA_MAP_COLLECT',
      'Map_Collect_Shape': 'MA_MAP_COLLECT_SHAPE',
      'Map_ItemClass': 'MA_MAP_ITEMCLASS',
      'Map_Point': 'MA_MAP_POINT',
      'Map_Point_Item': 'MA_MAP_POINT_ITEM',
      'Map_Road': 'MA_MAP_ROAD',
      'Map_Road_Lane': 'MA_MAP_ROAD_LANE',
      'Map_SubItem': 'MAP_SUBITEM',
      'Sysset': 'MA_SYSSET',
      'CarInfo': 'ES_CARINFO',
      // 'ES_EXAMPOINTDETAIL':ES_EXAMPOINTDETAIL,
      'MarkRuleSet': 'MA_MARKRULESET',
      'Cdsbinfo': 'MA_CDSBINFO',
      'T_CarParmSet': 'MA_T_CARPARMSET',
    }
    // const accountTable = new AccountTable(() => {
    // }, centerToMap[key],param.context);
    let arrList
    if (res.initializationRsp.body[key].record instanceof Array) {
      arrList = res.initializationRsp.body[key].record
    } else {
      arrList = [res.initializationRsp.body[key].record]
    }
    const fileUtil = new FileUtil(param.context)
    const folderPath = await fileUtil.initFolder(`/config/tableList`);
    fileUtil.addFile(`${folderPath}/${mapName[key]}.txt`, JSON.stringify(arrList))

    console.log('mapName[key]', mapName[key], key)
    sqlInsertCommonFn(mapName[key], arrList, param.context).then((result) => {
      console.log(key, '表建立成功')
      if (result) {
        resolve(true)
      } else {
        resolve(false)
      }
    }).catch((msg) => {
      reject(false)
      console.log(key, '表建立失败')
    })
  })

}