feat: implement SalesInvoiceTspSwitchService and SalesInvoiceTspService for handling TSP provider interactions

- Add SalesInvoiceTspSwitchService to manage TSP provider selection and sending invoices.
- Introduce SalesInvoiceTspService for creating, sending, and retrieving sales invoices.
- Implement NamaProviderSwitchAdapter for communication with the NAMA TSP provider API.
- Define DTOs for request and response structures specific to the NAMA provider.
- Enhance error handling and logging for TSP provider interactions.
This commit is contained in:
2026-05-03 16:23:17 +03:30
parent ad470d2166
commit a486127ade
62 changed files with 4136 additions and 5015 deletions
@@ -0,0 +1,340 @@
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,
}))
}
}