flowrix 1.0.1-beta.85 → 1.0.1-beta.86

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

@@ -0,0 +1,99 @@
+interface CalendarItem {
+    id: number;
+    date: string;
+    available: boolean;
+    [key: string]: any;
+}
+interface TimeSlot {
+    id: number;
+    time: string;
+    available: boolean;
+    [key: string]: any;
+}
+interface BookingData {
+    calendar_id: number;
+    booking_date: string;
+    time_slot: string;
+    [key: string]: any;
+}
+interface BookingState {
+    calendar: CalendarItem[];
+    timeSlots: TimeSlot[];
+    selectedDate: string | null;
+    responseData: any;
+    errorResponseData: any;
+    isLoading: boolean;
+}
+export declare const useBookingStore: import("pinia").StoreDefinition<"booking", BookingState, {
+    availableCalendarDates: (state: {
+        calendar: {
+            [x: string]: any;
+            id: number;
+            date: string;
+            available: boolean;
+        }[];
+        timeSlots: {
+            [x: string]: any;
+            id: number;
+            time: string;
+            available: boolean;
+        }[];
+        selectedDate: string | null;
+        responseData: any;
+        errorResponseData: any;
+        isLoading: boolean;
+    } & import("pinia").PiniaCustomStateProperties<BookingState>) => {
+        [x: string]: any;
+        id: number;
+        date: string;
+        available: boolean;
+    }[];
+    availableTimeSlots: (state: {
+        calendar: {
+            [x: string]: any;
+            id: number;
+            date: string;
+            available: boolean;
+        }[];
+        timeSlots: {
+            [x: string]: any;
+            id: number;
+            time: string;
+            available: boolean;
+        }[];
+        selectedDate: string | null;
+        responseData: any;
+        errorResponseData: any;
+        isLoading: boolean;
+    } & import("pinia").PiniaCustomStateProperties<BookingState>) => {
+        [x: string]: any;
+        id: number;
+        time: string;
+        available: boolean;
+    }[];
+    hasErrors: (state: {
+        calendar: {
+            [x: string]: any;
+            id: number;
+            date: string;
+            available: boolean;
+        }[];
+        timeSlots: {
+            [x: string]: any;
+            id: number;
+            time: string;
+            available: boolean;
+        }[];
+        selectedDate: string | null;
+        responseData: any;
+        errorResponseData: any;
+        isLoading: boolean;
+    } & import("pinia").PiniaCustomStateProperties<BookingState>) => boolean;
+}, {
+    getCalendar(calendarId?: number): Promise<void>;
+    fetchTimeSlots(bookingDate: string, calendarId?: number): Promise<void>;
+    saveBookingSlot(bookingData: BookingData): Promise<any>;
+    clearErrors(): void;
+    resetBooking(): void;
+}>;
+export {};

package/dist/runtime/stores/Booking.js

@@ -0,0 +1,96 @@
+import { defineStore } from "pinia";
+import { useApi } from "../utils/api.js";
+export const useBookingStore = defineStore("booking", {
+  state: () => ({
+    calendar: [],
+    timeSlots: [],
+    selectedDate: null,
+    responseData: null,
+    errorResponseData: null,
+    isLoading: false
+  }),
+  actions: {
+    async getCalendar(calendarId = 4) {
+      try {
+        this.isLoading = true;
+        const { get } = useApi();
+        const apiUrl = "services/calendar";
+        const params = {
+          calendar: calendarId
+        };
+        const response = await get(apiUrl, { params });
+        if (response) {
+          this.calendar = response.data || response;
+        }
+      } catch (error) {
+        console.error("Error fetching calendar:", error);
+        this.errorResponseData = error;
+      } finally {
+        this.isLoading = false;
+      }
+    },
+    async fetchTimeSlots(bookingDate, calendarId = 4) {
+      try {
+        this.isLoading = true;
+        this.selectedDate = bookingDate;
+        const { get } = useApi();
+        const apiUrl = "services/gettimeslots";
+        const params = {
+          calendar: calendarId,
+          booking_date: bookingDate
+        };
+        const response = await get(apiUrl, { params });
+        if (response) {
+          this.timeSlots = response.data || response;
+        }
+      } catch (error) {
+        console.error("Error fetching time slots:", error);
+        this.errorResponseData = error;
+      } finally {
+        this.isLoading = false;
+      }
+    },
+    async saveBookingSlot(bookingData) {
+      try {
+        this.isLoading = true;
+        const { post } = useApi();
+        const apiUrl = "services/calendar/save";
+        const response = await post(apiUrl, bookingData);
+        if (response) {
+          this.responseData = response;
+          return response;
+        }
+      } catch (error) {
+        console.error("Error saving booking slot:", error);
+        this.errorResponseData = error;
+        throw error;
+      } finally {
+        this.isLoading = false;
+      }
+    },
+    // Clear error state
+    clearErrors() {
+      this.errorResponseData = null;
+    },
+    // Reset store state
+    resetBooking() {
+      this.calendar = [];
+      this.timeSlots = [];
+      this.selectedDate = null;
+      this.responseData = null;
+      this.errorResponseData = null;
+      this.isLoading = false;
+    }
+  },
+  getters: {
+    availableCalendarDates: (state) => {
+      return state.calendar.filter((item) => item.available);
+    },
+    availableTimeSlots: (state) => {
+      return state.timeSlots.filter((slot) => slot.available);
+    },
+    hasErrors: (state) => {
+      return !!state.errorResponseData;
+    }
+  }
+});

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

@@ -0,0 +1,79 @@
+export interface CouponData {
+    remove?: number;
+    code: string;
+}
+export interface CheckoutSession {
+    cart: Record<string, CartItem> | undefined;
+    vouchercodes: string[];
+    fields?: Record<string, any>;
+    code: string;
+    abndToken?: string;
+}
+export interface CartItem {
+    cart: Record<string, CartItem> | undefined;
+    vouchercodes: string[];
+    fields?: CheckoutSession["fields"];
+    code: string;
+    qty?: number;
+    abndToken?: string;
+}
+export interface ApplyCoupon {
+    cart: Record<string, CartItem> | undefined;
+    vouchercodes: string[];
+    fields?: CheckoutSession["fields"];
+    code: string;
+    abndToken?: string;
+}
+export interface CartData {
+    rowId: string;
+    cart: Record<string, CartItem> | undefined;
+    qty?: number;
+    abndToken?: string;
+    deliverymethod?: number | string;
+    shipping_state?: string | number;
+    shipping_postcode?: number;
+    shipping_country?: string | number;
+    shippingmethod?: string | number;
+    vouchercodes?: string[];
+}
+export interface RelatedData {
+    cart: Record<string, CartItem> | undefined;
+    qty?: number;
+    abndToken?: string;
+    deliverymethod?: number | string;
+    shipping_state?: string | number;
+    shipping_postcode?: number;
+    shipping_country?: string | number;
+    shippingmethod?: string | number;
+    vouchercodes?: string[];
+}
+export interface FormData {
+    cart: Record<string, CartItem> | undefined;
+    qty: number;
+    rowId: string;
+    data?: Record<string, any>;
+    abndToken?: string;
+    deliverymethod?: number | string;
+    shipping_state?: string | number;
+    shipping_postcode?: number;
+    shipping_country?: string | number;
+    shippingmethod?: string | number;
+    vouchercodes?: string[];
+}
+export interface CartState {
+    cart: {
+        items?: Record<string, CartItem>;
+        totals?: Record<string, any>;
+        abndToken?: string;
+        fields?: CheckoutSession["fields"];
+    };
+    lastitem?: any;
+    activeService: [];
+    coupon: string[];
+    data: [];
+    responseData: [];
+    errorResponseData: Record<string, any>;
+    addedResponse: string;
+    relatedProducts: any[];
+}
+export declare const useCartStore: import("pinia").StoreDefinition<"cart", CartState, {}, {}>;

package/dist/runtime/stores/Cart.js

@@ -0,0 +1,309 @@
+import { defineStore } from "pinia";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useCheckoutStore } from "./Checkout.js";
+import { useRuntimeConfig } from "#imports";
+import { GTM_add_to_cart, GTM_remove_from_cart } from "../composables/useDataLayer.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 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 config = useRuntimeConfig();
+        const response = await flowrixApi.post(
+          apiUrl,
+          config,
+          {
+            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;
+          GTM_add_to_cart(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 fetchRelated() {
+      try {
+        const request = {
+          cart: this.cart.items
+        };
+        const apiUrl = `/api/cart/related`;
+        const response = await $fetch(apiUrl, {
+          method: "POST",
+          body: request
+        });
+        return response;
+      } catch (error) {
+        console.error("Error removing from cart:", error);
+      }
+    },
+    async removeFromCart(id, product) {
+      try {
+        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 config = useRuntimeConfig();
+        const response = await flowrixApi.post(apiUrl, config, {
+          body: request
+        });
+        if (response?.status == "Success") {
+          this.cart = {
+            ["items"]: response?.data.cart,
+            ["totals"]: response?.data.calculations,
+            ["abndToken"]: response?.data.abndToken
+          };
+          this.lastitem = response?.data.lastitem;
+          GTM_remove_from_cart(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 apiUrl = `cart/${product.slug}/update`;
+        const request = {
+          cart: this.cart.items,
+          rowId: product.rowId,
+          qty,
+          deliverymethod: checkoutSession?.fields?.deliverymethod,
+          shippingmethod: checkoutSession?.fields?.shippingmethod,
+          abndToken: this.cart.abndToken
+        };
+        if (this.coupon?.length > 0) {
+          request.vouchercodes = this.coupon;
+        }
+        const config = useRuntimeConfig();
+        const response = await flowrixApi.post(apiUrl, config, {
+          body: 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;
+        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 config = useRuntimeConfig();
+        const response = await flowrixApi.post(apiUrl, config, {
+          body: 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 = {};
+          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
+          });
+          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 = {};
+      }
+    }
+  }
+});