dm-web-react/src/services/dmLiteDatabaseService.ts

The DM web client with React.

import * as _ from "lodash";

import { DmLiteMessageService } from "./dmLiteMessageService";
import { BrokerMarketBestPriceTable } from "../modules/bond/databases/table/brokerMarketBestPriceTable";
import { ExchangeImagePriceTable } from "../modules/bond/databases/table/exchangeImagePriceTable";
import { BrokerMarketBestPriceView } from "../modules/bond/models/entity/view/brokerMarketBestPriceView";
import { SqlTemplateProvider, SqlTemplate } from "tsbatis";
import { DynamicQuery, FilterOperator } from "ts-dynamic-query";
import { BondInfoTable } from "../modules/bond/databases/table/bondInfoTable";
import { BondInfo } from "../modules/bond/models/entity/table/bondInfo";
import { deserializeArray } from "class-transformer";
import { ArrayUtils, DateUtils } from "ts-commons";
import { BinlogInfo } from "../modules/bond/models/entity/table/binlogInfo";
import { BinlogInfoTable } from "../modules/bond/databases/table/binlogInfoTable";
import { BrokerMarketBestPrice } from "../modules/bond/models/entity/table";

export class DmLiteDatabaseService {
  private readonly dmLiteMessageService = DmLiteMessageService.Instance;
  private static instance = new DmLiteDatabaseService();
  public static get Instance() {
    return this.instance;
  }

  // table
  private readonly bondInfoTable: BondInfoTable = new BondInfoTable();
  private readonly brokerMarketBestPriceTable: BrokerMarketBestPriceTable = new BrokerMarketBestPriceTable();
  private readonly exchangeImagePriceTable: ExchangeImagePriceTable = new ExchangeImagePriceTable();
  private readonly binlogInfoTable: BinlogInfoTable = new BinlogInfoTable();
  private readonly getBrokerMarketBestPriceViewSql: string;
  private readonly getBrokerMarketBestPriceCountSql: string;

  private constructor() {
    const columnStr = SqlTemplateProvider.getColumnsExpression(BrokerMarketBestPriceView);
    this.getBrokerMarketBestPriceViewSql = `SELECT ${columnStr} FROM ${BrokerMarketBestPriceTable.tableName} JOIN ${BondInfoTable.tableName} ON ${
      BondInfoTable.tableName
    }.bondUniCode = ${BrokerMarketBestPriceTable.tableName}.bondUniCode`;

    this.getBrokerMarketBestPriceCountSql = `SELECT COUNT(0) FROM ${BrokerMarketBestPriceTable.tableName} JOIN ${BondInfoTable.tableName} ON ${
      BondInfoTable.tableName
    }.bondUniCode = ${BrokerMarketBestPriceTable.tableName}.bondUniCode`;
  }

  public async isLocalDbVersionEqual(browserId: string): Promise<boolean> {
    try {
      const binlogVersion = await this.getTableVersion(browserId, BinlogInfoTable.tableName);
      const bondInfoVersion = await this.getTableVersion(browserId, BondInfoTable.tableName);
      const brokertMakertBestPriceVersion = await this.getTableVersion(browserId, BrokerMarketBestPriceTable.tableName);

      const isBinlogVersionEqual = (binlogVersion || 0) >= BinlogInfoTable.version;
      if (!isBinlogVersionEqual) {
        console.warn(`isBinlogVersionEqual: ${isBinlogVersionEqual}; dbVersion: ${binlogVersion}, currentVersion: ${BinlogInfoTable.version}`);
      }
      const isBondInfoVersionEqual = (bondInfoVersion || 0) >= BondInfoTable.version;
      if (!isBondInfoVersionEqual) {
        console.warn(`isBondInfoVersionEqual: ${isBondInfoVersionEqual}; dbVersion: ${bondInfoVersion}, currentVersion: ${BondInfoTable.version}`);
      }
      const isBrokertMakertBestPriceVersionEqual = (brokertMakertBestPriceVersion || 0) >= BrokerMarketBestPriceTable.version;
      if (!isBrokertMakertBestPriceVersionEqual) {
        console.warn(
          `isBrokertMakertBestPriceVersionEqual: ${isBrokertMakertBestPriceVersionEqual}, dbVersion: ${brokertMakertBestPriceVersion}, currentVersion: ${
            BrokerMarketBestPriceTable.version
          }`
        );
      }
      const result = isBinlogVersionEqual && isBondInfoVersionEqual && isBrokertMakertBestPriceVersionEqual;
      return new Promise<boolean>(resolve => resolve(result));
    } catch (e) {
      return new Promise<boolean>((resolve, reject) => reject(e));
    }
  }

  public async getBrokerMarketBestPriceViewWithTotalCount(
    browserId: string,
    dynamicQuery: DynamicQuery<BrokerMarketBestPriceView>,
    offset: number,
    limit: number
  ): Promise<{ data: BrokerMarketBestPriceView[]; totalCount: number }> {
    try {
      console.log("getBrokerMarketBestPriceViewWithTotalCount generate filter start");
      const queryList: SqlTemplate[] = [];
      const dataSqlTemplate = SqlTemplateProvider.getSqlByDynamicQuery<BrokerMarketBestPriceView>(
        BrokerMarketBestPriceView,
        this.getBrokerMarketBestPriceViewSql,
        dynamicQuery
      );
      dataSqlTemplate.sqlExpression = dataSqlTemplate.sqlExpression + ` limit ${offset}, ${limit}`;
      queryList.push(dataSqlTemplate);

      const totalCountSqlTemplate = SqlTemplateProvider.getSqlByDynamicQuery<BrokerMarketBestPriceView>(
        BrokerMarketBestPriceView,
        this.getBrokerMarketBestPriceCountSql,
        dynamicQuery
      );
      queryList.push(totalCountSqlTemplate);
      console.log("getBrokerMarketBestPriceViewWithTotalCount sqlTemplate: ", queryList);
      console.log("getBrokerMarketBestPriceViewWithTotalCount generate filter end");
      const resultListStr = await this.dmLiteMessageService.DatabaseQueryJsonsRequest(browserId, queryList);
      const resultList = JSON.parse(resultListStr);
      const data = resultList[0];
      const totalCount = _.values(resultList[1][0])[0];
      const result: { data: BrokerMarketBestPriceView[]; totalCount: number } = {
        data: data,
        totalCount: totalCount,
      };
      return new Promise<{ data: BrokerMarketBestPriceView[]; totalCount: number }>(resolve => resolve(result));
    } catch (e) {
      return new Promise<{ data: BrokerMarketBestPriceView[]; totalCount: number }>((resolve, reject) => reject(e));
    }
  }

  public async getBrokerMarketBestPriceView(
    browserId: string,
    dynamicQuery: DynamicQuery<BrokerMarketBestPriceView>,
    offset: number,
    limit: number
  ): Promise<BrokerMarketBestPriceView[]> {
    try {
      console.log("getBrokerMarketBestPriceView start");
      const sqlTemplate = SqlTemplateProvider.getSqlByDynamicQuery<BrokerMarketBestPriceView>(
        BrokerMarketBestPriceView,
        this.getBrokerMarketBestPriceViewSql,
        dynamicQuery
      );

      sqlTemplate.sqlExpression = sqlTemplate.sqlExpression + ` limit ${offset}, ${limit}`;
      const result = await this.dmLiteMessageService.DatabaseQueryJsonRequest(browserId, sqlTemplate);
      const views = deserializeArray(BrokerMarketBestPriceView, result);
      console.log("getBrokerMarketBestPriceView sqlTemplate: ", sqlTemplate);
      console.log("getBrokerMarketBestPriceView end");
      return new Promise<BrokerMarketBestPriceView[]>(resolve => resolve(views));
    } catch (e) {
      return new Promise<BrokerMarketBestPriceView[]>((resolve, reject) => reject(e));
    }
  }

  public async getBrokerMarketBestPriceCount(browserId: string, dynamicQuery: DynamicQuery<BrokerMarketBestPriceView>): Promise<number> {
    try {
      const sqlTemplate = SqlTemplateProvider.getSqlByDynamicQuery<BrokerMarketBestPriceView>(
        BrokerMarketBestPriceView,
        this.getBrokerMarketBestPriceCountSql,
        dynamicQuery
      );
      const result = await this.dmLiteMessageService.DatabaseExecuteScalarRequest(browserId, sqlTemplate);
      return new Promise<number>(resolve => resolve(result));
    } catch (e) {
      return new Promise<number>((resolve, reject) => reject(e));
    }
  }

  public async getBinlogInfoByTableName(browserId: string, tableName: string): Promise<BinlogInfo | undefined> {
    try {
      const binlogInfos = await this.getBinlogInfosByTableNames(browserId, [tableName]);
      if (ArrayUtils.isEmpty(binlogInfos)) {
        return new Promise<BinlogInfo | undefined>(resolve => resolve(undefined));
      } else {
        return new Promise<BinlogInfo | undefined>(resolve => resolve(binlogInfos[0]));
      }
    } catch (e) {
      return new Promise<BinlogInfo | undefined>((resolve, reject) => reject(e));
    }
  }

  public async getBinlogInfosByTableNames(browserId: string, tableNames: string[]): Promise<BinlogInfo[]> {
    try {
      if (ArrayUtils.isEmpty(tableNames)) {
        return new Promise<BinlogInfo[]>((resolve, reject) => resolve([]));
      }

      const dynamicQuery = new DynamicQuery<BinlogInfo>().addFilter({
        propertyPath: "tableName",
        operator: FilterOperator.IN,
        value: tableNames,
      });

      const sql = `SELECT tableName, position, updateTime FROM ${BinlogInfoTable.tableName}`;
      const sqlTemplate = SqlTemplateProvider.getSqlByDynamicQuery<BinlogInfo>(BinlogInfo, sql, dynamicQuery);
      const result = await this.dmLiteMessageService.DatabaseQueryJsonRequest(browserId, sqlTemplate);
      const binlogInfos = deserializeArray(BinlogInfo, result);
      return new Promise<BinlogInfo[]>(resolve => resolve(binlogInfos));
    } catch (e) {
      return new Promise<BinlogInfo[]>((resolve, reject) => reject(e));
    }
  }

  public async getBondInfosByBondUniCodes(browserId: string, bondUniCodes: number[]): Promise<BondInfo[]> {
    try {
      if (ArrayUtils.isEmpty(bondUniCodes)) {
        return new Promise<BondInfo[]>((resolve, reject) => resolve([]));
      }

      const dynamicQuery = new DynamicQuery<BondInfo>().addFilter({
        propertyPath: "bondUniCode",
        operator: FilterOperator.IN,
        value: bondUniCodes,
      });

      const sqlTemplate = SqlTemplateProvider.getSelectByDynamicQuery(BondInfo, dynamicQuery);
      const result = await this.dmLiteMessageService.DatabaseQueryJsonRequest(browserId, sqlTemplate);
      const bondInfos = deserializeArray(BondInfo, result);
      return new Promise<BondInfo[]>(resolve => resolve(bondInfos));
    } catch (e) {
      return new Promise<BondInfo[]>((resolve, reject) => reject(e));
    }
  }

  public async getBondInfoByBondCode(browserId: string, bondCode: string): Promise<BondInfo | undefined> {
    try {
      const sqlTemplate = SqlTemplateProvider.getSelectByPk(BondInfo, bondCode);
      const result = await this.dmLiteMessageService.DatabaseQueryJsonRequest(browserId, sqlTemplate);
      const bondInfos = deserializeArray(BondInfo, result);
      if (ArrayUtils.isEmpty(bondInfos)) {
        return new Promise<BondInfo | undefined>(resolve => resolve());
      } else {
        return new Promise<BondInfo | undefined>(resolve => resolve(bondInfos[0]));
      }
    } catch (e) {
      return new Promise<BondInfo | undefined>((resolve, reject) => reject(e));
    }
  }

  public createBinlogInfoTable(browserId: string): Promise<any> {
    const createTableTemplate = this.binlogInfoTable.getCreateTableTemplate();
    return this.dmLiteMessageService.DatabaseCreateTableTemplateRequest(browserId, createTableTemplate);
  }

  public createBondInfoTable(browserId: string): Promise<any> {
    const createTableTemplate = this.bondInfoTable.getCreateTableTemplate();
    return this.dmLiteMessageService.DatabaseCreateTableTemplateRequest(browserId, createTableTemplate);
  }

  public createBrokerMarketBestPriceTable(browserId: string): Promise<any> {
    const createTableTemplate = this.brokerMarketBestPriceTable.getCreateTableTemplate();
    return this.dmLiteMessageService.DatabaseCreateTableTemplateRequest(browserId, createTableTemplate);
  }

  public createExchangeImagePriceTable(browserId: string): Promise<any> {
    const createTableTemplate = this.exchangeImagePriceTable.getCreateTableTemplate();
    return this.dmLiteMessageService.DatabaseCreateTableTemplateRequest(browserId, createTableTemplate);
  }

  public fillBondInfoWithJsonGzipUrl(browserId: string, jsonGzipUrl: string): Promise<any> {
    const tableInfo = this.bondInfoTable.getTableInfo();
    return this.dmLiteMessageService.DatabaseFillWithJsonUrlEncryptRequest(browserId, tableInfo, jsonGzipUrl, 30000);
  }

  public fillBondInfoWithJsonGzipUrls(browserId: string, jsonGzipUrls: string[]): Promise<any> {
    const tableInfo = this.bondInfoTable.getTableInfo();
    return this.dmLiteMessageService.DatabaseFillWithBatchJsonUrlEncryptRequest(browserId, tableInfo, jsonGzipUrls, 60000);
  }

  public fillBrokerMarketBestPriceWithJsonGzipUrl(browserId: string, jsonGzipUrl: string): Promise<any> {
    const tableInfo = this.brokerMarketBestPriceTable.getTableInfo();
    return this.dmLiteMessageService.DatabaseFillWithJsonUrlEncryptRequest(browserId, tableInfo, jsonGzipUrl, 30000);
  }

  public fillBrokerMarketBestPriceWithJsonGzipUrls(browserId: string, jsonGzipUrls: string[]): Promise<any> {
    const tableInfo = this.brokerMarketBestPriceTable.getTableInfo();
    return this.dmLiteMessageService.DatabaseFillWithBatchJsonUrlEncryptRequest(browserId, tableInfo, jsonGzipUrls, 60000);
  }

  public updateBinlogInfo(browserId: string, tableName: string, position: number): Promise<any> {
    const data: BinlogInfo = new BinlogInfo();
    data.tableName = tableName;
    data.position = position;
    data.updateTime = DateUtils.dateToTimestamp(new Date());
    const tableInfo = this.binlogInfoTable.getTableInfo();
    return this.dmLiteMessageService.DatabaseFillWithJsonRequest(browserId, tableInfo, [data]);
  }

  public updateBondInfo(browserId: string, bondInfos: BondInfo[]): Promise<any> {
    const tableInfo = this.bondInfoTable.getTableInfo();
    return this.dmLiteMessageService.DatabaseFillWithJsonRequest(browserId, tableInfo, bondInfos);
  }

  public updateBrokerMarketBestPrice(browserId: string, bestPrices: BrokerMarketBestPrice[]): Promise<any> {
    const tableInfo = this.brokerMarketBestPriceTable.getTableInfo();
    return this.dmLiteMessageService.DatabaseFillWithJsonRequest(browserId, tableInfo, bestPrices);
  }

  public deleteTablePosition(browserId: string, tableName: string): Promise<any> {
    const sql = `DELETE from ${BinlogInfoTable.tableName} WHERE tableName = ?`;
    const sqlTemplate = new SqlTemplate();
    sqlTemplate.sqlExpression = sql;
    sqlTemplate.params = [tableName];
    return this.dmLiteMessageService.DatabaseExecuteScalarRequest(browserId, sqlTemplate);
  }

  public deleteOldBrokerMarketBestPrice(browserId: string): Promise<any> {
    const today = DateUtils.getToday();
    const timestamp = DateUtils.dateToTimestamp(today);
    const sql = `DELETE from ${BrokerMarketBestPriceTable.tableName} WHERE issueDataTime < ?`;
    const sqlTemplate = new SqlTemplate();
    sqlTemplate.sqlExpression = sql;
    sqlTemplate.params = [timestamp];
    return this.dmLiteMessageService.DatabaseExecuteScalarRequest(browserId, sqlTemplate);
  }

  public vacuum(browserId: string): Promise<any> {
    const sql = `vacuum`;
    const sqlTemplate = new SqlTemplate();
    sqlTemplate.sqlExpression = sql;
    return this.dmLiteMessageService.DatabaseExecuteNonQueryRequest(browserId, sqlTemplate);
  }

  private getTableVersion(browserId: string, tableName: string): Promise<number | undefined> {
    const sql = `SELECT version FROM table_version WHERE table_name = ?`;
    const sqlTemplate = new SqlTemplate();
    sqlTemplate.sqlExpression = sql;
    sqlTemplate.params = [tableName];
    return this.dmLiteMessageService.DatabaseExecuteScalarRequest(browserId, sqlTemplate);
  }
}