@experteam-mx/ngx-services 18.4.1 → 18.4.3

package/esm2022/lib/apis/api-invoices.service.mjs

@@ -17,13 +17,23 @@ export class ApiInvoicesService {
     get url() {
         return this.environments.apiInvoicesUrl ?? '';
     }
+    /**
+     * Sends an operation document to the server and processes the response.
+     *
+     * @param {OperationDocumentIn} body - The input data for the operation document.
+     * @return {Observable<OperationDocumentOut>} An observable containing the processed operation document output.
+     */
+    postOperationDocument(body) {
+        return this.http.post(`${this.url}/operation/document`, body)
+            .pipe(map(({ data }) => data));
+    }
     /**
      * Fetches and returns the collection receipt data for a given collection ID.
      *
      * @param {number} id - The unique identifier of the collection for which the receipt needs to be retrieved.
-     * @return {Observable<CollectionReceiptOut>} An observable containing the collection receipt data.
+     * @return {Observable<PrintCollectionReceiptOut>} An observable containing the collection receipt data.
      */
-    printCollectionReceipt(id) {
+    getPrintCollectionReceipt(id) {
         return this.http.get(`${this.url}/operation/print/collection-receipt/${id}`)
             .pipe(map(({ data }) => data));
     }
@@ -31,10 +41,10 @@ export class ApiInvoicesService {
      * Handles the account payment operation by sending a POST request to the specified endpoint.
      * Processes the response and returns the operation data.
      *
-     * @param {AccountPaymentOperationIn} body The payload containing information for the account payment operation.
-     * @return {Observable<AccountPaymentOperationOut>} An observable emitting the processed account payment operation data.
+     * @param {OperationAccountPaymentIn} body The payload containing information for the account payment operation.
+     * @return {Observable<OperationAccountPaymentOut>} An observable emitting the processed account payment operation data.
      */
-    accountPaymentOperation(body) {
+    postOperationAccountPayment(body) {
         return this.http.post(`${this.url}/operation/account-payment`, body)
             .pipe(map(({ data }) => data));
     }
@@ -45,7 +55,7 @@ export class ApiInvoicesService {
      * @param body The data required to cancel the payment receipt, encapsulated in a CancelPaymentReceiptIn object.
      * @return An Observable representing the result of the cancellation. Emits an empty object on success.
      */
-    cancelPaymentReceipt(body) {
+    postOperationCancelDocument(body) {
         return this.http.post(`${this.url}/operation/cancel-document`, body)
             .pipe(map(({ data }) => data));
     }
@@ -55,10 +65,70 @@ export class ApiInvoicesService {
      * @param {Object} parameters - The parameters required to cancel the invoice, encapsulated in a CancelBillingIn object.
      * @return {Observable<Object>} An observable that emits the response of the cancellation operation.
      */
-    cancelInvoice({ invoiceId, ...body }) {
+    postOperationCancelBilling({ invoiceId, ...body }) {
         return this.http.post(`${this.url}/operation/cancel-billing/${invoiceId}`, body)
             .pipe(map(({ data }) => data));
     }
+    /**
+     * Fetches a list of customer types from the server.
+     *
+     * @param {QueryParams} params - Query parameters to filter or customize the request.
+     * @return {Observable<CustomerTypesOut>} An observable emitting the customer types fetched from the server.
+     */
+    getCustomerTypes(params) {
+        return this.http.get(`${this.url}/customer-types`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves document types specific to a given country.
+     *
+     * @param {QueryParams} params - The query parameters containing country-specific information.
+     * @return {Observable<CustomerDocumentTypesOut>} An observable emitting the document types available for the specified country.
+     */
+    getCustomerDocumentTypes(params) {
+        return this.http.get(`${this.url}/customer-country-document-types`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches customer invoice details filtered by a custom invoice type.
+     *
+     * @param {InvoiceTypeCustomParamsIn} params - An object containing the filter parameters for the custom invoice type.
+     * @return {Observable<CustomersOut>} An observable containing customer invoice details of the specified type.
+     */
+    getCustomers(params) {
+        return this.http.get(`${this.url}/customers`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Sends a POST request to create or update an external shipment operation.
+     *
+     * @param {OperationShipmentExternalIn} params - The input parameters for the external shipment operation.
+     * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external shipment operation.
+     */
+    postOperationShipmentExternal(params) {
+        return this.http.post(`${this.url}/operation/shipment/external`, params)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Processes an external payment operation for a shipment.
+     *
+     * @param {OperationShipmentExternalIn} params - The input parameters required for the external payment operation.
+     * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external payment operation for a shipment.
+     */
+    postOperationShipmentExternalPayment(params) {
+        return this.http.post(`${this.url}/operation/shipment/external/payment`, params)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves and returns billing operation print details for a given document ID.
+     *
+     * @param {number} documentId - The ID of the document for which to fetch the print billing operation details.
+     * @return {Observable<OperationPrintDocumentOut>} An observable emitting the print billing operation details for the specified document.
+     */
+    getOperationPrintDocument(documentId) {
+        return this.http.get(`${this.url}/operation/print/document/${documentId}`)
+            .pipe(map(({ data }) => data));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiInvoicesService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiInvoicesService, providedIn: 'root' });
 }
@@ -71,4 +141,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     type: Inject,
                     args: ['env']
                 }] }, { type: i1.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-invoices.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam-mx/ngx-services/src/lib/apis/api-invoices.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http'\r\nimport { Inject, Injectable } from '@angular/core'\r\nimport { map, Observable } from 'rxjs'\r\nimport { Environment } from '../ngx-services.models'\r\nimport {\r\n  CancelPaymentReceiptIn,\r\n  CustomerDocumentTypesOut,\r\n  CustomersOut,\r\n  CustomerTypesOut,\r\n  InvoiceTypeCustomParamsIn,\r\n  OperationAccountPaymentIn,\r\n  OperationAccountPaymentOut,\r\n  OperationCancelBillingIn,\r\n  OperationDocumentIn,\r\n  OperationDocumentOut,\r\n  OperationPrintDocumentOut,\r\n  OperationShipmentExternalIn,\r\n  OperationShipmentExternalOut,\r\n  PrintCollectionReceiptOut\r\n} from './models/api-invoices.types'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiInvoicesService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private http: HttpClient\r\n  ) { }\r\n\r\n  /**\r\n   * Retrieves the API URL for invoices from the environments configuration.\r\n   *\r\n   * @return {string} The API URL for invoices.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiInvoicesUrl ?? ''\r\n  }\r\n\r\n  /**\r\n   * Sends an operation document to the server and processes the response.\r\n   *\r\n   * @param {OperationDocumentIn} body - The input data for the operation document.\r\n   * @return {Observable<OperationDocumentOut>} An observable containing the processed operation document output.\r\n   */\r\n  postOperationDocument (body: OperationDocumentIn): Observable<OperationDocumentOut> {\r\n    return this.http.post<ApiSuccess<OperationDocumentOut>>(`${this.url}/operation/document`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches and returns the collection receipt data for a given collection ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the collection for which the receipt needs to be retrieved.\r\n   * @return {Observable<PrintCollectionReceiptOut>} An observable containing the collection receipt data.\r\n   */\r\n  getPrintCollectionReceipt (id: number): Observable<PrintCollectionReceiptOut> {\r\n    return this.http.get<ApiSuccess<PrintCollectionReceiptOut>>(`${this.url}/operation/print/collection-receipt/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Handles the account payment operation by sending a POST request to the specified endpoint.\r\n   * Processes the response and returns the operation data.\r\n   *\r\n   * @param {OperationAccountPaymentIn} body The payload containing information for the account payment operation.\r\n   * @return {Observable<OperationAccountPaymentOut>} An observable emitting the processed account payment operation data.\r\n   */\r\n  postOperationAccountPayment (body: OperationAccountPaymentIn): Observable<OperationAccountPaymentOut> {\r\n    return this.http.post<ApiSuccess<OperationAccountPaymentOut>>(`${this.url}/operation/account-payment`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Cancels a payment receipt based on the provided input.\r\n   * This method sends a POST request to cancel a document.\r\n   *\r\n   * @param body The data required to cancel the payment receipt, encapsulated in a CancelPaymentReceiptIn object.\r\n   * @return An Observable representing the result of the cancellation. Emits an empty object on success.\r\n   */\r\n  postOperationCancelDocument (body: CancelPaymentReceiptIn): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/operation/cancel-document`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Cancels an invoice based on the provided invoice ID and additional parameters.\r\n   *\r\n   * @param {Object} parameters - The parameters required to cancel the invoice, encapsulated in a CancelBillingIn object.\r\n   * @return {Observable<Object>} An observable that emits the response of the cancellation operation.\r\n   */\r\n  postOperationCancelBilling ({ invoiceId, ...body }: OperationCancelBillingIn): Observable<{}> {\r\n    return this.http.post<ApiSuccess<{}>>(`${this.url}/operation/cancel-billing/${invoiceId}`, body)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of customer types from the server.\r\n   *\r\n   * @param {QueryParams} params - Query parameters to filter or customize the request.\r\n   * @return {Observable<CustomerTypesOut>} An observable emitting the customer types fetched from the server.\r\n   */\r\n  getCustomerTypes (params: QueryParams): Observable<CustomerTypesOut> {\r\n    return this.http.get<ApiSuccess<CustomerTypesOut>>(`${this.url}/customer-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves document types specific to a given country.\r\n   *\r\n   * @param {QueryParams} params - The query parameters containing country-specific information.\r\n   * @return {Observable<CustomerDocumentTypesOut>} An observable emitting the document types available for the specified country.\r\n   */\r\n  getCustomerDocumentTypes (params: QueryParams): Observable<CustomerDocumentTypesOut> {\r\n    return this.http.get<ApiSuccess<CustomerDocumentTypesOut>>(`${this.url}/customer-country-document-types`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches customer invoice details filtered by a custom invoice type.\r\n   *\r\n   * @param {InvoiceTypeCustomParamsIn} params - An object containing the filter parameters for the custom invoice type.\r\n   * @return {Observable<CustomersOut>} An observable containing customer invoice details of the specified type.\r\n   */\r\n  getCustomers (params: QueryParams): Observable<CustomersOut> {\r\n    return this.http.get<ApiSuccess<CustomersOut>>(`${this.url}/customers`, { params })\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Sends a POST request to create or update an external shipment operation.\r\n   *\r\n   * @param {OperationShipmentExternalIn} params - The input parameters for the external shipment operation.\r\n   * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external shipment operation.\r\n   */\r\n  postOperationShipmentExternal (params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut> {\r\n    return this.http.post<ApiSuccess<OperationShipmentExternalOut>>(`${this.url}/operation/shipment/external`, params)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Processes an external payment operation for a shipment.\r\n   *\r\n   * @param {OperationShipmentExternalIn} params - The input parameters required for the external payment operation.\r\n   * @return {Observable<OperationShipmentExternalOut>} An observable that emits the result of the external payment operation for a shipment.\r\n   */\r\n  postOperationShipmentExternalPayment (params: OperationShipmentExternalIn): Observable<OperationShipmentExternalOut> {\r\n    return this.http.post<ApiSuccess<OperationShipmentExternalOut>>(`${this.url}/operation/shipment/external/payment`, params)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves and returns billing operation print details for a given document ID.\r\n   *\r\n   * @param {number} documentId - The ID of the document for which to fetch the print billing operation details.\r\n   * @return {Observable<OperationPrintDocumentOut>} An observable emitting the print billing operation details for the specified document.\r\n   */\r\n  getOperationPrintDocument (documentId: number): Observable<OperationPrintDocumentOut> {\r\n    return this.http.get<ApiSuccess<OperationPrintDocumentOut>>(`${this.url}/operation/print/document/${documentId}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}

package/esm2022/lib/apis/api-open-items.service.mjs

@@ -0,0 +1,62 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiOpenItemsService {
+    environments;
+    http;
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the API URL for open-items from the environments' configuration.
+     *
+     * @return {string} The API URL for open-items.
+     */
+    get url() {
+        return this.environments.apiOpenItemsUrl ?? '';
+    }
+    /**
+     * Retrieves a list of open-items based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The parameters to use for querying open-items.
+     * @return {Observable<OpenItemsOut>} An observable that emits the open-item's data.
+     */
+    getOpenItems(params) {
+        return this.http.get(`${this.url}/open-items`, { params })
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Processes a payment for an open item.
+     *
+     * @param {PaymentOpenItemIn} body - The payment details for the open item.
+     * @return {Observable<PaymentOut>} An observable that emits the result of the payment processing.
+     */
+    postPayment(body) {
+        return this.http.post(`${this.url}/payment`, body)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Processes a payment for other invoice.
+     *
+     * @param {OtherInvoiceIn} body - The payment details for the other invoice.
+     * @return {Observable<OtherInvoiceOut>} An observable that emits the result of the payment processing.
+     */
+    postOtherInvoice(body) {
+        return this.http.post(`${this.url}/other-invoices`, body)
+            .pipe(map(({ data }) => data));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiOpenItemsService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiOpenItemsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiOpenItemsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }, { type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/apis/api-reports.service.mjs

@@ -28,6 +28,52 @@ export class ApiReportsService {
             params
         }).pipe(map(({ data }) => data));
     }
+    /**
+     * Fetches the list of shipments with pending payments.
+     *
+     * @param {ExistPendingPaymentsIn} params - The parameters to filter pending payment shipments.
+     * @return {Observable<ShipmentsReportOut>} An observable emitting the shipments report data.
+     */
+    shipmentsPendingPayments(params) {
+        return this.http.get(`${this.url}/shipments-report`, {
+            params: {
+                ...params,
+                limit: 1,
+                offset: 0,
+                to_landing: true,
+                shipment_status_code: 'PMPEN',
+            },
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches shipment reports that are pending invoices based on the specified parameters.
+     * This method retrieves a filtered list of shipments with pending invoice statuses.
+     *
+     * @param {ExistPendingInvoicesIn} params - The parameters to filter the pending invoices, including
+     *                                           shipment status codes, and pagination options.
+     * @return {Observable<ShipmentsReportOut>} An observable that emits the shipment report data based on the filter criteria.
+     */
+    shipmentsPendingInvoices(params) {
+        return this.http.get(`${this.url}/shipments-report`, {
+            params: {
+                ...params,
+                limit: 1,
+                offset: 0,
+                to_landing: true,
+                'shipment_status_code[in]': 'IPMPE,IMPEN,IPPEN',
+            },
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches shipment reports based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters used to filter or define the shipment reports.
+     * @return {Observable<ShipmentsReportOut>} An observable emitting the shipment report data.
+     */
+    getShipmentsReport(params) {
+        return this.http.get(`${this.url}/shipments-report`, { params })
+            .pipe(map(({ data }) => data));
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiReportsService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiReportsService, providedIn: 'root' });
 }
@@ -40,4 +86,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     type: Inject,
                     args: ['env']
                 }] }, { type: i1.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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