aps-data-api/src/services/aps-utility-data/aps-utility-data-service.ts

package for data extraction from APS company for omnimetic project

import {
  BatchResponse,
  GetDataPayload,
  Logger,
  LooseObject,
  RequestHeaders,
  UploadFileCallback,
} from '../../typings';
import { HourlyUtilityData, MonthlyUtilityData } from '../../models';

import { UtilityDataService } from './utility-data-service';
import { UtilityUserAccountResponse } from './utility-user-account-response';
import { APSWorkflow } from '../workflow/aps';
import { DateHelper } from '../../helpers';

export class APSUtilityDataService implements UtilityDataService {
  logger?: Logger;

  tunnelingAgentOptions: LooseObject;

  async getServiceAccounts(
    payload: GetDataPayload,
  ): Promise<UtilityUserAccountResponse> {
    try {
      this.logger.info('[APS] Get service accounts function start');

      const apsWorkflow = new APSWorkflow();
      apsWorkflow.logger = this.logger;

      await apsWorkflow.login(payload, this.tunnelingAgentOptions);

      const utilityUserAccountResponse: UtilityUserAccountResponse =
        await apsWorkflow.getServiceAccounts();

      this.logger.info('[APS] Get service accounts function end');

      return utilityUserAccountResponse;
    } catch (err) {
      this.logger.error(
        `[APS] Get service accounts function error: ${err.message}`,
      );

      return Promise.reject(err);
    }
  }

  async getMonthlyUtilityData(
    payload: GetDataPayload,
  ): Promise<MonthlyUtilityData[]> {
    try {
      this.logger.info('[APS] Get monthly utility data function start');

      const apsWorkflow = new APSWorkflow();
      apsWorkflow.logger = this.logger;

      await apsWorkflow.login(payload, this.tunnelingAgentOptions);
      const monthlyUtilityDataList: MonthlyUtilityData[] =
        await apsWorkflow.getMonthlyUtilityData();

      this.logger.info('[APS] Get monthly utility data function end');

      return monthlyUtilityDataList;
    } catch (err) {
      this.logger.error(
        `[APS] Get monthly utility data function error: ${err.message}`,
      );
      return Promise.reject(err);
    }
  }

  async getHourlyUtilityData(
    payload: GetDataPayload,
    beginDate?: Date,
    endDate?: Date,
  ): Promise<HourlyUtilityData[]> {
    try {
      this.logger.info('[APS] Get hourly utility data function start');

      let hourlyUtilityData: HourlyUtilityData[] = [];

      let dateDifference = 0;

      if (beginDate && endDate) {
        dateDifference = DateHelper.diffInDays(beginDate, endDate);
        while (dateDifference > 0) {
          const res: BatchResponse = await this.getHourlyData(
            payload,
            endDate,
            beginDate,
          );
          hourlyUtilityData = hourlyUtilityData.concat(res.batchResponse);

          if (res.nextBatchDate === null) break;

          dateDifference = DateHelper.diffInDays(beginDate, res.nextBatchDate);
        }
      } else {
        let startDate = new Date();
        while (startDate !== null) {
          const res: BatchResponse = await this.getHourlyData(
            payload,
            startDate,
          );
          hourlyUtilityData = hourlyUtilityData.concat(res.batchResponse);
          startDate = res.nextBatchDate;
        }
      }

      this.logger.info('[APS] Get hourly utility data function end');

      return hourlyUtilityData;
    } catch (err) {
      this.logger.error(
        `[APS] Get hourly utility data function error: ${err.message}`,
      );
      return Promise.reject(err);
    }
  }

  async getHourlyData(
    payload: GetDataPayload,
    nextDate: Date,
    finishDate?: Date,
  ): Promise<BatchResponse> {
    try {
      const apsWorkflow = new APSWorkflow();
      apsWorkflow.logger = this.logger;

      await apsWorkflow.login(payload, this.tunnelingAgentOptions);
      const headerAndBody: RequestHeaders =
        await apsWorkflow.getReqHeaderAndBody();

      const headers = headerAndBody.headers;
      const postBody = headerAndBody.requestBody;

      const res = await apsWorkflow.makeBatchRequest(
        headers,
        postBody,
        nextDate,
        finishDate,
      );

      return res;
    } catch (err) {
      this.logger.error(
        `[APS] Get hourly utility data function error: ${err.message}`,
      );
      return Promise.reject(err);
    }
  }

  async getUtilityBills(
    payload: GetDataPayload,
    serviceAccountId: string,
    upload: UploadFileCallback,
  ): Promise<void> {
    try {
      this.logger.info('[APS] Get utility bills function start');

      const apsWorkflow = new APSWorkflow();
      apsWorkflow.logger = this.logger;

      await apsWorkflow.login(payload, this.tunnelingAgentOptions);
      await apsWorkflow.getUtilityBillPDFs(serviceAccountId, upload);

      this.logger.info('[APS] Get utility bills function end');
    } catch (err) {
      this.logger.error(
        `[APS] Get utility bills function error: ${err.message}`,
      );
      return Promise.reject(err);
    }
  }

  async setTunnelingAgent(tunnelingAgentOptions: any): Promise<void> {
    try {
      this.tunnelingAgentOptions = tunnelingAgentOptions;
      return;
    } catch (err) {
      return Promise.reject(err);
    }
  }
}