@tomei/live-price/src/components/feed-history/feed-history.ts

Tomei live-price Package

import { ClassError, ObjectBase } from '@tomei/general';
import { FeedHistoryRepository } from './feed-history.repository';
import { IFeedHistoryAttr } from '../../interfaces/price-feed-history-attr.interface';
import { Op, Sequelize } from 'sequelize';
import { SourceFeedName } from '../../enum/feed.enum';
import { ActionEnum, Activity } from '@tomei/activity-history';

export class FeedHistory extends ObjectBase implements IFeedHistoryAttr {
  ObjectId: string;
  ObjectName: string;
  TableName: 'price_FeedHistory';
  ObjectType: 'FeedHistory';
  FeedName: SourceFeedName;
  DateTime: Date;
  Currency: string;
  SourceFeedBuyPrice: number;
  SourceFeedSellPrice: number;
  FeedBuyPrice: number;
  FeedSellPrice: number;
  IsSourceFeedAvailableYN: string;
  IsManualPriceActivatedYN: string;
  IsManualCutOffYN: string;
  IsCircuitBreakerActivatedYN: string;

  private static _Repo = new FeedHistoryRepository();

  get FeedHistoryId(): string {
    return this.ObjectId;
  }

  set FeedHistoryId(value: string) {
    this.ObjectId = value;
  }

  private constructor(feedHistoryAttr?: IFeedHistoryAttr) {
    super();
    if (feedHistoryAttr) {
      this.FeedHistoryId = feedHistoryAttr.FeedHistoryId;
      this.FeedName = feedHistoryAttr.FeedName;
      this.DateTime = feedHistoryAttr?.DateTime;
      this.Currency = feedHistoryAttr?.Currency;
      this.SourceFeedBuyPrice = feedHistoryAttr?.SourceFeedBuyPrice;
      this.SourceFeedSellPrice = feedHistoryAttr?.SourceFeedSellPrice;
      this.FeedBuyPrice = feedHistoryAttr?.FeedBuyPrice;
      this.FeedSellPrice = feedHistoryAttr?.FeedSellPrice;
      this.IsSourceFeedAvailableYN = feedHistoryAttr?.IsSourceFeedAvailableYN;
      this.IsManualPriceActivatedYN = feedHistoryAttr?.IsManualPriceActivatedYN;
      this.IsManualCutOffYN = feedHistoryAttr?.IsManualCutOffYN;
      this.IsCircuitBreakerActivatedYN =
        feedHistoryAttr?.IsCircuitBreakerActivatedYN;
    }
  }

  public static async init(dbTransaction: any, FeedHistoryId?: string) {
    try {
      if (FeedHistoryId) {
        const feedHistory = await FeedHistory._Repo.findByPk(
          FeedHistoryId,
          dbTransaction,
        );
        if (feedHistory) {
          return new FeedHistory(feedHistory);
        } else {
          throw new ClassError(
            'FeedHistory',
            'FeedHistoryErrMsg00',
            'FeedHistory Not Found',
          );
        }
      }
      return new FeedHistory();
    } catch (error) {
      throw new ClassError(
        'FeedHistory',
        'FeedHistoryErrMsg00',
        'FeedHistory To Initialize FeedHistory',
      );
    }
  }

  public async saveFeedPrice(priceData: IFeedHistoryAttr, dbTransaction: any) {
    try {
      const payload: IFeedHistoryAttr = {
        FeedHistoryId: this.createId(),
        ...priceData,
      };
      //Set the feed history object properties with the provided price data.
      this.FeedHistoryId = payload.FeedHistoryId;
      this.FeedName = payload.FeedName;
      this.DateTime = payload?.DateTime;
      this.Currency = payload?.Currency;
      this.SourceFeedBuyPrice = payload?.SourceFeedBuyPrice;
      this.SourceFeedSellPrice = payload?.SourceFeedSellPrice;
      this.FeedBuyPrice = payload?.FeedBuyPrice;
      this.FeedSellPrice = payload?.FeedSellPrice;
      this.IsSourceFeedAvailableYN = payload?.IsSourceFeedAvailableYN;
      this.IsManualCutOffYN = payload?.IsManualCutOffYN;
      this.IsCircuitBreakerActivatedYN = payload?.IsCircuitBreakerActivatedYN;
      this.IsManualPriceActivatedYN = payload?.IsManualPriceActivatedYN;
      const feedHistory = await FeedHistory._Repo.create(payload, {
        transaction: dbTransaction,
      });

      if (feedHistory) {
        return new FeedHistory(feedHistory);
      } else {
        throw new ClassError(
          'FeedHistory',
          'FeedHistoryErrMsg01',
          'FeedHistory Not Created',
        );
      }
    } catch (error) {
      throw error;
    }
  }

  public static async getLatestPrice(
    feedName: string,
    currency: string,
    timestamp?: Date,
    dbTransaction?: any,
  ): Promise<IFeedHistoryAttr> {
    //The getLatestPrice() method retrieves price data from the price_FeedHistory table based on the provided feedname and currency . If a timestamp is provided, it retrieves the price record closest to that specific time. If no timestamp is provided, it uses the current timestamp to retrieve the price record. If no matching record is found, it returns an appropriate message.
    try {
      // Part 1: Define Query Filter
      // Create a query filter to search the price_FeedHistory table, ensuring the query includes:
      // The feedname.
      // The currency.
      const queryFilter: any = {
        FeedName: feedName,
        Currency: currency,
      };
      const options: any = {
        where: queryFilter,
        order: [['DateTime', 'DESC']],
        limit: 1,
        transaction: dbTransaction,
      };
      // If a timestamp is provided, find records closest to the timestamp.
      // If no timestamp is provided, use the current timestamp for the search.
      if (timestamp) {
        options.order = [
          [
            Sequelize.literal(
              `ABS(TIMESTAMPDIFF(SECOND, DateTime, '${timestamp.toISOString()}'))`,
            ),
            'ASC',
          ],
        ];
      }
      // Part 2: Search for Price Record
      // Use the query filter to retrieve the closest matching price record.
      // If timestamp is provided, adjust the filter to find the record closest to the provided timestamp.
      // If no timestamp is provided, use the current timestamp and return the most recent record before or equal to this time.
      const feedHistory = await FeedHistory._Repo.findOne(options);
      // Part 3: Handle Response
      // If a matching record is found, return the record.
      // If no matching record is found:
      // If searching with a timestamp, return the message: "No price record found for the specified timestamp."
      // If searching with the current timestamp, return the message: "No latest price record found for the current timestamp."
      if (feedHistory) {
        return feedHistory;
      } else {
        return null;
      }
    } catch (error) {
      throw error;
    }
  }

  public static async findAll(
    page: number,
    row: number,
    feedName: string,
    search?: {
      DateTime: {
        startDate: Date;
        endDate: Date;
      };
    },
    dbTransaction?: any,
  ): Promise<{
    rows: IFeedHistoryAttr[];
    count: number;
  }> {
    try {
      const queryObj: any = {
        FeedName: feedName,
      };

      const options: any = {
        transaction: dbTransaction,
        limit: row,
        offset: row * (page - 1),
        order: [['DateTime', 'DESC']],
      };

      if (search) {
        queryObj.DateTime = {
          [Op.between]: [search.DateTime.startDate, search.DateTime.endDate],
        };
      }

      return await FeedHistory._Repo.findAllWithPagination({
        where: queryObj,
        ...options,
      });
    } catch (error) {
      throw error;
    }
  }
}