@lmnto/h-mall-shared 1.0.1

package/shared/services/api/services/ShipmentOrdersService.ts

@@ -0,0 +1,88 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { PlaceShipmentOrderDto } from "../models/PlaceShipmentOrderDto";
+import type { CancelablePromise } from "../core/CancelablePromise";
+import { OpenAPI } from "../core/OpenAPI";
+import { request as __request } from "../core/request";
+export class ShipmentOrdersService {
+  /**
+   * @param requestBody
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingOrdersControllerPlaceOrder(
+    requestBody: PlaceShipmentOrderDto,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "POST",
+      url: "/v1/shipment-orders",
+      body: requestBody,
+      mediaType: "application/json",
+    });
+  }
+  /**
+   * @param page
+   * @param limit
+   * @param sort
+   * @param sortBy
+   * @param keyword
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingOrdersControllerGetOrders(
+    page: number = 1,
+    limit: number = 30,
+    sort: string = "desc",
+    sortBy: string = "createdAt",
+    keyword?: string | null,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/shipment-orders",
+      query: {
+        page: page,
+        limit: limit,
+        sort: sort,
+        sortBy: sortBy,
+        keyword: keyword,
+      },
+      isServerAction: true,
+    });
+  }
+
+  /**
+   * @param id
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingOrdersControllerGetOrder(
+    id: string,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/shipment-orders/{id}",
+      path: {
+        id: id,
+      },
+    });
+  }
+
+  /**
+   * @param shipmentOrderId
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingOrdersControllerGetOrderInvoice(
+    shipmentOrderId: string,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/shipment-orders/{shipmentOrderId}/invoice",
+      path: {
+        shipmentOrderId: shipmentOrderId,
+      },
+    });
+  }
+}

package/shared/services/api/services/ShipmentsService.ts

@@ -0,0 +1,30 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+
+import type { CancelablePromise } from "../core/CancelablePromise";
+import { OpenAPI } from "../core/OpenAPI";
+import { request as __request } from "../core/request";
+export class ShipmentsService {
+  /**
+   * @param orderId
+   * @returns any
+   * @throws ApiError
+   */
+  public static shipmentsControllerGetAllShipmentItems(
+    orderId: string,
+    status?: "in-house" | "returned",
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/shipping/{orderId}/shipment-items",
+      path: {
+        orderId: orderId,
+      },
+      query: {
+        status: status,
+      },
+      isServerAction: true,
+    });
+  }
+}

package/shared/services/api/services/ShippingCartService.ts

@@ -0,0 +1,247 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { AddProductToShippingCartDto } from "../models/AddProductToShippingCartDto";
+import type { ShippingCartUpdateBillingAddressesDto } from "../models/ShippingCartUpdateBillingAddressesDto";
+import type { ShippingCartUpdateShippingMethodDto } from "../models/ShippingCartUpdateShippingMethodDto";
+import type { UpdateShippingCartPaymentMethodDto } from "../models/UpdateShippingCartPaymentMethodDto";
+import type { CancelablePromise } from "../core/CancelablePromise";
+import { OpenAPI } from "../core/OpenAPI";
+import { request as __request } from "../core/request";
+import { AddAllProductToShippingCartDto } from "../models/AddAllProductToShippingCartDto";
+export class ShippingCartService {
+  /**
+   * @param orderId
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingCartControllerGetShippingCart(
+    orderId: string,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/shipping-cart/{orderId}",
+      path: {
+        orderId: orderId,
+      },
+    });
+  }
+  /**
+   * @param orderId
+   * @param requestBody
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingCartControllerAddShippingCartForAllProduct(
+    orderId: string,
+    requestBody: AddAllProductToShippingCartDto,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "POST",
+      url: "/v1/shipping-cart/{orderId}",
+      path: {
+        orderId: orderId,
+      },
+      body: requestBody,
+      mediaType: "application/json",
+    });
+  }
+
+  /**
+   * @param orderId
+   * @param requestBody
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingCartControllerAddShippingCartProduct(
+    orderId: string,
+    requestBody: AddProductToShippingCartDto,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "POST",
+      url: "/v1/shipping-cart/{orderId}/items",
+      path: {
+        orderId: orderId,
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      isServerAction: true,
+    });
+  }
+  /**
+   * @param state
+   * @param orderId
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingCartControllerUpdateCartState(
+    state: string,
+    orderId: string,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "PATCH",
+      url: "/v1/shipping-cart/{orderId}/cart-state/{state}",
+      path: {
+        state: state,
+        orderId: orderId,
+      },
+    });
+  }
+  /**
+   * @param type
+   * @param id
+   * @param requestBody
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingCartControllerUpdateAddresses(
+    type: string,
+    id: number,
+    requestBody: ShippingCartUpdateBillingAddressesDto,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "PATCH",
+      url: "/v1/shipping-cart/{id}/address/{type}",
+      path: {
+        type: type,
+        id: id,
+      },
+      body: requestBody,
+      mediaType: "application/json",
+    });
+  }
+  /**
+   * @param id
+   * @param requestBody
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingCartControllerUpdateShippingMethod(
+    id: number,
+    requestBody: ShippingCartUpdateShippingMethodDto,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "PATCH",
+      url: "/v1/shipping-cart/{id}/shipping-method",
+      path: {
+        id: id,
+      },
+      body: requestBody,
+      mediaType: "application/json",
+    });
+  }
+  /**
+   * @param shippingCartId
+   * @param storeId
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingCartControllerUpdatePickupStore(
+    shippingCartId: number,
+    storeId: number,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "PATCH",
+      url: "/v1/shipping-cart/{shippingCartId}/store/{storeId}",
+      path: {
+        shippingCartId: shippingCartId,
+        storeId: storeId,
+      },
+    });
+  }
+  /**
+   * @param shippingCartId
+   * @param requestBody
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingCartControllerUpdatePaymentMethod(
+    shippingCartId: number,
+    requestBody: UpdateShippingCartPaymentMethodDto,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "PATCH",
+      url: "/v1/shipping-cart/{shippingCartId}/payment-method",
+      path: {
+        shippingCartId: shippingCartId,
+      },
+      body: requestBody,
+      mediaType: "application/json",
+    });
+  }
+  /**
+   * @param shippingCartId
+   * @param shippingMethodId
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingCartControllerGetALlowedShippingOrPickupCountries(
+    shippingCartId: number,
+    shippingMethodId: number,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/shipping-cart/{shippingCartId}/allowed-shipping-countries/{shippingMethodId}",
+      path: {
+        shippingCartId: shippingCartId,
+        shippingMethodId: shippingMethodId,
+      },
+    });
+  }
+  /**
+   * @param shippingCartId
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingCartControllerClearPaymentMethodOnCart(
+    shippingCartId: number,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/shipping-cart/{shippingCartId}/clear-payment-method",
+      path: {
+        shippingCartId: shippingCartId,
+      },
+    });
+  }
+
+  /**
+   * @param type
+   * @param id
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingCartControllerResetAddresses(
+    type: string,
+    id: number,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "PATCH",
+      url: "/v1/shipping-cart/{id}/reset-address/{type}",
+      path: {
+        type: type,
+        id: id,
+      },
+    });
+  }
+  /**
+   * @param mode
+   * @param orderId
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingCartControllerValidateCart(
+    mode: string,
+    orderId: string,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "PATCH",
+      url: "/v1/shipping-cart/{orderId}/refresh/{mode}",
+      path: {
+        mode: mode,
+        orderId: orderId,
+      },
+    });
+  }
+}

package/shared/services/api/services/ShippingMethodsService.ts

@@ -0,0 +1,20 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+
+import type { CancelablePromise } from "../core/CancelablePromise";
+import { OpenAPI } from "../core/OpenAPI";
+import { request as __request } from "../core/request";
+export class ShippingMethodsService {
+  /**
+   * @returns any
+   * @throws ApiError
+   */
+  public static shippingMethodControllerFindAll(): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/shipping-methods",
+      isServerAction: false,
+    });
+  }
+}

package/shared/services/api/services/StoresService.ts

@@ -0,0 +1,25 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+
+import type { CancelablePromise } from "../core/CancelablePromise";
+import { OpenAPI } from "../core/OpenAPI";
+import { request as __request } from "../core/request";
+export class StoresService {
+  /**
+   * @param countryId
+   * @returns any
+   * @throws ApiError
+   */
+  public static storesControllerFindAll(
+    countryId?: number,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/stores",
+      query: {
+        countryId: countryId,
+      },
+    });
+  }
+}

package/shared/services/api/services/SyncServiceQueueService.ts

@@ -0,0 +1,39 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+
+import type { CancelablePromise } from "../core/CancelablePromise";
+import { OpenAPI } from "../core/OpenAPI";
+import { request as __request } from "../core/request";
+export class SyncServiceQueueService {
+  /**
+   * @returns any
+   * @throws ApiError
+   */
+  public static syncServiceQueueControllerGetStats(): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/sync-service-queue/stats",
+    });
+  }
+  /**
+   * @returns any
+   * @throws ApiError
+   */
+  public static syncServiceQueueControllerStopQueue(): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "POST",
+      url: "/v1/sync-service-queue/stop",
+    });
+  }
+  /**
+   * @returns any
+   * @throws ApiError
+   */
+  public static syncServiceQueueControllerRestartQueue(): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "POST",
+      url: "/v1/sync-service-queue/restart",
+    });
+  }
+}

package/shared/services/api/services/UpgradeOrdersService.ts

@@ -0,0 +1,26 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { PlaceOrderDto } from "../models/PlaceOrderDto";
+import type { CancelablePromise } from "../core/CancelablePromise";
+import { OpenAPI } from "../core/OpenAPI";
+import { request as __request } from "../core/request";
+export class UpgradeOrdersService {
+  /**
+   * @param requestBody
+   * @returns any
+   * @throws ApiError
+   */
+  public static upgradeOrdersControllerPlaceOrder(
+    requestBody: PlaceOrderDto,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "POST",
+      url: "/v1/upgrade-orders",
+      body: requestBody,
+      mediaType: "application/json",
+      isServerAction: true,
+    });
+  }
+}

package/shared/services/api/services/UsersAuthService.ts

@@ -0,0 +1,45 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ValidateAuthCodeDto } from "../models/ValidateAuthCodeDto";
+import type { CancelablePromise } from "../core/CancelablePromise";
+import { OpenAPI } from "../core/OpenAPI";
+import { request as __request } from "../core/request";
+export class UsersAuthService {
+  /**
+   * @returns any return sso redirection link
+   * @throws ApiError
+   */
+  public static authControllerGetSsoUri(): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/auth/sso",
+    });
+  }
+  /**
+   * @param requestBody
+   * @returns any return user data and jwt
+   * @throws ApiError
+   */
+  public static authControllerValidateAuthCode(
+    requestBody: ValidateAuthCodeDto,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "POST",
+      url: "/v1/auth/sso",
+      body: requestBody,
+      mediaType: "application/json",
+    });
+  }
+  /**
+   * @returns any return user data and jwt
+   * @throws ApiError
+   */
+  public static authControllerRefreshAuthToken(): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "POST",
+      url: "/v1/auth/refresh-token",
+    });
+  }
+}

package/shared/services/api/services/UsersService.ts

@@ -0,0 +1,53 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+
+import type { CancelablePromise } from "../core/CancelablePromise";
+import { OpenAPI } from "../core/OpenAPI";
+import { request as __request } from "../core/request";
+export class UsersService {
+  /**
+   * @returns any
+   * @throws ApiError
+   */
+  public static usersControllerGetProfile(): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/users/me",
+    });
+  }
+
+  public static paymentGatewayControllerGetProfile(): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/payment-gateway/auth-code",
+    });
+  }
+
+  /**
+   * @param productSku
+   * @returns any
+   * @throws ApiError
+   */
+  public static usersControllerGetUserProductPurchases(
+    productSku: string,
+  ): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/users/purchases/{productSKU}",
+      path: {
+        productSKU: productSku,
+      },
+    });
+  }
+  /**
+   * @returns any
+   * @throws ApiError
+   */
+  public static usersControllerSaveConsent(): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "POST",
+      url: "/v1/users/wallet-consent",
+    });
+  }
+}

package/shared/services/api/services/XeraQueueService.ts

@@ -0,0 +1,39 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+
+import type { CancelablePromise } from "../core/CancelablePromise";
+import { OpenAPI } from "../core/OpenAPI";
+import { request as __request } from "../core/request";
+export class XeraQueueService {
+  /**
+   * @returns any
+   * @throws ApiError
+   */
+  public static xeraQueueControllerGetStats(): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "GET",
+      url: "/v1/xera-queue/stats",
+    });
+  }
+  /**
+   * @returns any
+   * @throws ApiError
+   */
+  public static xeraQueueControllerStopQueue(): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "POST",
+      url: "/v1/xera-queue/stop",
+    });
+  }
+  /**
+   * @returns any
+   * @throws ApiError
+   */
+  public static xeraQueueControllerRestartQueue(): CancelablePromise<any> {
+    return __request(OpenAPI, {
+      method: "POST",
+      url: "/v1/xera-queue/restart",
+    });
+  }
+}

package/shared/services/payment-method.service.ts

@@ -0,0 +1,29 @@
+"use server";
+
+import { PaymentsService } from "./api";
+
+export const proceedGetPaymentMethodsAsync = async (data: {
+  shipping?: boolean | undefined;
+}) => {
+  console.log("🚀 ~ proceedGetPaymentMethodsAsync ~ data:", data);
+  try {
+    return await PaymentsService.paymentsControllerGetPaymentMethods();
+  } catch (error) {
+    console.log("🚀 ~ proceedGetPaymentMethodsAsync ~ error:", error);
+    return null;
+  }
+};
+
+export const proceedGetPaymentMethodAssetsAsync = async (data: {
+  methodId: number;
+  shipping?: boolean | undefined;
+}) => {
+  try {
+    return await PaymentsService.paymentsControllerGetPaymentMethodAssets(
+      data.methodId,
+    );
+  } catch (error) {
+    console.log("🚀 ~ proceedGetPaymentMethodAssetsAsync ~ error:", error);
+    return null;
+  }
+};