@vendit-dev/thirdparty-adapters 0.7.6 → 0.7.9

package/.idea/codeStyles/Project.xml

@@ -0,0 +1,50 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Project" version="173">
+    <JSCodeStyleSettings version="0">
+      <option name="FORCE_SEMICOLON_STYLE" value="true" />
+      <option name="USE_DOUBLE_QUOTES" value="false" />
+      <option name="FORCE_QUOTE_STYlE" value="true" />
+      <option name="VAR_DECLARATION_WRAP" value="2" />
+      <option name="OBJECT_LITERAL_WRAP" value="2" />
+      <option name="SPACES_WITHIN_OBJECT_LITERAL_BRACES" value="true" />
+      <option name="SPACES_WITHIN_IMPORTS" value="true" />
+    </JSCodeStyleSettings>
+    <TypeScriptCodeStyleSettings version="0">
+      <option name="FORCE_SEMICOLON_STYLE" value="true" />
+      <option name="USE_DOUBLE_QUOTES" value="false" />
+      <option name="FORCE_QUOTE_STYlE" value="true" />
+      <option name="VAR_DECLARATION_WRAP" value="2" />
+      <option name="OBJECT_LITERAL_WRAP" value="2" />
+      <option name="SPACES_WITHIN_OBJECT_LITERAL_BRACES" value="true" />
+      <option name="SPACES_WITHIN_IMPORTS" value="true" />
+    </TypeScriptCodeStyleSettings>
+    <codeStyleSettings language="JavaScript">
+      <option name="BLOCK_COMMENT_ADD_SPACE" value="true" />
+      <option name="ALIGN_MULTILINE_PARAMETERS" value="false" />
+      <option name="ALIGN_MULTILINE_FOR" value="false" />
+      <option name="METHOD_CALL_CHAIN_WRAP" value="2" />
+      <option name="IF_BRACE_FORCE" value="1" />
+      <option name="DOWHILE_BRACE_FORCE" value="1" />
+      <option name="WHILE_BRACE_FORCE" value="1" />
+      <option name="FOR_BRACE_FORCE" value="1" />
+      <indentOptions>
+        <option name="INDENT_SIZE" value="2" />
+        <option name="CONTINUATION_INDENT_SIZE" value="2" />
+      </indentOptions>
+    </codeStyleSettings>
+    <codeStyleSettings language="TypeScript">
+      <option name="BLOCK_COMMENT_ADD_SPACE" value="true" />
+      <option name="ALIGN_MULTILINE_PARAMETERS" value="false" />
+      <option name="ALIGN_MULTILINE_FOR" value="false" />
+      <option name="METHOD_CALL_CHAIN_WRAP" value="2" />
+      <option name="IF_BRACE_FORCE" value="1" />
+      <option name="DOWHILE_BRACE_FORCE" value="1" />
+      <option name="WHILE_BRACE_FORCE" value="1" />
+      <option name="FOR_BRACE_FORCE" value="1" />
+      <indentOptions>
+        <option name="INDENT_SIZE" value="2" />
+        <option name="CONTINUATION_INDENT_SIZE" value="2" />
+      </indentOptions>
+    </codeStyleSettings>
+  </code_scheme>
+</component>

package/.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </state>
+</component>

package/.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
+  </profile>
+</component>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/thirdparty-adapters.iml" filepath="$PROJECT_DIR$/.idea/thirdparty-adapters.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/thirdparty-adapters.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/lib/adapters/externalChannelManagers/externalChannelManager.type.d.ts

@@ -0,0 +1,130 @@
+export interface ExternalRoomType {
+    roomTypeCode?: string | number;
+    roomTypeName?: string;
+    groups?: {
+        groupCode: string | number;
+        groupName?: string;
+        roomTypeCode?: string | number;
+    }[];
+    agentRoomTypes?: {
+        agentRoomTypeCode: string | number;
+        agentRoomTypeName?: string;
+        groupCode?: string | number;
+        roomTypeCode?: string | number;
+    }[];
+}
+type ReservationType = 'rent' | 'lodge';
+/**
+ *   CANCELLED
+ *   AWAIT
+ *   RESERVED
+ *   ROOM_ASSIGNED
+ *   ROOM_MANUALLY_ASSIGNED
+ *   CHECKED_IN
+ */
+export type ReservationStatus = 'CANCELLED' | 'AWAIT' | 'RESERVED' | 'ROOM_ASSIGNED' | 'ROOM_MANUALLY_ASSIGNED' | 'CHECKED_IN';
+export type ExternalReservationType = 'CREATED' | 'UPDATED' | 'CANCELLED';
+export interface ExternalReservation {
+    type: ExternalReservationType;
+    externalId: string;
+    externalRevision: string;
+    guestOrGroupInfo: {
+        isGroupReservation?: boolean;
+        email?: string;
+        name?: string;
+        memo?: string;
+        phone?: string;
+        platform?: string;
+        externalPlatformCode?: string | number;
+        externalPlatformName?: string;
+        /**
+         * 예약 경로
+         */
+        reservedBy?: string;
+        /**
+         * 예약 상태 가예약 'provision' | 확정예약 'reserved'| 지불완료 'paid'
+         */
+        status?: 'provision' | 'reserved' | 'paid';
+        useExpireAt?: string;
+        useStartAt?: string;
+    };
+    reservations: VenditReservationInput[];
+    rawData?: string;
+}
+export type VenditReservationInput = {
+    useStartAt: string;
+    useExpireAt: string;
+    externalRoomTypeCode: string;
+    externalRoomTypeName: string;
+    status: ReservationStatus;
+    type: ReservationType;
+    sleeps?: number;
+    phone?: string;
+    platform?: string;
+    externalPlatformCode?: string | number;
+    externalPlatformName?: string;
+    cmsOtaNumber?: string;
+    cmsProductName?: string;
+    guestName?: string;
+    useVehicle?: boolean;
+    vehicleNumber?: string;
+    data?: string;
+    memoContent?: string;
+    otaNumber?: string;
+    paymentInfo?: VenditPaymentInfoInput;
+};
+export type VenditPaymentInfoInput = {
+    amount: number;
+    approvalId?: string;
+    buyerCompany?: string;
+    cardNumber?: string;
+    commissionAmount?: number;
+    data?: string;
+    displayMessage?: string;
+    isCancelled?: boolean;
+    isFullyPaid?: boolean;
+    isReservationPayment?: boolean;
+    issuedCompany?: string;
+    merchantNumber?: string;
+    outstandingAmount?: number;
+    parentPaymentId?: string;
+    phone?: string;
+    purpose?: string;
+    reservationType: ReservationType;
+    externalRoomTypeCode: string;
+    externalRoomTypeName: string;
+    segments?: {
+        amount: number;
+        data?: string;
+        referenceId?: string;
+        referenceType: 'RESERVATION' | 'SERVICE';
+        referenceSubType?: string;
+        servedAt: string;
+    }[];
+    transactionId?: string;
+    type: 'creditCard' | 'cash' | 'account' | 'platform';
+    useStartAt: string;
+};
+export declare abstract class ExternalChannelManager {
+    abstract getRoomTypes(): Promise<ExternalRoomType[]>;
+    abstract getReservations(input?: unknown): Promise<ExternalReservation[] | undefined>;
+    abstract updateStocks(input?: unknown): Promise<boolean>;
+    abstract updatePricePlans(input?: unknown): Promise<boolean>;
+}
+export declare class ExternalChannelManagerError extends Error {
+    code?: string;
+    description?: string;
+    constructor({ message, code, description, }: {
+        message: string;
+        code?: string;
+        description?: string;
+    });
+}
+export interface ExternalChannelManagerUpdateStockRequest {
+    roomTypeCode: string;
+    dailyStocks: {
+        date: string;
+        stock: number;
+    }[];
+}
+export {};

package/lib/adapters/externalChannelManagers/externalChannelManager.type.js

@@ -0,0 +1,40 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalChannelManagerError = exports.ExternalChannelManager = void 0;
+var ExternalChannelManager = /** @class */ (function () {
+    function ExternalChannelManager() {
+    }
+    return ExternalChannelManager;
+}());
+exports.ExternalChannelManager = ExternalChannelManager;
+var ExternalChannelManagerError = /** @class */ (function (_super) {
+    __extends(ExternalChannelManagerError, _super);
+    function ExternalChannelManagerError(_a) {
+        var message = _a.message, code = _a.code, description = _a.description;
+        var _this = _super.call(this, message) || this;
+        _this.name = 'ExternalChannelManagerError';
+        _this.code = code;
+        _this.description = description;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(_this, ExternalChannelManagerError);
+        }
+        return _this;
+    }
+    return ExternalChannelManagerError;
+}(Error));
+exports.ExternalChannelManagerError = ExternalChannelManagerError;

package/lib/adapters/externalChannelManagers/externalChannelManagerCaller.d.ts

@@ -0,0 +1,10 @@
+import type { BaseExternalChannelManagerCaller } from './externalChannelManagerCaller.type';
+import type { ExternalChannelManager, ExternalChannelManagerUpdateStockRequest, ExternalReservation, ExternalRoomType } from './externalChannelManager.type';
+export default class ExternalChannelManagerCaller implements BaseExternalChannelManagerCaller {
+    private externalChannelManager;
+    use<TCredential>(externalChannelManager: ExternalChannelManager): void;
+    getReservations(...input: unknown[]): Promise<ExternalReservation[] | undefined>;
+    updateStocks(input: ExternalChannelManagerUpdateStockRequest[]): Promise<boolean>;
+    updatePricePlans<TRequest>(input: TRequest): Promise<boolean>;
+    getRoomTypes(): Promise<ExternalRoomType[]>;
+}

package/lib/adapters/externalChannelManagers/externalChannelManagerCaller.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var ExternalChannelManagerCaller = /** @class */ (function () {
+    function ExternalChannelManagerCaller() {
+    }
+    ExternalChannelManagerCaller.prototype.use = function (externalChannelManager) {
+        this.externalChannelManager = externalChannelManager;
+    };
+    ExternalChannelManagerCaller.prototype.getReservations = function () {
+        var input = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            input[_i] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.externalChannelManager.getReservations(input)];
+            });
+        });
+    };
+    ExternalChannelManagerCaller.prototype.updateStocks = function (input) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.externalChannelManager.updateStocks(input)];
+            });
+        });
+    };
+    ExternalChannelManagerCaller.prototype.updatePricePlans = function (input) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.externalChannelManager.updatePricePlans(input)];
+            });
+        });
+    };
+    ExternalChannelManagerCaller.prototype.getRoomTypes = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.externalChannelManager.getRoomTypes()];
+            });
+        });
+    };
+    return ExternalChannelManagerCaller;
+}());
+exports.default = ExternalChannelManagerCaller;

package/lib/adapters/externalChannelManagers/externalChannelManagerCaller.type.d.ts

@@ -0,0 +1,4 @@
+import { ExternalChannelManager } from './externalChannelManager.type';
+export declare abstract class BaseExternalChannelManagerCaller extends ExternalChannelManager {
+    abstract use<TCredential>(externalChannelManager: ExternalChannelManager): void;
+}

package/lib/adapters/externalChannelManagers/externalChannelManagerCaller.type.js

@@ -0,0 +1,27 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseExternalChannelManagerCaller = void 0;
+var externalChannelManager_type_1 = require("./externalChannelManager.type");
+var BaseExternalChannelManagerCaller = /** @class */ (function (_super) {
+    __extends(BaseExternalChannelManagerCaller, _super);
+    function BaseExternalChannelManagerCaller() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return BaseExternalChannelManagerCaller;
+}(externalChannelManager_type_1.ExternalChannelManager));
+exports.BaseExternalChannelManagerCaller = BaseExternalChannelManagerCaller;

package/lib/adapters/externalChannelManagers/tl-lincoln.d.ts

@@ -0,0 +1,25 @@
+import { type ExternalChannelManager, type ExternalChannelManagerUpdateStockRequest, type ExternalReservation, type ExternalRoomType } from './externalChannelManager.type';
+import { type TlLincolnCredentials, type TlLincolnReservationRequestInput, type TlLincolnReservationResponse, type TlLincolnStockUpdateInput, type TlLincolnStockUpdateResponse } from './tl-lincoln.types';
+export declare class TlLincoln implements ExternalChannelManager {
+    private API_URL;
+    private readonly systemId;
+    private readonly pmsUserId;
+    private readonly pmsPassword;
+    constructor({ credentials, apiHost }: {
+        credentials: TlLincolnCredentials;
+        apiHost?: string;
+    });
+    getReservations(input?: TlLincolnReservationRequestInput, mergedReservations?: ExternalReservation[]): Promise<ExternalReservation[] | undefined>;
+    getRoomTypes(): Promise<ExternalRoomType[]>;
+    updatePricePlans<TRequest>(): Promise<boolean>;
+    updateStocks(input: ExternalChannelManagerUpdateStockRequest[]): Promise<boolean>;
+    private generateEightByteId;
+    private refineUpdateStockData;
+    private callApi;
+    private netRoomTypeMasterSearchService;
+    netStockAdjustmentService(input: TlLincolnStockUpdateInput): Promise<TlLincolnStockUpdateResponse>;
+    netPlanMasterSearchService(): Promise<ExternalRoomType[]>;
+    netPriceAdjustmentService(): Promise<boolean>;
+    bookingInfoOutputService(input?: TlLincolnReservationRequestInput): Promise<TlLincolnReservationResponse>;
+    outputCompleteService(outputId: string): Promise<boolean>;
+}

package/lib/adapters/externalChannelManagers/tl-lincoln.helper.d.ts

@@ -0,0 +1,23 @@
+import type { ExternalReservation, ExternalReservationType, ReservationStatus } from './externalChannelManager.type';
+import { type BasicInformation as TBasicInformation, type DataClassificationType, type InfoTravelXML, type MealConditionType, type RoomInformation, type SpecificMealConditionType } from './tl-lincoln.types';
+interface CommonRequest {
+    systemId: string;
+    pmsUserId: string;
+    pmsPassword: string;
+}
+interface JsonRequest {
+    commonRequest: CommonRequest;
+    request?: Record<string, unknown>;
+    pmsUrl: string;
+}
+export declare function jsonToXml(json: JsonRequest): string;
+export declare function xmlToJson(xml: string): Record<string, unknown>;
+export declare function getReservationStatusFromDataClassification(dataClassification: DataClassificationType): ReservationStatus;
+export declare function getExternalReservationTypeFromDataClassification(dataClassification: DataClassificationType): ExternalReservationType;
+export declare const formattedNameForMealCondition: (mealCondition: MealConditionType, specificMealCondition?: SpecificMealConditionType) => string;
+export declare const formattedPaxCountText: (roomInformation: RoomInformation | TBasicInformation, genderDivision?: boolean) => string;
+export declare const refineReservationData: (infoTravelXML: InfoTravelXML) => ExternalReservation;
+export declare const withAsyncBandwidth: <T = unknown>(array: T[], asyncMapper: (arg0: T, index: number) => void, { bandwidth }?: {
+    bandwidth?: number | undefined;
+}) => Promise<void>[];
+export {};