@pexcode/dlis-sdk 1.0.0

package/dist/api/services/RegionsControllerService.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegionsControllerService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class RegionsControllerService {
+    /**
+     * @param regionId
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getCities(regionId) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/api/regions/cities/{regionId}',
+            path: {
+                'regionId': regionId,
+            },
+        });
+    }
+    /**
+     * @param countryId
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getRegions(countryId) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/api/regions/{countryId}',
+            path: {
+                'countryId': countryId,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static createNewCity(requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/api/regions/create-city',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+}
+exports.RegionsControllerService = RegionsControllerService;

package/dist/api/services/SdkControllerService.d.ts

@@ -0,0 +1,54 @@
+import type { branchesAttributes } from '../models/branchesAttributes';
+import type { BranchLedgerAttributes } from '../models/BranchLedgerAttributes';
+import type { CalculateCostAttributes } from '../models/CalculateCostAttributes';
+import type { HttpSuccess } from '../models/HttpSuccess';
+import type { SdkInfoAttributes } from '../models/SdkInfoAttributes';
+import type { SdkLedgerOverview } from '../models/SdkLedgerOverview';
+import type { ShippingServiceData } from '../models/ShippingServiceData';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class SdkControllerService {
+    /**
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getTenantBranches(): CancelablePromise<Array<branchesAttributes>>;
+    /**
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getMyInfo(): CancelablePromise<SdkInfoAttributes>;
+    /**
+     * @param cityId
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getListOfCity(cityId: number): CancelablePromise<Array<branchesAttributes>>;
+    /**
+     * @param requestBody
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static calculateCost(requestBody: CalculateCostAttributes): CancelablePromise<ShippingServiceData>;
+    /**
+     * @param year
+     * @param month
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getLedgerList(year?: number, month?: number): CancelablePromise<Array<BranchLedgerAttributes>>;
+    /**
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getLedgerOverView(): CancelablePromise<SdkLedgerOverview>;
+    /**
+     * @param requestBody
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static setWebhook(requestBody: {
+        host: string;
+        webhookToken: string;
+        path: string;
+    }): CancelablePromise<HttpSuccess>;
+}

package/dist/api/services/SdkControllerService.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SdkControllerService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class SdkControllerService {
+    /**
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getTenantBranches() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/sdk/v2/tenant-branches',
+        });
+    }
+    /**
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getMyInfo() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/sdk/v2/me-info',
+        });
+    }
+    /**
+     * @param cityId
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getListOfCity(cityId) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/sdk/v2/place/{city}',
+            query: {
+                'cityId': cityId,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static calculateCost(requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/sdk/v2/shipping/cost',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @param year
+     * @param month
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getLedgerList(year, month) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/sdk/v2/ledger',
+            query: {
+                'year': year,
+                'month': month,
+            },
+        });
+    }
+    /**
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getLedgerOverView() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/sdk/v2/ledger-overview',
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static setWebhook(requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/sdk/v2/set-webhook',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+}
+exports.SdkControllerService = SdkControllerService;

package/dist/api/services/SdkPackagesControllerService.d.ts

@@ -0,0 +1,55 @@
+import type { CheckBlackListAttribute } from '../models/CheckBlackListAttribute';
+import type { ClientAttributes } from '../models/ClientAttributes';
+import type { HttpSuccess } from '../models/HttpSuccess';
+import type { PackageId } from '../models/PackageId';
+import type { packagesAttributes } from '../models/packagesAttributes';
+import type { SdkPackagesCreationAttributes } from '../models/SdkPackagesCreationAttributes';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class SdkPackagesControllerService {
+    /**
+     * @param id
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getPackageDetails(id: PackageId): CancelablePromise<packagesAttributes>;
+    /**
+     * @param page
+     * @param pageSize
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getList(page?: number, pageSize?: number): CancelablePromise<Array<packagesAttributes>>;
+    /**
+     * @param requestBody
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static createNewPackage(requestBody: SdkPackagesCreationAttributes): CancelablePromise<packagesAttributes>;
+    /**
+     * @param id
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static sendDataToCEnter(id: PackageId): CancelablePromise<HttpSuccess>;
+    /**
+     * @param id
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static canceled(id: PackageId): CancelablePromise<HttpSuccess>;
+    /**
+     * @param id
+     * @param requestBody
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static reportPackage(id: PackageId, requestBody: {
+        reportId: number;
+    }): CancelablePromise<HttpSuccess>;
+    /**
+     * @param requestBody
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static checkBlackList(requestBody: CheckBlackListAttribute): CancelablePromise<ClientAttributes>;
+}

package/dist/api/services/SdkPackagesControllerService.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SdkPackagesControllerService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class SdkPackagesControllerService {
+    /**
+     * @param id
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getPackageDetails(id) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/sdk/v2/packages/package-details/{id}',
+            path: {
+                'id': id,
+            },
+        });
+    }
+    /**
+     * @param page
+     * @param pageSize
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getList(page = 1, pageSize = 10) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/sdk/v2/packages/list',
+            query: {
+                'page': page,
+                'page_size': pageSize,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static createNewPackage(requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/sdk/v2/packages/create',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @param id
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static sendDataToCEnter(id) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/sdk/v2/packages/sentDataToCenter/{id}',
+            path: {
+                'id': id,
+            },
+        });
+    }
+    /**
+     * @param id
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static canceled(id) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'PATCH',
+            url: '/sdk/v2/packages/cancel/{id}',
+            path: {
+                'id': id,
+            },
+        });
+    }
+    /**
+     * @param id
+     * @param requestBody
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static reportPackage(id, requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/sdk/v2/packages/report/{id}',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static checkBlackList(requestBody) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/sdk/v2/packages/check-black-list',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+}
+exports.SdkPackagesControllerService = SdkPackagesControllerService;

package/dist/api/services/SdkRegionsControllerService.d.ts

@@ -0,0 +1,17 @@
+import type { citiesAttributes } from '../models/citiesAttributes';
+import type { regionsAttributes } from '../models/regionsAttributes';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class SdkRegionsControllerService {
+    /**
+     * @param regionId
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getCities(regionId: number): CancelablePromise<Array<citiesAttributes>>;
+    /**
+     * @param countryId
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getRegions(countryId: number): CancelablePromise<Array<regionsAttributes>>;
+}

package/dist/api/services/SdkRegionsControllerService.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SdkRegionsControllerService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class SdkRegionsControllerService {
+    /**
+     * @param regionId
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getCities(regionId) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/sdk/regions/cities/{regionId}',
+            path: {
+                'regionId': regionId,
+            },
+        });
+    }
+    /**
+     * @param countryId
+     * @returns any Ok
+     * @throws ApiError
+     */
+    static getRegions(countryId) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/sdk/regions/{countryId}',
+            path: {
+                'countryId': countryId,
+            },
+        });
+    }
+}
+exports.SdkRegionsControllerService = SdkRegionsControllerService;

package/dist/api-handler.d.ts

@@ -0,0 +1,10 @@
+interface HttpError {
+    status: number;
+    message: string;
+    messageKey: string;
+}
+export declare function ApiCall<T>(service: () => Promise<T>): Promise<{
+    result?: T;
+    error?: HttpError;
+}>;
+export {};

package/dist/api-handler.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiCall = ApiCall;
+function traceError(error) {
+    const exceptionError = error;
+    return exceptionError.body;
+}
+async function exceptionHandler(error) {
+    const exceptionError = traceError(error);
+    if (exceptionError) {
+        console.log(exceptionError.message);
+        console.log(exceptionError.messageKey);
+        console.log(exceptionError.status);
+        throw new Error(exceptionError.message);
+    }
+}
+async function ApiCall(service) {
+    try {
+        const result = await service();
+        return { result };
+    }
+    catch (error) {
+        await exceptionHandler(error);
+        return { error: traceError(error) };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import { branchesAttributes } from "./api/models/branchesAttributes";
+import { CalculateCostAttributes } from "./api/models/CalculateCostAttributes";
+import { CheckBlackListAttribute } from "./api/models/CheckBlackListAttribute";
+import { HttpSuccess } from "./api/models/HttpSuccess";
+import { packagesAttributes } from "./api/models/packagesAttributes";
+import { SdkPackagesCreationAttributes } from "./api/models/SdkPackagesCreationAttributes";
+import { SdkInfoAttributes } from "./api/models/SdkInfoAttributes";
+import { ShippingServiceData } from "./api/models/ShippingServiceData";
+import { regionsAttributes } from "./api/models/regionsAttributes";
+import { citiesAttributes } from "./api/models/citiesAttributes";
+import { BranchLedgerAttributes } from "./api/models/BranchLedgerAttributes";
+import { SdkLedgerOverview } from "./api/models/SdkLedgerOverview";
+export declare class DLISystem {
+    constructor(baseUrl: string, tokenKey: string);
+    GetList(page?: number, pageSize?: number): Promise<packagesAttributes[]>;
+    getCompanyListOfCity(cityId: number): Promise<branchesAttributes[]>;
+    MyInfo(): Promise<SdkInfoAttributes>;
+    getTenantBranches(): Promise<branchesAttributes[]>;
+    GetPackageDetails(id: string): Promise<packagesAttributes>;
+    CheckBlackList(query: CheckBlackListAttribute): Promise<CheckBlackListAttribute>;
+    CancelOne(id: string): Promise<HttpSuccess>;
+    ReportOne(id: string, body: any): Promise<HttpSuccess>;
+    CreatePackage(payload: SdkPackagesCreationAttributes): Promise<packagesAttributes>;
+    CalculateCost(params: CalculateCostAttributes): Promise<ShippingServiceData>;
+    SendDataToCenter(id: string): Promise<HttpSuccess>;
+    GetRegionsList(countryId: number): Promise<regionsAttributes[]>;
+    GetCitiesListInByRegion(regionId: number): Promise<citiesAttributes[]>;
+    GetMyLedger(year?: number, month?: number): Promise<BranchLedgerAttributes[]>;
+    GetMyLedgerOverview(): Promise<SdkLedgerOverview>;
+    SetWebhook(payload: {
+        host: string;
+        webhookToken: string;
+        path: string;
+    }): Promise<HttpSuccess>;
+}
+export { DLISystem as QDSystem };

package/dist/index.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QDSystem = exports.DLISystem = void 0;
+const api_handler_1 = require("./api-handler");
+const OpenAPI_1 = require("./api/core/OpenAPI");
+const SdkControllerService_1 = require("./api/services/SdkControllerService");
+const SdkPackagesControllerService_1 = require("./api/services/SdkPackagesControllerService");
+const SdkRegionsControllerService_1 = require("./api/services/SdkRegionsControllerService");
+const SDK_api_ver = "v3";
+class DLISystem {
+    constructor(baseUrl, tokenKey) {
+        OpenAPI_1.OpenAPI.TOKEN = tokenKey;
+        OpenAPI_1.OpenAPI.BASE = baseUrl;
+        OpenAPI_1.OpenAPI.HEADERS = { 'x-version': SDK_api_ver };
+    }
+    async GetList(page = 1, pageSize = 10) {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkPackagesControllerService_1.SdkPackagesControllerService.getList(page, pageSize));
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async getCompanyListOfCity(cityId) {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkControllerService_1.SdkControllerService.getListOfCity(cityId));
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async MyInfo() {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkControllerService_1.SdkControllerService.getMyInfo());
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async getTenantBranches() {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkControllerService_1.SdkControllerService.getTenantBranches());
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async GetPackageDetails(id) {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkPackagesControllerService_1.SdkPackagesControllerService.getPackageDetails(id));
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async CheckBlackList(query) {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkPackagesControllerService_1.SdkPackagesControllerService.checkBlackList(query));
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async CancelOne(id) {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkPackagesControllerService_1.SdkPackagesControllerService.canceled(id));
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async ReportOne(id, body) {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkPackagesControllerService_1.SdkPackagesControllerService.reportPackage(id, body));
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async CreatePackage(payload) {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkPackagesControllerService_1.SdkPackagesControllerService.createNewPackage(payload));
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async CalculateCost(params) {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkControllerService_1.SdkControllerService.calculateCost(params));
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async SendDataToCenter(id) {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkPackagesControllerService_1.SdkPackagesControllerService.sendDataToCEnter(id));
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async GetRegionsList(countryId) {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkRegionsControllerService_1.SdkRegionsControllerService.getRegions(countryId));
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async GetCitiesListInByRegion(regionId) {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkRegionsControllerService_1.SdkRegionsControllerService.getCities(regionId));
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async GetMyLedger(year, month) {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkControllerService_1.SdkControllerService.getLedgerList(year, month));
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async GetMyLedgerOverview() {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkControllerService_1.SdkControllerService.getLedgerOverView());
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+    async SetWebhook(payload) {
+        const { result, error } = await (0, api_handler_1.ApiCall)(() => SdkControllerService_1.SdkControllerService.setWebhook(payload));
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+}
+exports.DLISystem = DLISystem;
+exports.QDSystem = DLISystem;

package/dist/sdk.spec.d.ts

@@ -0,0 +1 @@
+export {};