@ikas/storefront-model-functions 4.0.0-alpha.10

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@ikas/storefront-model-functions",
+  "version": "4.0.0-alpha.10",
+  "description": "Functions for ikas storefront models.",
+  "author": "Umut Ozan Yıldırım",
+  "license": "ISC",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "files": [
+    "./src"
+  ],
+  "type": "module",
+  "scripts": {
+    "pack": "npm pack",
+    "release": "npm publish",
+    "build": "rm -rf build && rollup -c"
+  },
+  "devDependencies": {
+    "@ikas/storefront-config": "^4.0.0-alpha.10",
+    "@ikas/storefront-models": "^4.0.0-alpha.10",
+    "@rollup/plugin-node-resolve": "^13.3.0",
+    "@rollup/plugin-commonjs": "^22.0.0",
+    "@types/lodash": "^4.14.182",
+    "prettier": "^2.2.1",
+    "rollup": "^2.75.6",
+    "rollup-plugin-terser": "^7.0.2",
+    "rollup-plugin-typescript2": "^0.32.1",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "typescript": "^4.7.2",
+    "ttypescript": "^1.5.12",
+    "typescript-transform-paths": "^2.2.2",
+    "lodash": "^4.17.21"
+  },
+  "peerDependencies": {
+    "@ikas/storefront-config": "^4.0.0-alpha.10",
+    "@ikas/storefront-models": "^4.0.0-alpha.10",
+    "lodash": "^4.17.21"
+  }
+}

package/src/functions/blog/category/index.ts

@@ -0,0 +1,6 @@
+import { IkasBlogCategory } from "@ikas/storefront-models";
+
+export function getIkasBlogCategoryHref(blogCategory: IkasBlogCategory) {
+  if (!blogCategory.metadata?.slug) return "";
+  return `/blog/${blogCategory.metadata.slug}`;
+}

package/src/functions/blog/index.ts

@@ -0,0 +1,6 @@
+import { IkasBlog } from "@ikas/storefront-models";
+
+export function getIkasBlogHref(blog: IkasBlog) {
+  if (!blog.metadata?.slug) return "";
+  return `/blog/${blog.metadata.slug}`;
+}

package/src/functions/brand/index.ts

@@ -0,0 +1,6 @@
+import { IkasBrand } from "@ikas/storefront-models";
+
+export function getIkasBrandHref(brand: IkasBrand) {
+  if (!brand.metaData?.slug) return "";
+  return `/${brand.metaData.slug}`;
+}

package/src/functions/category/index.ts

@@ -0,0 +1,6 @@
+import { IkasCategory } from "@ikas/storefront-models";
+
+export function getIkasCategoryHref(category: IkasCategory) {
+  if (!category.metaData?.slug) return "";
+  return `/${category.metaData.slug}`;
+}

package/src/functions/category/path-item/index.ts

@@ -0,0 +1,15 @@
+import { IkasCategoryPathItem } from "@ikas/storefront-models";
+
+export function getIkasCategoryPathItemSlug(
+  categoryPathItem: IkasCategoryPathItem
+) {
+  return categoryPathItem.metaData?.slug;
+}
+
+export function getIkasCategoryPathItemHref(
+  categoryPathItem: IkasCategoryPathItem
+) {
+  const slug = getIkasCategoryPathItemSlug(categoryPathItem);
+  if (!slug) return "";
+  return `/${slug}`;
+}

package/src/functions/checkout/index.ts

@@ -0,0 +1,35 @@
+import {
+  IkasCheckout,
+  IkasPaymentGateway,
+  IkasPaymentGatewayAdditionalPriceType,
+} from "@ikas/storefront-models";
+import { getCalculatedAdditionalPrices } from "../payment-gateway";
+
+export function isComplete(checkout: IkasCheckout) {
+  return !!checkout.orderNumber;
+}
+
+export function getTotalFinalPrice(
+  checkout: IkasCheckout,
+  selectedPaymentGateway: IkasPaymentGateway
+) {
+  const calculatedAdditionalPrices = selectedPaymentGateway
+    ? getCalculatedAdditionalPrices(
+        selectedPaymentGateway,
+        checkout.totalFinalPrice || 0,
+        checkout.shippingLines || null
+      )
+    : undefined;
+
+  let total = checkout.totalFinalPrice || 0;
+
+  calculatedAdditionalPrices?.forEach((additionalPrice) => {
+    if (
+      additionalPrice.type === IkasPaymentGatewayAdditionalPriceType.DECREMENT
+    )
+      total -= additionalPrice.amount;
+    else total += additionalPrice.amount;
+  });
+
+  return total;
+}

package/src/functions/customer/address/index.ts

@@ -0,0 +1,90 @@
+import {
+  IkasCheckoutRequirement,
+  IkasCheckoutSettings,
+  IkasCustomerAddress,
+} from "@ikas/storefront-models";
+import { validatePhoneNumber } from "../../../utils/helper";
+
+export function getAddressText(address: IkasCustomerAddress) {
+  const strings: string[] = [];
+
+  if (address.addressLine1) strings.push(address.addressLine1);
+  if (address.addressLine2) strings.push(address.addressLine2);
+  if (address.postalCode) strings.push(address.postalCode);
+  if (address.district && address.district.name)
+    strings.push(address.district.name);
+  if (address.city && address.city.name) strings.push(address.city.name);
+  if (address.state && address.state.name && address.state.name !== "Default")
+    strings.push(address.state.name);
+  if (address.country && address.country.name)
+    strings.push(address.country.name);
+
+  return strings.join(", ");
+}
+
+export function getValidationResult(
+  address: IkasCustomerAddress,
+  checkoutSettings: IkasCheckoutSettings,
+  isDistrictRequired: boolean
+): IkasCustomerAddressValidationResult {
+  const isValidPhone =
+    !!address.phone &&
+    address.phone.length >= 10 &&
+    validatePhoneNumber(address.phone);
+
+  const results = {
+    firstName: !!address.firstName,
+    lastName: !!address.lastName,
+    addressLine1: !!address.addressLine1,
+    country: !!address.country?.name,
+    state: !!address.state,
+    city: !!address.city?.name,
+    district: isDistrictRequired ? !!address.district?.id : true,
+    phone:
+      checkoutSettings.phoneRequirement === IkasCheckoutRequirement.MANDATORY ||
+      (checkoutSettings.phoneRequirement === IkasCheckoutRequirement.OPTIONAL &&
+        address.phone)
+        ? isValidPhone
+        : true,
+    postalCode:
+      checkoutSettings.postalCodeRequirement ===
+      IkasCheckoutRequirement.MANDATORY
+        ? !!address.postalCode
+        : true,
+    identityNumber:
+      checkoutSettings.identityNumberRequirement ===
+      IkasCheckoutRequirement.MANDATORY
+        ? !!address.identityNumber
+        : true,
+    title: !!address.title,
+  };
+
+  return results;
+}
+
+export function isValidAddress(
+  address: IkasCustomerAddress,
+  checkoutSettings: IkasCheckoutSettings,
+  isDistrictRequired: boolean
+) {
+  const validationResult = getValidationResult(
+    address,
+    checkoutSettings,
+    isDistrictRequired
+  );
+  return Object.values(validationResult).every((result) => result);
+}
+
+export type IkasCustomerAddressValidationResult = {
+  firstName: boolean;
+  lastName: boolean;
+  addressLine1: boolean;
+  country: boolean;
+  state: boolean;
+  city: boolean;
+  district: boolean;
+  phone: boolean;
+  postalCode: boolean;
+  identityNumber: boolean;
+  title: boolean;
+};

package/src/functions/customer/attribute/index.ts

@@ -0,0 +1,18 @@
+import { IkasStorefrontConfig } from "@ikas/storefront-config";
+import { IkasCustomerAttribute } from "@ikas/storefront-models";
+
+export function getAccountPagePermission(attribute: IkasCustomerAttribute) {
+  const salesChannelId = IkasStorefrontConfig.getSalesChannelId();
+
+  return attribute.salesChannels?.find(
+    (sc) => sc.salesChannelId === salesChannelId
+  )?.permission;
+}
+
+export function getRegisterPageRequirement(attribute: IkasCustomerAttribute) {
+  const salesChannelId = IkasStorefrontConfig.getSalesChannelId();
+
+  return attribute.salesChannels?.find(
+    (sc) => sc.salesChannelId === salesChannelId
+  )?.registerPageRequirement;
+}

package/src/functions/customer/index.ts

@@ -0,0 +1,23 @@
+import {
+  IkasCustomer,
+  IkasCustomerEmailSubscriptionStatus,
+} from "@ikas/storefront-models";
+
+export function isSubscribed(customer: IkasCustomer) {
+  return (
+    customer.subscriptionStatus ===
+      IkasCustomerEmailSubscriptionStatus.SUBSCRIBED ||
+    customer.subscriptionStatus ===
+      IkasCustomerEmailSubscriptionStatus.PENDING_CONFIRMATION
+  );
+}
+
+export function getBasicInfo(customer: IkasCustomer) {
+  return {
+    id: customer.id,
+    firstName: customer.firstName,
+    lastName: customer.lastName,
+    email: customer.email,
+    phone: customer.phone,
+  };
+}

package/src/functions/filter-category/index.ts

@@ -0,0 +1,6 @@
+import { IkasFilterCategory } from "@ikas/storefront-models";
+
+export function getIkasFilterCategoryHref(filterCategory: IkasFilterCategory) {
+  if (!filterCategory.metaData) return "";
+  return `/${filterCategory.metaData.slug}`;
+}

package/src/functions/image/index.ts

@@ -0,0 +1,27 @@
+import { IkasStorefrontConfig } from "@ikas/storefront-config";
+import { IkasImage } from "@ikas/storefront-models";
+
+export function getDefaultSrc(image: IkasImage) {
+  return getSrc(image, 1080);
+}
+
+export function getThumbnailSrc(image: IkasImage) {
+  return getSrc(image, 180);
+}
+
+export function getSrc(image: IkasImage, size: number) {
+  const cdnUrl = IkasStorefrontConfig.getCdnUrl();
+  if (image.id.includes("/")) {
+    if (image.isVideo) {
+      return `${cdnUrl}videos/${image.id}/original.mp4`;
+    }
+
+    return `${cdnUrl}images/${image.id}/image_${size}.webp`;
+  }
+
+  const merchantId = IkasStorefrontConfig.getMerchantSettings()?.merchantId;
+
+  if (image.isVideo)
+    return `${cdnUrl}videos/${merchantId}/${image.id}/original.mp4`;
+  return `${cdnUrl}images/${merchantId}/${image.id}/image_${size}.webp`;
+}

package/src/functions/order/address/index.ts

@@ -0,0 +1,110 @@
+import {
+  IkasCheckoutRequirement,
+  IkasCheckoutSettings,
+  IkasOrderAddress,
+} from "@ikas/storefront-models";
+import { validatePhoneNumber } from "../../../utils/helper";
+
+export function createOrderAddress(): IkasOrderAddress {
+  return {
+    addressLine1: "",
+    addressLine2: null,
+    company: null,
+    firstName: "",
+    id: null,
+    identityNumber: null,
+    isDefault: false,
+    lastName: "",
+    phone: null,
+    postalCode: null,
+    taxNumber: null,
+    taxOffice: null,
+
+    country: null,
+    state: null,
+    city: null,
+    district: null,
+  };
+}
+
+export function getAddressText(address: IkasOrderAddress) {
+  const strings: string[] = [];
+
+  if (address.addressLine1) strings.push(address.addressLine1);
+  if (address.addressLine2) strings.push(address.addressLine2);
+  if (address.postalCode) strings.push(address.postalCode);
+  if (address.district && address.district.name)
+    strings.push(address.district.name);
+  if (address.city && address.city.name) strings.push(address.city.name);
+  if (address.state && address.state.name && address.state.name !== "Default")
+    strings.push(address.state.name);
+  if (address.country && address.country.name)
+    strings.push(address.country.name);
+
+  return strings.join(", ");
+}
+
+export function getValidationResult(
+  address: IkasOrderAddress,
+  checkoutSettings: IkasCheckoutSettings,
+  isDistrictRequired: boolean
+): IkasOrderAddressValidationResult {
+  const isValidPhone =
+    !!address.phone &&
+    address.phone.length >= 10 &&
+    validatePhoneNumber(address.phone);
+
+  const results = {
+    firstName: !!address.firstName,
+    lastName: !!address.lastName,
+    addressLine1: !!address.addressLine1,
+    country: !!address.country?.name,
+    state: !!address.state,
+    city: !!address.city?.name,
+    district: isDistrictRequired ? !!address.district?.id : true,
+    phone:
+      checkoutSettings.phoneRequirement === IkasCheckoutRequirement.MANDATORY ||
+      (checkoutSettings.phoneRequirement === IkasCheckoutRequirement.OPTIONAL &&
+        address.phone)
+        ? isValidPhone
+        : true,
+    postalCode:
+      checkoutSettings.postalCodeRequirement ===
+      IkasCheckoutRequirement.MANDATORY
+        ? !!address.postalCode
+        : true,
+    identityNumber:
+      checkoutSettings.identityNumberRequirement ===
+      IkasCheckoutRequirement.MANDATORY
+        ? !!address.identityNumber
+        : true,
+  };
+
+  return results;
+}
+
+export function isValidAddress(
+  address: IkasOrderAddress,
+  checkoutSettings: IkasCheckoutSettings,
+  isDistrictRequired: boolean
+) {
+  const validationResult = getValidationResult(
+    address,
+    checkoutSettings,
+    isDistrictRequired
+  );
+  return Object.values(validationResult).every((result) => result);
+}
+
+export type IkasOrderAddressValidationResult = {
+  firstName: boolean;
+  lastName: boolean;
+  addressLine1: boolean;
+  country: boolean;
+  state: boolean;
+  city: boolean;
+  district: boolean;
+  phone: boolean;
+  postalCode: boolean;
+  identityNumber: boolean;
+};

package/src/functions/order/index.ts

@@ -0,0 +1,92 @@
+import {
+  IkasOrder,
+  IkasOrderLineItem,
+  IkasOrderLineItemStatus,
+  IkasOrderRefundSettings,
+} from "@ikas/storefront-models";
+import { formatDate, validateEmail } from "../../utils/helper";
+
+export function getRefundableItems(
+  order: IkasOrder,
+  refundSettings: IkasOrderRefundSettings
+) {
+  if (refundSettings && !refundSettings.isActiveRefundSection) return [];
+
+  return order.orderLineItems.filter(
+    (item) =>
+      [
+        IkasOrderLineItemStatus.FULFILLED,
+        IkasOrderLineItemStatus.UNFULFILLED,
+        IkasOrderLineItemStatus.DELIVERED,
+      ].includes(item.status) &&
+      (refundSettings.orderRefundDayLimit
+        ? refundSettings.orderRefundDayLimit >= getItemOrderedAtDays(item)
+        : true)
+  );
+}
+
+export function getUnfullfilledItems(order: IkasOrder) {
+  return order.orderLineItems.filter((item) => {
+    const isInAPackage = order.orderPackages?.some((op) =>
+      op.orderLineItemIds.includes(item.id)
+    );
+    return !isInAPackage;
+  });
+}
+
+export function getRefundedItems(order: IkasOrder) {
+  return order.orderLineItems.filter(
+    (item) =>
+      item.status === IkasOrderLineItemStatus.REFUNDED ||
+      item.status === IkasOrderLineItemStatus.REFUND_REQUESTED ||
+      item.status === IkasOrderLineItemStatus.REFUND_REQUEST_ACCEPTED ||
+      item.status === IkasOrderLineItemStatus.REFUND_REJECTED
+  );
+}
+
+export function getTotalTax(order: IkasOrder) {
+  return (
+    order.taxLines?.reduce((total, current) => total + current.price, 0) || 0
+  );
+}
+
+export function getShippingTotal(order: IkasOrder) {
+  return (
+    order.shippingLines?.reduce((total, current) => total + current.price, 0) ||
+    0
+  );
+}
+
+export function hasCustomer(order: IkasOrder) {
+  return !!order.customer?.id;
+}
+
+export function hasValidCustomerEmail(order: IkasOrder) {
+  return !!order.customer?.email && validateEmail(order.customer.email);
+}
+
+export function getCustomerFullName(order: IkasOrder) {
+  return `${order.customer?.firstName || ""} ${order.customer?.lastName || ""}`;
+}
+
+export function getFormattedDate(order: IkasOrder) {
+  const newDate = new Date();
+  newDate.setTime(order.updatedAt);
+  return formatDate(newDate);
+}
+
+export function getCouponAdjustment(order: IkasOrder) {
+  return order.orderAdjustments?.find((a) => !!a.couponId);
+}
+
+export function getNonCouponAdjustments(order: IkasOrder) {
+  return order.orderAdjustments?.filter((a) => !a.couponId);
+}
+
+function getItemOrderedAtDays(item: IkasOrderLineItem) {
+  const orderedAt = item.orderedAt;
+  const now = Date.now();
+  const diffTime = Math.abs(now - orderedAt);
+
+  return diffTime / (1000 * 60 * 60 * 24);
+}

package/src/functions/order/line-item/index.ts

@@ -0,0 +1,30 @@
+import { IkasOrderLineItem } from "@ikas/storefront-models";
+
+export function getPriceWithQuantity(item: IkasOrderLineItem) {
+  return item.price * item.quantity;
+}
+
+export function getOverridenPriceWithQuantity(item: IkasOrderLineItem) {
+  const price =
+    item.discountPrice !== undefined && item.discountPrice !== null
+      ? item.price * item.quantity
+      : null;
+
+  return price !== null && price < 0 ? 0 : price;
+}
+
+export function getFinalPriceWithQuantity(item: IkasOrderLineItem) {
+  const price =
+    (item.discountPrice !== undefined && item.discountPrice !== null
+      ? item.discountPrice
+      : item.price) * item.quantity;
+
+  return price < 0 ? 0 : price;
+}
+
+export function getTax(item: IkasOrderLineItem) {
+  const taxValue = item.taxValue || 0;
+  return (
+    (((item.finalPrice || 0) * item.quantity) / (100 + taxValue)) * taxValue
+  );
+}

package/src/functions/order/line-item/variant/index.ts

@@ -0,0 +1,15 @@
+import { IkasOrderLineVariant } from "@ikas/storefront-models";
+import { getIkasVariantNameSlug, getIkasVariantTypeSlug } from "./value";
+
+export function getIkasOrderLineVariantHref(variant: IkasOrderLineVariant) {
+  if (!variant.slug) return;
+
+  const variantParams = variant.variantValues
+    ?.map((vv) => {
+      return `${getIkasVariantTypeSlug(vv)}=${getIkasVariantNameSlug(vv)}`;
+    })
+    .join("&");
+
+  if (variantParams) return `/${variant.slug}?${variantParams}`;
+  else return `/${variant.slug}`;
+}

package/src/functions/order/line-item/variant/value/index.ts

@@ -0,0 +1,18 @@
+import { IkasOrderLineVariantVariantValue } from "@ikas/storefront-models";
+import { stringToSlug } from "../../../../../utils/helper";
+
+export function getIkasVariantTypeSlug(
+  variantValue: IkasOrderLineVariantVariantValue
+) {
+  return variantValue.variantTypeName
+    ? stringToSlug(variantValue.variantTypeName)
+    : "";
+}
+
+export function getIkasVariantNameSlug(
+  variantValue: IkasOrderLineVariantVariantValue
+) {
+  return variantValue.variantValueName
+    ? stringToSlug(variantValue.variantValueName)
+    : "";
+}

package/src/functions/payment-gateway/index.ts

@@ -0,0 +1,44 @@
+import {
+  IkasOrderShippingLine,
+  IkasPaymentGateway,
+  IkasPaymentGatewayAdditionalPriceType,
+  IkasPaymentGatewayTransactionFeeType,
+} from "@ikas/storefront-models";
+
+export function getCalculatedAdditionalPrices(
+  paymentGateway: IkasPaymentGateway,
+  totalFinalPrice: number,
+  shippingLines: IkasOrderShippingLine[] | null
+) {
+  if (paymentGateway.additionalPrices) {
+    const shippingPrice =
+      shippingLines?.reduce((sum, item) => sum + item.price, 0) || 0;
+
+    totalFinalPrice -= shippingPrice;
+
+    return paymentGateway.additionalPrices.map((additionalPrice) => {
+      let amount = 0;
+
+      if (
+        additionalPrice.amountType ===
+        IkasPaymentGatewayTransactionFeeType.RATIO
+      ) {
+        amount = ((totalFinalPrice || 0) * additionalPrice.amount) / 100;
+      } else {
+        amount = additionalPrice.amount;
+      }
+
+      if (
+        additionalPrice.type === IkasPaymentGatewayAdditionalPriceType.DECREMENT
+      )
+        totalFinalPrice -= amount;
+      else totalFinalPrice += amount;
+
+      return {
+        name: additionalPrice.name || paymentGateway.name,
+        amount: amount,
+        type: additionalPrice.type,
+      };
+    });
+  }
+}

package/src/functions/product/attribute-value/index.ts

@@ -0,0 +1,5 @@
+import { IkasAttributeTableCellValue } from "@ikas/storefront-models";
+
+export function getTableValue(value: string | null) {
+  if (value) return JSON.parse(value) as IkasAttributeTableCellValue[];
+}