@longvansoftware/storefront-js-client 4.6.2 → 4.6.3

package/dist/src/lib/orderGraphQL/index.js

@@ -0,0 +1,342 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderGraphQLService = void 0;
+const mutations_1 = require("../../graphql/orderGraphQL/mutations");
+const queries_1 = require("../../graphql/orderGraphQL/queries");
+const serviceSDK_1 = require("../serviceSDK");
+class OrderGraphQLService extends serviceSDK_1.Service {
+    constructor(endpoint, orgId, storeId) {
+        super(endpoint, orgId, storeId);
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    setStoreId(storeId) {
+        this.storeId = storeId;
+    }
+    createOrder(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mutation = mutations_1.CREATE_ORDER;
+            const variables = {
+                input,
+            };
+            try {
+                const response = yield this.graphqlMutationV2(mutation, variables);
+                return response.createOrder;
+            }
+            catch (error) {
+                console.log(`Error in createOrder: ${error}`);
+                throw error;
+            }
+        });
+    }
+    getOrderDetail(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = queries_1.GET_ORDER_DETAIL;
+            const variables = {
+                orderId,
+            };
+            try {
+                const response = yield this.graphqlQueryV2(query, variables);
+                return response.orderDetail;
+            }
+            catch (error) {
+                console.log(`Error in orderDetail: ${error}`);
+                throw error;
+            }
+        });
+    }
+    getOrderDetailDynamic(orderId, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = (0, queries_1.GET_ORDER_DETAIL_DYNAMIC)(fields);
+            const variables = {
+                orderId,
+            };
+            try {
+                const response = yield this.graphqlQueryV2(query, variables);
+                return response.orderDetail;
+            }
+            catch (error) {
+                console.log(`Error in orderDetailDynamic: ${error}`);
+                throw error;
+            }
+        });
+    }
+    getQuantityOrderLineItems(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = queries_1.GET_QUANTITY_ORDER_LINEITEMS;
+            const variables = {
+                orderId,
+            };
+            try {
+                const response = yield this.graphqlQueryV2(query, variables);
+                return response.orderDetail;
+            }
+            catch (error) {
+                console.log(`Error in orderDetail: ${error}`);
+                throw error;
+            }
+        });
+    }
+    updateQuantityV2(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mutations = mutations_1.UPDATE_QUANTITY_V2;
+            const variables = Object.assign({ partnerId: this.orgId }, payload);
+            try {
+                const response = yield this.graphqlMutationV2(mutations, variables);
+                return response.updateQuantityV2;
+            }
+            catch (error) {
+                console.log(`Error in updateQuantityV2: ${error}`);
+                throw error;
+            }
+        });
+    }
+    getOrderLineItemByServiceId(serviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = queries_1.GET_ORDER_LINE_ITEM_BY_SERVICE_ID;
+            const variables = {
+                partnerId: this.orgId,
+                serviceId,
+            };
+            try {
+                const response = yield this.graphqlQueryV2(query, variables);
+                return response.getOrderLineItemByServiceId;
+            }
+            catch (error) {
+                console.log(`Error in getOrderLineItemByServiceId: ${error}`);
+                throw error;
+            }
+        });
+    }
+    getOrderByServiceId(serviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = queries_1.GET_ORDER_BY_SERVICE_ID;
+            const variables = {
+                serviceId,
+            };
+            try {
+                const response = yield this.graphqlQueryV2(query, variables);
+                return response.getOrderByServiceId;
+            }
+            catch (error) {
+                console.log(`Error in getOrderByServiceId: ${error}`);
+                throw error;
+            }
+        });
+    }
+    addToCart(serviceId, actorId, cartId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mutation = mutations_1.ADD_TO_CART;
+            const variables = {
+                serviceId,
+                actorId,
+                cartId,
+            };
+            try {
+                const response = yield this.graphqlMutationV2(mutation, variables);
+                return response.addToCart;
+            }
+            catch (error) {
+                console.log(`Error in addToCart: ${error}`);
+                throw error;
+            }
+        });
+    }
+    removeProductOptionOrderLineItem(orderLineItemId, optionId, updateBy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mutation = mutations_1.REMOVE_PRODUCT_OPTION_ORDER_LINE_ITEM;
+            const variables = {
+                partnerId: this.orgId,
+                orderLineItemId,
+                optionId,
+                updateBy,
+            };
+            try {
+                const response = yield this.graphqlMutationV2(mutation, variables);
+                return response.removeProductOptionOrderLineItem;
+            }
+            catch (error) {
+                console.log(`Error in removeProductOptionOrderLineItem: ${error}`);
+                throw error;
+            }
+        });
+    }
+    findOrderByOwnerPartyId(ownerPartyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = queries_1.FIND_ORDER_BY_OWNER_PARTYID;
+            const variables = {
+                partnerId: this.orgId,
+                ownerPartyId,
+            };
+            try {
+                const response = yield this.graphqlQueryV2(query, variables);
+                return response.findOrderByOwnerPartyId;
+            }
+            catch (error) {
+                console.log(`Error in findOrderByOwnerPartyId: ${error}`);
+                throw error;
+            }
+        });
+    }
+    calcExchangePriceExtendResourceDetail(serviceId, productBaseIdNew, durationQuantity, durationUnit, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = (0, queries_1.CALC_EXCHANGE_PRICE_EXTEND_RESOURCE_DETAIL_DYNAMIC)(fields);
+            const variables = {
+                partnerId: this.orgId,
+                storeId: this.storeId,
+                serviceId,
+                productBaseIdNew,
+                durationQuantity,
+                durationUnit,
+            };
+            try {
+                const response = yield this.graphqlQueryV2(query, variables);
+                return response.calcExchangePriceExtendResourceDetail;
+            }
+            catch (error) {
+                console.log(`Error in calcExchangePriceExtendResourceDetail: ${error}`);
+                throw error;
+            }
+        });
+    }
+    searchOrderDynamic(params, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("🚀 ~ OrderGraphQLService ~ searchOrderDynamic ~ params:", params);
+            const query = (0, queries_1.SEARCH_ORDER_DYNAMIC)(fields);
+            const variables = {
+                filter: params,
+            };
+            try {
+                const response = yield this.graphqlQueryV2(query, variables);
+                return response.searchOrder;
+            }
+            catch (error) {
+                console.log(`Error in searchOrderDynamic: ${error}`);
+                throw error;
+            }
+        });
+    }
+    addItemIntoOrderByProductJsonResource(serviceId, orderId, itemInput, durationQuantity, durationUnit, actorId, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mutation = (0, mutations_1.ADD_ITEM_INTO_ORDER_BY_PRODUCT_JSON_RESOURCE)(fields);
+            const variables = {
+                partnerId: this.orgId,
+                serviceId,
+                orderId,
+                itemInput,
+                durationQuantity,
+                durationUnit,
+                actorId,
+            };
+            try {
+                const response = yield this.graphqlMutationV2(mutation, variables);
+                return response.addItemIntoOrderByProductJsonResource;
+            }
+            catch (error) {
+                console.log(`Error in addItemIntoOrderByProductJsonResource: ${error}`);
+                throw error;
+            }
+        });
+    }
+    updateOrderLineItemParentId(orderLineItemChildIds, orderLineItemParentId, updateBy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mutation = mutations_1.UPDATE_ORDER_LINE_ITEM_PARENT_ID;
+            const variables = {
+                partnerId: this.orgId,
+                orderLineItemChildIds,
+                orderLineItemParentId,
+                updateBy,
+            };
+            try {
+                const response = yield this.graphqlMutationV2(mutation, variables);
+                return response.updateOrderLineItemParentId;
+            }
+            catch (error) {
+                console.log(`Error in addItemIntoOrderByProductJsonResource: ${error}`);
+                throw error;
+            }
+        });
+    }
+    updateProductOptionOrderLineItem(orderLineItemId, productOptionUpdate, updateBy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mutation = mutations_1.UPDATE_PRODUCT_OPTION_ORDERLINE_ITEM;
+            const variables = {
+                orderLineItemId,
+                productOptionUpdate,
+                updateBy,
+            };
+            try {
+                const response = yield this.graphqlMutationV2(mutation, variables);
+                return response.updateProductOptionOrderLineItem;
+            }
+            catch (error) {
+                console.log(`Error in updateProductOptionOrderLineItem: ${error}`);
+                throw error;
+            }
+        });
+    }
+    calculateResourceChangePrice(productIds, quantity, unit, storeId, fields, serviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = (0, queries_1.CALCULATE_RESOURCE_CHANGE_PRICE)(fields);
+            const variables = {
+                partnerId: this.orgId,
+                storeId: storeId ? storeId : this.storeId,
+                productIds,
+                quantity,
+                unit,
+                serviceId
+            };
+            try {
+                const response = yield this.graphqlQueryV2(query, variables);
+                return response.calculateResourceChangePrice;
+            }
+            catch (error) {
+                console.log(`Error in calculateResourceChangePrice: ${error}`);
+                throw error;
+            }
+        });
+    }
+    applyReferralCode(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mutation = mutations_1.APPLY_REFERRAL_CODE;
+            const variables = {
+                input,
+            };
+            try {
+                const response = yield this.graphqlMutationV2(mutation, variables);
+                return response.applyReferralCode;
+            }
+            catch (error) {
+                console.log(`Error in applyReferralCode: ${error}`);
+                throw error;
+            }
+        });
+    }
+    removeReferralCode(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mutation = mutations_1.REMOVE_REFERRAL_CODE;
+            const variables = {
+                input,
+            };
+            try {
+                const response = yield this.graphqlMutationV2(mutation, variables);
+                return response.removeReferralCode;
+            }
+            catch (error) {
+                console.log(`Error in removeReferralCode: ${error}`);
+                throw error;
+            }
+        });
+    }
+}
+exports.OrderGraphQLService = OrderGraphQLService;

package/dist/src/lib/order_cloud_rest/index.d.ts

@@ -0,0 +1,7 @@
+import { Service } from "../serviceSDK";
+export declare class OrderCloudRestService extends Service {
+    constructor(endpoint: string, orgId: string, storeId: string);
+    setToken(token: string): void;
+    setStoreId(storeId: string): void;
+    updateOrderConfirmation(orderId: string, createBy: string): Promise<any>;
+}

package/dist/src/lib/order_cloud_rest/index.js

@@ -0,0 +1,39 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderCloudRestService = void 0;
+const serviceSDK_1 = require("../serviceSDK");
+class OrderCloudRestService extends serviceSDK_1.Service {
+    constructor(endpoint, orgId, storeId) {
+        super(endpoint, orgId, storeId);
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    setStoreId(storeId) {
+        this.storeId = storeId;
+    }
+    updateOrderConfirmation(orderId, createBy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = `/service-webhook?partnerId=${this.orgId}&orderId=${orderId}&createBy=${createBy}`;
+            const method = "GET";
+            try {
+                const response = yield this.restApiCallWithToken(endpoint, method);
+                return response;
+            }
+            catch (error) {
+                console.log(`Error in updateOrderConfirmation: ${error}`);
+                throw error;
+            }
+        });
+    }
+}
+exports.OrderCloudRestService = OrderCloudRestService;

package/dist/src/lib/paymentLV/index.d.ts

@@ -0,0 +1,13 @@
+import { Service } from "../serviceSDK";
+export declare class PaymentLVService extends Service {
+    constructor(endpoint: string, orgId: string, storeId: string);
+    setToken(token: string): void;
+    setStoreId(storeId: string): void;
+    paymentsByOrders(orderIds: [string]): Promise<any>;
+    getTransferInfo(paymentId: string, store: string): Promise<any>;
+    cancelPayment(paymentId: string, reason: string, createBy: string): Promise<any>;
+    confirmPaidManual(paymentId: string, confirmBy: string): Promise<any>;
+    getPaymentMethodTypes(store: string): Promise<any>;
+    paymentMethods(): Promise<any>;
+    paymentStatus(paymentId: string): Promise<any>;
+}

package/dist/src/lib/paymentLV/index.js

@@ -0,0 +1,149 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentLVService = void 0;
+const mutations_1 = require("../../graphql/paymentLV/mutations");
+const queries_1 = require("../../graphql/paymentLV/queries");
+const serviceSDK_1 = require("../serviceSDK");
+class PaymentLVService extends serviceSDK_1.Service {
+    constructor(endpoint, orgId, storeId) {
+        super(endpoint, orgId, storeId);
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    setStoreId(storeId) {
+        this.storeId = storeId;
+    }
+    paymentsByOrders(orderIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = queries_1.PAYMENTS_BY_ORDERS;
+            const variables = {
+                orderIds,
+            };
+            // const headers = { PartnerId: this.orgId };
+            try {
+                const response = yield this.graphqlQueryCustomHeader(query, variables
+                // headers
+                );
+                return response.paymentsByOrders;
+            }
+            catch (error) {
+                console.log(`Error in paymentsByOrders: ${error}`);
+                throw error;
+            }
+        });
+    }
+    getTransferInfo(paymentId, store) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = queries_1.GET_TRANSFER_INFO;
+            const variables = {
+                partnerId: this.orgId,
+                storeId: store ? store : this.storeId,
+                paymentId,
+            };
+            try {
+                const response = yield this.graphqlQueryCustomHeader(query, variables);
+                return response.getTransferInfo;
+            }
+            catch (error) {
+                console.log(`Error fetching get getTransferInfo method: ${error}`);
+                throw error;
+            }
+        });
+    }
+    cancelPayment(paymentId, reason, createBy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mutation = mutations_1.CANCEL_PAYMENT;
+            const variables = {
+                paymentId,
+                safeMode: true,
+                reason,
+                createBy,
+            };
+            try {
+                const response = yield this.graphqlMutationCustomHeader(mutation, variables);
+                return response.cancelPayment;
+            }
+            catch (error) {
+                console.log(`Error fetching get cancelPayment method: ${error}`);
+                throw error;
+            }
+        });
+    }
+    confirmPaidManual(paymentId, confirmBy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mutation = mutations_1.CONFIRM_PAID_MANUAL;
+            const variables = {
+                paymentId,
+                confirmBy,
+            };
+            try {
+                const response = yield this.graphqlMutationCustomHeader(mutation, variables);
+                return response.confirmPaidManual;
+            }
+            catch (error) {
+                console.log(`Error fetching get confirmPaidManual method: ${error}`);
+                throw error;
+            }
+        });
+    }
+    getPaymentMethodTypes(store) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = queries_1.GET_PAYMENT_METHOD_TYPES;
+            const variables = {
+                partnerId: this.orgId,
+                storeId: store ? store : this.storeId,
+            };
+            try {
+                const response = yield this.graphqlQueryCustomHeader(query, variables);
+                return response.getPaymentMethodTypes;
+            }
+            catch (error) {
+                console.log(`Error fetching get getPaymentMethodTypes method: ${error}`);
+                throw error;
+            }
+        });
+    }
+    paymentMethods() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = queries_1.PAYMENT_METHODS;
+            const variables = {
+                partnerCode: this.orgId,
+            };
+            try {
+                const response = yield this.graphqlQueryCustomHeader(query, variables);
+                return response.paymentMethods;
+            }
+            catch (error) {
+                console.log(`Error fetching get paymentMethods method: ${error}`);
+                throw error;
+            }
+        });
+    }
+    paymentStatus(paymentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = queries_1.PAYMENT_STATUS;
+            const variables = {
+                paymentId,
+            };
+            try {
+                const response = yield this.graphqlQueryCustomHeader(query, variables);
+                return response.paymentStatus;
+            }
+            catch (error) {
+                console.log(`Error fetching get paymentStatus method: ${error}`);
+                throw error;
+            }
+        });
+    }
+}
+exports.PaymentLVService = PaymentLVService;

package/dist/src/lib/product/index.d.ts

@@ -92,4 +92,5 @@ export declare class ProductService extends Service {
     getProductMarketplaceDetailBySlug(storeChannel: string, slug: string): Promise<any>;
     getProductMarketplaceDetailById(storeChannel: string, id: string): Promise<any>;
     getProductMarketplaceBySupplier(dataQuery: any): Promise<any>;
+    getProductSimpleByHandle(handle: string, store: string, fields: string[]): Promise<any>;
 }

package/dist/src/lib/product/index.js

@@ -1074,5 +1074,23 @@ class ProductService extends serviceSDK_1.Service {
             }
         });
     }
+    getProductSimpleByHandle(handle, store, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = (0, queries_1.GET_PRODUCT_SIMPLE_BY_HANDLE_DYNAMIC)(fields);
+            const variablesHandle = {
+                partnerId: this.orgId,
+                storeChannel: store ? store : this.storeId,
+                handle,
+            };
+            try {
+                const response = yield this.graphqlQuery(query, variablesHandle);
+                return response.getProductSimpleByHandle;
+            }
+            catch (error) {
+                console.log(`Error fetching getProductSimpleByHandle : ${error}`);
+                throw error;
+            }
+        });
+    }
 }
 exports.ProductService = ProductService;

package/dist/src/lib/quicklab_service/index.d.ts

@@ -0,0 +1,19 @@
+import { Service } from "../serviceSDK";
+export declare class QuicklabService extends Service {
+    constructor(endpoint: string, orgId: string, storeId: string);
+    setToken(token: string): void;
+    setStoreId(storeId: string): void;
+    getTemplatesByArticleId(articleId: string): Promise<any>;
+    getTypeLabSessions(): Promise<any>;
+    getLabSessionsByUserId(userId: string): Promise<any>;
+    getLabSessionsByUserIdAndArticleId(userId: string, articleId: string): Promise<any>;
+    createLabSessionByTemplateId(templateId: string, userId: string, articleId: string, typeLabSessionCode: string): Promise<any>;
+    createLabSessionByLabSessionId(labSessionId: string, userId: string, articleId: string): Promise<any>;
+    createLabSessionByComputingId(computingId: string, userId: string, articleId: string): Promise<any>;
+    updateEndTimeLabSession(labSessionId: string, userId: string): Promise<any>;
+    stopLabSession(labSessionId: string, userId: string, note: string): Promise<any>;
+    updateTypeLabSession(labSessionId: string, typeLabSessionCode: string, userId: string): Promise<any>;
+    getLabSessionsChillByParent(labSessionId: string, userId: string): Promise<any>;
+    stopLabSessionForCustomer(labSessionId: string, userId: string, note: string): Promise<any>;
+    getLabDoingAndDoneByUserId(userId: string, fields: string[]): Promise<any>;
+}