game2006web3/server/web3dbspider/metadata/factory.js

const app = require('j7/app');
const utils = require('j7/utils');
const bcutils = require('j7/bcutils');
const log = require('j7/log');

const metaClassList = [];
const metaClasses = {};
const web3ConfHash = {};
const airDropTokenIdHash = {};
let web3DbSpiderConf = null;
let configDir = './config/';

function registerMetaClass(fileName, primKey, wrapClass) {
  const metaClass = {
    'fileName' : fileName,
    'primKey' : primKey,
    'wrapClassName': wrapClass,
    'wrapClass': require('./' + wrapClass),
    'rawList' : [],
    'rawHash' : {},
    'wrapList' : [],
    'wrapHash' : {},
  };
  metaClassList.push(metaClass);
  metaClasses[wrapClass] = metaClass;
}

function load() {
  metaClassList.forEach((metaClass) => {
    const json = utils.readJsonFromFile(metaClass['fileName']);
    if (!json) {
      throw new Error('读取配置' + metaClass['fileName'] + '失败');
    }
    if (Array.isArray(json)) {
      metaClass['rawList'] = json;

    } else {
      metaClass['rawList'].push(json);
    }
    let idx = 0;
    metaClass['rawList'].forEach(function (item) {
      const wrapOjb = new metaClass['wrapClass'](item, metaClass);
      const wrapProxy = new Proxy(wrapOjb, wrapOjb._getHandler());
      metaClass['wrapList'].push(wrapProxy);
      if (metaClass['primKey'] == '') {
        metaClass['rawHash'][idx] = item;
        metaClass['wrapHash'][idx] = wrapProxy;
      } else {
        metaClass['rawHash'][item[metaClass['primKey']]] = item;
        metaClass['wrapHash'][item[metaClass['primKey']]] = wrapProxy;
      }
      ++idx;
    });
    //log.debug(utils.jsonEncode(metaClass));
  });
  {
    for (let i = 0; i < 3; ++i) {
      metaClassList.forEach((metaClass) => {
        metaClass['wrapList'].forEach((item) => {
          if (item['_init' + i]) {
            item['_init' + i](exports);
          }
        });
      });
    }
    metaClassList.forEach((metaClass) => {
      metaClass['wrapList'].forEach((item) => {
        item.lock();
      });
    });
  }
}

async function init() {
  configDir = './config/';
  if (utils.isOnlineEnv()) {
    configDir = '../config/';
  } else if (utils.getArgv('env') == 'dev'){
    configDir = './config_dev/';
  }
  console.log(configDir, utils.getArgv('env'));

  let resDir = './res/';
  if (utils.isOnlineEnv()) {
    resDir = '../res/';
  } else if (utils.getArgv('env') == 'dev'){
    resDir = './res/';
  }
  console.log(resDir);

  registerMetaClass(configDir + 'config.json',
                    '',
                    'Config'
                   );
  registerMetaClass(configDir + 'bcevent_mysql.json',
                    '',
                    'BcEventDb'
                   );
  registerMetaClass(configDir + 'bcnft_mysql.json',
                    '',
                    'BcNftDb'
                   );
  registerMetaClass(configDir + 'game_mysql.json',
                    '',
                    'GameDb'
                   );
  registerMetaClass(configDir + 'web3dbspider.cluster.json',
                    '',
                    'Web3DbSpider'
                   );
  registerMetaClass(configDir + 'events.json',
                    'net_id',
                    'Events'
                   );
  registerMetaClass(resDir + 'item@item.json',
                    'id',
                    'Item'
                   );
  load();
  {
    traverseMetaList('BcEventDb', (dbConf, idx) => {
      app.registerDb('BcEventDb' + idx, dbConf);
    });
    traverseMetaList('BcNftDb', (dbConf, idx) => {
      app.registerDb('BcNftDb' + idx, dbConf);
    });
    traverseMetaList('GameDb', (dbConf, idx) => {
      app.registerDb('GameDb' + idx, dbConf);
    });
    traverseMetaList('Web3DbSpider', (item, idx) => {
      if (item['instance_id'] == app.getInstanceId()) {
        web3DbSpiderConf = item;
        item['nets'].forEach((net) => {
          const netId = net['net_id'];
          const netDir = configDir + 'nets/' + netId + '/';
          const netObj = {
            'net_id': netId,
            'netId': netId,
            'Web3': utils.readJsonFromFile(netDir + 'web3.json'),
            'Contract': utils.readJsonFromFile(netDir + 'contract.json'),
            'Events': getMetaByKey('Events', netId)['events']
          };
          netObj.getContractAddressByName = (name) => {
            let address = '';
            netObj.Contract.forEach(
              (item) => {
                if (item['name'] == name) {
                  address = bcutils.toNormalAddress(item['address']);
                }
              }
            );
            return address;
          };
          web3ConfHash[netId] = netObj;
          {
            net['air_drop'].forEach(
              (item) => {
                const airDropDate = item;
                console.log('load AirDrop: ' + item);
                const jsonData = utils.readJsonFromFile
                (configDir + `airdrops/${airDropDate}.airdrop.json`);
              }
            );
          }
        });//end forEach nets
      }
    });
  }
}

function getMetaClass(name) {
  return utils.hasKey(metaClasses, name) ? metaClasses[name] : null;
}

function getMetaByKey(name, key) {
  const metaClass = getMetaClass(name);
  return metaClass && key in metaClass['wrapHash'] ? metaClass['wrapHash'][key] : null;
}

function getMetaList(name) {
  const metaClass = getMetaClass(name);
  return metaClass ? metaClass['wrapList'] : null;
}

function callMetaStatic(name, method, ...args) {
  const metaClass = getMetaClass(name);
  return metaClass['wrapClass'][method](...args);
}

function traverseMetaList(name, cb) {
  const metaList = getMetaList(name);
  if (metaList) {
    for (let i = 0; i < metaList.length; ++i) {
      if (!cb(metaList[i], i, metaList.length)) {
        break;
      }
    }
  }
}

function getConf(netId) {
  const keys = Object.keys(web3ConfHash);
  for (let i = 0; i < keys.length; ++i) {
    const conf = web3ConfHash[keys[i]];
    if (conf['net_id'] == netId) {
      return conf;
    }
  }
  return null;
}

function getWeb3Conf(netId) {
  const conf = getConf(netId);
  return conf ? conf['Web3'] : null;
}

function getWeb3DbSpiderConf() {
  return web3DbSpiderConf;
}

function getContractsConf(netId) {
  const conf = getConf(netId);
  return conf ? conf['Contract'] : null;
}

function getNetList() {
  const netList = [];
  const keys = Object.keys(web3ConfHash);
  for (let i = 0; i < keys.length; ++i) {
    netList.push(web3ConfHash[keys[i]]);
  }
  return netList;
}

function getNetDir(netId) {
  const netDir = configDir + 'nets/' + netId + '/';
  return netDir;
}

function getAllTables() {
  const tables = {};
  getNetList().forEach(
    (net) => {
      net['Events'].forEach(
        (item) => {
          tables[item['table_name']] = {
            'table_name': item['table_name']
          };
        }
      );
    });
  return tables;
}

function getAirDrop(tokenId, netId, tokenType, contractAddress) {
  const airDropMeta = callMetaStatic('AirDrop', 'getAirDropByTokenId', tokenId);
  return airDropMeta;
}

exports.init = init;

exports.getMetaByKey = getMetaByKey;
exports.traverseMetaList = traverseMetaList;
exports.callMetaStatic = callMetaStatic;

exports.getWeb3Conf = getWeb3Conf;
exports.getWeb3DbSpiderConf = getWeb3DbSpiderConf;
exports.getContractsConf = getContractsConf;
exports.getNetList = getNetList;
exports.getNetDir = getNetDir;
exports.getAllTables = getAllTables;
exports.getAirDrop = getAirDrop;