Untitled

import { ShipmentService } from "./shipment.service";

import { DeliveryServices, UidDeliveryServices } from "./enums/delivery.services";

import { CACHE_MANAGER } from "@nestjs/cache-manager";

import { Cache } from "cache-manager";

import { ConfigService } from "@nestjs/config";

import { ShipmentWithItems } from "./interfaces/shipment.interface";

import fetch from "node-fetch";

import { CreateFedexPayloadService } from "./fedex.payload.service";

import { Inject, Injectable } from "@nestjs/common";

import { IResponseAlertInterface } from "./interfaces/response.alert.interface";

import { ShipmentLogType, ShipmentStatus } from "@prisma/client";

import { IResponseErrorInterface } from "./interfaces/response.error.interface";

import { ShipmentCancelSchemaDto } from "./dto/fedex/cancel-payload.dto";

import { AccountNumberDto } from "./dto/fedex/accountNumber.dto";

import { DeletionControl } from "./enums/fedex.const";

import { IResponseCancelInterface } from "./interfaces/response.cancel.interface";

import { IResponseShipmentDocumentsInterface } from "./interfaces/response.shipment.documents.interface";

​

@Injectable()

export class ShipmentApiService {

    private fedexApiKey: string;

    private fedexSecretKey: string;

​

    constructor(

        @Inject(CACHE_MANAGER) private cacheManager: Cache,

        private config: ConfigService,

        private shipmentService: ShipmentService,

        private createFedexPayloadService: CreateFedexPayloadService

    ) {}

​

    async sendShipmentByTransactionId(transactionId: string) {

        const shipment = await this.shipmentService.getByTransactionId(transactionId);

        if (shipment.shipmentStatus === ShipmentStatus.ACCEPTED_BY_SHIPPING_SERVICE) {

            return { error: "Shipment already sent and accepted" };

        }

​

        switch (UidDeliveryServices[shipment.shipmentServiceUid]) {

            case DeliveryServices.FEDEX:

                this.sendShipmentToFedex(shipment);

                break;

            case DeliveryServices.DHL:

                this.sendShipmentToDhl(shipment);

                break;

            default:

                break;

        }

    }

​

    async sendShipmentToFedex(shipment: ShipmentWithItems) {

        this.fedexApiKey = this.config.get("FEDEX_API_KEY");

        this.fedexSecretKey = this.config.get("FEDEX_SECRET_KEY");

​

        const fedexShipmentDto = await this.createFedexPayloadService.createPayload(shipment);

        const token = await this.getFedexToken();

        const response = await fetch(this.config.get("FEDEX_API_URL") + "/ship/v1/shipments", {

            method: "POST",

            body: JSON.stringify(fedexShipmentDto),

            headers: {

                Authorization: "Bearer " + token,

                "Content-Type": "application/json",

                "x-customer-transaction-id": shipment.shipmentTransactionId,

            },

        });

​

        const responseObject = await response.json();

​

        let trackingNumber = null;

        switch (true) {

                case responseObject.hasOwnProperty("output"):

                    let count = responseObject.output.transactionShipments.length;

                    let shipmentAlerts: Array<IResponseAlertInterface> = [];

                    const result = responseObject.output.transactionShipments[count - 1];

                    trackingNumber = result.masterTrackingNumber;

                    if (result.hasOwnProperty("alerts")) {

                        shipmentAlerts = result.alerts;

                        shipmentAlerts.forEach(function (alert) {

                            this.shipmentService.addShipmentLog(shipment.id, ShipmentLogType.WARNING, alert.code, alert.message);

                        }, this);

                    }

​

                    let pieceResponses = result.pieceResponses[result.pieceResponses.length - 1];

                    if (pieceResponses.hasOwnProperty("packageDocuments")) {

                        let shipmentDocuments: Array<IResponseShipmentDocumentsInterface> = [];

                        shipmentDocuments = pieceResponses.packageDocuments;

                        shipmentDocuments.forEach(function (document) {

                            this.shipmentService.addShipmentDocuments(

                                shipment.id, 

                                document.url,

                                document.docType, 

                                document.contentType, 

                                pieceResponses.masterTrackingNumber

                            );

                        }, this);

                    }

                break;

                case responseObject.hasOwnProperty("errors"):

                    let shipmentErrors: Array<IResponseErrorInterface> = [];

                    shipmentErrors = responseObject.errors;

                    shipmentErrors.forEach(function (error) {

                        this.shipmentService.addShipmentLog(shipment.id, ShipmentLogType.ERROR, error.code, error.message, null);

                    }, this);

                break;

                default:

                    this.shipmentService.addShipmentLog(shipment.id, ShipmentLogType.ERROR, 'OWN', 'Unexpected json', JSON.stringify(responseObject));

                    return;

        }

​

        let status: ShipmentStatus;

        switch (true) {

            case null === trackingNumber:

                status = ShipmentStatus.REJECTED_BY_SHIPPING_SERVICE;

                break;

            default:

                status = ShipmentStatus.ACCEPTED_BY_SHIPPING_SERVICE;

                break;

        }

​

        this.shipmentService.updateShipment(shipment.id, status, trackingNumber, JSON.stringify(fedexShipmentDto), JSON.stringify(responseObject));

    }

​

    async cancelShipmentFedex(shipment: ShipmentWithItems) {

        const cancelShipmentFedex = new ShipmentCancelSchemaDto();

        cancelShipmentFedex.accountNumber = new AccountNumberDto(this.config.get("FEDEX_ACCOUNT_NUMBER"));

        cancelShipmentFedex.deletionControl = DeletionControl.DELETE_ALL_PACKAGES;

        cancelShipmentFedex.emailShipment = false;

        cancelShipmentFedex.senderCountryCode = shipment.countryFrom;

        cancelShipmentFedex.trackingNumber = shipment.shipmentTrackingNumber;

​

        const token = await this.getFedexToken();

        const response = await fetch(this.config.get("FEDEX_API_URL") + "/ship/v1/shipments/cancel", {

            method: "POST",

            body: JSON.stringify(cancelShipmentFedex),

            headers: {

                Authorization: "Bearer " + token,

                "Content-Type": "application/json",

            },

        });

​

        const responseObject = await response.json();

        let cancelResult: IResponseCancelInterface = undefined;

​

        if (responseObject.hasOwnProperty("output")) {

            cancelResult = responseObject.output;

        }

​

        if (undefined === cancelResult) {

            return;

        }

​

        if (true === cancelResult.cancelledShipment) {

            shipment.shipmentStatus = ShipmentStatus.CANCELED_BY_MANAGER;

        }

    }

​

    async sendShipmentToDhl(shipment: ShipmentWithItems) {

        console.log(JSON.stringify(shipment));

    }

​

    async getFedexToken() {

        const fedexTokenCacheKey = "fedex-token";

​

        let token = await this.cacheManager.get(fedexTokenCacheKey);

        if (undefined !== token) {

            return token;

        }

​

        const data = {

            grant_type: "client_credentials",

            client_id: this.fedexApiKey,

            client_secret: this.fedexSecretKey,

        };

​

        const response = await fetch(this.config.get("FEDEX_API_URL") + "/oauth/token", {

            method: "POST",

            body: new URLSearchParams(data),

            headers: {

                "Content-Type": "application/x-www-form-urlencoded",

            },

        });

​

        const responseJson = await response.json();

        token = responseJson.access_token;

​

        await this.cacheManager.set(fedexTokenCacheKey, token, 3500 * 100);

​

        return token;

    }

}