denet-node-server/model/db/withdraw_db.js

const mysql = require("./mysql_db")
const logger = require('../logger')
var { db_config } = require('../../config/config.js')
const utils = require('../utils.js')
/**
 * 创建提币任务
 * 
 * @param {*} task_obj 
 */
async function create_withdraw_task(task_obj) {
    logger.log('create_withdraw_task', task_obj)
    // 提币 id
    var withdraw_id = task_obj.withdraw_id;
    if (!withdraw_id) {
        return {
            code: -1,
            error: 'withdraw_id cannot be empty.'
        }
    }
    //提币任务创建时间
    var withdraw_create_time = utils.getTimestamp();
    var from_address = task_obj.user_address
    var to_address = task_obj.receiver
    var contract_address = task_obj.contractAddress
    var chain_id = parseInt(utils.getChainId(task_obj.chain))
    var type = task_obj.type
    var amount = task_obj.amount

    if (!from_address || !to_address) {
        return {
            code: -1,
            error: 'from_address and to_address cannot be empty.'
        }
    }
    var create_withdraw_sql = 'INSERT INTO withdraw_manage (withdraw_id,withdraw_status,create_time,from_address,to_address,chain_id,type,contract_address,amount)' +
        'VALUES(?,?,?,?,?,?,?,?,?)'
    var create_withdraw_params = [withdraw_id, 0, withdraw_create_time, from_address, to_address, chain_id, type, contract_address ? contract_address : '', amount]

    logger.log('create_withdraw_task create_withdraw_sql', create_withdraw_sql);
    return new Promise((resolve) => {
        mysql.getMySqlInstance().getConnection(function (err, connection) {
            if (err) {
                logger.error('create_withdraw_task', err)
                logger.error('create_withdraw_sql', create_withdraw_sql)
                resolve(null);
                return;
            }
            connection.query(
                create_withdraw_sql, create_withdraw_params,
                function selectCb(error, results) {
                    if (error) {
                        logger.error('create_withdraw_task', error, create_withdraw_sql, create_withdraw_params)
                        resolve(null);
                        return;
                    }
                    logger.log('create_withdraw_task ret=', error, results);
                    //用完当前连接需要释放,归还给连接池
                    connection.release();
                    resolve({
                        err: error,
                        results: results.insertId
                    });
                }
            );
        })
    })

}

/**
 * 更新提币任务
 * @param {*} task_obj 
 */
function update_withdraw_task(withdraw_id, ret_obj) {
    logger.log('update_withdraw_task', ret_obj, withdraw_id)
    // 提币 id
    var withdraw_id = withdraw_id;
    if (!withdraw_id) {
        return {
            code: -1,
            error: 'withdraw_id cannot be empty.'
        }
    }
    var update_withdraw_sql = 'update  withdraw_manage SET withdraw_status=?,withdraw_hash=?,nonce=?,update_time=?,gas_price=?,gas_limit=?,value=?,errorMsg=? WHERE withdraw_id=?'

    var status = ret_obj.withdraw_status
    var hash = ret_obj.withdraw_hash
    var nonce = ret_obj.nonce
    var update_time = ret_obj.update_time
    var gas_price = ret_obj.gas_price
    var gas_limit = ret_obj.gas_limit
    if (!status)
        status = 3
    if (!update_time)
        update_time = utils.getTimestamp()
    var update_withdraw_params = [status, hash, nonce, update_time, gas_price, gas_limit, ret_obj.value, ret_obj.errorMsg ? ret_obj.errorMsg : '', withdraw_id]
    return new Promise((resolve) => {
        mysql.getMySqlInstance().getConnection(function (err, connection) {
            if (err) {
                logger.error('update_withdraw_task', err)
                logger.error('update_withdraw_task', update_withdraw_sql)
                resolve(null);
                return;
            }
            connection.query(
                update_withdraw_sql, update_withdraw_params,
                function selectCb(error, results) {
                    if (error) {
                        logger.error('update_withdraw_task', error, update_withdraw_sql, update_withdraw_params)
                        resolve(null);
                        return;
                    }
                    logger.log('update_withdraw_task ret=', error, results);
                    //用完当前连接需要释放,归还给连接池
                    connection.release();
                    resolve({
                        err: error,
                        results: results
                    });
                }
            );
        })
    })
}

function queryWithdrawInfoFromWithdrawId(withdrawId){
    logger.log('queryWithdrawInfoFromWithdrawId', withdrawId)
    // 提币 id
    if (!withdrawId) {
        return {
            code: -1,
            error: 'withdraw_id cannot be empty.'
        }
    }
    var create_withdraw_sql = 'select * from withdraw_manage WHERE withdraw_id=?'
    var create_withdraw_params = [withdrawId]
    return new Promise((resolve) => {
        mysql.getMySqlInstance().getConnection(function (err, connection) {
            if (err) {
                logger.error('queryWithdrawInfoFromWithdrawId', err)
                logger.error('queryWithdrawInfoFromWithdrawId', create_withdraw_sql)
                resolve(null);
                return;
            }
            connection.query(
                create_withdraw_sql, create_withdraw_params,
                function selectCb(error, results) {
                    if (error) {
                        logger.error('queryWithdrawInfoFromWithdrawId', error, create_withdraw_sql, create_withdraw_params)
                        resolve(null);
                        return;
                    }
                    logger.log('queryWithdrawInfoFromWithdrawId ret=', error, results);
                    //用完当前连接需要释放,归还给连接池
                    connection.release();
                    if (results && Array.isArray(results) && results.length > 0) {
                        resolve(results[0]);
                    } else {
                        resolve(null);
                    }
                }
            );
        })
    })
}

/**
 * 判断该任务是否存在
 * @param {*} withdrawId 
 */
function withdraw_id_exist(withdrawId) {
    logger.log('create_withdraw_task', withdrawId)
    // 提币 id
    if (!withdrawId) {
        return {
            code: -1,
            error: 'withdraw_id cannot be empty.'
        }
    }
    var create_withdraw_sql = 'select * from withdraw_manage WHERE withdraw_id=?'
    var create_withdraw_params = [withdrawId]
    return new Promise((resolve) => {
        mysql.getMySqlInstance().getConnection(function (err, connection) {
            if (err) {
                logger.error('withdraw_id_exist', err)
                logger.error('withdraw_id_exist', create_withdraw_sql)
                resolve(null);
                return;
            }
            connection.query(
                create_withdraw_sql, create_withdraw_params,
                function selectCb(error, results) {
                    if (error) {
                        logger.error('withdraw_id_exist', error, create_withdraw_sql, create_withdraw_params)
                        resolve(null);
                        return;
                    }
                    logger.log('withdraw_id_exist ret=', error, results);
                    //用完当前连接需要释放,归还给连接池
                    connection.release();
                    if (results && Array.isArray(results) && results.length > 0) {
                        resolve(true);
                    } else {
                        resolve(false);
                    }
                }
            );
        })
    })
}


module.exports = {
    create_withdraw_task,
    update_withdraw_task,
    queryWithdrawInfoFromWithdrawId,
    withdraw_id_exist
}