@ikas/storefront 1.0.21 → 2.0.0-alpha.1

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

@@ -0,0 +1,392 @@
+import { makeAutoObservable } from "mobx";
+import { IkasImage } from "../image";
+import { IkasStorefrontConfig } from "../../../storefront";
+import _sortBy from "lodash/sortBy";
+
+export enum IkasProductOptionType {
+  CHOICE = "CHOICE",
+  TEXT = "TEXT",
+  TEXT_AREA = "TEXT_AREA",
+  // IMAGE = "IMAGE",
+  // FILE = "FILE",
+  COLOR_PICKER = "COLOR_PICKER",
+  // DATE_PICKER = "DATE_PICKER",
+  CHECKBOX = "CHECKBOX",
+}
+
+export enum IkasProductOptionSelectType {
+  SELECT = "SELECT",
+  BOX = "BOX",
+  SWATCH = "SWATCH",
+}
+
+export class IkasProductOptionSelectValueTranslations {
+  id: string;
+  value: string | null;
+
+  constructor(data: Partial<IkasProductOptionSelectValueTranslations>) {
+    this.id = data.id || "";
+    this.value = data.value || null;
+    makeAutoObservable(this);
+  }
+}
+
+export class IkasProductOptionTranslations {
+  id: string;
+  name: string | null;
+  optionalText: string | null;
+  values: IkasProductOptionSelectValueTranslations[] | null;
+
+  constructor(data: Partial<IkasProductOptionTranslations>) {
+    this.id = data.id || "";
+    this.name = data.name || null;
+    this.optionalText = data.optionalText || null;
+    this.values =
+      data.values?.map(
+        (o) => new IkasProductOptionSelectValueTranslations(o)
+      ) || [];
+    makeAutoObservable(this);
+  }
+}
+
+export class IkasProductOptionSetTranslations {
+  locale: string;
+  options: IkasProductOptionTranslations[] | null;
+
+  constructor(data: Partial<IkasProductOptionSetTranslations>) {
+    this.locale = data.locale || "";
+    this.options =
+      data.options?.map((o) => new IkasProductOptionTranslations(o)) || [];
+    makeAutoObservable(this);
+  }
+}
+
+export class IkasProductOptionSelectValue {
+  id: string;
+  order: number;
+  value: string;
+  price: number | null;
+  thumbnailImageId: string | null;
+  colorCode: string | null;
+  thumbnailImage: IkasImage | null = null;
+
+  constructor(data: Partial<IkasProductOptionSelectValue> = {}) {
+    this.id = data.id || "";
+    this.order = data.order || 0;
+    this.value = data.value || "";
+    this.price = data.price || null;
+    this.thumbnailImageId = data.thumbnailImageId || null;
+    this.colorCode = data.colorCode || null;
+    this.thumbnailImage = this.thumbnailImageId
+      ? new IkasImage(this.thumbnailImageId)
+      : null;
+    makeAutoObservable(this);
+  }
+}
+
+export class IkasProductOptionSelectSettings {
+  type: IkasProductOptionSelectType;
+  minSelect: number | null;
+  maxSelect: number | null;
+  values: IkasProductOptionSelectValue[];
+
+  constructor(data: Partial<IkasProductOptionSelectSettings> = {}) {
+    this.type = data.type || IkasProductOptionSelectType.BOX;
+    this.minSelect =
+      data.minSelect !== null && data.minSelect !== undefined
+        ? data.minSelect
+        : null;
+    this.maxSelect =
+      data.maxSelect !== null && data.maxSelect !== undefined
+        ? data.maxSelect
+        : null;
+    this.values = _sortBy(
+      data.values?.map((o) => new IkasProductOptionSelectValue(o)) || [],
+      "order"
+    );
+    makeAutoObservable(this);
+  }
+}
+
+export class IkasProductOptionDateSettings {
+  min: Date | null;
+  max: Date | null;
+
+  constructor(data: Partial<IkasProductOptionDateSettings>) {
+    this.min = data.min || null;
+    this.max = data.max || null;
+    makeAutoObservable(this);
+  }
+}
+
+export class IkasProductOptionTextSettings {
+  min: number | null;
+  max: number | null;
+
+  constructor(data: Partial<IkasProductOptionTextSettings> = {}) {
+    this.min = data.min !== null && data.min !== undefined ? data.min : null;
+    this.max = data.max !== null && data.max !== undefined ? data.max : null;
+    makeAutoObservable(this);
+  }
+}
+
+export class IkasProductOptionFileSettings {
+  allowedExtensions: string[] | null;
+  minQuantity: number | null;
+  maxQuantity: number | null;
+
+  constructor(data: Partial<IkasProductOptionFileSettings>) {
+    this.allowedExtensions = data.allowedExtensions || null;
+    this.minQuantity =
+      data.minQuantity !== null && data.minQuantity !== undefined
+        ? data.minQuantity
+        : null;
+    this.maxQuantity =
+      data.maxQuantity !== null && data.maxQuantity !== undefined
+        ? data.maxQuantity
+        : null;
+    makeAutoObservable(this);
+  }
+}
+
+export class IkasProductOption {
+  id: string;
+  productOptionSetId: string;
+  name: string;
+  order: number;
+  type: IkasProductOptionType;
+  selectSettings: IkasProductOptionSelectSettings | null;
+  textSettings: IkasProductOptionTextSettings | null;
+  fileSettings: IkasProductOptionFileSettings | null;
+  dateSettings: IkasProductOptionDateSettings | null;
+  price: number | null;
+  isOptional: boolean;
+  optionalText: string | null;
+  requiredOptionId: string | null;
+  requiredOptionValueIds: string[] | null;
+
+  private _values: string[] = [];
+  private childOptions: IkasProductOption[] = [];
+
+  constructor(data: Partial<IkasProductOption>) {
+    this.id = data.id || "";
+    this.productOptionSetId = data.productOptionSetId || "";
+    this.name = data.name || "";
+    this.order = data.order || 0;
+    this.type = data.type || IkasProductOptionType.CHOICE;
+    this.selectSettings = data.selectSettings
+      ? new IkasProductOptionSelectSettings(data.selectSettings || {})
+      : null;
+    this.textSettings = data.textSettings
+      ? new IkasProductOptionTextSettings(data.textSettings || {})
+      : null;
+
+    this.fileSettings = data.fileSettings
+      ? new IkasProductOptionFileSettings(data.fileSettings || {})
+      : null;
+    this.dateSettings = data.dateSettings
+      ? new IkasProductOptionDateSettings(data.dateSettings || {})
+      : null;
+    this.price = data.price || null;
+    this.isOptional = data.isOptional || false;
+    this.optionalText = data.optionalText || null;
+    this.requiredOptionId = data.requiredOptionId || null;
+    this.requiredOptionValueIds = data.requiredOptionValueIds || null;
+
+    this.values = data.values || [];
+    //@ts-ignore
+    this.childOptions = data.childOptions || [];
+
+    makeAutoObservable(this);
+  }
+
+  get displayedChildOptions() {
+    return _sortBy(
+      this.childOptions.filter((co) => {
+        // Check if all required options are selected
+        if (co.requiredOptionValueIds?.length) {
+          return co.requiredOptionValueIds.every((rovId) =>
+            this.values.some((v) => v === rovId)
+          );
+        } else {
+          if (this.type === IkasProductOptionType.CHECKBOX) {
+            return !!this.values.length && this.values[0] === "true";
+          }
+          return !!this.values.length;
+        }
+      }),
+      "order"
+    );
+  }
+
+  get hasValidValues(): boolean {
+    if (!this.values.length && !this.isOptional) {
+      return false;
+    }
+
+    let hasValidValues = false;
+
+    switch (this.type) {
+      case IkasProductOptionType.TEXT:
+      case IkasProductOptionType.TEXT_AREA:
+        hasValidValues = this.isValidTextOptionValue();
+        break;
+
+      case IkasProductOptionType.CHECKBOX:
+      case IkasProductOptionType.COLOR_PICKER:
+        hasValidValues = true;
+        break;
+
+      case IkasProductOptionType.CHOICE:
+        hasValidValues = this.isValidChoiceOptionValue();
+        break;
+
+      default:
+        break;
+    }
+
+    return (
+      hasValidValues &&
+      this.displayedChildOptions.every((co) => co.hasValidValues)
+    );
+  }
+
+  get values() {
+    return this._values;
+  }
+
+  set values(values: string[]) {
+    this._values = values;
+    if (!values.length) {
+      this.childOptions.forEach((co) => (co.values = []));
+    }
+  }
+
+  initValues = () => {
+    if (!this.isOptional) {
+      this.values = [];
+      if (this.childOptions) {
+        this.childOptions.forEach((co) => co.initValues());
+      }
+    }
+  };
+
+  private isValidTextOptionValue = () => {
+    const value = this.values[0];
+    if (!value) {
+      return !!this.isOptional;
+    }
+
+    return (
+      !!this.textSettings &&
+      (this.textSettings.min !== null
+        ? value.length >= this.textSettings.min
+        : true) &&
+      (this.textSettings.max !== null
+        ? value.length <= this.textSettings.max
+        : true)
+    );
+  };
+
+  private isValidChoiceOptionValue = () => {
+    if (!this.values.length) {
+      return !!this.isOptional;
+    }
+
+    return (
+      !!this.selectSettings &&
+      (this.selectSettings.minSelect !== null
+        ? this.values.length >= this.selectSettings.minSelect
+        : true) &&
+      (this.selectSettings.maxSelect !== null
+        ? this.values.length <= this.selectSettings.maxSelect
+        : true)
+    );
+  };
+}
+
+export class IkasProductOptionSet {
+  id: string;
+  name: string;
+  options: IkasProductOption[];
+  translations: IkasProductOptionSetTranslations[] | null;
+
+  constructor(data: Partial<IkasProductOptionSet>) {
+    this.id = data.id || "";
+    this.name = data.name || "";
+    this.options =
+      data.options?.map(
+        (o) =>
+          new IkasProductOption({
+            ...o,
+            productOptionSetId: this.id,
+          })
+      ) || [];
+    this.translations = data.translations
+      ? data.translations?.map((o) => new IkasProductOptionSetTranslations(o))
+      : null;
+
+    this.setChildOptions();
+    this.setTranslations();
+    this.initOptionValues();
+
+    makeAutoObservable(this);
+  }
+
+  get displayedOptions() {
+    return _sortBy(
+      this.options.filter((o) => !o.requiredOptionId),
+      "order"
+    );
+  }
+
+  private setTranslations() {
+    const locale = IkasStorefrontConfig.getCurrentLocale();
+
+    if (
+      this.translations &&
+      this.translations.some((t) => t.locale === locale)
+    ) {
+      const localeTranslations = this.translations.find(
+        (t) => t.locale === locale
+      );
+
+      localeTranslations?.options?.forEach((translatedOption) => {
+        const option = this.options.find((o) => o.id === translatedOption.id);
+
+        if (option) {
+          option.name = translatedOption.name || option.name;
+          option.optionalText =
+            translatedOption.optionalText || option.optionalText;
+
+          if (option.type === IkasProductOptionType.CHOICE) {
+            translatedOption.values?.forEach((translatedValue) => {
+              const selectValue = option.selectSettings?.values.find(
+                (sv) => sv.id === translatedValue.id
+              );
+              if (selectValue) {
+                selectValue.value = translatedValue.value || selectValue.value;
+              }
+            });
+          }
+        }
+      });
+    }
+  }
+
+  private setChildOptions() {
+    this.options.forEach((option) => {
+      const childOptions = this.options.filter(
+        (o) => o.requiredOptionId === option.id
+      );
+      if (childOptions.length) {
+        //@ts-ignore
+        option.childOptions = childOptions;
+      }
+    });
+  }
+
+  initOptionValues = async () => {
+    this.options.forEach((o) => o.initValues());
+  };
+}

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

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

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

@@ -0,0 +1,159 @@
+import { makeAutoObservable } from "mobx";
+import moment from "moment";
+import { IkasProductDetail } from "../../ui/product-detail";
+
+export class RaffleDateRangeField {
+  start: number | null;
+  end: number | null;
+
+  constructor(data: Partial<RaffleDateRangeField>) {
+    this.start = data.start || null;
+    this.end = data.end || null;
+
+    makeAutoObservable(this);
+  }
+}
+
+export enum IkasRaffleVerificationTypeEnum {
+  EMAIL = "EMAIL",
+  MERSIS = "MERSIS",
+}
+
+export class IkasRaffle {
+  id: string;
+  createdAt: number;
+  updatedAt: number;
+  deleted: boolean | null;
+  dateRange: RaffleDateRangeField | null;
+  metadata: IkasRaffleMetaData | null;
+  name: string;
+  participantCount?: number | null;
+  requiredCustomerAccount: boolean;
+  status: boolean;
+  variants: IkasRaffleAppliedProduct[] | null;
+  products: IkasProductDetail[];
+  verificationType: IkasRaffleVerificationTypeEnum;
+
+  constructor(data: Partial<IkasRaffle> = {}) {
+    this.id = data.id || Date.now() + "";
+    this.createdAt = data.createdAt || Date.now();
+    this.updatedAt = data.updatedAt || Date.now();
+    this.deleted = data.deleted || null;
+    this.name = data.name || "";
+    this.participantCount = data.participantCount || 0;
+    this.requiredCustomerAccount = data.requiredCustomerAccount || false;
+    this.status = data.status || false;
+    this.verificationType =
+      data.verificationType || IkasRaffleVerificationTypeEnum.EMAIL;
+
+    this.dateRange = data.dateRange
+      ? new RaffleDateRangeField(data.dateRange)
+      : null;
+    this.metadata = data.metadata
+      ? new IkasRaffleMetaData(data.metadata)
+      : null;
+    this.variants =
+      data.variants?.map((v) => new IkasRaffleAppliedProduct(v)) || [];
+    this.products =
+      data.products?.map(
+        (p) => new IkasProductDetail(p.product, p.selectedVariantValues)
+      ) || [];
+  }
+
+  get isRaffleAvailable() {
+    const now = moment().utc(true);
+    if (!this.status) return false;
+    else if (
+      !now.isBetween(
+        this.dateRange?.start,
+        this.dateRange?.end,
+        undefined,
+        "[]"
+      )
+    )
+      return false;
+    else return true;
+  }
+}
+
+export enum IkasRaffleMetadataTargetType {
+  RAFFLE = "RAFFLE",
+}
+
+export class IkasRaffleMetaData {
+  id: string;
+  createdAt: number;
+  updatedAt: number;
+  deleted: boolean | null;
+  description: string | null;
+  pageTitle: string | null;
+  slug: string;
+  targetId: string | null;
+  targetType: IkasRaffleMetadataTargetType | null;
+
+  constructor(data: Partial<IkasRaffleMetaData>) {
+    this.id = data.id || Date.now() + "";
+    this.createdAt = data.createdAt || Date.now();
+    this.updatedAt = data.updatedAt || Date.now();
+    this.deleted = data.deleted || null;
+    this.description = data.description || "";
+    this.pageTitle = data.pageTitle || "";
+    this.slug = data.slug || "";
+    this.targetId = data.targetId || "";
+    this.targetType = data.targetType || IkasRaffleMetadataTargetType.RAFFLE;
+  }
+}
+
+export class IkasRaffleParticipant {
+  id?: string | null;
+  createdAt?: number | null;
+  updatedAt?: number | null;
+  deleted?: boolean | null;
+  customerId?: string | null;
+  raffleId: string;
+  firstName: string;
+  lastName: string;
+  fullName?: string | null;
+  email: string;
+  applicationDate?: number;
+  phone?: string | null;
+  isWinner?: boolean | null;
+
+  extraData?: Record<string, any> | null;
+  appliedProducts: IkasRaffleAppliedProduct[];
+
+  constructor(data: Partial<IkasRaffleParticipant>) {
+    this.id = data.id || null;
+    this.createdAt = data.createdAt || Date.now();
+    this.updatedAt = data.updatedAt || Date.now();
+    this.deleted = data.deleted || false;
+    this.customerId = data.customerId || null;
+    this.raffleId = data.raffleId || "";
+    this.firstName = data.firstName || "";
+    this.lastName = data.lastName || "";
+    this.fullName = data.fullName || null;
+    this.email = data.email || "";
+    this.applicationDate = data.applicationDate || 0;
+    this.phone = data.phone || null;
+    this.isWinner = data.isWinner || null;
+
+    this.extraData = data.extraData || {};
+    this.appliedProducts = data.appliedProducts
+      ? data.appliedProducts.map((ap) => new IkasRaffleAppliedProduct(ap))
+      : [];
+
+    makeAutoObservable(this);
+  }
+}
+
+export class IkasRaffleAppliedProduct {
+  productId: string;
+  variantId: string;
+
+  constructor(data: Partial<IkasRaffleAppliedProduct>) {
+    this.productId = data.productId || "";
+    this.variantId = data.variantId || "";
+
+    makeAutoObservable(this);
+  }
+}

package/src/models/data/sales-channel/index.ts

@@ -0,0 +1,41 @@
+export class IkasSalesChannel {
+  id: string;
+  name: string;
+  priceListId: string | null;
+  stockLocations: IkasSalesChannelStockLocation[] | null;
+  paymentGateways: IkasSalesChannelPaymentGateway[] | null;
+
+  constructor(data: Partial<IkasSalesChannel> = {}) {
+    this.id = data.id || "";
+    this.name = data.name || "";
+    this.priceListId = data.priceListId || "";
+
+    this.stockLocations =
+      data.stockLocations?.map((sl) => new IkasSalesChannelStockLocation(sl)) ||
+      [];
+    this.paymentGateways =
+      data.paymentGateways?.map(
+        (pg) => new IkasSalesChannelPaymentGateway(pg)
+      ) || [];
+  }
+}
+
+export class IkasSalesChannelStockLocation {
+  id: string;
+  order: number;
+
+  constructor(data: Partial<IkasSalesChannelStockLocation>) {
+    this.id = data.id || "";
+    this.order = data.order || 0;
+  }
+}
+
+export class IkasSalesChannelPaymentGateway {
+  id: string;
+  order: number;
+
+  constructor(data: Partial<IkasSalesChannelPaymentGateway>) {
+    this.id = data.id || "";
+    this.order = data.order || 0;
+  }
+}