flowrix 1.0.0

package/dist/runtime/stores/Cart.js

@@ -0,0 +1,272 @@
+import { defineStore } from "pinia";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useCheckoutStore } from "./Checkout.js";
+import { useApi } from "../utils/api.js";
+export const useCartStore = defineStore("cart", {
+  state: () => ({
+    cart: {},
+    lastitem: {},
+    activeService: [],
+    coupon: [],
+    data: [],
+    responseData: [],
+    errorResponseData: {},
+    addedResponse: ""
+  }),
+  actions: {
+    transformData(data) {
+      const attribute_id = {};
+      const fraction = {};
+      for (const [key, value] of Object.entries(data)) {
+        const match = key.match(/(attribute_id|fraction)\[(\d+)\]/);
+        if (match) {
+          const [, type, id] = match;
+          if (type === "attribute_id") {
+            attribute_id[id] = value;
+          } else if (type === "fraction") {
+            fraction[id] = value;
+          }
+        }
+      }
+      return { attribute_id, fraction };
+    },
+    async addToCart(product, qty, data, productId = "", service = []) {
+      const { post } = useApi();
+      const checkoutSession = useCheckoutStore().checkoutSession;
+      let formData = {
+        cart: void 0,
+        qty: qty ?? 1,
+        rowId: productId,
+        deliverymethod: checkoutSession?.fields?.deliverymethod,
+        shippingmethod: checkoutSession?.fields?.shippingmethod
+      };
+      if (this.coupon?.length > 0) {
+        formData.vouchercodes = this.coupon;
+      }
+      if (this.cart.items != void 0) {
+        formData.cart = this.cart.items;
+        formData.abndToken = this.cart.abndToken;
+      }
+      if (data) {
+        formData = { ...formData, ...this.transformData(data) };
+      }
+      let apiUrl = "";
+      if (productId) {
+        if (this.cart.items != void 0) {
+          formData.qty = this.cart.items[productId]?.qty ?? 1;
+        }
+        apiUrl = `cart/${product.slug}/update`;
+        formData.rowId = productId;
+      } else {
+        apiUrl = `cart/${product.slug}/add`;
+      }
+      if (service?.length !== 0) {
+        formData.deliverymethod = service.fulfilment_id;
+        apiUrl = `cart/service/${service.slug}/add`;
+      }
+      try {
+        const response = await flowrixApi.post(apiUrl, {
+          body: formData
+        });
+        if (response?.status == "Success") {
+          this.addedResponse = "success";
+          this.cart = {
+            ["items"]: response?.data.cart,
+            ["totals"]: response?.data.calculations,
+            ["abndToken"]: response?.data.abndToken
+          };
+          this.lastitem = response?.data.lastItem;
+          useCheckoutStore().saveToCheckoutSession({
+            cart: response?.data,
+            calculations: response?.data.calculations,
+            abndToken: response?.data.abndToken,
+            fields: checkoutSession?.fields
+          });
+        } else {
+          this.addedResponse = "no";
+        }
+      } catch (error) {
+        console.error("Error adding to cart:", error);
+        this.addedResponse = "";
+      }
+    },
+    async removeFromCart(id, product) {
+      try {
+        const { post } = useApi();
+        const checkoutSession = useCheckoutStore().checkoutSession;
+        const apiUrl = `cart/remove`;
+        const request = {
+          cart: this.cart.items,
+          rowId: id,
+          abndToken: this.cart.abndToken,
+          deliverymethod: checkoutSession?.fields?.deliverymethod,
+          shippingmethod: checkoutSession?.fields?.shippingmethod
+        };
+        if (product.type === "service" || product.fulfilment_id !== void 0) {
+          request.deliverymethod = 1;
+        }
+        if (this.coupon?.length > 0) {
+          request.vouchercodes = this.coupon;
+        }
+        const response = await post(apiUrl, request);
+        if (response?.status == "Success") {
+          this.cart = {
+            ["items"]: response?.data.cart,
+            ["totals"]: response?.data.calculations,
+            ["abndToken"]: response?.data.abndToken
+          };
+          this.lastitem = response?.data.lastItem;
+          useCheckoutStore().saveToCheckoutSession({
+            cart: response.cart.items,
+            calculations: response.cart.calculations,
+            abndToken: response.cart.abndToken,
+            fields: checkoutSession?.fields
+          });
+        } else {
+          this.cart = {};
+        }
+      } catch (error) {
+        console.error("Error removing from cart:", error);
+      }
+    },
+    async updateQuantity(product, qty) {
+      try {
+        const checkoutSession = useCheckoutStore().checkoutSession;
+        const { post } = useApi();
+        const apiUrl = `cart/${product.slug}/update`;
+        const request = {
+          cart: this.cart.items,
+          rowId: product.rowId,
+          qty,
+          deliverymethod: checkoutSession?.fields?.deliverymethod,
+          // shipping_state: checkoutSession?.fields?.shipping_state,
+          // shipping_postcode: checkoutSession?.fields?.shipping_postcode,
+          // shipping_country: checkoutSession?.fields?.shipping_country,
+          shippingmethod: checkoutSession?.fields?.shippingmethod,
+          abndToken: this.cart.abndToken
+        };
+        if (this.coupon?.length > 0) {
+          request.vouchercodes = this.coupon;
+        }
+        const response = await post(apiUrl, request);
+        if (response?.status == "Success") {
+          this.cart = {
+            ["items"]: response?.data.cart,
+            ["totals"]: response?.data.calculations,
+            ["abndToken"]: response?.data.abndToken
+          };
+          this.lastitem = response?.data.lastItem;
+          if (qty < product.qty) {
+            GTM_remove_from_cart(this.lastitem);
+            META_remove_from_cart(this.lastitem);
+          } else {
+            GTM_add_to_cart(this.lastitem);
+            META_add_to_cart(this.lastitem);
+          }
+          useCheckoutStore().saveToCheckoutSession({
+            cart: response.data.cart,
+            calculations: response.data.calculations,
+            abndToken: response.data.abndToken,
+            fields: checkoutSession?.fields
+          });
+        } else {
+          this.cart = {};
+        }
+      } catch (error) {
+        console.error("Error updating quantity:", error);
+      }
+    },
+    async ApplyCoupon(coupon) {
+      try {
+        let couponsCodes = this.coupon || [];
+        const checkoutSession = useCheckoutStore().checkoutSession;
+        const { post } = useApi();
+        let apiUrl = "/checkout/applyCoupon";
+        const removeValue = coupon.remove ?? void 0;
+        if (removeValue !== void 0) {
+          couponsCodes.splice(removeValue, 1);
+          apiUrl = "/checkout/remove-coupon";
+        }
+        const couponData = {
+          cart: this.cart.items,
+          vouchercodes: Array.from(new Set(couponsCodes)),
+          fields: checkoutSession?.fields,
+          code: removeValue === void 0 ? coupon.code : "",
+          abndToken: this.cart.abndToken
+        };
+        const response = await post(apiUrl, couponData);
+        if (response?.status === "Success" && response?.data?.calculations) {
+          this.cart.totals = response.data.calculations;
+          if (removeValue === void 0) {
+            couponsCodes.push(coupon.code);
+          }
+          this.coupon = Array.from(new Set(couponsCodes));
+          useCheckoutStore().saveToCheckoutSession(response.data);
+          this.errorResponseData = {};
+          return response;
+        } else {
+          const errorMessage = response?.message || "Failed to apply coupon";
+          this.errorResponseData = { message: errorMessage };
+          throw new Error(errorMessage);
+        }
+      } catch (error) {
+        console.error("Apply coupon error:", error);
+        const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to apply coupon";
+        this.errorResponseData = { message: errorMessage };
+        throw new Error(errorMessage);
+      }
+    },
+    async AbandonedCartComplete(token) {
+      try {
+        const apiUrl = `/api/cart/abandoned/${token}/complete`;
+        await $fetch(apiUrl, {
+          method: "POST"
+        });
+      } catch (error) {
+        console.error("Error completing abandoned cart:", error);
+      }
+    },
+    async fetchAbandonedCart(token) {
+      try {
+        const apiUrl = `/api/cart/abandoned/${token}`;
+        const response = await $fetch(apiUrl);
+        if (response?.data?.cart) {
+          this.cart = {
+            items: response.data.cart,
+            totals: response.data.calculations,
+            abndToken: response.data.abndToken,
+            fields: response.data.fields
+          };
+          useCheckoutStore().saveToCheckoutSession(response.data);
+        }
+      } catch (error) {
+        console.error("Error fetching abandoned cart:", error);
+      }
+    },
+    clearCoupon() {
+      this.coupon = [];
+    },
+    clearCart() {
+      this.cart = {};
+    }
+  },
+  getters: {
+    itemsCount() {
+      if (this.cart?.items) {
+        return Object.values(this.cart.items).reduce(
+          (total, item) => {
+            return total + (typeof item.qty === "number" ? item.qty : 10);
+          },
+          0
+        );
+      }
+      return 0;
+    }
+  },
+  persist: {
+    enabled: true,
+    // simple shape that works with most versions:
+    key: "cart",
+    storage: typeof window !== "undefined" ? localStorage : void 0
+  }
+});

package/dist/runtime/stores/Categories.d.ts

@@ -0,0 +1,13 @@
+interface CategoryState {
+    data: Record<string, any>;
+    category: Record<string, any>;
+    currentPage: number;
+    slug: string | null;
+    error: string | null;
+}
+export declare const useCategories: import("pinia").StoreDefinition<"Categories", CategoryState, {}, {
+    getCategories(slug: string, query?: {}): Promise<void>;
+    getChildCategories(slug: string, query?: {}): Promise<void>;
+    getAllCategories(query: any): Promise<void>;
+}>;
+export {};

package/dist/runtime/stores/Categories.js

@@ -0,0 +1,90 @@
+import { defineStore } from "pinia";
+export const useCategories = defineStore("Categories", {
+  state: () => ({
+    data: {},
+    category: {},
+    allCategories: {},
+    currentPage: 1,
+    slug: null,
+    error: null
+  }),
+  actions: {
+    async getCategories(slug, query = {}) {
+      try {
+        this.slug = slug;
+        let tags = "";
+        if (slug == "blinds-spare-parts") {
+          tags = "spare-part";
+        }
+        if (tags != "") {
+          query.tags = tags;
+        }
+        const apiUrl = `categories/${slug}`;
+        const response = await $fetch(apiUrl, { params: query });
+        if (response.status === 200) {
+          this.data = response.data;
+          this.category = response.data.category;
+          this.error = null;
+        } else {
+          this.data = {};
+          this.error = "No data found";
+        }
+      } catch (error) {
+        if (error.response) {
+          this.error = error.response.data.message || "An error occurred";
+          console.error(error.response);
+        } else {
+          this.error = "An error occurred";
+          console.error(error);
+        }
+        this.data = {};
+      }
+    },
+    async getChildCategories(slug, query = {}) {
+      try {
+        this.slug = slug;
+        const apiUrl = `categories/childern/${slug}`;
+        const response = await $fetch(apiUrl, { params: query });
+        if (response.status === 200) {
+          this.data = response.data.data;
+          this.category = response.data.data.category;
+          this.error = null;
+        } else {
+          this.data = {};
+          this.error = "No data found";
+        }
+      } catch (error) {
+        if (error.response) {
+          this.error = error.response.data.message || "An error occurred";
+          console.error(error.response);
+        } else {
+          this.error = "An error occurred";
+          console.error(error);
+        }
+        this.data = {};
+      }
+    },
+    async getAllCategories(query) {
+      try {
+        const apiUrl = `categories`;
+        const response = await $fetch(apiUrl, { params: query });
+        if (response.status === 200) {
+          this.allCategories = response.data;
+          this.error = null;
+        } else {
+          this.allCategories = {};
+          this.error = "No data found";
+        }
+      } catch (error) {
+        if (error.response) {
+          this.error = error.response.data.message || "An error occurred";
+          console.error(error.response);
+        } else {
+          this.error = "An error occurred";
+          console.error(error);
+        }
+        this.allCategories = {};
+      }
+    }
+  }
+});

package/dist/runtime/stores/Checkout.d.ts

@@ -0,0 +1,85 @@
+interface PreferenceData {
+    fields?: Record<string, any>;
+    deliverytype?: string;
+    order_no?: string;
+    publishableKey?: any;
+    [key: string]: any;
+}
+interface CartItem {
+    fields?: Record<string, any>;
+    deliverytype?: string;
+    order_no?: string;
+    publishableKey?: any;
+    [key: string]: any;
+}
+interface ConfigData {
+    preferences?: Record<string, any>[];
+    outlets?: Record<string, any>[];
+    deliverytype?: string;
+    order_no?: string;
+    publishableKey?: any;
+    calculations?: any;
+    shippingmethods?: any;
+    cart?: Record<string, CartItem>;
+    totals?: Record<string, any>;
+    [key: string]: any;
+}
+interface FieldData {
+    billing_state?: number | string;
+    billing_firstname?: string | number;
+    firstname?: string | number;
+    billing_lastname?: string | number;
+    lastname?: string | number;
+    email?: string | number;
+    billing_mobile?: string | number;
+    billing_address?: string | number;
+    billing_suburb?: string | undefined;
+    billing_postcode?: number | undefined;
+    shipping_postcode?: number | undefined;
+    deliverymethod?: number | string;
+    shippingmethod?: number | string;
+    authoritytoleave?: number | undefined;
+    customernotes?: string;
+    shippingasbilling?: boolean;
+    shipping_address?: string;
+    shipping_country?: number | string;
+    shipping_state?: number | string;
+    shipping_suburb?: string;
+    shipping_firstname?: string;
+    shipping_fullname?: string;
+    shipping_lastname?: string;
+    shipping_middlename?: string;
+    shipping_mobile?: string;
+    billing_fullname?: string;
+    billing_middlename?: string;
+    mobile?: string | number;
+    fullname?: string;
+    invoice?: string;
+    quotation_no?: string;
+    [key: string]: any;
+}
+interface CheckoutState {
+    publishableKey: Record<string, any>;
+    responseData: any[];
+    config: ConfigData;
+    checkoutSession: PreferenceData & {
+        fields?: FieldData;
+        calculations?: any;
+    };
+    errorResponseData: Record<string, any>;
+    checkCustomer: any;
+    stripeElemets: any;
+    orderData: any;
+    PaymentErrors: any;
+    loading: boolean;
+}
+export declare const useCheckoutStore: import("pinia").StoreDefinition<"checkout", CheckoutState, {}, {
+    resetState(): void;
+    paymentMethods(formData: any): Promise<any>;
+    getConfig(): Promise<void>;
+    submitCheckout(): Promise<any>;
+    confirmPayment(checkoutId: string): Promise<void>;
+    CheckUserAccount(email: string): Promise<any>;
+    saveToCheckoutSession(fieldsData: FieldData): Promise<void>;
+}>;
+export {};

package/dist/runtime/stores/Checkout.js

@@ -0,0 +1,213 @@
+import { useCartStore } from "./Cart.js";
+import { defineStore } from "pinia";
+import { useApi } from "../utils/api.js";
+export const useCheckoutStore = defineStore("checkout", {
+  state: () => ({
+    publishableKey: {},
+    responseData: [],
+    config: {},
+    checkoutSession: {},
+    errorResponseData: {},
+    checkCustomer: {},
+    stripeElemets: {},
+    orderData: {},
+    PaymentErrors: {},
+    loading: false
+  }),
+  actions: {
+    resetState() {
+      this.publishableKey = {};
+      this.responseData = [];
+      this.config = {};
+      this.checkoutSession = {};
+      this.errorResponseData = {};
+      this.checkCustomer = {};
+      this.stripeElemets = {};
+      this.orderData = {};
+      this.PaymentErrors = {};
+      this.loading = false;
+    },
+    async paymentMethods(formData) {
+      try {
+        const sessionData = JSON.parse(localStorage.getItem("Checkout")) || {};
+        const apiUrl = `/api/checkout/paymentmethod`;
+        const response = await $fetch(apiUrl, {
+          method: "POST",
+          body: formData
+        });
+        if (response?.data) {
+          this.publishableKey = response.data;
+          const cart = {
+            items: useCartStore().cart.items,
+            totals: useCartStore().cart.totals
+          };
+          const paymentMethod = formData.paymentmethod;
+          if (paymentMethod === "web-eway") {
+          } else if (paymentMethod === "web-flowrix-pay") {
+          } else if (paymentMethod === "web-stripe") {
+          } else if (paymentMethod === "web-paypal") {
+          } else if (paymentMethod === "web-direct-deposit") {
+          } else if (paymentMethod === "web-zippay") {
+          }
+        }
+        this.checkoutSession.fields = {
+          ...this.checkoutSession.fields,
+          paymentmethod: formData.paymentmethod
+        };
+        return response;
+      } catch (error) {
+        this.errorResponseData = error?.data || {};
+        return error;
+      }
+    },
+    async getConfig() {
+      try {
+        const { post } = useApi();
+        const formData = this.checkoutSession.fields || this.checkoutSession;
+        if (formData.cart && Object.keys(formData.cart).length > 0) {
+          const samples = Object.keys(formData.cart).filter(
+            (key) => formData.cart[key].product_type === "sample"
+          );
+          if (samples.length > 0) {
+            samples.forEach(
+              (key) => formData.cart[key].id = formData.cart[key].pid
+            );
+          }
+        }
+        formData.vouchercodes = [];
+        if (useCartStore().coupon?.length > 0) {
+          formData.vouchercodes = useCartStore().coupon;
+        }
+        formData.cart = useCartStore().cart.items;
+        formData.abndToken = useCartStore().cart.abndToken;
+        const apiUrl = `checkout/configs`;
+        const response = await post(apiUrl, formData);
+        if (response?.data) {
+          this.config = response.data;
+          const shippingMethods = response.data.shippingmethods;
+          const shippingMethod = shippingMethods?.find(
+            (method) => method.selected === true
+          );
+          const deliveryMethods = response.data.preferences;
+          const deliveryMethod = deliveryMethods?.find(
+            (method) => method.selected === true
+          );
+          if (shippingMethod) {
+            this.checkoutSession.fields = {
+              ...this.checkoutSession.fields,
+              shippingmethod: shippingMethod.id
+            };
+          }
+          if (deliveryMethod) {
+            this.checkoutSession.fields = {
+              ...this.checkoutSession.fields,
+              deliverymethod: deliveryMethod.id
+            };
+          }
+          const cart = {
+            items: response.data.cart,
+            totals: response.data.calculations
+          };
+          useCartStore().cart.items = cart.items;
+          useCartStore().cart.totals = cart.totals;
+          this.config.totals = response.data.calculations;
+          this.checkoutSession.calculations = response.data.calculations;
+        }
+      } catch (error) {
+        this.errorResponseData = error?.data || {};
+      }
+    },
+    async submitCheckout() {
+      try {
+        this.loading = true;
+        const { post } = useApi();
+        const formData = this.checkoutSession.fields || {};
+        const apiUrl = `customer/checkout`;
+        formData.billing_address2 = formData.billing_address;
+        const response = await post(apiUrl, formData);
+        if (response?.data?.order || response?.data?.order_no) {
+          const orderData = response.data.order || response.data;
+          const invoiceId = orderData.order_no;
+          this.responseData = response.data;
+          this.checkoutSession.fields = {
+            ...this.checkoutSession.fields,
+            invoice: invoiceId
+          };
+          this.orderData = orderData;
+          const cart = {
+            items: useCartStore().cart.items,
+            totals: useCartStore().cart.totals
+          };
+        }
+        this.loading = false;
+        return response;
+      } catch (error) {
+        this.errorResponseData = error?.data || {};
+        this.checkoutSession.fields = {
+          ...this.checkoutSession.fields,
+          invoice: error?.data?.data?.order_no
+        };
+        this.loading = false;
+        return error;
+      }
+    },
+    async confirmPayment(checkoutId) {
+      try {
+        const apiUrl = `/api/checkout/success`;
+        await $fetch(apiUrl, {
+          method: "POST",
+          body: { token: checkoutId }
+        });
+      } catch (error) {
+        console.error("Error confirming payment:", error);
+      }
+    },
+    async CheckUserAccount(email) {
+      try {
+        this.loading = true;
+        const apiUrl = `/api/customer/search`;
+        const response = await $fetch(apiUrl, {
+          method: "POST",
+          body: { email }
+        });
+        this.checkCustomer = response;
+        this.loading = false;
+        return response;
+      } catch (error) {
+        this.checkCustomer = error?.data;
+        this.loading = false;
+        return error?.data;
+      }
+    },
+    async saveToCheckoutSession(fieldsData) {
+      this.loading = true;
+      fieldsData.firstname = fieldsData.billing_firstname ?? void 0;
+      fieldsData.lastname = fieldsData.billing_lastname ?? void 0;
+      fieldsData.mobile = fieldsData.billing_mobile ?? void 0;
+      fieldsData.fullname = `${fieldsData.billing_firstname} ${fieldsData.billing_lastname}`;
+      fieldsData.billing_fullname = `${fieldsData.billing_firstname} ${fieldsData.billing_lastname}`;
+      fieldsData.shipping_fullname = `${fieldsData.billing_firstname} ${fieldsData.billing_lastname}`;
+      if (fieldsData.shippingasbilling === true) {
+        fieldsData.billing_address = fieldsData.shipping_address ?? void 0;
+        fieldsData.billing_country = fieldsData.shipping_country ?? null;
+        fieldsData.billing_state = fieldsData.shipping_state ?? void 0;
+        fieldsData.billing_suburb = fieldsData.shipping_suburb ?? void 0;
+        fieldsData.billing_firstname = fieldsData.shipping_firstname ?? void 0;
+        fieldsData.billing_fullname = fieldsData.shipping_fullname ?? null;
+        fieldsData.billing_lastname = fieldsData.shipping_lastname ?? void 0;
+        fieldsData.billing_middlename = fieldsData.shipping_middlename ?? void 0;
+        fieldsData.billing_mobile = fieldsData.shipping_mobile ?? void 0;
+        fieldsData.billing_postcode = fieldsData.shipping_postcode ?? void 0;
+      }
+      this.checkoutSession.fields = {
+        ...this.checkoutSession.fields,
+        ...fieldsData
+      };
+      this.errorResponseData = {};
+      if (!fieldsData.quotation_no) {
+        await this.getConfig();
+      }
+    }
+  },
+  persist: true
+});

package/dist/runtime/stores/IpLocation.d.ts

@@ -0,0 +1,18 @@
+interface LocationData {
+    city?: string;
+    country_name?: string;
+    country_code?: string;
+    country_id?: number;
+    ip?: string;
+    proxy?: boolean;
+    region?: string;
+    region_short?: string;
+    region_id?: number;
+    zip_code?: string;
+}
+export declare const useIpLocation: import("pinia").StoreDefinition<"IpLocation", {
+    location: LocationData | null;
+}, {}, {
+    getLocation(): Promise<void>;
+}>;
+export {};