@vendit-dev/thirdparty-adapters 0.1.0

package/lib/adapters/sanhaWings.d.ts

@@ -0,0 +1,171 @@
+import { UserServiceGrpcCaller } from '@vendit-dev/utility-modules';
+import { Redis } from 'ioredis';
+import MutexLock from '../utils/mutex';
+declare type VenditWingsAuthInfo = {
+    scope: string;
+    credential: {
+        companyId: string;
+        vendorId: string;
+        apiKey: string;
+        kioskIp: string;
+        HOTEL_FAX_NO: string;
+        HOTEL_MAIL_ADDR: string;
+        HOTEL_TEL_NO: string;
+        BSNS_ENG_NAME: string;
+        CEO_NAME: string;
+        BSNS_OTH_NAME: string;
+        BSNS_NAME: string;
+        HOTEL_DTL_ADDR: string;
+        BSNS_CODE: string;
+        BRN: string;
+    };
+    expiresAt: number;
+};
+declare type WingsCommonCredential = {
+    vendorId: string;
+    companyId: string;
+    apiKey: string;
+    kioskIp: string;
+};
+declare type WingsApiCommonResponse = {
+    resultData: any;
+};
+export declare class WingsApiController {
+    URI: string;
+    CONTEXT: string;
+    constructor({ contextApi }: {
+        contextApi: string;
+    });
+    callWingsApi: ({ route, params, auth }: {
+        route: string;
+        params?: any;
+        auth: {
+            params: any;
+            headers: any;
+        };
+    }) => Promise<WingsApiCommonResponse>;
+}
+export default class WingsAdapter {
+    static indexAccommodation: ({ accommodationId }: {
+        accommodationId: string;
+    }) => string;
+    static authFromCredentials: ({ vendorId, companyId, apiKey, kioskIp, }: WingsCommonCredential) => {
+        headers: {
+            'API-KEY': string;
+            VENDOR_ID: string;
+            'API-COMPANY': string;
+        };
+        params: {
+            KIOSK_IP: string;
+        };
+    };
+    mutexLock: MutexLock;
+    authenticator: UserServiceGrpcCaller;
+    redis: Redis;
+    PROVIDER_KEY: string;
+    constructor({ authenticator, redis }: {
+        authenticator: UserServiceGrpcCaller;
+        redis: Redis;
+    });
+    checkWingsIntegration: ({ accommodationId }: {
+        accommodationId: string;
+    }) => Promise<boolean>;
+    getAccommodationAuthInfo: ({ accommodationId }: {
+        accommodationId: string;
+    }) => Promise<VenditWingsAuthInfo>;
+    getHotelInformation: ({ accommodationId }: {
+        accommodationId: string;
+    }) => Promise<any>;
+    checkInReservation: ({ accommodationId, reservationNumber, sequenceNumber, startDate, endDate, }: {
+        accommodationId: string;
+        reservationNumber: string;
+        sequenceNumber: string;
+        startDate: string;
+        endDate: string;
+    }) => Promise<any>;
+    cancelCheckInReservation: ({ accommodationId, folioNumber }: {
+        accommodationId: string;
+        folioNumber: string;
+    }) => Promise<boolean>;
+    getReservationByNumber: ({ accommodationId, reservationNumber }: {
+        accommodationId: string;
+        reservationNumber: string;
+    }) => Promise<any>;
+    getPurchaseAmount: ({ accommodationId, folioNumber }: {
+        accommodationId: string;
+        folioNumber: string;
+    }) => Promise<null | undefined>;
+    getWalkinInfo: ({ accommodationId, startDate, endDate, adultCount, childCount, langType, }: {
+        accommodationId: string;
+        startDate: string;
+        endDate: string;
+        adultCount: number;
+        childCount: number;
+        langType: string;
+    }) => Promise<{
+        walkinInfo: any;
+        roomInfo: any;
+    } | null>;
+    getWalkInRoomRate: ({ accommodationId, roomTypeCode, startDate, endDate, salesDate, }: {
+        accommodationId: string;
+        startDate: string;
+        endDate: string;
+        roomTypeCode: string;
+        salesDate: string;
+    }) => Promise<any>;
+    queryWalkinRoomTypesWithPrices: ({ accommodationId, startDate, endDate, adultCount, childCount, langType, }: {
+        accommodationId: string;
+        startDate: string;
+        endDate: string;
+        adultCount: number;
+        childCount: number;
+        langType: string;
+    }) => Promise<{
+        walkinInfo: any;
+        roomInfo: any[];
+    } | null>;
+    processWalkIn: ({ accommodationId, roomTypeCode, startDate, endDate, nights, salesDate, guestName, adultCount, childCount, dailyRoomFees, }: {
+        accommodationId: string;
+        roomTypeCode: string;
+        startDate: string;
+        endDate: string;
+        nights: number;
+        salesDate: string;
+        guestName: string;
+        adultCount: number;
+        childCount: number;
+        dailyRoomFees: Array<string>;
+    }) => Promise<any>;
+    getCheckOutInfo: ({ accommodationId, folioNumber, }: {
+        accommodationId: string;
+        folioNumber: string;
+    }) => Promise<any>;
+    processCheckOut: ({ accommodationId, folioNumber, }: {
+        accommodationId: string;
+        folioNumber: string;
+    }) => Promise<any>;
+    reportKeyIssue: ({ accommodationId, folioNumber, roomNumber, registerDate, issuedCount, resultMessage, }: {
+        accommodationId: string;
+        folioNumber: string;
+        roomNumber: string;
+        registerDate: string;
+        issuedCount: number;
+        resultMessage: string;
+    }) => Promise<any>;
+    reportKeyRetrieve: ({ accommodationId, folioNumber, }: {
+        accommodationId: string;
+        folioNumber: string;
+    }) => Promise<any>;
+    savePayment: ({ accommodationId, folioNumber, paymentAmount, saleDate, paymentInfo, }: {
+        accommodationId: string;
+        folioNumber: string;
+        paymentAmount: string;
+        saleDate: string;
+        paymentInfo: string;
+    }) => Promise<any>;
+    savePaymentWithPaymentId: ({ paymentId, folioNumber, }: {
+        paymentId: string;
+        folioNumber: string;
+    }) => Promise<null | undefined>;
+}
+export {};

package/lib/adapters/sanhaWings.js

@@ -0,0 +1,476 @@
+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());
+    });
+};
+import fetch from 'node-fetch';
+import moment from 'moment';
+import MutexLock from '../utils/mutex';
+const WINGS_API_ENDPOINT = 'https://wingsapi.sanhait.com';
+const WINGS_COMMON_REQUEST_HEADERS = {
+    'Content-Type': 'application/json',
+    'Echo-Token': '',
+};
+const WINGS_COMMON_REQUEST_PARAMS = {
+    LANG_TYPE: 'KOR',
+    KIOSK_ID: 'KIOSK',
+};
+export class WingsApiController {
+    constructor({ contextApi }) {
+        this.callWingsApi = ({ route, params = {}, auth }) => __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = {
+                method: 'POST',
+                headers: Object.assign(Object.assign({}, WINGS_COMMON_REQUEST_HEADERS), auth.headers),
+                body: JSON.stringify(Object.assign(Object.assign(Object.assign({}, auth.params), WINGS_COMMON_REQUEST_PARAMS), params)),
+            };
+            if (process.env.NODE_ENV === 'development') {
+                console.log(requestOptions);
+            }
+            const response = yield fetch(`${this.URI}/${this.CONTEXT}/${route}`, requestOptions);
+            return response.json();
+        });
+        this.URI = WINGS_API_ENDPOINT;
+        this.CONTEXT = contextApi;
+    }
+}
+const apiController = new WingsApiController({
+    contextApi: 'kiosk',
+});
+export default class WingsAdapter {
+    constructor({ authenticator, redis }) {
+        this.PROVIDER_KEY = 'SanhaWings';
+        this.checkWingsIntegration = ({ accommodationId }) => __awaiter(this, void 0, void 0, function* () { return !!this.getAccommodationAuthInfo({ accommodationId }); });
+        this.getAccommodationAuthInfo = ({ accommodationId }) => __awaiter(this, void 0, void 0, function* () {
+            let existingAuth = yield this.redis.get(WingsAdapter.indexAccommodation({ accommodationId }));
+            if (existingAuth) {
+                if (existingAuth === 'NOT_FOUND') {
+                    throw new Error('THIRDPARTY_AUTH_NOT_FOUND');
+                }
+                return JSON.parse(existingAuth);
+            }
+            const lockId = `WINGS-HKEY|${accommodationId}`;
+            const lockHash = yield this.mutexLock.getMutexLock(lockId);
+            existingAuth = yield this.redis.get(WingsAdapter.indexAccommodation({ accommodationId }));
+            try {
+                if (existingAuth) {
+                    return JSON.parse(existingAuth);
+                }
+                const newAuth = yield this.authenticator.getThirdPartyCredential({ accommodationId, provider: this.PROVIDER_KEY });
+                if (!newAuth) {
+                    yield this.redis.set(WingsAdapter.indexAccommodation({ accommodationId }), 'NOT_FOUND', 'EX', 60 * 10);
+                    throw new Error('THIRDPARTY_AUTH_NOT_FOUND');
+                }
+                newAuth.credential = JSON.parse(newAuth.credential);
+                yield this.redis.set(WingsAdapter.indexAccommodation({ accommodationId }), JSON.stringify(newAuth), 'EX', 60 * 10);
+                return newAuth;
+            }
+            catch (err) {
+                console.log(err);
+                throw err;
+            }
+            finally {
+                yield this.mutexLock.unlockMutexLock(lockId, lockHash);
+            }
+        });
+        this.getHotelInformation = ({ accommodationId }) => __awaiter(this, void 0, void 0, function* () {
+            const authInfo = yield this.getAccommodationAuthInfo({ accommodationId });
+            const response = yield apiController.callWingsApi({
+                route: 'ki00/getHotelInformation',
+                auth: WingsAdapter.authFromCredentials(authInfo.credential),
+            });
+            return response.resultData;
+        });
+        this.checkInReservation = ({ accommodationId, reservationNumber, sequenceNumber, startDate, endDate, }) => __awaiter(this, void 0, void 0, function* () {
+            const authInfo = yield this.getAccommodationAuthInfo({ accommodationId });
+            try {
+                const response = yield apiController.callWingsApi({
+                    route: 'ki01/kioskCheckIn',
+                    auth: WingsAdapter.authFromCredentials(authInfo.credential),
+                    params: {
+                        RSVN_NO: reservationNumber,
+                        RSVN_SEQ_NO: sequenceNumber,
+                        ARRV_DATE: startDate,
+                        DEPT_DATE: endDate,
+                        BSNS_CODE: authInfo.credential.BSNS_CODE,
+                    },
+                });
+                const { resultData } = response;
+                if (!resultData) {
+                    throw new Error('FAILED_TO_CHECKIN');
+                }
+                return resultData;
+            }
+            catch (err) {
+                console.log(err);
+                throw err;
+            }
+        });
+        this.cancelCheckInReservation = ({ accommodationId, folioNumber }) => __awaiter(this, void 0, void 0, function* () {
+            const authInfo = yield this.getAccommodationAuthInfo({ accommodationId });
+            try {
+                const response = yield apiController.callWingsApi({
+                    route: 'ki00/kioskCancel',
+                    auth: WingsAdapter.authFromCredentials(authInfo.credential),
+                    params: {
+                        FOLIO_NO: folioNumber,
+                    },
+                });
+                const { resultData: { RESULT_YN, RESULT_MSG } } = response;
+                if (RESULT_YN !== 'Y') {
+                    throw new Error(RESULT_MSG || 'DATA_NOT_FOUND');
+                }
+                return true;
+            }
+            catch (err) {
+                console.log(err);
+                throw err;
+            }
+        });
+        this.getReservationByNumber = ({ accommodationId, reservationNumber }) => __awaiter(this, void 0, void 0, function* () {
+            const authInfo = yield this.getAccommodationAuthInfo({ accommodationId });
+            try {
+                const response = yield apiController.callWingsApi({
+                    route: 'ki01/kioskRsvnInfo',
+                    auth: WingsAdapter.authFromCredentials(authInfo.credential),
+                    params: {
+                        RSVN_NO: reservationNumber,
+                    },
+                });
+                const { resultData: { rsvnInfo } } = response;
+                if (!rsvnInfo) {
+                    throw new Error('Data not found');
+                }
+                return rsvnInfo;
+            }
+            catch (err) {
+                console.log(err);
+                return null;
+            }
+        });
+        this.getPurchaseAmount = ({ accommodationId, folioNumber }) => __awaiter(this, void 0, void 0, function* () {
+            const authInfo = yield this.getAccommodationAuthInfo({ accommodationId });
+            try {
+                const response = yield apiController.callWingsApi({
+                    route: 'ki01/searchPaymentAmount',
+                    auth: WingsAdapter.authFromCredentials(authInfo.credential),
+                    params: {
+                        FOLIO_NO: folioNumber,
+                    },
+                });
+            }
+            catch (err) {
+                console.log(err);
+                return null;
+            }
+        });
+        this.getWalkinInfo = ({ accommodationId, startDate, endDate, adultCount, childCount, langType, }) => __awaiter(this, void 0, void 0, function* () {
+            const authInfo = yield this.getAccommodationAuthInfo({ accommodationId });
+            try {
+                const response = yield apiController.callWingsApi({
+                    route: 'ki02/kioskWalkInInfo',
+                    auth: WingsAdapter.authFromCredentials(authInfo.credential),
+                    params: {
+                        ARRV_DATE: moment(startDate).format('YYYYMMDD'),
+                        DEPT_DATE: moment(endDate).format('YYYYMMDD'),
+                        ADULT_CNT: adultCount,
+                        CHILD_CNT: childCount,
+                        LANG_TYPE: langType,
+                    },
+                });
+                const { resultData: { walkinInfo, roomInfo } } = response;
+                return {
+                    walkinInfo,
+                    roomInfo,
+                };
+            }
+            catch (err) {
+                console.log(err);
+                return null;
+            }
+        });
+        this.getWalkInRoomRate = ({ accommodationId, roomTypeCode, startDate, endDate, salesDate, }) => __awaiter(this, void 0, void 0, function* () {
+            const authInfo = yield this.getAccommodationAuthInfo({ accommodationId });
+            try {
+                const response = yield apiController.callWingsApi({
+                    route: 'ki02/kioskWalkInRoomRate',
+                    auth: WingsAdapter.authFromCredentials(authInfo.credential),
+                    params: {
+                        ARRV_DATE: moment(startDate).format('YYYYMMDD'),
+                        DEPT_DATE: moment(endDate).format('YYYYMMDD'),
+                        ROOM_TYPE_CODE: roomTypeCode,
+                        SALES_DATE: moment(salesDate).format('YYYYMMDD'),
+                        BSNS_CODE: authInfo.credential.BSNS_CODE,
+                    },
+                });
+                const { resultData } = response;
+                return resultData;
+            }
+            catch (err) {
+                console.log(err);
+                return null;
+            }
+        });
+        this.queryWalkinRoomTypesWithPrices = ({ accommodationId, startDate, endDate, adultCount, childCount, langType, }) => __awaiter(this, void 0, void 0, function* () {
+            const authInfo = yield this.getAccommodationAuthInfo({ accommodationId });
+            try {
+                const response = yield apiController.callWingsApi({
+                    route: 'ki02/kioskWalkInInfo',
+                    auth: WingsAdapter.authFromCredentials(authInfo.credential),
+                    params: {
+                        ARRV_DATE: moment(startDate).format('YYYYMMDD'),
+                        DEPT_DATE: moment(endDate).format('YYYYMMDD'),
+                        ADULT_CNT: adultCount,
+                        CHILD_CNT: childCount,
+                        LANG_TYPE: langType,
+                    },
+                });
+                const { resultData: { walkinInfo, roomInfo } } = response;
+                const roomInfoWithPrices = yield Promise.all(roomInfo.map((roomType) => __awaiter(this, void 0, void 0, function* () {
+                    const { ROOM_TYPE_CODE } = roomType;
+                    const priceData = yield this.getWalkInRoomRate({
+                        accommodationId,
+                        endDate,
+                        startDate,
+                        salesDate: startDate,
+                        roomTypeCode: ROOM_TYPE_CODE,
+                    });
+                    priceData.rawData = JSON.stringify(priceData);
+                    priceData.dailyPrices = priceData.walkinRoomDaily.map((dailyPrice) => ({
+                        rawData: JSON.stringify(dailyPrice),
+                        amount: dailyPrice.ROOM_FEE,
+                        date: dailyPrice.LODG_DATE,
+                    }));
+                    delete priceData.walkinRoomDaily;
+                    return Object.assign(Object.assign({}, roomType), { price: priceData });
+                })));
+                return {
+                    walkinInfo,
+                    roomInfo: roomInfoWithPrices,
+                };
+            }
+            catch (err) {
+                console.log(err);
+                return null;
+            }
+        });
+        this.processWalkIn = ({ accommodationId, roomTypeCode, startDate, endDate, nights, salesDate, guestName, adultCount, childCount, dailyRoomFees, }) => __awaiter(this, void 0, void 0, function* () {
+            const authInfo = yield this.getAccommodationAuthInfo({ accommodationId });
+            try {
+                const response = yield apiController.callWingsApi({
+                    route: 'ki02/walkinProcess',
+                    auth: WingsAdapter.authFromCredentials(authInfo.credential),
+                    params: {
+                        walkinInfo: {
+                            ARRV_DATE: startDate,
+                            DEPT_DATE: endDate,
+                            NIGHTS: nights,
+                            ROOM_TYPE_CODE: roomTypeCode,
+                            SALES_DATE: salesDate,
+                            ADULT_CNT: adultCount,
+                            CHILD_CNT: childCount,
+                            INHS_GEST_NAME: guestName,
+                            BSNS_CODE: authInfo.credential.BSNS_CODE,
+                        },
+                        walkinRoomDaily: dailyRoomFees === null || dailyRoomFees === void 0 ? void 0 : dailyRoomFees.map(value => JSON.parse(value)),
+                    },
+                });
+                const { resultData } = response;
+                return resultData;
+            }
+            catch (err) {
+                console.log(err);
+                return null;
+            }
+        });
+        this.getCheckOutInfo = ({ accommodationId, folioNumber, }) => __awaiter(this, void 0, void 0, function* () {
+            const authInfo = yield this.getAccommodationAuthInfo({ accommodationId });
+            try {
+                const response = yield apiController.callWingsApi({
+                    route: 'ki03/kioskCheckOutInfo',
+                    auth: WingsAdapter.authFromCredentials(authInfo.credential),
+                    params: {
+                        FOLIO_NO: folioNumber,
+                    },
+                });
+                const { resultData } = response;
+                return resultData;
+            }
+            catch (err) {
+                console.log(err);
+                return null;
+            }
+        });
+        this.processCheckOut = ({ accommodationId, folioNumber, }) => __awaiter(this, void 0, void 0, function* () {
+            const authInfo = yield this.getAccommodationAuthInfo({ accommodationId });
+            try {
+                const response = yield apiController.callWingsApi({
+                    route: 'ki03/kioskCheckOutProcess',
+                    auth: WingsAdapter.authFromCredentials(authInfo.credential),
+                    params: {
+                        BSNS_CODE: authInfo.credential.BSNS_CODE,
+                        FOLIO_NO: folioNumber,
+                    },
+                });
+                const { resultData } = response;
+                return resultData;
+            }
+            catch (err) {
+                console.log(err);
+                return null;
+            }
+        });
+        this.reportKeyIssue = ({ accommodationId, folioNumber, roomNumber, registerDate, issuedCount, resultMessage, }) => __awaiter(this, void 0, void 0, function* () {
+            const authInfo = yield this.getAccommodationAuthInfo({ accommodationId });
+            try {
+                const response = yield apiController.callWingsApi({
+                    route: 'ki01/kioskRoomKeyIssue',
+                    auth: WingsAdapter.authFromCredentials(authInfo.credential),
+                    params: {
+                        FOLIO_NO: folioNumber,
+                        ROOM_NO: roomNumber,
+                        REG_DATE: registerDate,
+                        REG_TIME: moment().format('HHmmSS'),
+                        ISSUE_CNT: issuedCount,
+                        RESULT_MSG: resultMessage,
+                    },
+                });
+                const { resultData } = response;
+                if (!resultData) {
+                    throw new Error('Data not found');
+                }
+                return resultData;
+            }
+            catch (err) {
+                console.log(err);
+                return null;
+            }
+        });
+        this.reportKeyRetrieve = ({ accommodationId, folioNumber, }) => __awaiter(this, void 0, void 0, function* () {
+            const authInfo = yield this.getAccommodationAuthInfo({ accommodationId });
+            try {
+                const response = yield apiController.callWingsApi({
+                    route: 'ki03/kioskCheckOutRoomKey',
+                    auth: WingsAdapter.authFromCredentials(authInfo.credential),
+                    params: {
+                        FOLIO_NO: folioNumber,
+                        BSNS_CODE: authInfo.credential.BSNS_CODE,
+                        ROOM_KEY_CHECK_YN: 'Y',
+                        RETURN_KEY_CNT: 1,
+                    },
+                });
+                const { resultData } = response;
+                if (!resultData) {
+                    throw new Error('Data not found');
+                }
+                return resultData;
+            }
+            catch (err) {
+                console.log(err);
+                return null;
+            }
+        });
+        this.savePayment = ({ accommodationId, folioNumber, paymentAmount, saleDate, paymentInfo, }) => __awaiter(this, void 0, void 0, function* () {
+            const authInfo = yield this.getAccommodationAuthInfo({ accommodationId });
+            const parsedData = JSON.parse(paymentInfo);
+            let refinedData;
+            switch (parsedData.vanType) {
+                case ('KSNET'): {
+                    refinedData = {
+                        // KSNET data
+                        APPR_TYPE_CODE: parsedData.APPR_TYPE_CODE || '11',
+                        COMT: parsedData.NOTICE2.trim(),
+                        PUR_CPNY_NAME: parsedData.PURCHASENAME.trim(),
+                        PUR_CPNY_CODE: parsedData.PURCHASECODE.trim(),
+                        ISSUE_CPMY_NAME: parsedData.MESSAGE1.trim(),
+                        ISSUE_CPMY_CODE: parsedData.ISSUERCODE.trim(),
+                        FRNC_STORE_NO: parsedData.MERCHANTNUMBER.trim(),
+                        CRDT_CARD_NO: parsedData.FILLER.trim(),
+                        RSPNS_CODE: parsedData.CORPRESPCODE.trim(),
+                        TERM_NO: parsedData.TERMID.trim(),
+                        APPR_NO: parsedData.APPROVALNO.trim(),
+                        APPR_DATE: `20${parsedData.TRADETIME.slice(0, 6)}`,
+                        APPR_TIME: parsedData.TRADETIME.slice(6, 10),
+                        CNFM_DATE: `20${parsedData.TRADETIME.slice(0, 6)}`,
+                        CNFM_TYPE: parsedData.TRADETIME.slice(6, 10),
+                        // Generated data
+                        INSTA_MMS_CNT: parsedData.INSTA_MMS_CNT || '00',
+                        APPR_LINE_TYPE_CODE: parsedData.APPR_LINE_TYPE_CODE || 'A',
+                        KEY_IN_TYPE_CODE: parsedData.KEY_IN_TYPE_CODE || 'S',
+                        SPC_UNIQUE_ALIAS: parsedData.SPC_UNIQUE_ALIAS || 'SEND_GB_APP',
+                        CARD_READING_DATA: parsedData.CARD_READING_DATA || '0000000000000000:00000000000000000000',
+                        SPC_TYPE_CODE: parsedData.SPC_TYPE_CODE,
+                    };
+                    break;
+                }
+                case ('CASH'): {
+                    refinedData = {
+                        CRDT_CARD_NO: 'KICASH',
+                        COMT: 'KISOK_CASH_PURCHASE',
+                    };
+                    break;
+                }
+                default: {
+                    throw new Error('NOT_REGISTERED_VAN');
+                }
+            }
+            try {
+                const response = yield apiController.callWingsApi({
+                    route: 'ki00/payment',
+                    auth: WingsAdapter.authFromCredentials(authInfo.credential),
+                    params: {
+                        FOLIO_NO: folioNumber,
+                        PAY_AMT: paymentAmount,
+                        SALE_DATE: saleDate,
+                        CREDIT_RESULT: Object.assign({ APPR_AMT: paymentAmount, FOLIO_NO: folioNumber }, refinedData),
+                        BSNS_CODE: authInfo.credential.BSNS_CODE,
+                    },
+                });
+                const { resultData } = response;
+                console.log(response);
+                console.log(resultData);
+                return resultData;
+            }
+            catch (err) {
+                console.log(err);
+                return false;
+            }
+        });
+        this.savePaymentWithPaymentId = ({ paymentId, folioNumber, }) => __awaiter(this, void 0, void 0, function* () {
+            const foundPaymentInfo = yield this.redis.get(`SanhaWings|${paymentId}`);
+            if (!foundPaymentInfo)
+                return null;
+            try {
+                const parsedPayment = JSON.parse(foundPaymentInfo);
+                yield this.savePayment({
+                    accommodationId: parsedPayment.accommodationId,
+                    folioNumber,
+                    paymentAmount: parsedPayment.amount.toString(),
+                    paymentInfo: parsedPayment.data,
+                    saleDate: moment(parsedPayment.createdAt).format('YYYYMMDD'),
+                });
+            }
+            catch (err) {
+                console.log(err);
+                throw new Error('FAILED_TO_SAVE_PAYMENT');
+            }
+        });
+        this.authenticator = authenticator;
+        this.redis = redis;
+        this.mutexLock = new MutexLock({ hashPrefix: 'RES_WINGS_MUTEX_', mutexLockInterval: 50, redis });
+    }
+}
+WingsAdapter.indexAccommodation = ({ accommodationId }) => `AUTH|WINGS-API|${accommodationId}`;
+WingsAdapter.authFromCredentials = ({ vendorId, companyId, apiKey, kioskIp, }) => ({
+    headers: {
+        'API-KEY': apiKey,
+        VENDOR_ID: vendorId,
+        'API-COMPANY': companyId,
+    },
+    params: {
+        KIOSK_IP: kioskIp,
+    },
+});

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import SanhaWingsAdapter from './adapters/sanhaWings';
+export { SanhaWingsAdapter, };

package/lib/index.js

@@ -0,0 +1,2 @@
+import SanhaWingsAdapter from './adapters/sanhaWings';
+export { SanhaWingsAdapter, };

package/lib/utils/mutex.d.ts

@@ -0,0 +1,15 @@
+import { Redis } from 'ioredis';
+export default class MutexLock {
+    redis: Redis;
+    hashPrefix: string;
+    mutexLockInterval: number;
+    constructor({ redis, hashPrefix, mutexLockInterval }: {
+        redis: Redis;
+        hashPrefix: string;
+        mutexLockInterval?: number;
+    });
+    getMutexLockKey: (id: string) => string;
+    tryMutexLock: (streamId: string, lockHash: string) => Promise<"OK" | null>;
+    getMutexLock: (streamId: string) => Promise<string>;
+    unlockMutexLock: (streamId: string, lockHash: string) => Promise<string | null>;
+}

package/lib/utils/mutex.js

@@ -0,0 +1,37 @@
+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());
+    });
+};
+import { v4 as uuid } from 'uuid';
+const sleep = (sleepTime) => new Promise(resolve => setTimeout(resolve, sleepTime));
+export default class MutexLock {
+    constructor({ redis, hashPrefix, mutexLockInterval = 50 }) {
+        this.getMutexLockKey = (id) => `${this.hashPrefix}${id}`;
+        this.tryMutexLock = (streamId, lockHash) => this.redis.set(this.getMutexLockKey(streamId), lockHash, 'EX', 60, 'NX');
+        this.getMutexLock = (streamId) => __awaiter(this, void 0, void 0, function* () {
+            const lockHash = uuid();
+            let lock;
+            while (!lock) {
+                lock = yield this.tryMutexLock(streamId, lockHash); // eslint-disable-line
+                yield sleep(this.mutexLockInterval); // eslint-disable-line
+            }
+            return lockHash;
+        });
+        this.unlockMutexLock = (streamId, lockHash) => __awaiter(this, void 0, void 0, function* () {
+            const existingLockHash = yield this.redis.get(this.getMutexLockKey(streamId));
+            if (existingLockHash === lockHash) {
+                yield this.redis.del(this.getMutexLockKey(streamId));
+                return existingLockHash;
+            }
+            return null;
+        });
+        this.redis = redis;
+        this.hashPrefix = hashPrefix;
+        this.mutexLockInterval = mutexLockInterval;
+    }
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@vendit-dev/thirdparty-adapters",
+  "version": "0.1.0",
+  "description": "Third party adapters between v-cloud and other PMS/CMS providers.",
+  "main": "lib/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "node ./test/index.js"
+  },
+  "keywords": [
+    "vendit"
+  ],
+  "author": "Vendit <dev@vendit.co.kr> (https://vendit.co.kr)",
+  "license": "MIT",
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^5.18.0",
+    "@typescript-eslint/parser": "^5.18.0",
+    "@vendit-dev/utility-modules": "^0.10.3",
+    "eslint-config-airbnb-base": "^13.1.0",
+    "eslint-plugin-import": "^2.16.0",
+    "eslint": "^8.12.0",
+    "tslint": "^6.1.3",
+    "typescript": "^4.6.3"
+  },
+  "dependencies": {
+    "ioredis": "^5.0.4",
+    "moment": "^2.29.2",
+    "node-fetch": "^3.2.3",
+    "uuid": "^8.3.2"
+  }
+}

package/readme.md

@@ -0,0 +1,131 @@
+# Passive Promise
+
+Promise that's resolvable from outside of executor context.
+
+It comes with super light-weighted bundle with 0 dependencies.
+
+## What is this?
+
+This library exports the class named `PassivePromise` which works exactly like normal Promises, but can be resolved outside of promise executor context.
+
+## Installation
+
+`npm install passive-promise`
+
+or
+
+`yarn add passive-promise`
+
+The library exported with esnext module syntax.
+
+## Usage Examples
+
+Just use exactly like normal promise, but returned promise (which is extended Promise class) also comes with the `resolve()` and `reject()` method in it, which you can use them to force resolve or reject the promise from outside.
+
+All the chain methods such as then, catch, finally works as expected, but remind that the both resolve, reject method of any chained PassivePromise instance will propagate to the root PassivePromise instance regardless of its depth.
+
+### Common Usage
+
+```javascript
+import PassivePromise from 'passive-promise';
+
+(async () => {
+  const foo = new PassivePromise((resolve, reject) => setTimeout(() => resolve(1), 1000));
+
+  console.log(await foo); // 1 after 1 sec
+
+  const bar = new PassivePromise((resolve, reject) => setTimeout(() => resolve(1), 1000));
+
+  bar.resolve(-1);
+
+  console.log(await bar); // -1 immedietly
+
+  const baz = new PassivePromise((resolve, reject) => setTimeout(() => resolve(1), 1000));
+
+  baz.reject(0) // Unhandled promise rejection.
+})()
+
+(async () => {
+  const foo = new PassivePromise(() => {})
+    .then((fulfilled) => console.log(fulfilled));
+  
+  foo.resolve(1); // 1
+
+  
+  const bar = new PassivePromise(() => {})
+    .then((fulfilled) => console.log(fulfilled))
+    .catch((errored) => console.log('Promise rejected!', errored));
+  
+  bar.reject(-1); // Promise rejected! -1
+
+  const baz = new PassivePromise(() => {})
+    .then(
+      (fulfilled) => console.log(fulfilled),
+      (errored) => console.log('Promise rejected!', errored),
+    )
+    .finally(() => console.log('Finally.'));
+
+  baz.reject(-1) // Promise rejected! -1 Finally.
+})()
+
+```
+
+### Chain propagation
+
+
+```javascript
+import PassivePromise from 'passive-promise';
+
+(async () => {
+  const chainedPromise = new PassivePromise(() => {})
+    .then((firstRes) => {
+      console.log('first.');
+    })
+    .then((secondRes) => {
+      console.log('second.');
+    })
+    .then((thirdRes) => {
+      console.log('third.');
+    });
+  
+  chainedPromise.resolve(1); 
+
+  await chainedPromise; // first. second. third.
+
+  const middleChain = new PassivePromise(() => {})
+    .then((firstRes) => {
+      console.log('first.');
+    })
+    .then((secondRes) => {
+      console.log('second.');
+    });
+
+  middleChain.then((thirdRes) => {
+    console.log('third.');
+  });
+
+  // Regardless of position of PassivePromise instance in the chained promises, they always resolve root promise in the chain.
+  middleChain.resolve(1);
+
+  await middleChain; // first. second. third.
+  
+  // If you want to resolve the instance itself rather than root instance, use passiveResolve() and passiveReject() instead.
+
+  const anotherChain = new PassivePromise(() => {})
+    .then((firstRes) => {
+      console.log('first.');
+    })
+    .then((secondRes) => {
+      console.log('second.');
+    });
+
+  anotherChain.then((thirdRes) => {
+    console.log('third.');
+  });
+
+  // We want to directly resolve this promise rather than the whole promise chain here.
+  anotherChain.passiveResolve(1);
+
+  await anotherChain; // third.
+})()
+```