@facturacr/atv-sdk 0.0.7-beta → 0.0.9-beta

package/src/ATV/index.ts

@@ -0,0 +1,101 @@
+import axios from 'axios'
+import { GetToken } from '../services/getToken/GetToken'
+import { GetTokenDto, GetTokenResponse } from '../services/getToken/types'
+import * as parser from 'fast-xml-parser'
+import qs from 'querystring'
+import { ConfirmationMessageRaw } from '@src/types/facturaInterfaces'
+import { ATVOptions, ConfirmationMessage, Mode, SendConfirmationInput, SendResponse } from './types'
+import { Command, CreateAndSendDocumentResponse, CreateDocumentInput } from './useCases/createDocument/types'
+import { CreateDocumentCommand } from './useCases/createDocument'
+
+export class ATV {
+  public readonly options: ATVOptions
+  constructor(options?: ATVOptions, public readonly mode: Mode = 'prod') {
+    this.options = options
+  }
+
+  public getToken(params: GetTokenDto): Promise<GetTokenResponse> {
+    const tokenService = new GetToken(this)
+    return tokenService.execute(params)
+  }
+
+  public createDocumentCommand(input: CreateDocumentInput): Promise<CreateAndSendDocumentResponse> {
+    const createDocument = new CreateDocumentCommand(this)
+    return createDocument.execute(input)
+  }
+
+  public async sendDocument(input: Command): Promise<SendResponse> {
+    try {
+      const response = await axios(input)
+      return {
+        status: response.status,
+        location: response.headers.location,
+        errorCause: null
+      }
+    } catch (error) {
+      const response = error.response || {}
+      const header = response.headers || {}
+      return {
+        status: error.response.status || 500,
+        errorCause: header['x-error-cause'],
+        location: null
+      }
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  public async sendConfirmation(input: SendConfirmationInput) {
+    try {
+      const response = await axios(input)
+      console.log('response', response)
+      const xmlResponse = response.data['respuesta-xml']
+      if (!xmlResponse) {
+        const state = response.data['ind-estado']
+        return {
+          status: response.status,
+          state,
+          errorCause: null
+        }
+      }
+      const xmlString = this.decodeBase64(xmlResponse)
+
+      return {
+        status: response.status,
+        confirmation: this.parseConfirmationMessage(xmlString),
+        xml: xmlString,
+        errorCause: null
+      }
+    } catch (error) {
+      const response = error.response || {}
+      return {
+        status: response.status || 500,
+        errorCause: response.statusText
+      }
+    }
+  }
+
+  private parseConfirmationMessage(xml: string): ConfirmationMessage {
+    const parsedXml: ConfirmationMessageRaw = parser.parse(xml, {
+      ignoreAttributes: false,
+      tagValueProcessor: a => qs.unescape(a.replace(/(\r\n|\n|\r)/gm, '')),
+      ignoreNameSpace: false,
+      parseNodeValue: false
+    })
+    const msj = parsedXml.MensajeHacienda
+    return {
+      clave: msj.Clave,
+      message: msj.Mensaje,
+      details: msj.DetalleMensaje,
+      emitterFullName: msj.NombreEmisor,
+      emitterIdentifierId: msj.NumeroCedulaEmisor,
+      receiverIdentifierId: msj.NumeroCedulaReceptor,
+      taxesTotalAmount: msj.MontoTotalImpuesto,
+      totalInvoiceAmount: msj.TotalFactura
+    }
+  }
+
+  private decodeBase64(encodedStr: string): string {
+    const buff = Buffer.from(encodedStr, 'base64')
+    return buff.toString('utf-8')
+  }
+}

package/src/ATV/mappers/billDocToAtv.ts

@@ -0,0 +1,103 @@
+import { Document, FacturaElectronicaContenedor, DetalleServicio, Resumen, Persona } from '@src/types/facturaInterfaces'
+import { Document as DomainDocument } from '../core/Document'
+import { OrderLine } from '../core/OrderLine'
+import { Person } from '../core/Person'
+
+type AtvFormat = FacturaElectronicaContenedor
+
+const mapOrderLinesToAtvFormat = (orderLines: OrderLine[]): DetalleServicio => {
+  const LineaDetalle = orderLines.map<DetalleServicio['LineaDetalle'][0]>((orderLine) => {
+    return {
+      NumeroLinea: orderLine.lineNumber,
+      Codigo: orderLine.code,
+      // CodigoComercial
+      Cantidad: orderLine.quantity,
+      UnidadMedida: orderLine.measureUnit,
+      // UnidadMedidaComercial
+      Detalle: orderLine.detail,
+      PrecioUnitario: orderLine.unitaryPrice,
+      MontoTotal: orderLine.totalAmount,
+      // Descuento
+      SubTotal: orderLine.subTotal,
+      // BaseImponible
+      Impuesto: {
+        Codigo: orderLine.tax.code,
+        CodigoTarifa: orderLine.tax.rateCode,
+        Tarifa: orderLine.tax.rate,
+        Monto: orderLine.tax.amount
+      },
+      // ImpuestoNeto
+      MontoTotalLinea: orderLine.totalOrderLineAmount
+    }
+  })
+  return { LineaDetalle }
+}
+
+const mapSummaryInvoice = (summaryInvoice: DomainDocument['summaryInvoice']): Resumen => {
+  return {
+    CodigoTipoMoneda: {
+      CodigoMoneda: summaryInvoice.currency.code,
+      TipoCambio: summaryInvoice.currency.exchangeRate
+    },
+    TotalServGravados: summaryInvoice.totalEncumberedServices,
+    TotalServExentos: summaryInvoice.totalExemptServices,
+    TotalMercanciasGravadas: summaryInvoice.totalEncumberedMerchandise,
+    TotalMercanciasExentas: summaryInvoice.totalExemptMerchandise,
+    TotalGravado: summaryInvoice.totalEncumbered,
+    TotalExento: summaryInvoice.totalExempt,
+    TotalExonerado: summaryInvoice.totalExonerated,
+    TotalVenta: summaryInvoice.totalSale,
+    TotalDescuentos: summaryInvoice.totalDiscounts,
+    TotalVentaNeta: summaryInvoice.totalNetSale,
+    TotalImpuesto: summaryInvoice.totalTaxes,
+    TotalComprobante: summaryInvoice.totalVoucher
+  }
+}
+
+const mapPerson = (person: Person): Persona => {
+  return {
+    Nombre: person.fullName,
+    Identificacion: {
+      Tipo: person.identifierType,
+      Numero: person.identifierId
+    },
+    NombreComercial: person.commercialName,
+    Ubicacion: {
+      Provincia: person.location?.province,
+      Canton: person.location?.canton.padStart(2, '0'),
+      Distrito: person.location?.district.padStart(2, '0'),
+      Barrio: person.location?.neighborhood.padStart(2, '0'),
+      OtrasSenas: person.location?.details
+    },
+    Telefono: {
+      CodigoPais: person.phone?.countryCode,
+      NumTelefono: person.phone?.number
+    },
+    Fax: {
+      CodigoPais: person.fax?.countryCode,
+      NumTelefono: person.fax?.number
+    },
+    CorreoElectronico: person.email
+  }
+}
+
+export const mapDocumentToAtvFormat = (docName: string, document: DomainDocument): AtvFormat => {
+  const key = docName
+  const doc: Document = {
+    Clave: document.clave,
+    CodigoActividad: document.activityCode.padStart(6, '0'),
+    NumeroConsecutivo: document.fullConsecutive,
+    FechaEmision: document.issueDate.toISOString(),
+    Emisor: mapPerson(document.emitter),
+    Receptor: mapPerson(document.receiver),
+    CondicionVenta: document.conditionSale,
+    PlazoCredito: document.deadlineCredit,
+    MedioPago: document.paymentMethod,
+    DetalleServicio: mapOrderLinesToAtvFormat(document.orderLines),
+    ResumenFactura: mapSummaryInvoice(document.summaryInvoice),
+    Otros: document.others
+  }
+  return {
+    [key]: doc
+  }
+}

package/src/ATV/types.ts

@@ -0,0 +1,37 @@
+export type Mode = 'prod' | 'stg' | 'custom';
+
+export type ATVOptions = {
+  defaultOverwrites?: {
+    tokenServiceUrl: string;
+  };
+}
+
+export type TokenServiceProps = {
+  serviceUrl: string;
+  clientId: string;
+}
+
+export type SendResponse = {
+  status: number;
+  location: string;
+  errorCause?: string | null;
+}
+
+export type SendConfirmationInput = {
+  url: string;
+  headers: {
+    Authorization: string;
+    'Content-Type': string;
+  };
+}
+
+export type ConfirmationMessage = {
+  clave: string;
+  message: string;
+  details: string;
+  emitterFullName: string;
+  emitterIdentifierId: string;
+  receiverIdentifierId: string;
+  taxesTotalAmount: string;
+  totalInvoiceAmount: string;
+}

package/src/ATV/useCases/createDocument/index.ts

@@ -0,0 +1,137 @@
+import { Person } from '@src/ATV/core/Person'
+import { OrderLine } from '@src/ATV/core/OrderLine'
+import { FullConsecutive } from '@src/ATV/core/FullConsecutive'
+import { Document } from '@src/ATV/core/Document'
+import { Clave } from '@src/ATV/core/Clave'
+import { mapDocumentToAtvFormat as mapBillToAtvFormat } from '@src/ATV/mappers/billDocToAtv'
+import { genXML } from '@src/lib/genXML'
+import { CreateAndSendDocumentResponse, CreateDocumentInput, Command } from './types'
+import { ATV } from '@src/ATV'
+import { DocumentType } from '@src/ATV/core/DocumentType'
+export type { CreateDocumentInput as CreateBillInput } from './types'
+
+const options: { [key: string]: { serviceUrl: string}} = {
+  prod: {
+    serviceUrl: 'https://api.comprobanteselectronicos.go.cr/v1/recepcion'
+  },
+  stg: {
+    serviceUrl: 'https://api-sandbox.comprobanteselectronicos.go.cr/recepcion/v1/recepcion'
+  }
+}
+
+export class CreateDocumentCommand {
+  private readonly serviceUrl: string
+
+  constructor(scope: ATV) {
+    this.serviceUrl = options[scope.mode].serviceUrl
+  }
+
+  public async execute(dto: CreateDocumentInput): Promise<CreateAndSendDocumentResponse> {
+    const documentName = dto.document.documentName || 'FacturaElectronica'
+    const document = this.createDocument(dto.document)
+    const atvDocument = mapBillToAtvFormat(documentName, document)
+    const xml = await genXML(documentName, atvDocument, dto.signatureOptions)
+    const command = await this.createDocumentCommand(document, xml, dto.token)
+    return {
+      command,
+      extraData: {
+        xml
+      }
+    }
+  }
+
+  private async createDocumentCommand(document: Document, xml: string, token: string): Promise<Command> {
+    return {
+      url: this.serviceUrl,
+      method: 'post',
+      data: {
+        clave: document.clave,
+        fecha: document.issueDate.toISOString(),
+        emisor: {
+          tipoIdentificacion: document.emitter.identifierType,
+          numeroIdentificacion: document.emitter.identifierId
+        },
+        receptor: {
+          tipoIdentificacion: document.receiver.identifierType,
+          numeroIdentificacion: document.receiver.identifierId
+        },
+        comprobanteXml: this.encodeXML(xml)
+      },
+      headers: {
+        Authorization: 'bearer ' + token,
+        'Content-Type': 'application/json'
+      }
+    }
+  }
+
+  private createDocument(document: CreateDocumentInput['document']): Document {
+    const documentType = DocumentType.create(document.documentName)
+    const emitter = this.createEmitter(document.emitter)
+    const receiver = this.createReceiver(document.receiver)
+    const clave = this.createClave(document, documentType)
+    const fullConsective = this.createFullConsecutive(document, documentType)
+    const orderLines = this.createOrderLines(document)
+    return Document.create({
+      clave,
+      fullConsecutive: fullConsective,
+      orderLines,
+      activityCode: document.activityCode,
+      issueDate: new Date(),
+      emitter,
+      receiver,
+      conditionSale: '01',
+      paymentMethod: '01'
+    })
+  }
+
+  private createEmitter(emitterInput: CreateDocumentInput['document']['emitter']): Person {
+    return Person.create(emitterInput)
+  }
+
+  private createReceiver(receiverInput: CreateDocumentInput['document']['receiver']): Person {
+    return Person.create(receiverInput)
+  }
+
+  private createOrderLines(dto: CreateDocumentInput['document']): OrderLine[] {
+    return dto.orderLines.map((orderLine, index) => {
+      return OrderLine.create({
+        detail: orderLine.detail,
+        unitaryPrice: orderLine.unitaryPrice,
+        lineNumber: orderLine.lineNumber || (index + 1).toString(),
+        code: orderLine.code,
+        quantity: orderLine.quantity,
+        measureUnit: orderLine.measureUnit,
+        totalAmount: orderLine.totalAmount,
+        tax: orderLine.tax
+      })
+    })
+  }
+
+  private createFullConsecutive(dto: CreateDocumentInput['document'], docType: DocumentType): FullConsecutive {
+    return FullConsecutive.create({
+      consecutiveIdentifier: dto.consecutiveIdentifier,
+      branch: dto.branch,
+      terminal: dto.terminal,
+      documentType: docType.value
+    })
+  }
+
+  private createClave(dto: CreateDocumentInput['document'], docType: DocumentType): Clave {
+    return Clave.create({
+      branch: dto.branch,
+      ceSituation: dto.ceSituation,
+      consecutiveIdentifier: dto.consecutiveIdentifier,
+      countryCode: dto.countryCode,
+      docKeyType: docType.value,
+      emitterIdentifier: dto.emitter.identifier.id,
+      identifierType: dto.emitter.identifier.type, // TODO add default
+      securityCode: dto.securityCode,
+      terminal: dto.terminal
+    })
+  }
+
+  private encodeXML(xmlStr: string): string {
+    const buffer = Buffer.from(xmlStr)
+    return buffer.toString('base64')
+  }
+}

package/src/ATV/useCases/createDocument/types.ts

@@ -0,0 +1,79 @@
+import { PersonProps } from '@src/ATV/core/Person'
+import { DocumentNames } from '@src/ATV/core/documentNames.types'
+import { Method } from 'axios'
+
+type PersonInput = PersonProps;
+
+type TaxInput = {
+  code: string;
+  rateCode: string;
+  rate: number;
+  amount?: number;
+}
+
+type OrderInput = {
+  detail: string;
+  unitaryPrice: number;
+  lineNumber?: string;
+  code?: string;
+  quantity?: number;
+  measureUnit?: string;
+  totalAmount?: number;
+  subTotal?: number;
+  tax?: TaxInput;
+  totalOrderLineAmount?: number;
+}
+
+export type DocumentTypes = 'FE'
+
+type DocumentInput = {
+  emitter: PersonInput;
+  receiver: PersonInput;
+  branch: string; // sucursal
+  terminal: string; // terminal
+  // documentType: DocumentTypes; // @deprecated
+  documentName: DocumentNames;
+  countryCode: string; // codigoPais
+  securityCode: string; // codigoSeguridad
+  activityCode: string;
+  consecutiveIdentifier: string; // consecutivo
+  ceSituation: string; // situacionCE
+  orderLines: OrderInput[];
+}
+
+export type CreateDocumentInput = {
+  document: DocumentInput;
+  token: string;
+  signatureOptions: {
+    buffer: string;
+    password: string;
+  };
+}
+
+export type Command = {
+  url: string;
+  method: Method;
+  data: {
+    clave: string;
+    fecha: string;
+    emisor: {
+      tipoIdentificacion: string;
+      numeroIdentificacion: string;
+    };
+    receptor: {
+      tipoIdentificacion: string;
+      numeroIdentificacion: string;
+    };
+    comprobanteXml: string;
+  };
+  headers: {
+    Authorization: string;
+    'Content-Type': string;
+  };
+}
+export type CreateAndSendDocumentResponse = {
+  command: Command;
+  extraData: {
+    xml: string;
+  };
+}

package/src/helpers/comprobantes.ts

@@ -39,7 +39,7 @@ export function getBillResum(frontEndRequest: ClientPayload): Resumen {
     },
     TotalServGravados: 0,
     TotalServExentos: 0,
-    TotalServExonerado: 0,
+    // TotalServExonerado: 0,
     TotalMercanciasGravadas: frontEndRequest.total,
     TotalMercanciasExentas: 0,
     TotalGravado: frontEndRequest.total,

package/src/lib/genJSON/confirmXML.ts

@@ -41,7 +41,7 @@ export function getFinalMessage(fullInvoice: any, consecutivoReceptor: string, x
       tipoIdentificacion: fullInvoice.Emisor.Identificacion.Tipo,
       numeroIdentificacion: fullInvoice.Emisor.Identificacion.Numero
     },
-    consecutivoReceptor: consecutivoReceptor,
+    consecutivoReceptor,
     comprobanteXml: xmlBase64
   }
 }

package/src/lib/genJSON/index.ts

@@ -30,7 +30,7 @@ function getBillResum(lines: LineaDetalle[]): Resumen {
     },
     TotalServGravados: 0,
     TotalServExentos: 0,
-    TotalServExonerado: 0,
+    // TotalServExonerado: 0,
     TotalMercanciasGravadas: sum.total,
     TotalMercanciasExentas: 0,
     TotalGravado: sum.total,
@@ -70,7 +70,7 @@ function setTaxObj(subtotal: number, taxObj: Impuesto): Impuesto {
   }
 }
 
-function setLinesDefaults(lines: LineaDetalle[]): LineaDetalle[] {
+export function setLinesDefaults(lines: LineaDetalle[]): LineaDetalle[] {
   return lines.map((line, index) => {
     const quantity = line.Cantidad || 1
     const total = line.PrecioUnitario * quantity

package/src/lib/genXML/xmlConfig.ts

@@ -57,8 +57,8 @@ const MR_XML_ATTRS = { // Mensaje Receptor
 export const xmlExtructures = {
   FacturaElectronica: FE_XML_ATTRS,
   FacturaElectronicaExportacion: FEE_XML_ATTRS,
-  NC: NC_XML_ATTRS,
-  ND: ND_XML_ATTRS,
+  NotaCreditoElectronica: NC_XML_ATTRS,
+  NotaDebitoElectronica: ND_XML_ATTRS,
   CCE: MR_XML_ATTRS,
   CPCE: MR_XML_ATTRS,
   RCE: MR_XML_ATTRS

package/src/services/getToken/GetToken.ts

@@ -7,7 +7,7 @@ const MAIN_DOMAIN = 'https://idp.comprobanteselectronicos.go.cr'
 const options: { [key: string]: GetTokenInternalProps} = {
   prod: {
     serviceUrl: `${MAIN_DOMAIN}/auth/realms/rut/protocol/openid-connect/token`,
-    clientId: 'api'
+    clientId: 'api-prod'
   },
   stg: {
     serviceUrl: `${MAIN_DOMAIN}/auth/realms/rut-stag/protocol/openid-connect/token`,
@@ -16,7 +16,7 @@ const options: { [key: string]: GetTokenInternalProps} = {
 }
 
 export class GetToken {
-  private readonly props: GetTokenInternalProps;
+  private readonly props: GetTokenInternalProps
   constructor(scope: ATV) {
     this.props = this.initProps(scope.mode)
   }

package/src/services/send/index.ts

@@ -20,7 +20,7 @@ export function send(token: string, postOptions: any): Record<string, any> {
 
 export function sendToCustomURL(token: string, url: string): Record<string, any> {
   return axios({
-    url: url,
+    url,
     method: 'get',
     headers: {
       Authorization: 'bearer ' + token,

package/src/types/facturaInterfaces.d.ts

@@ -35,7 +35,7 @@ export interface Resumen {
   };
   TotalServGravados: number;
   TotalServExentos: number;
-  TotalServExonerado: number;
+  // TotalServExonerado: number;
   TotalMercanciasGravadas?: number;
   TotalMercanciasExentas?: number;
   TotalGravado?: number;
@@ -78,11 +78,11 @@ export interface Message {
   DetalleMensaje: string;
 }
 
-export interface FacturaElectronica {
+export interface Document {
   Clave: string;
   CodigoActividad: string;
   NumeroConsecutivo: string;
-  FechaEmision?: Date;
+  FechaEmision?: string;
   Emisor: Persona;
   Receptor: Persona;
   CondicionVenta?: string;
@@ -95,23 +95,30 @@ export interface FacturaElectronica {
   };
 }
 
-export interface FacturaElectronicaExportacion {
-  Clave: string;
-  CodigoActividad: string;
-  NumeroConsecutivo: string;
-  FechaEmision?: Date;
-  Emisor: Persona;
-  Receptor: Persona;
-  CondicionVenta?: string;
-  PlazoCredito?: string;
-  MedioPago?: string;
-  DetalleServicio?: DetalleServicio;
-  ResumenFactura: Resumen;
-  Otros?: {
-    OtroTexto: string;
-  };
+export interface FacturaElectronicaContenedor {
+  [key: 'FacturaElectronica' | 'FacturaElectronicaExportacion']: Document | FacturaElectronicaExportacion;
 }
 
-export interface FacturaElectronicaContenedor {
-  [key: 'FacturaElectronica' | 'FacturaElectronicaExportacion']: FacturaElectronica | FacturaElectronicaExportacion;
+export type ConfirmationMessageRaw = {
+  MensajeHacienda: {
+    Clave: string;
+    NombreEmisor: string;
+    TipoIdentificacionEmisor: string;
+    NumeroCedulaEmisor: string;
+    TipoIdentificacionReceptor: string;
+    NumeroCedulaReceptor: string;
+    Mensaje: string;
+    DetalleMensaje: string;
+    MontoTotalImpuesto: string;
+    TotalFactura: string;
+    '@_xmlns': string;
+    'ds:Signature': {
+      '@_xmlns:ds': string;
+      '@_Id': string;
+      'ds:SignedInfo': unknown;
+      'ds:SignatureValue': unknown;
+      'ds:KeyInfo': unknown;
+      'ds:Object': unknown;
+    };
+  };
 }

package/tools/xsdToJsonSchema.ts

@@ -73,7 +73,7 @@ function processElementsFromComplexType(array: Array<any>): any {
     if (propKey) {
       newObj[propKey] = {
         description: element?.annotation?.documentation,
-        simpleType: simpleType
+        simpleType
       }
     }
   }
@@ -84,7 +84,7 @@ function processComplexType(object: any): any {
   const elements = processElementsFromComplexType(object?.sequence?.element)
   const newObject = {}
   newObject[object?.attributes?.name] = {
-    elements: elements
+    elements
   }
   return newObject
 }

package/__tests__/tests/electronicBill.test.ts

@@ -1,28 +0,0 @@
-import { tokenStub } from '@test/stubs/token.stub'
-import requestStub from '@test/stubs/frontendRequest.stub'
-import eletronicBill from '@src/electronicBill'
-import { send } from '@src/services/send/index'
-import fs from 'fs'
-import path from 'path'
-const SOURCE_P12_URI = path.join(__dirname, '../stubs/dummyKeys/client-identity.p12')
-
-jest.mock('@src/services/send/index')
-
-const mockedSend = send as jest.MockedFunction<typeof send>
-const pem = fs.readFileSync(SOURCE_P12_URI, 'binary')
-
-describe('Get Token', () => {
-  it('should return a valid token', async () => {
-    mockedSend.mockImplementation(() => {
-      return Promise.resolve('')
-    })
-    const bill = await eletronicBill(tokenStub, requestStub, {
-      buffer: pem,
-      password: '1234'
-    })
-
-    console.log('bill', bill)
-
-    expect(bill).toEqual('')
-  })
-})

package/dist/__tests__/stubs/frontendRequest.stub.d.ts

@@ -1,3 +0,0 @@
-import { ClientPayload } from '@src/types/globalInterfaces';
-declare const requestStub: ClientPayload;
-export default requestStub;