psp_api/src/modules/tspProviders/switch/nama/nama-provider.adapter.ts

import {
  createEnsureSuccessResponseInterceptor,
  createHeaderRequestInterceptor,
  FetchRequestInterceptor,
} from '@/common/interceptors/fetch-request.interceptor'
import { HttpClientUtil } from '@/common/utils/http-client.util'
import {
  CustomerType,
  InvoiceTemplateType,
  PaymentMethodType,
  TspProviderCustomerType,
  TspProviderRequestType,
  TspProviderResponseStatus,
} from '@/generated/prisma/enums'
import { Injectable, Logger } from '@nestjs/common'
import {
  CustomerInfoDto,
  IProviderSwitchAdapter,
  PaymentInfoDto,
  TspProviderBulkSendResultDto,
  TspProviderGetResultDto,
  TspProviderSendItemResultDto,
  TspProviderSendPayloadDto,
} from '../../dto/provider-switch.dto'
import {
  NamaProviderGetResponseDto,
  NamaProviderPaymentInfoDto,
  NamaProviderRequestDto,
  NamaProviderResponseStatus,
  NamaProviderSendItemResponseDto,
} from './nama-provider.dto'

@Injectable()
export class NamaProviderSwitchAdapter implements IProviderSwitchAdapter {
  readonly code = 'NAMA'
  private readonly logger = new Logger(NamaProviderSwitchAdapter.name)
  private readonly sandboxBaseUrl =
    process.env.NAMA_PROVIDER_SANDBOX_URL || 'https://external-api-dev.namatsp.ir'
  private readonly productionBaseUrl =
    process.env.NAMA_PROVIDER_PRODUCTION_URL || 'https://api.nama.ir'

  private readonly sendPath = '/api/v1/invoices/single-send'
  private readonly sendBulkPath = '/api/v1/invoices'
  private readonly checkBulkStatus = '/api/v1/invoices/check-by-uuids'
  private readonly getPath = '/api/v1/invoices'
  constructor(private readonly httpClient: HttpClientUtil) {}

  private get baseUrl() {
    return this.sandboxBaseUrl
    // return process.env.NODE_ENV === 'production'
    //   ? this.productionBaseUrl
    //   : this.sandboxBaseUrl
  }

  private buildSendUrl() {
    return `${this.baseUrl}${this.sendPath}`
  }

  private buildGetUrl(invoiceId: string) {
    return `${this.baseUrl}${this.getPath}/${invoiceId}`
  }

  private createRequestInterceptors(token: string): FetchRequestInterceptor[] {
    return [
      createHeaderRequestInterceptor({
        'Content-Type': 'application/json',
        Authorization: token,
      }),
      createEnsureSuccessResponseInterceptor(),
      {
        onError: (context, error) => {
          this.logger.error(`NAMA request failed: ${context.url}`, error)
          return Promise.reject(error)
        },
      },
    ]
  }

  async send(payload: TspProviderSendPayloadDto): Promise<TspProviderSendItemResultDto> {
    const mappedRequest = this.mapToNamaRequestDto(payload)
    try {
      console.log(mappedRequest)

      const response = await this.httpClient.request(
        this.buildSendUrl(),
        {
          method: 'POST',
          body: JSON.stringify(mappedRequest),
        },
        this.createRequestInterceptors(payload.tsp_token),
      )
      const providerResponse: NamaProviderSendItemResponseDto = await response.json()
      this.logger.debug('NAMA provider response', providerResponse)

      const result: TspProviderSendItemResultDto = {
        invoice_id: payload.invoice_id,
        request_payload: payload,
        hasError: !response.ok,
        message: providerResponse.message,
        sent_at: new Date().toISOString(),
        response_payload: providerResponse,
        received_at: providerResponse.tsp_update_time,
        tax_id: providerResponse.tax_id,
        status: this.mapResponseStatus(
          providerResponse.status as NamaProviderResponseStatus,
        ),
      }

      return result
    } catch (err) {
      this.logger.error('NAMA send failed', err)
      const failure: TspProviderSendItemResultDto = {
        invoice_id: payload.invoice_id,
        request_payload: payload,
        hasError: true,
        message: (err as Error).message,
        sent_at: new Date().toISOString(),
        received_at: new Date().toISOString(),
        tax_id: null,
        status: TspProviderResponseStatus.NOT_SEND,
      }
      return failure
    }
  }

  async sendBulk(
    payloads: TspProviderSendPayloadDto[],
  ): Promise<TspProviderBulkSendResultDto[]> {
    const result: TspProviderBulkSendResultDto[] = []
    for (const payload of payloads) {
      const itemResults = await this.send(payload)
      result.push({
        invoice_id: payload.invoice_id,
        items: [itemResults],
      })
    }
    return result
  }

  async get(invoiceId: string, tsp_token: string): Promise<TspProviderGetResultDto> {
    try {
      const response = await this.httpClient.request(
        this.buildGetUrl(invoiceId),
        {
          method: 'GET',
        },
        this.createRequestInterceptors(tsp_token),
      )
      const providerResponse: NamaProviderGetResponseDto = await response.json()
      this.logger.debug('NAMA provider response', providerResponse)

      const result: TspProviderGetResultDto = {
        hasError: !response.ok,
        message: providerResponse.message,
        response_payload: providerResponse,
        sent_at: new Date().toISOString(),
        received_at: providerResponse.tsp_update_time || new Date().toISOString(),
        tax_id: providerResponse.tax_id,
        status: this.mapResponseStatus(
          providerResponse.status as NamaProviderResponseStatus,
        ),
      }

      return result
    } catch (err) {
      this.logger.error('NAMA send failed', err)
      //  const failure: TspProviderGetResultDto = {
      //    invoice_id: invoiceId,
      //    hasError: true,
      //    message: (err as Error).message,
      //    received_at: new Date().toISOString(),
      //    tax_id: null,
      //    status: TspProviderResponseStatus.NOT_SEND,
      //  }
      //  return failure
      throw err
    }
  }

  private mapResponseStatus(
    status: NamaProviderResponseStatus,
  ): TspProviderResponseStatus {
    switch (status.toUpperCase()) {
      case NamaProviderResponseStatus.SUCCESS:
      case NamaProviderResponseStatus.POSTED:
        return TspProviderResponseStatus.SUCCESS
      case NamaProviderResponseStatus.PENDING:
      case NamaProviderResponseStatus.IN_PROGRESS:
        return TspProviderResponseStatus.QUEUED
      case NamaProviderResponseStatus.FAILED:
        return TspProviderResponseStatus.FAILURE
      default:
        return TspProviderResponseStatus.QUEUED
    }
  }

  private mapToNamaRequestDto(
    payload: TspProviderSendPayloadDto,
  ): NamaProviderRequestDto {
    return {
      uuid: payload.invoice_id,
      economic_code: payload.economic_code,
      fiscal_id: payload.fiscal_id,
      payment: this.mapPayments(payload.payments),
      header: {
        ins: this.mapTspProviderRequestType(payload.type),
        inp: this.mapInvoiceTemplate(payload.invoice_template),
        inty: this.mapTspProviderCustomerType(payload.customer_type),
        inno: payload.invoice_number.toString(),
        tins: '',
        indatim: payload.invoice_date.getTime() + '',
        setm: '1',
        ...this.mapCustomerInfo(payload.customer),
      },
      body: payload.items.map(item => ({
        sstid: item.sku,
        vra: item.sku_vat,
        // sstt: item.unit_type,
        fee: String(item.unit_price),
        dis: String(item.discount),
        mu: item.measure_unit,
        am: String(item.quantity),
        consfee: '0',
        bros: '0',
        spro: '0',
      })),
    }
  }

  private mapTspProviderRequestType(type: TspProviderRequestType) {
    switch (type) {
      case TspProviderRequestType.MAIN:
        return '1'
      case TspProviderRequestType.UPDATE:
        return '2'
      case TspProviderRequestType.REVOKE:
        return '3'
      case TspProviderRequestType.REMOVE:
        return '4'
    }
  }

  private mapInvoiceTemplate(template: InvoiceTemplateType) {
    switch (template) {
      case InvoiceTemplateType.SALE:
        return '1'
      case InvoiceTemplateType.FX_SALE:
        return '2'
      case InvoiceTemplateType.GOLD_JEWELRY:
        return '3'
      case InvoiceTemplateType.CONTRACT:
        return '4'
      case InvoiceTemplateType.UTILITY:
        return '5'
      case InvoiceTemplateType.AIR_TICKET:
        return '6'
      case InvoiceTemplateType.EXPORT:
        return '7'
      case InvoiceTemplateType.BILL_OF_LADING:
        return '8'
      case InvoiceTemplateType.PETROCHEMICAL:
        return '9'
      case InvoiceTemplateType.COMMODITY_EXCHANGE:
        return '11'
      case InvoiceTemplateType.INSURANCE:
        return '13'
    }
  }

  private mapTspProviderCustomerType(type?: TspProviderCustomerType) {
    switch (type) {
      case TspProviderCustomerType.Unknown:
        return '1'
      case TspProviderCustomerType.Known:
        return '2'
      default:
        return '3'
    }
  }

  private mapCustomerType(type?: CustomerType) {
    switch (type) {
      case CustomerType.INDIVIDUAL:
        return '1'
      case CustomerType.LEGAL:
        return '2'
      default:
        return '5'
    }
  }

  private mapCustomerInfo(customer?: CustomerInfoDto) {
    const info = {} as any
    info.tob = this.mapCustomerType(customer?.type)
    if (customer?.type === CustomerType.LEGAL && customer.legal_info) {
      info.name = customer.legal_info.name
      info.bid = customer.legal_info.economic_code
      info.address = ''
    } else if (customer?.type === CustomerType.INDIVIDUAL && customer.individual_info) {
      info.name = `${customer.individual_info?.first_name || ''} ${
        customer.individual_info?.last_name || ''
      }`.trim()
      info.bid = customer.individual_info.national_id
      info.mobile = customer.individual_info.mobile_number
      info.address = ''
    }
    return info
  }

  private mapPaymentMethod(method: PaymentMethodType): number {
    switch (method) {
      case PaymentMethodType.CHEQUE:
        return 1
      case PaymentMethodType.SET_OFF:
        return 2
      case PaymentMethodType.CASH:
        return 3
      case PaymentMethodType.TERMINAL:
        return 4
      case PaymentMethodType.PAYMENT_GATEWAY:
        return 5
      case PaymentMethodType.CARD:
        return 6
      case PaymentMethodType.BANK:
        return 7
      case PaymentMethodType.OTHER:
        return 8
    }
  }

  private mapPayments(payments: PaymentInfoDto[]): NamaProviderPaymentInfoDto[] {
    return payments.map(payment => ({
      pmt: this.mapPaymentMethod(payment.payment_method),
      pv: payment.amount,
      trn: payment.tracking_code,
      pcn: payment.card_number,
      pdt: payment.paid_at ? String(payment.paid_at.getTime()) : undefined,
    }))
  }
}