Rules-For-Quantumult-X/Scripts/SignIn/HelloBike/hellobike.js

const HELLO_BIKE = init()
const TASK_NAME = '哈啰出行'
const TOKEN_KEY = 'hellobike'
const API_URL = 'https://gameapi.hellobike.com/api'
const UA = 'Mozilla/5.0 (iPhone; CPU iPhone OS 13_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148; app=easybike; version=5.35.0'

if (typeof $request !== 'undefined') {
  getToken()
  HELLO_BIKE.done()
} else {
  ;(async () => {
    let token = HELLO_BIKE.getdata(TOKEN_KEY)
    if (!token) {
      HELLO_BIKE.msg(TASK_NAME, '请先获取 Token')
      HELLO_BIKE.done()
      return
    }

    await checkin(token).then(data => {
      if (data && data.isSuccess) {
        HELLO_BIKE.msg(TASK_NAME, `签到成功，获取 ${data.energy}c 能量`)
      } else if (data && !data.isSuccess) {
        HELLO_BIKE.msg(TASK_NAME, `重复签到`)
      }
    }).catch(error => {
      HELLO_BIKE.msg(TASK_NAME, error.reason)
      if (error.isInvalidToken) {
        token = null
      }
    })

    await share(token).then(data => {
      HELLO_BIKE.log(TASK_NAME, `分享成功, ${JSON.stringify(data)}`)
    }).catch(error => {
      HELLO_BIKE.msg(TASK_NAME, error.reason)
      if (error.isInvalidToken) {
        token = null
      }
    })

    await getEnergyList(token).then(
      data => {
        HELLO_BIKE.log(TASK_NAME, `获取能量：${JSON.stringify(data)}`)
        return mergePromise(data.map(energy => collectEnergy(token, energy.guid)))
      },
      error => {
        HELLO_BIKE.msg(TASK_NAME, error.reason)
        if (error.isInvalidToken) {
          token = null
        }
      },
    ).then(
      data => {
        if (Array.isArray(data) && data.length > 0) {
          HELLO_BIKE.log(TASK_NAME, `收取能量： ${JSON.stringify(data)}`)
          let collected = data.filter(energy => {
            return energy != null
          }).reduce((total, currentValue) => {
            return total + currentValue.energy
          }, 0)
          HELLO_BIKE.msg(TASK_NAME, `收取能量成功，总共收取 ${collected}c 能量`)
        }
        HELLO_BIKE.done()
      },
      error => {
        HELLO_BIKE.msg(TASK_NAME, error.reason)
        HELLO_BIKE.done()
      },
    )
  })()
}

function getToken() {
  if ($request.body) {
    let body = JSON.parse($request.body)
    if (body && body.token) {
      let token = HELLO_BIKE.getdata(TOKEN_KEY)
      if (token != null) {
        if (token !== body.token) {
          if (!HELLO_BIKE.setdata(body.token, TOKEN_KEY)) {
            HELLO_BIKE.msg(`更新 ${TASK_NAME} Token 失败‼️`)
          } else {
            HELLO_BIKE.msg(`更新 ${TASK_NAME} Token 成功 🎉`)
          }
        }
      } else {
        if (!HELLO_BIKE.setdata(body.token, TOKEN_KEY)) {
          HELLO_BIKE.msg(`首次写入 ${TASK_NAME} Token 失败‼️`)
        } else {
          HELLO_BIKE.msg(`首次写入 ${TASK_NAME} Token 成功 🎉`)
        }
      }
    }
  }
}

function checkin(token) {
  if (!token) {
    return Promise.resolve({})
  }
  return new Promise((resolve, reject) => {
    let action = 'happy.energy.dailyCheck.v2'
    let options = {
      url: API_URL,
      headers: { 'User-Agent': UA },
      body: JSON.stringify({
        action,
        token,
        ticket: '',
      }),
    }
    HELLO_BIKE.post(options, (error, response, data) => {
      if (error) {
        HELLO_BIKE.log(TASK_NAME, `签到失败，error：${error}`)
        reject(new RequestFailed(action, error))
        return
      }
      let result = JSON.parse(data)
      if (result && result.code === 0 && result.data) {
        resolve(result.data)
      } else {
        HELLO_BIKE.log(TASK_NAME, `签到失败，response：${data}`)
        reject(new RequestFailed(action, result.msg, result.code === 103))
      }
    })
  })
}

function share(token) {
  if (!token) {
    return Promise.resolve({})
  }
  return new Promise((resolve, reject) => {
    let action = 'happy.energy.dailyShare'
    let options = {
      url: API_URL,
      headers: { 'User-Agent': UA },
      body: JSON.stringify({
        token,
        action,
        ticket: '',
      }),
    }
    HELLO_BIKE.post(options, (error, response, data) => {
      if (error) {
        HELLO_BIKE.log(TASK_NAME, `分享失败，error：${error}`)
        reject(new RequestFailed(action, error))
        return
      }
      let result = JSON.parse(data)
      if (result && result.code === 0) {
        resolve(result)
      } else {
        HELLO_BIKE.log(TASK_NAME, `分享失败，response：${data}`)
        reject(new RequestFailed(action, result.msg, result.code === 103))
      }
    })
  })
}

function getEnergyList(token) {
  if (!token) {
    return Promise.resolve([])
  }
  return new Promise((resolve, reject) => {
    let action = 'happy.energy.getEnergyList'
    let options = {
      url: API_URL,
      headers: { 'User-Agent': UA },
      body: JSON.stringify({
        token,
        action,
        ticket: '',
        limit: 6,
      }),
    }
    HELLO_BIKE.post(options, (error, response, data) => {
      if (error) {
        HELLO_BIKE.log(TASK_NAME, `获取能量失败，error：${error}`)
        reject(new RequestFailed(action, error))
        return
      }
      let result = JSON.parse(data)
      if (result && result.code === 0 && result.data) {
        resolve(result.data)
      } else {
        HELLO_BIKE.log(TASK_NAME, `获取能量失败，response：${data}`)
        reject(new RequestFailed(action, result.msg, result.code === 103))
      }
    })
  })
}

function collectEnergy(token, energyGuid) {
  if (!token) {
    return Promise.resolve({})
  }
  return new Promise((resolve, reject) => {
    let action = 'happy.energy.collectEnergy'
    let options = {
      url: API_URL,
      headers: { 'User-Agent': UA },
      body: JSON.stringify({
        token,
        action,
        ticket: '',
        energyGuid,
      }),
    }
    HELLO_BIKE.post(options, (error, response, data) => {
      if (error) {
        HELLO_BIKE.log(TASK_NAME, `收取能量失败，error：${error}`)
        reject(new RequestFailed(action, error))
        return
      }
      let result = JSON.parse(data)
      if (result && result.code === 0 && result.data) {
        resolve(result.data)
      } else {
        HELLO_BIKE.log(TASK_NAME, `收取能量失败，response：${data}`)
        reject(new RequestFailed(action, result.msg, result.code === 103))
      }
    })
  })
}

function mergePromise(promises = []) {
  let array = []
  let sequence = Promise.resolve([])
  promises.forEach(promise => {
    sequence = sequence.then(() => promise).then(data => {
      array.push(data)
      return array
    })
  })
  return sequence
}

function init() {
  isSurge = () => {
    return undefined !== this.$httpClient
  }
  isQuanX = () => {
    return undefined !== this.$task
  }
  getdata = (key) => {
    if (isSurge()) return $persistentStore.read(key)
    if (isQuanX()) return $prefs.valueForKey(key)
  }
  setdata = (key, val) => {
    if (isSurge()) return $persistentStore.write(key, val)
    if (isQuanX()) return $prefs.setValueForKey(key, val)
  }
  msg = (title, subtitle = '', body = '') => {
    if (isSurge()) $notification.post(title, subtitle, body)
    if (isQuanX()) $notify(title, subtitle, body)
  }
  log = (title, msg) => {
    console.log(`${title}:\n${msg}\n`)
  }
  get = (options, callback) => {
    if (isQuanX()) {
      if (typeof options == 'string') options = { url: options }
      options['method'] = 'GET'
      return $task.fetch(options).then(
        response => {
          response['status'] = response.statusCode
          callback(null, response, response.body)
        },
        reason => callback(reason.error, null, null),
      )
    }
    if (isSurge()) return $httpClient.get(options, callback)
  }
  post = (options, callback) => {
    if (isQuanX()) {
      if (typeof options == 'string') options = { url: options }
      options['method'] = 'POST'
      $task.fetch(options).then(
        response => {
          response['status'] = response.statusCode
          callback(null, response, response.body)
        },
        reason => callback(reason.error, null, null),
      )
    }
    if (isSurge()) $httpClient.post(options, callback)
  }
  done = (value = {}) => {
    $done(value)
  }
  return { isSurge, isQuanX, msg, log, getdata, setdata, get, post, done }
}

function RequestFailed(action = '', reason = '', isInvalidToken = false) {
  this.action = action
  this.reason = reason
  this.isInvalidToken = isInvalidToken
}

RequestFailed.prototype = {
  constructor: RequestFailed,
}