pay-svr/src/controllers/alchemy.controller.ts
2023-07-14 13:53:06 +08:00

135 lines
4.6 KiB
TypeScript

import logger from 'logger/logger'
import BaseController from 'common/base.controller'
import { ZError } from 'common/ZError'
import { router } from 'decorators/router'
import { createOrder, queryFiat, queryPrice, refreshToken } from 'service/alchemy.svr'
import { generateKVStr } from 'utils/net.util'
import { PayRecord, PayStatus } from 'modules/PayRecord'
import { PriceSvr } from 'service/price.svr'
import { reportPayResult } from 'service/game.svr'
const CALL_BACK_URL = `${process.env.ALCHEMY_PAY_CB_URL}/pay/out/alchemy/buycb`
class AlchemyController extends BaseController {
@router('post /pay/alchemy/buy')
async beginApiPay(req, res) {
const user = req.user
const { network, crypto, address, fiat, fiatAmount, payWayCode, country, accountId, orderId, env } = req.params
let envStr = env || 'dev'
if (fiat || fiatAmount || country) {
if (!fiat || !fiatAmount || !country || !payWayCode) {
throw new ZError(11, 'fiat, fiatAmount payWayCode and country must be provided')
}
}
if (network || crypto) {
if (!network || !crypto) {
throw new ZError(12, 'network and crypto must be provided')
}
}
const tokenResult = await refreshToken(user.emailReal || user.email)
if (!tokenResult.success || tokenResult.returnCode !== '0000') {
logger.info(`fetch pay token error::code: ${tokenResult.returnCode} msg: ${tokenResult.returnMsg}`)
throw new ZError(10, 'fetch pay token error')
}
const { id, email, accessToken } = tokenResult.data
if (crypto.toLowerCase() === 'agor') {
let today = new Date()
today.setHours(0, 0, 0, 0)
let count = await PayRecord.countDocuments({
account: user.id,
crypto,
status: PayStatus.SUCCESS,
createdAt: { $gte: today },
})
if (count >= 3) {
throw new ZError(13, 'daily limit')
}
}
// 根据 `查询数字货币接口` 返回的数据, 预估可获得的数字货币数量
// 用户法币接口做简单的验证
let priceData = await queryPrice({ crypto, network, fiat, amount: fiatAmount, payWayCode, country })
logger.debug('pirce data::', JSON.stringify(priceData))
let amountEstimate = priceData.data.cryptoAmount
let record = new PayRecord({
account: user.id,
address,
network,
crypto,
env: envStr,
gameAccountId: accountId,
gameOrderId: orderId,
cryptoAmountEstimate: amountEstimate,
})
if (fiat) record.fiat = fiat
if (fiatAmount) record.fiatAmount = fiatAmount
if (country) record.country = country
await record.save()
let payData: any = {
side: 'BUY',
merchantOrderNo: record.id,
amount: record.fiatAmount,
fiatCurrency: record.fiat,
cryptoCurrency: record.crypto,
depositType: '2',
address: address,
network: record.network,
payWayCode,
alpha2: record.country,
callbackUrl: CALL_BACK_URL,
merchantName: 'CEBG',
}
logger.info(`create order data::${JSON.stringify(payData)}`)
let payRes = await createOrder(accessToken, payData)
logger.info(`create order result::${JSON.stringify(payRes)}`)
record.outData = payRes.data
if (payRes.success) {
record.outOrderId = payRes.data.orderNo
await record.save()
} else {
record.status = PayStatus.FAIL
await record.save()
setImmediate(() => {
reportPayResult(record)
})
throw new ZError(payRes.returnCode, payRes.returnMsg)
}
return { url: payRes.data.payUrl }
}
@router('post /pay/alchemy/crypto_price')
async queryCryptoPrice(req, res) {
let { token, chain, currency, env } = req.params
if (!token || !chain) {
throw new ZError(11, 'token or network not found')
}
if (
(chain.toLowerCase() === 'agor' || chain.toLowerCase() === 'eth') &&
(token.toLowerCase() === 'ceg' || token.toLowerCase() === 'cec')
) {
return { price: 1 }
}
if ((chain.toLowerCase() === 'agor' || chain.toLowerCase() === 'eth') && token.toLowerCase() === 'agor') {
token = 'ETH'
chain = 'ETH'
}
if (token.toLowerCase() === 'ceg') {
return { price: 1 }
}
let data = {
crypto: token,
network: chain,
fiat: currency || 'USD',
}
let result = await new PriceSvr().fetchPrice(data)
return { price: result }
}
@router('get /pay/alchemy/fait_list')
async cryptoList(req, res) {
let result = await queryFiat()
if (!result.success) {
throw new ZError(10, result.returnMsg || 'fetch fiat list error')
}
return result.data
}
}