game2006web3/server/web3dbspider/services/events/common/BaseEventProcess.js

const log = require('j7/log');
const app = require('j7/app');
const bcutils = require('j7/bcutils');
const utils = require('j7/utils');
const j7event = require('j7/event');
const http = require('j7/http');
const constant = require('common/constant');
const metaFactory = require('../../../metadata/factory');

class BaseEventProcess {

  constructor(proc, conn, eventDb) {
    this.eventProc = proc;
    //this.conn = conn;
    this.eventDb = eventDb;
    this.returnValues = utils.jsonDecode(this.getEventDb()['return_values']);
    this.bcEventConn = null;
    this.bcNftConn = null;
    this.gameConn = null;
  }

  async safeRelease() {
    try {
      if (this.bcEventConn) {
        this.bcEventConn.release();
        this.bcEventConn = null;
      }
      if (this.bcNftConn) {
        this.bcNftConn.release();
        this.bcNftConn = null;
      }
      if (this.gameConn) {
        this.gameConn.release();
        this.gameConn = null;
      }
    } catch (err) {
      utils.safeDumpErrStack(err);
    }
  }

  genLogHead(msg) {
    return this.eventProc.genLogHead(' activate721nft ' + msg);
  }

  getEventDb() {
    return this.eventDb;
  }

  getBlockNumber() {
    return this.eventDb['block_number'];
  }

  getNetId() {
    return this.eventProc.getNetId();
  }

  getContractAddress() {
    return this.eventProc.getContractAddress();
  }

  getContractName() {
    return this.eventProc.getContractName();
  }

  getReturnValues() {
    return this.returnValues;
  }

  throwError(err) {
    const errMsg = this.genLogHead(err);
    throw errMsg;
  }

  async markOk() {
    await this.updateEventDb(
      [
          ['state', constant.EVENTDB_STATE_HANDLED],
          ['modifytime', utils.getUtcTime()],
      ]
    );
  }

  async updateEventDb(fields) {
    const logHead = this.genLogHead('updateEventDb');
    while (true) {
      const {err} = await this.bcEventConn(
        'update',
        this.eventProc.getTableName(),
        [
          ['idx', this.getEventDb['idx']],
        ],
        fields
      );
      if (!err) {
        break;
      }
      log.error(logHead + err);
      await utils.sleep(5000 + utils.randRange(500, 1500));
    }
  }

  async callGameApi(params, checkCb) {
    while (true) {
      try {
        const {err, data} = await http.get('',params);
        if (err) {
          await utils.sleep(3000 + utils.randRange(500, 1500));
          continue;
        }
        const ret = await checkCb(data);
        if (ret) {
          break;
        }
      } catch (e) {
        log.error(e);
      }
      await utils.sleep(3000 + utils.randRange(500, 1500));
    }
  }

  async add721NftRefresh(netId, contractAddress, contractName, tokenId) {
    while (true) {
      const nowTime = utils.getUtcTime();
      const {err} = await this.bcEventConn(
        'upsert',
        't_erc721_refresh',
        [
          ['net_id', netId],
          ['contract_address', contractAddress],
          ['token_id', tokenId],
        ],
        [
          ['status', 0],
          ['!refresh_count', () => {
            return 'refresh_count + 1';
          }],
          ['modifytime', nowTime]
        ],
        [
          ['net_id', netId],
          ['contract_address', contractAddress],
          ['token_id', tokenId],
          ['status', 0],
          ['refresh_count', 1],
          ['createtime', nowTime],
          ['modifytime', nowTime]
        ]
      );
      if (!err) {
        break;
      }
      await utils.sleep(3000 + utils.randRange(500, 1500));
    }
  }

  async bcEventDbConn(method, ...args) {
    if (!this.bcEventConn) {
      const {err, conn} = await app.getDbConn(constant.BCEVENTDB_NAME);
      if (err) {
        return {
          'err': err,
          'row': null,
          'rows': null
        };
      }
      this.bcEventConn = conn;
    }
    return await this.internalDbConn(this.bcEventConn, method, ...args);
  }

  async bcNftDbConn(method, ...args) {
    if (!this.bcNftConn) {
      const {err, conn} = await app.getDbConn(constant.BCNFTDB_NAME);
      if (err) {
        return {
          'err': err,
          'row': null,
          'rows': null
        };
      }
      this.bcNftConn = conn;
    }
    return await this.internalDbConn(this.bcNftConn, method, ...args);
  }

  async gameDbConn(method, ...args) {
    if (!this.gameConn) {
      const {err, conn} = await app.getDbConn(constant.BCNFTDB_NAME);
      if (err) {
        return {
          'err': err,
          'row': null,
          'rows': null
        };
      }
      this.gameConn = conn;
    }
    return await this.internalDbConn(this.gameConn, method, ...args);
  }

  async internalDbConn(conn, method, ...args) {
    const ret = await conn[method](...args);
    return ret;
  }

}

module.exports = BaseEventProcess;