ZYZ/web-server/app.ts

import 'reflect-metadata'
import * as mongoose from 'mongoose';
import { Application, IBoot } from 'egg';
import { connectRedis } from './app/pubUtils/redis';
import { loadGmDb } from '@db/index';
import { SDK_TA_CONST, THINKING_DATA_MODE, THINKING_DATA_MODE_LIST } from '@consts';
const ThinkingAnalytics = require("thinkingdata-node");

export default class FooBoot implements IBoot {
  private readonly app: Application;

  constructor(app: Application) {
    this.app = app;
  }

  async configWillLoad() {
    // Ready to call configDidLoad,`
    // Config, plugin files are referred,`
    // this is the last chance to modify the config.
    await this.connectDB(this.app);
    await this.connectGMDB(this.app);
    await this.connectRedis(this.app);

    this.app.config.realEnv = this.app.config.env;
    if(this.app.config.env == 'local') {
      this.app.config.realEnv = 'development';
    }
    this.connectThinkingData(this.app);
  }

  configDidLoad() {
    // Config, plugin files have loaded.
  }

  async didLoad() {
    // All files have loaded, start plugin here.
  }

  async willReady() {
    // All plugins have started, can do some thing before app ready.
    // await this.customLoadModel();
    // const ctx = await this.app.createAnonymousContext();
    // await ctx.service.game.readDbMaintenance();
  }

  async didReady() {
    // Worker is ready, can do some things
    // don't need to block the app boot.
  }

  async serverDidReady() {
    // Server is listening.
  }

  async beforeClose() {
    // Do some thing before app close.
  }

  //#region 手动挂载model，测试需要ctx.model 

  public async connectDB(app: Application) {
    const { url, options } = app.config.mongoose
    try {
      if (url) {
        const connection = await mongoose.connect(url, options)
        console.log('******connectDB suc', url, options)
        app.context.connection = connection
      }
    } catch(e) {
      console.log(e)
    }
  }

  public async connectGMDB(app: Application) {
    const { url, options } = app.config.gmmongoose
    try {
      if (url) {
        const connection = await mongoose.createConnection(url, options)
        app.context.connectionGM = connection;
        loadGmDb(connection);
        console.log('******connectGMDB suc', url, options)
      }
    } catch(e) {
      console.log(e)
    }
  }

  public async connectRedis(app: Application) {
    const { url, pw } = app.config.redis
    if (url) {
      const redisClient = connectRedis(url, pw);
      app.context.redisClient = redisClient;
    }
  }

  public connectThinkingData(app: Application) {
    let ta;
    if(THINKING_DATA_MODE == THINKING_DATA_MODE_LIST.DEBUG) {
        ta = ThinkingAnalytics.initWithDebugMode(SDK_TA_CONST.APPID, SDK_TA_CONST.SERVER_URL);
    } else if (THINKING_DATA_MODE == THINKING_DATA_MODE_LIST.BATCH) {
        ta = ThinkingAnalytics.initWithBatchMode(SDK_TA_CONST.APPID, SDK_TA_CONST.SERVER_URL);
    } else if (THINKING_DATA_MODE == THINKING_DATA_MODE_LIST.LOGGING) {
        ta = ThinkingAnalytics.initWithLoggingMode(SDK_TA_CONST.LOG_PATH, {
            pm2: true
        });
    }
    // ta.setDynamicSuperProperties(() => {
    //     return {
    //         env: app.get('env'),
    //         server: app.getServerId(),
    //         mode: THINKING_DATA_MODE
    //     };
    //   });
    app.context.ta = ta;
}

  //#endregion
}
  
  module.exports = FooBoot;