thinkraz-api-sdk/classes/Payment.js

橡芮科技API开发包

const Promise = require('bluebird');
const baseClass = require('../lib/baseClass');

module.exports = class Payment extends baseClass {
    /**
     * 建立账户，返回id
     */
    makeAccount() {
        return new Promise((resolve, reject) => {
            this.request().post(`account`).then(object => {
                resolve(object.id);
            }).catch(err => {
                reject(err);
            });
        });
    }

    /**
     * 查询账户，输入id，返回对象
     */
    getAccount(id) {
        return new Promise((resolve, reject) => {
            this.request().get(`account/${id}`).then(object => {
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }

    /**
     * 创建“钱袋” / “钱的购物车”，用于收款
     */
    makePayment(amount, orderId, notifyUrl, notifyParams, notifyHeaders,useOriginalOrder) {
        return new Promise((resolve, reject) => {
            this.request().post(this.getPath(), {
                notifyUrl: notifyUrl,
                notifyParams: notifyParams,
                notifyHeaders: notifyHeaders,
                amount: amount,
                orderId: orderId,
                useOriginalOrder: useOriginalOrder === undefined ? true : useOriginalOrder
            }).then(object => {
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }

    getNativeQrCode(channel, amount, paymentId, receiver, body, certToken) {
        return new Promise((resolve, reject)=> {
            switch (channel) {
                case 'WEIXIN':
                    this.request().post(`${this.getPath()}/weixin/native/pay`, {
                        amount: amount,
                        paymentId: paymentId,
                        receiver: receiver,
                        body: body,
                        certToken: certToken,
                        notifyUrl: `${this.request().getBaseAddress()}/${this.getPath()}/weixin/webHook/`
                    }).then(object => {
                        resolve(object.url);
                    }).catch(err => {
                        reject(err);
                    });
                    break;
                case 'ALIPAY':
                    this.request().post(`${this.getPath()}/alipay/native/pay`, {
                        amount: amount,
                        paymentId: paymentId,
                        receiver: receiver,
                        body: body,
                        certToken: certToken,
                        notifyUrl: `${this.request().getBaseAddress()}/${this.getPath()}/alipay/webHook/`
                    }).then(object => {
                        resolve(object.url);
                    }).catch(err => {
                        reject(err);
                    });
                    break;
                default:
                    throw new Error('channel 参数不正确');
            }
        });
    }

    payWithAuthcode(authCode, amount, paymentId, receiver, body, certToken) {
        return new Promise((resolve, reject)=> {
            this.request().post(`${this.getPath()}/uni/scan/pay`, {
                authCode: authCode,
                amount: amount,
                paymentId: paymentId,
                receiver: receiver,
                body: body,
                certToken: certToken
            }).then(object => {
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }

    payOffline(amount, paymentId, receiver, channel, mchid) {
        return new Promise((resolve, reject)=> {
            this.request().post(`${this.getPath()}/offline/pay`, {
                amount: amount,
                paymentId: paymentId,
                receiver: receiver,
                channel: mchid + '_' + channel
            }).then(object => {
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }
    payTransfer(amount, paymentId, receiver, payer) {
        return new Promise((resolve, reject)=> {
            this.request().post(`${this.getPath()}/transfer/pay`, {
                amount: amount,
                paymentId: paymentId,
                receiver: receiver,
                payer: payer
            }).then(object => {
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }
    /**
     * 单笔payment按原channel倒回，不包含order的refund
     * @param paymentId
     * @param receiver
     * @param amount
     */
    refundPaymentRollback(paymentId, receiver,amount) {
        return new Promise((resolve, reject)=> {
            this.request().post(`${this.getPath()}/rollback`, {
                paymentId: paymentId,
                receiver: receiver,
                amount:amount
            }).then(object => {
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }

    /**
     * 单笔payment强制按某个channel退回，如果channel余额不足将报错。现金可以超支退
     * @param paymentId
     * @param channel
     * @param amount
     * @param receiver
     */
    refundPaymentByOtherChannel(paymentId, channel, amount, receiver) {
        return new Promise((resolve, reject)=> {
            this.request().post(`${this.getPath()}/refund`, {
                paymentId: paymentId,
                channel: channel,
                amount: amount,
                receiver: receiver
            }).then(object => {
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }

    /**
     * 查询某个payment的所有记录
     * @param paymentId
     */
    queryPayment(paymentId) {
        return new Promise((resolve, reject)=> {
            this.request().get(`${this.getPath()}/query/${paymentId}`).then(object => {
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }

    getPayment(query) {
        return new Promise((resolve, reject)=> {
            this.request().get(`${this.getPath()}`, query).then(object => {
                if(!object){
                    reject('找不到支付单');
                }
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }

    registerChannel(name, desc) {
        return new Promise((resolve, reject)=> {
            this.request().post(`${this.getPath()}/registerChannel`, {
                name: name,
                desc: desc
            }).then(object => {
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }

    registerCert(name, cert) {
        return new Promise((resolve, reject)=> {
            this.request().post(`${this.getPath()}/registerCert`, {
                token: name,
                cert: cert
            }).then(object => {
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }

    getCert(name) {
        return new Promise((resolve, reject)=> {
            this.request().get(`${this.getPath()}/getCert/${name}`).then(object => {
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }

    getPendingPayment(){
        return new Promise((resolve, reject)=> {
            this.request().get(`${this.getPath()}/pending`).then(object => {
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }

    getPayments(query){
        return new Promise((resolve, reject)=> {
            this.request().post(`${this.getPath()}/payments`,query).then(object => {
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }

    getPaymentRecords(query){
        return new Promise((resolve, reject)=> {
            this.request().post(`${this.getPath()}/paymentRecords`,query).then(object => {
                resolve(object);
            }).catch(err => {
                reject(err);
            });
        });
    }
};