@oceans/cli/common/utils.js

work for oceans

const fs = require('fs')
const path = require('path')
const axios = require('axios')
const { exec } = require('child_process')
const base32 = require('base32')
const log4js = require('log4js')
const chalk = require('chalk')
const { PROJECT_WORK_FOLDER } = require('../config')

let version = ''

exports.getVersion = () => {
  if (version) {
    return version
  }

  const packageJsonPath = path.resolve(__dirname, '../package.json')
  const rawData = fs.readFileSync(packageJsonPath, { encoding: 'utf8' })
  const json = JSON.parse(rawData)
  version = json.version

  return version
}

exports.execCommand = (command) => {
  return new Promise((resolve, reject) => {
    const childProcess = exec(command)

    childProcess.stdout.on('data', (data) => {
      console.log(data.toString())
    })

    childProcess.stderr.on('data', (data) => {
      console.log(data.toString())
    })

    childProcess.on('error', (err) => {
      console.error('error ==>', err.message)
      reject && reject(err.message)
      process.exit(0)
    })

    childProcess.on('close', () => {
      console.log('create react app done')
      resolve()
    })
  })
}

exports.merge = (source, target, isSkipEmptyValue) => {
  const t = {}

  for (const k in source) {
    if (typeof target[k] !== 'undefined') {
      t[k] = target[k]
    } else {
      if (source[k] === '_false_') {
        if (!isSkipEmptyValue) {
          t[k] = source[k]
        }
      } else {
        t[k] = source[k]
      }
    }
  }

  return t
}

exports.generateKey = () => {
  return 'k_' + base32.encode(new Date().getTime() + '')
}

exports.getAxiosInstance = (apiDomain, token) => {
  const instance = axios.create({
    baseURL: apiDomain,
    withCredentials: true,
    crossDomain: true
  })

  instance.interceptors.request.use(
    config => {
      if (config.method === 'get') {
        config.params = config.params || {}
        config.params.t = new Date().getTime()
      } else if (config.method === 'post') {
        config.data = config.data || {}
        config.data.t = new Date().getTime()
      }

      if (token) {
        config.headers.token = token
      }

      return config
    },
    error => Promise.reject(error)
  )

  instance.interceptors.response.use(
    response => {
      return response.data
    },
    error => Promise.reject(error)
  )

  return instance
}

exports.getProjectPath = () => {
  return path.join(__filename, '../../')
}

exports.ensureProjectWorkChildFolder = (p) => {
  const target = path.join(PROJECT_WORK_FOLDER, p)

  if (!fs.existsSync(target)) {
    fs.mkdirSync(target)
  }

  return true
}
exports.getLogger = () => {
  const logsPath = path.join(PROJECT_WORK_FOLDER, 'logs/log')

  console.log('getLogger logsPath => ' + logsPath)

  log4js.configure({
    appenders: {
      cheese: {
        type: 'datefile',
        filename: logsPath,
        pattern: '-yyyy-MM-dd-hh.log',
        alwaysIncludePattern: true
      }
    },
    categories: { default: { appenders: ['cheese'], level: 'info' } }
  })

  const logger = log4js.getLogger('cheese')

  const api = {
    info: (msg) => {
      logger.level = 'info'
      console.info(chalk.yellow(msg))
      logger.info(msg)
    },
    error: (msg) => {
      logger.level = 'error'
      console.error(msg)
      logger.error(msg)
    }
  }

  return api
}