@ikas/storefront 1.0.21 → 2.0.0-alpha.1

package/src/models/data/payment-gateway/index.ts

@@ -0,0 +1,150 @@
+import { makeAutoObservable } from "mobx";
+import { IkasStorefrontConfig } from "../../../storefront";
+import { IkasOrderShippingLine } from "../order/shipping-line";
+
+export class IkasPaymentGateway {
+  paymentMethods: IkasPaymentMethod[];
+  paymentMethodType: IkasPaymentMethodType;
+  id: string | null;
+  name: string;
+  code: string;
+  type: IkasPaymentGatewayType;
+  logoUrl: string | null;
+  testMode: boolean | null;
+  description: string | null;
+  additionalPrices: IkasPaymentGatewayAdditionalPrice[] | null;
+  translations: IkasPaymentGatewayTranslation[] | null;
+  supportedCurrencies: string[] = [];
+  availableCountries: string[] = [];
+
+  constructor(data: Partial<IkasPaymentGateway>) {
+    this.paymentMethods = data.paymentMethods || [];
+    this.paymentMethodType =
+      data.paymentMethodType || IkasPaymentMethodType.OTHER;
+    this.id = data.id || null;
+    this.name = data.name || "";
+    this.code = data.code || "";
+    this.type = data.type || IkasPaymentGatewayType.INTERNAL;
+    this.logoUrl = data.logoUrl || null;
+    this.testMode = data.testMode || null;
+    this.description = data.description || null;
+    this.additionalPrices =
+      data.additionalPrices?.map(
+        (ap) => new IkasPaymentGatewayAdditionalPrice(ap)
+      ) || null;
+    this.translations = data.translations || null;
+    this.supportedCurrencies = data.supportedCurrencies || [];
+    this.availableCountries = data.availableCountries || [];
+
+    this.setTranslations();
+    makeAutoObservable(this);
+  }
+
+  getCalculatedAdditionalPrices(
+    totalFinalPrice: number,
+    shippingLines: IkasOrderShippingLine[] | null
+  ) {
+    if (this.additionalPrices) {
+      const shippingPrice =
+        shippingLines?.reduce((sum, item) => sum + item.price, 0) || 0;
+
+      totalFinalPrice -= shippingPrice;
+
+      return this.additionalPrices.map((additionalPrice) => {
+        let amount = 0;
+
+        if (
+          additionalPrice.amountType ===
+          IkasPaymentGatewayAdditionalPriceAmountType.RATIO
+        ) {
+          amount = ((totalFinalPrice || 0) * additionalPrice.amount) / 100;
+        } else {
+          amount = additionalPrice.amount;
+        }
+
+        if (
+          additionalPrice.type ===
+          IkasPaymentMethodAdditionalPriceType.DECREMENT
+        )
+          totalFinalPrice -= amount;
+        else totalFinalPrice += amount;
+
+        return {
+          name: additionalPrice.name || this.name,
+          amount: amount,
+          type: additionalPrice.type,
+        };
+      });
+    }
+  }
+
+  private setTranslations() {
+    if (
+      this.translations &&
+      this.translations.some(
+        (t) => t.locale === IkasStorefrontConfig.getCurrentLocale()
+      )
+    ) {
+      const localeTranslations = this.translations.find(
+        (t) => t.locale === IkasStorefrontConfig.getCurrentLocale()
+      );
+
+      if (localeTranslations?.name) this.name = localeTranslations.name;
+      if (localeTranslations?.description)
+        this.description = localeTranslations.description;
+    }
+  }
+}
+
+export type IkasPaymentMethod = {
+  name: string;
+  logoUrl: string | null;
+};
+
+export class IkasPaymentGatewayAdditionalPrice {
+  amount: number;
+  amountType: IkasPaymentGatewayAdditionalPriceAmountType;
+  name: string;
+  type: IkasPaymentMethodAdditionalPriceType;
+
+  constructor(data: Partial<IkasPaymentGatewayAdditionalPrice>) {
+    this.amount = data.amount || 0;
+    this.amountType =
+      data.amountType || IkasPaymentGatewayAdditionalPriceAmountType.AMOUNT;
+    this.name = data.name || "";
+    this.type = data.type || IkasPaymentMethodAdditionalPriceType.INCREMENT;
+
+    makeAutoObservable(this);
+  }
+}
+
+export enum IkasPaymentMethodType {
+  BUY_ONLINE_PAY_AT_STORE = "BUY_ONLINE_PAY_AT_STORE",
+  CASH = "CASH",
+  CASH_ON_DELIVERY = "CASH_ON_DELIVERY",
+  CREDIT_CARD = "CREDIT_CARD",
+  GIFT_CARD = "GIFT_CARD",
+  MONEY_ORDER = "MONEY_ORDER",
+  OTHER = "OTHER",
+}
+
+export enum IkasPaymentMethodAdditionalPriceType {
+  DECREMENT = "DECREMENT",
+  INCREMENT = "INCREMENT",
+}
+
+export enum IkasPaymentGatewayAdditionalPriceAmountType {
+  AMOUNT = "AMOUNT",
+  RATIO = "RATIO",
+}
+
+export enum IkasPaymentGatewayType {
+  EXTERNAL = "EXTERNAL",
+  INTERNAL = "INTERNAL",
+}
+
+type IkasPaymentGatewayTranslation = {
+  description: string | null;
+  locale: string;
+  name: string | null;
+};

package/src/models/data/product/attribute-value/index.ts

@@ -0,0 +1,42 @@
+import { makeAutoObservable } from "mobx";
+import { IkasProductAttribute } from "../../product-attribute";
+import IkasProductAttributeOption from "../../product-attribute/product-attribute-option";
+
+export class IkasProductAttributeValue {
+  value: any;
+  productAttributeId: string | null;
+  productAttributeOptionId: string | null;
+
+  productAttribute?: IkasProductAttribute | null;
+  productAttributeOption?: IkasProductAttributeOption | null;
+
+  constructor(data: Partial<IkasProductAttributeValue>) {
+    this.value = data.value || null;
+    this.productAttributeId = data.productAttributeId || "";
+    this.productAttributeOptionId = data.productAttributeOptionId || null;
+    this.productAttribute = data.productAttribute
+      ? new IkasProductAttribute(data.productAttribute)
+      : null;
+    this.productAttributeOption = data.productAttributeOption
+      ? new IkasProductAttributeOption(data.productAttributeOption)
+      : null;
+
+    makeAutoObservable(this);
+  }
+
+  get tableValue() {
+    if (this.value)
+      return JSON.parse(this.value) as IkasAttributeTableCellValue[];
+  }
+}
+
+export type IkasAttributeTableCellValue = {
+  colId: string;
+  rowId: string;
+  value: string | null;
+};
+
+export type IkasProductAttributeMap = {
+  attribute: IkasProductAttribute;
+  values: IkasProductAttributeValue[];
+};

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

@@ -0,0 +1,95 @@
+import { makeAutoObservable } from "mobx";
+import { IkasCategory } from "../category";
+import { IkasProductVariant } from "./variant";
+import { IkasProductAttributeValue } from "./attribute-value";
+import { IkasProductVariantType } from "./variant-type";
+import { IkasBrand } from "../brand";
+import { IkasHTMLMetaData } from "../html-meta-data";
+import { IkasProductTag } from "../product-tag";
+import { IkasProductOptionSet } from "../product-option-set";
+
+export class IkasProduct {
+  id: string;
+  name: string;
+  type: IkasProductType;
+  description: string;
+  shortDescription: string;
+  metaData?: IkasHTMLMetaData;
+  brand: IkasBrand | null;
+  categories: IkasCategory[];
+  tags: IkasProductTag[] | null;
+  variants: IkasProductVariant[];
+  attributes: IkasProductAttributeValue[];
+  variantTypes: IkasProductVariantType[];
+  productOptionSetId?: string | null;
+  productOptionSet?: IkasProductOptionSet | null;
+
+  constructor(data: Partial<IkasProduct> = {}) {
+    this.id = data.id || Date.now() + "";
+    this.name = data.name || "";
+    this.type = data.type || IkasProductType.PHYSICAL;
+    this.description = data.description || "";
+    this.shortDescription = data.shortDescription || "";
+    this.metaData = data.metaData
+      ? new IkasHTMLMetaData(data.metaData)
+      : undefined;
+
+    this.brand = data.brand ? new IkasBrand(data.brand) : null;
+    this.categories = data.categories
+      ? data.categories.map((c) => new IkasCategory(c))
+      : [];
+    this.tags = data.tags
+      ? data.tags.map((tag) => new IkasProductTag(tag))
+      : [];
+    this.variants = data.variants
+      ? data.variants.map((v) => new IkasProductVariant(v))
+      : [];
+    this.attributes = data.attributes
+      ? data.attributes.map((a) => new IkasProductAttributeValue(a))
+      : [];
+    this.variantTypes = data.variantTypes
+      ? data.variantTypes.map((v) => new IkasProductVariantType(v))
+      : [];
+    this.productOptionSetId = data.productOptionSetId || null;
+    this.productOptionSet = data.productOptionSet
+      ? new IkasProductOptionSet(data.productOptionSet)
+      : null;
+
+    makeAutoObservable(this);
+  }
+
+  get hasVariant() {
+    return !!this.variantTypes.length;
+  }
+
+  get hasStock() {
+    return this.variants.some((v) => v.stock > 0);
+  }
+
+  get mainVariantType() {
+    if (!this.hasVariant) return;
+    return this.variantTypes[0].variantType;
+  }
+
+  get href() {
+    if (!this.metaData?.slug) return "";
+    return `/${this.metaData.slug}`;
+  }
+
+  get canAddToCart() {
+    if (this.productOptionSetId) {
+      return (
+        !!this.productOptionSet &&
+        this.productOptionSet.displayedOptions.every((o) => o.hasValidValues)
+      );
+    } else {
+      return true;
+    }
+  }
+}
+
+export enum IkasProductType {
+  PHYSICAL = "PHYSICAL",
+  DIGITAL = "DIGITAL",
+  MEMBERSHIP = "MEMBERSHIP",
+}

package/src/models/data/product/variant/index.ts

@@ -0,0 +1,93 @@
+import { makeAutoObservable } from "mobx";
+import { IkasProductPrice } from "./price";
+import { IkasVariantValue } from "../../variant-type/variant-value";
+import { IkasProductAttributeValue } from "../attribute-value";
+import { IkasImage } from "../../image";
+import { IkasStorefrontConfig } from "../../../../storefront";
+import { IkasProductBackInStockReminderAPI } from "../../../../api";
+
+export class IkasProductVariant {
+  id: string;
+  sku: string | null;
+  barcodeList: string[];
+  variantValues: IkasVariantValue[];
+  images: IkasImage[];
+  attributes: IkasProductAttributeValue[];
+  price: IkasProductPrice;
+  stock: number;
+  isActive: boolean;
+  productId: string;
+  private _backInStockReminderSaved = false;
+
+  constructor(data: Partial<IkasProductVariant> = {}) {
+    this.id = data.id || Date.now() + "";
+    this.productId = data.productId || "";
+    this.sku = data.sku || null;
+    this.barcodeList = data.barcodeList || [];
+    this.variantValues = data.variantValues
+      ? data.variantValues.map((vv) => new IkasVariantValue(vv))
+      : [];
+    this.images = data.images
+      ? data.images.map((i) => new IkasImage(i.id))
+      : [];
+    this.attributes = data.attributes
+      ? data.attributes.map((a) => new IkasProductAttributeValue(a))
+      : [];
+    this.price = data.price
+      ? new IkasProductPrice(data.price)
+      : new IkasProductPrice();
+    this.stock = data.stock || 0;
+    this.isActive = data.isActive !== undefined ? data.isActive : true;
+
+    makeAutoObservable(this);
+  }
+
+  get mainImage() {
+    return this.images.length ? this.images[0] : undefined;
+  }
+
+  get hasStock() {
+    return this.stock > 0;
+  }
+
+  get isBackInStockEnabled() {
+    return IkasStorefrontConfig.productBackInStockSettings !== null;
+  }
+
+  get isBackInStockCustomerLoginRequired() {
+    return (
+      IkasStorefrontConfig.productBackInStockSettings &&
+      IkasStorefrontConfig.productBackInStockSettings.customerLoginRequired
+    );
+  }
+
+  get isBackInStockReminderSaved() {
+    return this._backInStockReminderSaved;
+  }
+
+  async saveBackInStockReminder(email: string) {
+    const listResponse = await IkasProductBackInStockReminderAPI.list({
+      email: email,
+      productId: this.productId,
+      variantId: this.id,
+    });
+
+    if (listResponse && listResponse.data.length) {
+      this._backInStockReminderSaved = true;
+      return false;
+    } else {
+      const saveResponseSuccess = await IkasProductBackInStockReminderAPI.save({
+        email: email,
+        productId: this.productId,
+        variantId: this.id,
+      });
+      if (saveResponseSuccess) {
+        this._backInStockReminderSaved = true;
+        return true;
+      } else {
+        this._backInStockReminderSaved = false;
+        return false;
+      }
+    }
+  }
+}

package/src/models/data/product/variant/price/index.ts

@@ -0,0 +1,38 @@
+import { getCurrencySymbol } from "../../../../../utils";
+import { makeAutoObservable } from "mobx";
+
+export class IkasProductPrice {
+  sellPrice: number;
+  discountPrice: number | null;
+  currency: string;
+  currencySymbol: string;
+
+  constructor(data: Partial<IkasProductPrice> = {}) {
+    this.sellPrice = data.sellPrice || 0;
+    this.discountPrice =
+      data.discountPrice !== undefined ? data.discountPrice : null;
+    this.currency = data.currency || "";
+    this.currencySymbol = getCurrencySymbol(this.currency);
+
+    makeAutoObservable(this);
+  }
+
+  get finalPrice() {
+    return this.discountPrice !== null ? this.discountPrice : this.sellPrice;
+  }
+
+  get hasDiscount() {
+    return this.discountPrice !== null;
+  }
+
+  get discountAmount() {
+    if (this.hasDiscount) return this.sellPrice - this.discountPrice!;
+    return 0;
+  }
+
+  get discountPercentage() {
+    if (this.hasDiscount)
+      return (100 - (this.finalPrice * 100) / this.sellPrice).toFixed(0);
+    return 0;
+  }
+}

package/src/models/data/product/variant-type/index.ts

@@ -0,0 +1,24 @@
+import { makeAutoObservable } from "mobx";
+import { IkasVariantType } from "../../variant-type";
+import { IkasVariantValue } from "../../variant-type/variant-value";
+
+export class IkasProductVariantType {
+  variantType: IkasVariantType;
+  variantValueIds: string[];
+
+  constructor(data: Partial<IkasProductVariantType>) {
+    this.variantType = data.variantType
+      ? new IkasVariantType(data.variantType)
+      : new IkasVariantType();
+    this.variantValueIds = data.variantValueIds || [];
+
+    const orderedVariantValues: IkasVariantValue[] = [];
+    this.variantValueIds.forEach((vvId) => {
+      const variantValue = this.variantType.values.find((vv) => vv.id === vvId);
+      if (variantValue) orderedVariantValues.push(variantValue);
+    });
+    this.variantType.values = orderedVariantValues;
+
+    makeAutoObservable(this);
+  }
+}

package/src/models/data/product-attribute/index.ts

@@ -0,0 +1,75 @@
+import { makeAutoObservable } from "mobx";
+import { IkasStorefrontConfig } from "../../../storefront";
+import IkasProductAttributeOption from "./product-attribute-option";
+import { IkasProductAttributeTableTemplate } from "./product-attribute-table-template";
+
+export class IkasProductAttribute {
+  id: string;
+  name: string;
+  description: string | null;
+  type: IkasProductAttributeType;
+  options?: IkasProductAttributeOption[] | null;
+  tableTemplate?: IkasProductAttributeTableTemplate | null;
+  translations: IkasProductAttributeTranslation[] | null = null;
+
+  constructor(data: Partial<IkasProductAttribute>) {
+    this.id = data.id || "";
+    this.name = data.name || "";
+    this.description = data.description || "";
+    this.type = data.type || IkasProductAttributeType.TEXT;
+    this.options = data.options || null;
+    this.tableTemplate = data.tableTemplate || null;
+    this.translations = data.translations || null;
+
+    this.setTranslations();
+    makeAutoObservable(this);
+  }
+
+  private setTranslations() {
+    if (
+      this.translations &&
+      this.translations.some(
+        (t) => t.locale === IkasStorefrontConfig.getCurrentLocale()
+      )
+    ) {
+      const localeTranslations = this.translations.find(
+        (t) => t.locale === IkasStorefrontConfig.getCurrentLocale()
+      );
+
+      if (localeTranslations?.name) this.name = localeTranslations.name;
+      if (localeTranslations?.description)
+        this.description = localeTranslations.description;
+      if (localeTranslations?.options) {
+        this.options?.forEach((o) => {
+          const translatedVV = localeTranslations.options?.find(
+            (to) => to.id === o.id
+          );
+          if (translatedVV && translatedVV.name) o.name = translatedVV.name;
+        });
+      }
+    }
+  }
+}
+
+export enum IkasProductAttributeType {
+  CHOICE = "CHOICE",
+  MULTIPLE_CHOICE = "MULTIPLE_CHOICE",
+  TEXT = "TEXT",
+  BOOLEAN = "BOOLEAN",
+  NUMERIC = "NUMERIC",
+  DATETIME = "DATETIME",
+  HTML = "HTML",
+  TABLE = "TABLE",
+}
+
+type IkasProductAttributeTranslation = {
+  description: string | null;
+  locale: string;
+  name: string | null;
+  options: IkasProductAttributeOptionTranslation[] | null;
+};
+
+type IkasProductAttributeOptionTranslation = {
+  id: string;
+  name: string | null;
+};

package/src/models/data/product-attribute/product-attribute-option/index.ts

@@ -0,0 +1,13 @@
+import { makeAutoObservable } from "mobx";
+
+export default class IkasProductAttributeOption {
+  id: string;
+  name: string;
+
+  constructor(data: Partial<IkasProductAttributeOption> = {}) {
+    this.id = data.id || "";
+    this.name = data.name || "";
+
+    makeAutoObservable(this);
+  }
+}

package/src/models/data/product-attribute/product-attribute-table-cell/index.ts

@@ -0,0 +1,13 @@
+import { makeAutoObservable } from "mobx";
+
+export class IkasProductAttributeTableCell {
+  id: string;
+  name: string | null;
+
+  constructor(data?: Partial<IkasProductAttributeTableCell>) {
+    this.id = data?.id || "";
+    this.name = data?.name || null;
+
+    makeAutoObservable(this);
+  }
+}

package/src/models/data/product-attribute/product-attribute-table-template/index.ts

@@ -0,0 +1,18 @@
+import { makeAutoObservable } from "mobx";
+import { IkasProductAttributeTableCell } from "../product-attribute-table-cell";
+
+export class IkasProductAttributeTableTemplate {
+  columns: IkasProductAttributeTableCell[] | null;
+  rows: IkasProductAttributeTableCell[] | null;
+
+  constructor(data?: Partial<IkasProductAttributeTableTemplate>) {
+    this.columns = data?.columns
+      ? data.columns.map((c) => new IkasProductAttributeTableCell(c))
+      : [];
+    this.rows = data?.rows
+      ? data.rows.map((r) => new IkasProductAttributeTableCell(r))
+      : [];
+
+    makeAutoObservable(this);
+  }
+}

package/src/models/data/product-back-in-stock-settings/index.ts

@@ -0,0 +1,3 @@
+export type IkasProductBackInStockSettings = {
+  customerLoginRequired: boolean;
+};

package/src/models/data/product-cart-item-options/index.ts

@@ -0,0 +1,15 @@
+import { makeAutoObservable } from "mobx";
+
+export class IkasProductCartLineOption {
+  productOptionId: string;
+  productOptionsSetId: string;
+  values: string[];
+
+  constructor(data: Partial<IkasProductCartLineOption> = {}) {
+    this.productOptionId = data.productOptionId || "";
+    this.productOptionsSetId = data.productOptionsSetId || "";
+    this.values = data.values || [];
+
+    makeAutoObservable(this);
+  }
+}