LaiTool/src/main/setting/autoSync.js

import fs from 'fs'
import { version } from '../../../package.json'
import { define } from '../../define/define'
const fspromises = fs.promises
import { MJSettingService } from '../../define/db/service/SoftWare/mjSettingService'
import _, { isEmpty } from 'lodash'
import { SoftwareService } from '../../define/db/service/SoftWare/softwareService'
import { CheckFileOrDirExist } from '../../define/Tools/file'
import path from 'path'

//#region 通用同步

/**
 * 通用的自动初始化配置，所有的配置都在这里面进行初始化
 */
async function GlobalAutoSync() {
  try {
    let _softwareService = await SoftwareService.getInstance()
    let softData = _softwareService.GetSoftwareData(null)
    let initConifgPath
    let isExist = await CheckFileOrDirExist(define.config_path)
    if (isExist) {
      initConifgPath = define.config_path
    } else {
      initConifgPath = path.join(define.init_config_path, 'global_setting.json')
    }

    // 判断是不是有数据，没有的话初始化整个设置数据，有的话判断是不是有全局设置，没有在设置
    if (softData.data.length <= 0) {
      // 初始化全局设置
      let initGlobalConfig = await fspromises.readFile(initConifgPath, 'utf-8')

      let addSfotwareRes = _softwareService.AddSfotware({
        theme: 'light',
        reverse_display_show: false,
        reverse_show_book_striped: false,
        reverse_data_table_size: 'small',
        globalSetting: initGlobalConfig
      })
      if (addSfotwareRes.code == 1) {
        global.logger.info('AutoSunc_GlobalAutoSync', '初始化全局设置成功')
      }
    } else {
      // 有，只需要检查全局设置是不是存在，不存在的话初始化
      let softWareData = softData.data[0]
      if (softWareData.globalSetting == null || softWareData.globalSetting == '') {
        let initGlobalConfig = await fspromises.readFile(initConifgPath, 'utf-8')
        softWareData.globalSetting = initGlobalConfig
        let updateSfotwareRes = _softwareService.UpdateSoftware(softWareData)
        if (updateSfotwareRes.code == 1) {
          global.logger.info('AutoSunc_GlobalAutoSync', '初始化全局设置成功')
        }
      }
    }
  } catch (error) {
    // 同步数据不报错，只添加日志
    global.logger.error(
      'AutoSunc_GlobalAutoSync',
      '初始化全局设置失败，失败信息如下' + '\n' + error.toString()
    )
  }
}

//#endregion

//#region 2.2.10 版本 自动同步数据
/**
 * 自动同步MJ配置数据
 */

async function AutoSyncMJConfig2210() {
  try {
    // 判断版本
    if (version != '2.2.10') {
      return
    }

    // 同步MJ的配置到服务器中
    let mjConfigJson = JSON.parse(await fspromises.readFile(define.img_base, 'utf-8'))
    // 开始同步APIMJsetting
    let _mjSettingService = await MJSettingService.getInstance()

    if (!mjConfigJson.mj_config) {
      return
    }

    // 判断数据库中有没有API数据
    let dbApiSetting = _mjSettingService.GetAPIMjSetting(null)
    if (dbApiSetting.code == 1 && dbApiSetting.data.length <= 0) {
      // 同步API请求配置
      if (
        mjConfigJson.mj_config.mj_api_url &&
        mjConfigJson.mj_config.mj_speed &&
        mjConfigJson.mj_config.api_key
      ) {
        let apiSetting = {
          mjApiUrl: mjConfigJson.mj_config.mj_api_url,
          mjSpeed: mjConfigJson.mj_config.mj_speed,
          apiKey: mjConfigJson.mj_config.api_key
        }
        let res = _mjSettingService.AddAPIMjSetting(apiSetting)
        if (res.code == 1) {
          global.logger.info('AutoSyncMJConfig2210', '自动同步MJ API 配置数据成功')
        } else {
          global.logger.error(
            'AutoSyncMJConfig2210',
            '自动同步MJ API 配置数据失败，错误信息如下：' + '\n' + res.message
          )
        }
      }
    }

    // 判断数据库中是不是存在浏览器配置数据，不存在同步
    let dbBrowserSetting = _mjSettingService.GetBrowserMJSetting(null)
    if (dbBrowserSetting.code == 1 && dbBrowserSetting.data.length <= 0) {
      // 同步浏览器配置，判断数据是不是存在
      if (
        isEmpty(mjConfigJson.mj_config.serviceID) ||
        isEmpty(mjConfigJson.mj_config.channelID) ||
        isEmpty(mjConfigJson.mj_config.token) ||
        !mjConfigJson.mj_config.userAgent ||
        isEmpty(mjConfigJson.mj_config.userAgent) ||
        isEmpty(mjConfigJson.mj_config.userAgent.userAgent)
      ) {
        return
      }

      // 开始添加浏览器配置
      let browserSetting = {
        serviceId: mjConfigJson.mj_config.serviceID,
        channelId: mjConfigJson.mj_config.channelID,
        token: mjConfigJson.mj_config.token,
        userAgent: mjConfigJson.mj_config.userAgent.userAgent
      }
      let res = _mjSettingService.AddBrowserMJSetting(browserSetting)
      if (res.code == 1) {
        global.logger.info('AutoSyncMJConfig2210', '自动同步MJ 浏览器配置数据成功')
      } else {
        global.logger.error(
          'AutoSyncMJConfig2210',
          '自动同步MJ 浏览器配置数据失败，错误信息如下：' + '\n' + res.message
        )
      }
    }

    // 判断基础数据，不存在同步
    let mjSetting = _mjSettingService.GetMjSetting(null)
    if (mjSetting.code == 1 && mjSetting.data.length <= 0) {
      //判断数据然后选择同步
      if (
        isEmpty(mjConfigJson.mj_config.request_model) ||
        isEmpty(mjConfigJson.mj_config.select_robot) ||
        isEmpty(mjConfigJson.mj_config.image_scale) ||
        isEmpty(mjConfigJson.mj_config.image_model) ||
        isEmpty(mjConfigJson.mj_config.image_suffix)
      ) {
        return
      }

      // 开始添加基础配置
      let mjSettingData = {
        requestModel: mjConfigJson.mj_config.request_model,
        selectRobot: mjConfigJson.mj_config.select_robot,
        imageScale: mjConfigJson.mj_config.image_scale,
        imageModel: mjConfigJson.mj_config.image_model,
        imageSuffix: mjConfigJson.mj_config.image_suffix,
        taskCount: mjConfigJson.mj_config.task_count ? mjConfigJson.mj_config.task_count : 3,
        spaceTime: mjConfigJson.mj_config.space_time ? mjConfigJson.mj_config.space_time : 5
      }
      let res = _mjSettingService.AddMJSetting(mjSettingData)
      if (res.code == 1) {
        global.logger.info('AutoSyncMJConfig2210', '自动同步MJ 基础配置数据成功')
      } else {
        global.logger.error(
          'AutoSyncMJConfig2210',
          '自动同步MJ 基础配置数据失败，错误信息如下：' + '\n' + res.message
        )
      }
    }

    // 初始化默认数据
    let _softwareService = await SoftwareService.getInstance()
    let softs = await _softwareService.GetSoftwareData(null)
    if (softs.code == 1 && softs.data.length <= 0) {
      // 添加
      let softData = {
        theme: 'light',
        reverse_display_show: false,
        reverse_show_book_striped: false,
        reverse_data_table_size: 'small'
      }
      let res = await _softwareService.AddSfotware(softData)
      if (res.code == 0) {
        throw new Error(res.message)
      }

      global.logger.info('AutoSyncMJConfig2210', '自动同步软件配置数据成功')
    }

    return mjConfigJson
  } catch (error) {
    // 同步数据不报错，只添加日志
    global.logger.error(
      'AutoSyncMJConfig2210',
      '自动同步MJ配置数据失败，错误信息如下：' + '\n' + error.toString()
    )
  }
}
//#endregion

export async function AutoSync() {
  // 2.2.10 版本 自动同步数据
  await AutoSyncMJConfig2210()
  // 通用同步
  await GlobalAutoSync()
}