@ikas/storefront 1.0.21 → 2.0.0-alpha.1

package/src/models/data/order/index.ts

@@ -0,0 +1,289 @@
+import { IkasOrderAddress } from "./address";
+import { IkasOrderShippingLine } from "./shipping-line";
+import { IkasOrderLineItem } from "./line-item";
+import { makeAutoObservable } from "mobx";
+import { IkasOrderRefundOrderLineInput } from "./refund/refund-line-item";
+import { IkasCustomerAPI } from "../../../api";
+import { IkasOrderRefundSettings } from "./refund/settings";
+import { getCurrencySymbol } from "../../../utils";
+
+export class IkasOrder {
+  id: string;
+  orderNumber: string;
+  note: string | null;
+  totalPrice: number | null;
+  totalFinalPrice: number | null;
+  // totalDiscountPrice: number | null;
+  // totalWeight: number | null;
+  currencyCode: string;
+  currencySymbol: string;
+
+  // Dates
+  orderedAt: number;
+  cancelledAt: number | null;
+
+  // Enums
+  status: IkasOrderStatus;
+  cancelReason: IkasOrderCancelledReason | null;
+  orderPaymentStatus: IkasOrderPaymentStatus | null;
+  orderPackageStatus: IkasOrderPackageStatus | null;
+  shippingMethod: IkasOrderShippingMethod | null;
+
+  // Sub Models
+  shippingAddress: IkasOrderAddress | null;
+  billingAddress: IkasOrderAddress | null;
+  orderLineItems: IkasOrderLineItem[];
+  orderAdjustments: IkasOrderAdjustment[] | null;
+  shippingLines: IkasOrderShippingLine[] | null;
+  customer: IkasOrderCustomer | null;
+  taxLines: IkasOrderTaxLine[] | null;
+  orderPackages: IkasOrderPackage[] | null;
+  currencyRates: IkasOrderCurrencyRate[] | null;
+
+  // Extra
+  private _refundSettings: IkasOrderRefundSettings | null = null;
+
+  constructor(data: IkasOrder) {
+    this.id = data.id;
+    this.orderNumber = data.orderNumber;
+    this.note = data.note;
+    this.totalPrice = data.totalPrice;
+    this.totalFinalPrice = data.totalFinalPrice;
+    // this.totalDiscountPrice = data.totalDiscountPrice;
+    // this.totalWeight = data.totalWeight;
+    this.currencyCode = data.currencyCode;
+    this.currencySymbol = getCurrencySymbol(this.currencyCode);
+
+    this.orderedAt = data.orderedAt;
+    this.cancelledAt = data.cancelledAt;
+
+    this.status = data.status;
+    this.cancelReason = data.cancelReason;
+    this.orderPaymentStatus = data.orderPaymentStatus;
+    this.orderPackageStatus = data.orderPackageStatus;
+    this.shippingMethod = data.shippingMethod;
+
+    this.shippingAddress = data.shippingAddress
+      ? new IkasOrderAddress(data.shippingAddress)
+      : null;
+    this.billingAddress = data.billingAddress
+      ? new IkasOrderAddress(data.billingAddress)
+      : null;
+    this.orderLineItems = data.orderLineItems
+      ? data.orderLineItems.map(
+          (o) =>
+            new IkasOrderLineItem({
+              ...o,
+              orderedAt: data.orderedAt,
+            })
+        )
+      : [];
+    this.orderAdjustments = data.orderAdjustments;
+    this.shippingLines = data.shippingLines;
+    this.customer = data.customer;
+    this.taxLines = data.taxLines;
+    this.orderPackages = data.orderPackages;
+    this.currencyRates = data.currencyRates;
+
+    makeAutoObservable(this);
+  }
+
+  get refundableItems() {
+    if (
+      !this._refundSettings ||
+      (this._refundSettings && !this._refundSettings.isActiveRefundSection)
+    )
+      return [];
+
+    return this.orderLineItems.filter(
+      (item) =>
+        [
+          OrderLineItemStatusEnum.FULFILLED,
+          OrderLineItemStatusEnum.UNFULFILLED,
+          OrderLineItemStatusEnum.DELIVERED,
+        ].includes(item.status) &&
+        (this._refundSettings?.orderRefundDayLimit
+          ? this._refundSettings.orderRefundDayLimit >= item.orderedAtDays
+          : true)
+    );
+  }
+
+  get unfullfilledItems() {
+    return this.orderLineItems.filter((item) => {
+      const isInAPackage = this.orderPackages?.some((op) =>
+        op.orderLineItemIds.includes(item.id)
+      );
+      return !isInAPackage;
+    });
+  }
+
+  get refundedItems() {
+    return this.orderLineItems.filter(
+      (item) =>
+        item.status === OrderLineItemStatusEnum.REFUNDED ||
+        item.status === OrderLineItemStatusEnum.REFUND_REQUESTED ||
+        item.status === OrderLineItemStatusEnum.REFUND_REQUEST_ACCEPTED ||
+        item.status === OrderLineItemStatusEnum.REFUND_REJECTED
+    );
+  }
+
+  refund = async () => {
+    try {
+      const refundOrderLineItems: IkasOrderRefundOrderLineInput[] = [];
+      this.orderLineItems.map((item) => {
+        if (item.refundQuantity !== null) {
+          refundOrderLineItems?.push({
+            orderLineItemId: item.id,
+            quantity: item.refundQuantity ? item.refundQuantity : 0,
+          });
+        }
+      });
+
+      const result = await IkasCustomerAPI.saveIkasOrderRefund({
+        orderId: this.id,
+        orderLineItems: refundOrderLineItems,
+      });
+
+      if (result) {
+        // Set the new order object to this
+        Object.entries(result).forEach(([key, value]) => {
+          (this as any)[key] = value;
+        });
+        return true;
+      }
+    } catch (err) {}
+
+    return false;
+  };
+}
+
+export type IkasOrderAdjustment = {
+  amount: number;
+  amountType: IkasAmountTypeEnum;
+  name: string;
+  order: number;
+  type: IkasAdjustmentEnum;
+  couponId: string | null;
+  appliedOrderLines: IkasOrderAdjustmentAppliedLine[] | null;
+};
+
+export type IkasOrderAdjustmentAppliedLine = {
+  amount: number;
+  appliedQuantity: number;
+  orderLineId: string;
+};
+
+export type IkasOrderCustomer = {
+  id: string;
+  email: string;
+  firstName: string;
+  lastName: string;
+};
+
+export type IkasOrderTaxLine = {
+  price: number;
+  rate: number;
+};
+
+export type IkasOrderPackage = {
+  id: string;
+  createdAt: number;
+  updatedAt: number;
+  deleted: boolean;
+  orderLineItemIds: string[];
+  orderPackageFulfillStatus: IkasOrderPackageFulfillStatus;
+  orderPackageNumber: string;
+  stockLocationId: string;
+  trackingInfo: IkasOrderTrackingInfo | null;
+};
+
+export type IkasOrderTrackingInfo = {
+  cargoCompany: string;
+  isSendNotification: boolean;
+  trackingLink: string;
+  trackingNumber: string;
+};
+
+export enum IkasOrderStatus {
+  DRAFT = "DRAFT",
+  CREATED = "CREATED",
+  CANCELLED = "CANCELLED",
+  REFUNDED = "REFUNDED",
+}
+
+export enum IkasOrderCancelledReason {
+  CUSTOMER = "CUSTOMER",
+  INVENTORY = "INVENTORY",
+  DECLINED = "DECLINED",
+  OTHER = "OTHER",
+}
+
+export enum IkasAmountTypeEnum {
+  AMOUNT = "AMOUNT",
+  RATIO = "RATIO",
+}
+
+enum IkasAdjustmentEnum {
+  DECREMENT = "DECREMENT",
+  INCREMENT = "INCREMENT",
+}
+
+export enum IkasOrderPaymentStatus {
+  WAITING = "WAITING",
+  PAID = "PAID",
+  PARTIALLY_PAID = "PARTIALLY_PAID",
+}
+
+export enum IkasOrderPackageStatus {
+  CANCELLED = "CANCELLED",
+  CANCEL_REJECTED = "CANCEL_REJECTED",
+  CANCEL_REQUESTED = "CANCEL_REQUESTED",
+  DELIVERED = "DELIVERED",
+  FULFILLED = "FULFILLED",
+  READY_FOR_SHIPMENT = "READY_FOR_SHIPMENT",
+  PARTIALLY_CANCELLED = "PARTIALLY_CANCELLED",
+  PARTIALLY_DELIVERED = "PARTIALLY_DELIVERED",
+  PARTIALLY_FULFILLED = "PARTIALLY_FULFILLED",
+  PARTIALLY_REFUNDED = "PARTIALLY_REFUNDED",
+  REFUNDED = "REFUNDED",
+  REFUND_REJECTED = "REFUND_REJECTED",
+  REFUND_REQUESTED = "REFUND_REQUESTED",
+  REFUND_REQUEST_ACCEPTED = "REFUND_REQUEST_ACCEPTED",
+  UNABLE_TO_DELIVER = "UNABLE_TO_DELIVER",
+  UNFULFILLED = "UNFULFILLED",
+}
+
+export enum IkasOrderPackageFulfillStatus {
+  DELIVERED = "DELIVERED",
+  FULFILLED = "FULFILLED",
+  SHIPPED = "SHIPPED",
+}
+
+export enum IkasOrderShippingMethod {
+  CLICK_AND_COLLECT = "CLICK_AND_COLLECT",
+  SHIPMENT = "SHIPMENT",
+  NO_SHIPMENT = "NO_SHIPMENT",
+}
+
+export type IkasOrderCurrencyRate = {
+  code: string;
+  originalRate: number;
+  rate: number;
+};
+
+export enum OrderLineItemStatusEnum {
+  FULFILLED = "FULFILLED",
+  UNFULFILLED = "UNFULFILLED",
+  DELIVERED = "DELIVERED",
+
+  // Cancel Enums
+  CANCELLED = "CANCELLED",
+  CANCEL_REQUESTED = "CANCEL_REQUESTED",
+  CANCEL_REJECTED = "CANCEL_REJECTED",
+
+  // Refund Enums
+  REFUND_REQUESTED = "REFUND_REQUESTED",
+  REFUND_REQUEST_ACCEPTED = "REFUND_REQUEST_ACCEPTED",
+  REFUNDED = "REFUNDED",
+  REFUND_REJECTED = "REFUND_REJECTED",
+}

package/src/models/data/order/line-item/discount/index.ts

@@ -0,0 +1,15 @@
+enum IkasAmountTypeEnum {
+  AMOUNT = "AMOUNT",
+  RATIO = "RATIO",
+}
+export class IkasOrderLineDiscount {
+  amount: number;
+  amountType: IkasAmountTypeEnum;
+  reason: string | null;
+
+  constructor(data: IkasOrderLineDiscount) {
+    this.amount = data.amount;
+    this.amountType = data.amountType;
+    this.reason = data.reason;
+  }
+}

package/src/models/data/order/line-item/index.ts

@@ -0,0 +1,123 @@
+import { IkasOrderLineDiscount } from "./discount";
+import { IkasOrderLineVariant } from "./variant";
+import { makeAutoObservable } from "mobx";
+import { getCurrencySymbol } from "../../../../utils";
+import moment from "moment";
+import { IkasOrderLineOptions } from "./options";
+
+export class IkasOrderLineItem {
+  id: string;
+  createdAt: string;
+  updatedAt: string;
+  orderedAt: number;
+  deleted: boolean;
+  currencyCode: string;
+  currencySymbol: string;
+  discount?: IkasOrderLineDiscount | null = null;
+  discountPrice?: number | null = null;
+  finalPrice: number;
+  options: IkasOrderLineOptions[] | null;
+  originalOrderLineItemId?: string | null = null;
+  price: number;
+  quantity: number;
+  taxValue?: number | null = null;
+  private _refundQuantity?: number | null = null;
+
+  variant: IkasOrderLineVariant;
+  status: OrderLineItemStatusEnum;
+
+  constructor(data: Partial<IkasOrderLineItem>) {
+    this.id = data.id || "";
+    this.createdAt = data.createdAt || "";
+    this.updatedAt = data.updatedAt || "";
+    this.orderedAt = data.orderedAt || 0;
+    this.deleted = data.deleted || false;
+    this.currencyCode = data.currencyCode || "";
+    this.currencySymbol = getCurrencySymbol(this.currencyCode);
+    this.discount = data.discount
+      ? new IkasOrderLineDiscount(data.discount)
+      : undefined;
+    this.discountPrice = data.discountPrice;
+    this.finalPrice = data.finalPrice || 0;
+    this.originalOrderLineItemId = data.originalOrderLineItemId;
+    this.price = data.price || 0;
+    this.quantity = data.quantity || 0;
+    this.taxValue = data.taxValue;
+    this.variant = data.variant
+      ? new IkasOrderLineVariant(data.variant)
+      : new IkasOrderLineVariant();
+    this.status = data.status || OrderLineItemStatusEnum.FULFILLED;
+    this.options = data.options
+      ? data.options.map((oP) => new IkasOrderLineOptions(oP))
+      : null;
+    makeAutoObservable(this);
+  }
+
+  get orderedAtDays() {
+    try {
+      const orderedAt = moment(new Date(this.orderedAt));
+      const now = moment();
+      return now.diff(orderedAt, "days");
+    } catch {
+      return 0;
+    }
+  }
+
+  get priceWithQuantity() {
+    return this.price * this.quantity;
+  }
+
+  get overridenPriceWithQuantity() {
+    return this.discountPrice !== undefined && this.discountPrice !== null
+      ? this.price * this.quantity
+      : null;
+  }
+
+  get finalPriceWithQuantity() {
+    return (
+      (this.discountPrice !== undefined && this.discountPrice !== null
+        ? this.discountPrice
+        : this.price) * this.quantity
+    );
+  }
+
+  get tax() {
+    const taxValue = this.taxValue || 0;
+    return ((this.finalPrice * this.quantity) / (100 + taxValue)) * taxValue;
+  }
+
+  get refundQuantity() {
+    return this._refundQuantity;
+  }
+
+  set refundQuantity(value: number | null | undefined) {
+    if (value) {
+      if (value > this.quantity) {
+        value = this.quantity;
+      }
+      if (value <= 0) {
+        value = null;
+      }
+      this._refundQuantity = value;
+    } else {
+      this._refundQuantity = null;
+    }
+  }
+}
+
+export enum OrderLineItemStatusEnum {
+  FULFILLED = "FULFILLED",
+  UNFULFILLED = "UNFULFILLED",
+  DELIVERED = "DELIVERED",
+
+  // Cancel Enums
+  CANCELLED = "CANCELLED",
+  CANCEL_REQUESTED = "CANCEL_REQUESTED",
+  CANCEL_REJECTED = "CANCEL_REJECTED",
+
+  // Refund Enums
+  REFUND_REQUESTED = "REFUND_REQUESTED",
+  REFUND_REQUEST_ACCEPTED = "REFUND_REQUEST_ACCEPTED",
+  REFUNDED = "REFUNDED",
+  REFUND_REJECTED = "REFUND_REJECTED",
+}

package/src/models/data/order/line-item/options/index.ts

@@ -0,0 +1,18 @@
+import { IkasProductOptionType } from "../../../product-option-set";
+import { IkasOrderLineOptionsValue } from "./options-value";
+
+export class IkasOrderLineOptions {
+  name: string;
+  productOptionId: string;
+  productOptionsSetId: string;
+  type: IkasProductOptionType;
+  values: IkasOrderLineOptionsValue[];
+
+  constructor(data: IkasOrderLineOptions) {
+    this.name = data.name;
+    this.productOptionId = data.productOptionId;
+    this.productOptionsSetId = data.productOptionsSetId;
+    this.type = data.type;
+    this.values = data.values;
+  }
+}

package/src/models/data/order/line-item/options/options-value/index.ts

@@ -0,0 +1,11 @@
+export class IkasOrderLineOptionsValue {
+  name: string | null;
+  price: number | null;
+  value: string;
+
+  constructor(data: IkasOrderLineOptionsValue) {
+    this.name = data.name || "";
+    this.price = data.price || null;
+    this.value = data.value;
+  }
+}

package/src/models/data/order/line-item/variant/index.ts

@@ -0,0 +1,75 @@
+import { makeAutoObservable } from "mobx";
+import { IkasImage } from "../../../../../models/data/image";
+import { stringToSlug } from "../../../../../utils";
+
+export class IkasOrderLineVariant {
+  id: string;
+  name: string;
+  productId: string;
+  sku?: string | null = null;
+  slug?: string | null = null;
+  barcodeList: string[];
+  mainImageId?: string | null = null;
+  taxValue: number;
+  variantValues: IkasOrderLineVariantVariantValue[];
+
+  // Extra
+  mainImage?: IkasImage | null = null;
+
+  constructor(data: Partial<IkasOrderLineVariant> = {}) {
+    this.id = data.id || "";
+    this.name = data.name || "";
+    this.productId = data.productId || "";
+    this.sku = data.sku;
+    this.slug = data.slug;
+    this.barcodeList = data.barcodeList || [];
+    this.mainImageId = data.mainImageId;
+    this.taxValue = data.taxValue || 0;
+    this.variantValues = data.variantValues
+      ? data.variantValues.map((vv) => new IkasOrderLineVariantVariantValue(vv))
+      : [];
+
+    if (this.mainImageId) this.mainImage = new IkasImage(this.mainImageId);
+
+    makeAutoObservable(this);
+  }
+
+  get href() {
+    if (!this.slug) return;
+
+    const variantParams = this.variantValues
+      .map((vv) => {
+        return `${vv.variantTypeSlug}=${vv.variantNameSlug}`;
+      })
+      .join("&");
+
+    if (variantParams) return `/${this!.slug}?${variantParams}`;
+    else return `/${this!.slug}`;
+  }
+}
+
+export class IkasOrderLineVariantVariantValue {
+  order: number;
+  variantTypeId: string;
+  variantTypeName: string;
+  variantValueId: string;
+  variantValueName: string;
+
+  constructor(data: IkasOrderLineVariantVariantValue) {
+    this.order = data.order;
+    this.variantTypeId = data.variantTypeId;
+    this.variantTypeName = data.variantTypeName;
+    this.variantValueId = data.variantValueId;
+    this.variantValueName = data.variantValueName;
+
+    makeAutoObservable(this);
+  }
+
+  get variantTypeSlug() {
+    return stringToSlug(this.variantTypeName);
+  }
+
+  get variantNameSlug() {
+    return stringToSlug(this.variantValueName);
+  }
+}

package/src/models/data/order/refund/index.ts

@@ -0,0 +1,18 @@
+import { makeAutoObservable } from "mobx";
+import { IkasOrderRefundOrderLineInput } from "./refund-line-item";
+
+export class IkasRefund {
+  orderId: string;
+  orderLineItems: IkasOrderRefundOrderLineInput[];
+
+  constructor(data: Partial<IkasRefund>) {
+    this.orderId = data.orderId || "";
+    this.orderLineItems = data.orderLineItems
+      ? data.orderLineItems.map(
+          (item) => new IkasOrderRefundOrderLineInput(item)
+        )
+      : [];
+
+    makeAutoObservable(this);
+  }
+}

package/src/models/data/order/refund/refund-line-item/index.ts

@@ -0,0 +1,13 @@
+import { makeAutoObservable } from "mobx";
+
+export class IkasOrderRefundOrderLineInput {
+  quantity: number;
+  orderLineItemId: string;
+
+  constructor(data: Partial<IkasOrderRefundOrderLineInput>) {
+    this.quantity = data.quantity || 1;
+    this.orderLineItemId = data.orderLineItemId || "";
+
+    makeAutoObservable(this);
+  }
+}

package/src/models/data/order/refund/settings.ts

@@ -0,0 +1,15 @@
+import { makeAutoObservable } from "mobx";
+
+export class IkasOrderRefundSettings {
+  isActiveRefundSection: boolean;
+  orderRefundDayLimit: number | null = null;
+  refundDesc: string;
+
+  constructor(data: Partial<IkasOrderRefundSettings>) {
+    this.isActiveRefundSection = data.isActiveRefundSection || false;
+    this.orderRefundDayLimit = data.orderRefundDayLimit || null;
+    this.refundDesc = data.refundDesc || "";
+
+    makeAutoObservable(this);
+  }
+}

package/src/models/data/order/shipping-line/index.ts

@@ -0,0 +1,7 @@
+export type IkasOrderShippingLine = {
+  price: number;
+  taxValue: number | null;
+  title: string;
+  shippingSettingsId: string;
+  shippingZoneRateId: string;
+};

package/src/models/data/order-transaction/index.ts

@@ -0,0 +1,105 @@
+import { getCurrencySymbol } from "../../../utils";
+
+export class IkasOrderTransaction {
+  amount: number | null;
+  checkoutId: string | null;
+  createdAt: number | null;
+  currencyCode: string | null;
+  currencySymbol: string | null;
+  customerId: string | null;
+  error: IkasTransactionError | null;
+  id: string | null;
+  orderId: string | null;
+  paymentGatewayId: string | null;
+  paymentGatewayName: string | null;
+  paymentMethod: IkasPaymentMethodEnum | null;
+  paymentMethodDetail: IkasTransactionPaymentMethodDetail | null;
+  processedAt: number | null;
+  refundReason: string | null;
+  status: IkasTransactionStatusEnum | null;
+  type: IkasTransactionTypeEnum | null;
+  updatedAt: number | null;
+
+  constructor(data: Partial<IkasOrderTransaction> = {}) {
+    this.amount = data.amount || null;
+    this.checkoutId = data.checkoutId || null;
+    this.createdAt = data.createdAt || null;
+    this.currencyCode = data.currencyCode || null;
+    this.currencySymbol = this.currencyCode
+      ? getCurrencySymbol(this.currencyCode)
+      : null;
+    this.customerId = data.customerId || null;
+    this.error = data.error || null;
+    this.id = data.id || null;
+    this.orderId = data.orderId || null;
+    this.paymentGatewayId = data.paymentGatewayId || null;
+    this.paymentGatewayName = data.paymentGatewayName || null;
+    this.paymentMethod = data.paymentMethod || null;
+    this.paymentMethodDetail = data.paymentMethodDetail || null;
+    this.processedAt = data.processedAt || null;
+    this.refundReason = data.refundReason || null;
+    this.status = data.status || null;
+    this.type = data.type || null;
+    this.updatedAt = data.updatedAt || null;
+  }
+}
+
+type IkasTransactionError = {
+  code: string;
+  declineCode: string;
+  message: string;
+};
+
+export enum IkasPaymentMethodEnum {
+  BUY_ONLINE_PAY_AT_STORE = "BUY_ONLINE_PAY_AT_STORE",
+  CASH = "CASH",
+  CASH_ON_DELIVERY = "CASH_ON_DELIVERY",
+  CREDIT_CARD_ON_DELIVERY = "CREDIT_CARD_ON_DELIVERY",
+  CREDIT_CARD = "CREDIT_CARD",
+  GIFT_CARD = "GIFT_CARD",
+  MONEY_ORDER = "MONEY_ORDER",
+  OTHER = "OTHER",
+}
+
+export type IkasTransactionPaymentMethodDetail = {
+  bankName: string;
+  binNumber: string;
+  cardAssociation: IkasTransactionCardAssociationEnum;
+  cardFamily: string;
+  cardType: IkasTransactionCardTypeEnum;
+  installment: IkasTransactionInstallmentPrice | null;
+  lastFourDigits: string;
+  threeDSecure: boolean;
+};
+
+export enum IkasTransactionCardAssociationEnum {
+  AMERICAN_EXPRESS = "AMERICAN_EXPRESS",
+  MASTER_CARD = "MASTER_CARD",
+  TROY = "TROY",
+  VISA = "VISA",
+}
+
+export enum IkasTransactionCardTypeEnum {
+  CREDIT = "CREDIT",
+  DEBIT = "DEBIT",
+  PREPAID = "PREPAID",
+}
+
+export type IkasTransactionInstallmentPrice = {
+  installmentCount: number | null;
+  installmentPrice: number | null;
+  totalPrice: number | null;
+};
+
+export enum IkasTransactionStatusEnum {
+  FAILED = "FAILED",
+  PENDING = "PENDING",
+  SUCCESS = "SUCCESS",
+  AUTHORIZED = "AUTHORIZED",
+}
+
+export enum IkasTransactionTypeEnum {
+  REFUND = "REFUND",
+  SALE = "SALE",
+  VOID = "VOID",
+}