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

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

@@ -0,0 +1,79 @@
+export interface PreferenceData {
+    fields?: Record<string, any>;
+    deliverytype?: string;
+    order_no?: string;
+    publishableKey?: any;
+    [key: string]: any;
+}
+export interface CartItem {
+    fields?: Record<string, any>;
+    deliverytype?: string;
+    order_no?: string;
+    publishableKey?: any;
+    [key: string]: any;
+}
+export interface Country {
+    id: number | string;
+}
+export 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;
+}
+export 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;
+}
+export 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, {}, {}>;

package/dist/runtime/stores/Checkout.js

@@ -0,0 +1,208 @@
+import { useCartStore } from "./Cart.js";
+import { defineStore } from "pinia";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useApi } from "../utils/api.js";
+import { useRuntimeConfig } from "#imports";
+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 config = useRuntimeConfig();
+        const response = await flowrixApi.post(
+          apiUrl,
+          config,
+          {
+            body: 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 formData = this.checkoutSession.fields || {};
+        const apiUrl = `customer/checkout`;
+        formData.billing_address2 = formData.billing_address;
+        const config = useRuntimeConfig();
+        const response = await flowrixApi.post(apiUrl, config, { body: 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.data;
+      }
+    },
+    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.checkoutSession.fields = {
+        ...this.checkoutSession.fields,
+        ...fieldsData
+      };
+      this.errorResponseData = {};
+      if (!fieldsData.quotation_no) {
+        await this.getConfig();
+      }
+    }
+  },
+  persist: {
+    enabled: true,
+    // simple shape that works with most versions:
+    key: "checkoutSession",
+    storage: typeof window !== "undefined" ? localStorage : void 0
+  }
+});

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 {};

package/dist/runtime/stores/IpLocation.js

@@ -0,0 +1,29 @@
+import { defineStore } from "pinia";
+export const useIpLocation = defineStore("IpLocation", {
+  state: () => ({
+    location: null
+  }),
+  actions: {
+    async getLocation() {
+      try {
+        if (this.location == null) {
+          const response = await $fetch(`/api/location`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+          if (response.status == "Success" && response.data != null) {
+            this.location = response.data;
+          } else {
+            this.location = null;
+          }
+        }
+      } catch (error) {
+        console.error("Error fetching data:", error);
+        this.location = null;
+      }
+    }
+  },
+  persist: true
+});

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

@@ -0,0 +1,15 @@
+export interface NavMenuState {
+    Menu: {
+        location: string;
+        items: MenuItem[];
+    }[];
+}
+export interface MenuItem {
+    title: string;
+    url: string;
+    sortorder: number;
+    children?: MenuItem[];
+}
+export declare const useNavMenu: import("pinia").StoreDefinition<"NavMenu", NavMenuState, {}, {
+    navMenu(id: number, location?: string): Promise<void>;
+}>;

package/dist/runtime/stores/NavMenu.js

@@ -0,0 +1,26 @@
+import { defineStore } from "pinia";
+export const useNavMenu = defineStore("NavMenu", {
+  state: () => ({
+    Menu: []
+  }),
+  actions: {
+    async navMenu(id, location = "header") {
+      try {
+        const existingMenu = this.Menu.find((menu) => menu.location === location);
+        if (!existingMenu) {
+          const response = await $fetch(`/api/nav/${id}/links`, {
+            method: "GET",
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+          if (response.status === "Success") {
+            this.Menu.push({ location, items: response.data });
+          }
+        }
+      } catch (error) {
+        console.error("Error fetching data:", error);
+      }
+    }
+  }
+});

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

@@ -0,0 +1,5 @@
+export declare const useSearchStore: import("pinia").StoreDefinition<"SearchStore", {
+    data: any[];
+}, {}, {
+    fetchSearchData(query: string): Promise<any>;
+}>;

package/dist/runtime/stores/Search.js

@@ -0,0 +1,33 @@
+import { useApi } from "../utils/api.js";
+import { defineStore } from "pinia";
+export const useSearchStore = defineStore("SearchStore", {
+  state: () => ({
+    data: []
+  }),
+  actions: {
+    async fetchSearchData(query) {
+      const { get } = useApi();
+      try {
+        this.data = [];
+        const params = new URLSearchParams();
+        params.append("search", query);
+        params.append("ProductType[]", "custom");
+        params.append("ProductType[]", "simple");
+        params.append("ProductType[]", "bundle");
+        const apiUrl = `search?${params.toString()}`;
+        const response = await get(apiUrl);
+        if (response?.status === "Success" && Array.isArray(response.data.products.data)) {
+          this.data = response.data.products.data;
+          return this.data;
+        } else {
+          this.data = [];
+          return [];
+        }
+      } catch (error) {
+        console.error("Error fetching search data:", error);
+        this.data = [];
+        throw error;
+      }
+    }
+  }
+});

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

@@ -0,0 +1,7 @@
+export declare const useServiceStore: import("pinia").StoreDefinition<"ServiceStore", {
+    services: never[];
+    availability: boolean;
+}, {}, {
+    getAllServices(): Promise<void>;
+    checkAvailability(data: any): Promise<any>;
+}>;

package/dist/runtime/stores/Services.js

@@ -0,0 +1,49 @@
+import { defineStore } from "pinia";
+import { useCheckoutStore } from "./Checkout.js";
+export const useServiceStore = defineStore("ServiceStore", {
+  state: () => ({
+    services: [],
+    availability: false
+  }),
+  actions: {
+    async getAllServices() {
+      try {
+        const apiUrl = `/api/service/getall`;
+        const response = await $fetch(apiUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        if (response.status == "Success") {
+          this.services = response.data;
+        } else {
+          this.services = null;
+        }
+      } catch (error) {
+        console.error("Error fetching data:", error);
+      }
+    },
+    async checkAvailability(data) {
+      try {
+        const apiUrl = `/api/services/availability`;
+        const response = await $fetch(apiUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: data
+        });
+        if (response.status == "Success") {
+          this.availability = response.data.service;
+          useCheckoutStore().saveToCheckoutSession(data);
+          return response.data;
+        } else {
+          this.data = null;
+        }
+      } catch (error) {
+        console.error("Error fetching data:", error);
+      }
+    }
+  }
+});

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

@@ -0,0 +1,5 @@
+interface UtilitiesData {
+    loading: any;
+}
+export declare const useUtilities: import("pinia").StoreDefinition<"Utilities", UtilitiesData, {}, {}>;
+export {};

package/dist/runtime/stores/Utilities.js

@@ -0,0 +1,11 @@
+import { defineStore } from "pinia";
+export const useUtilities = defineStore("Utilities", {
+  state: () => ({
+    loading: false,
+    productloading: false
+  }),
+  actions: {},
+  persist: {
+    key: "Utilities"
+  }
+});

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

@@ -0,0 +1,15 @@
+export interface Address {
+    id: number;
+}
+export declare const useAddressesStore: import("pinia").StoreDefinition<"addresses", {
+    addresses: Address[];
+    loading: boolean;
+    error: string | null;
+}, {}, {
+    setAddresses(addresses: Address[]): void;
+    addAddress(address: Address): void;
+    updateAddress(updatedAddress: Address): void;
+    removeAddress(id: number): void;
+    setLoading(loading: boolean): void;
+    setError(error: string | null): void;
+}>;

package/dist/runtime/stores/addresses.js

@@ -0,0 +1,31 @@
+import { defineStore } from "pinia";
+export const useAddressesStore = defineStore("addresses", {
+  state: () => ({
+    addresses: [],
+    loading: false,
+    error: null
+  }),
+  actions: {
+    setAddresses(addresses) {
+      this.addresses = addresses;
+    },
+    addAddress(address) {
+      this.addresses.push(address);
+    },
+    updateAddress(updatedAddress) {
+      const index = this.addresses.findIndex((a) => a.id === updatedAddress.id);
+      if (index !== -1) {
+        this.addresses[index] = updatedAddress;
+      }
+    },
+    removeAddress(id) {
+      this.addresses = this.addresses.filter((a) => a.id !== id);
+    },
+    setLoading(loading) {
+      this.loading = loading;
+    },
+    setError(error) {
+      this.error = error;
+    }
+  }
+});

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

@@ -0,0 +1,59 @@
+export interface Address {
+    id: number;
+    fullname: string | null;
+    firstname: string;
+    middlename: string | null;
+    lastname: string;
+    address: string;
+    suburb: string;
+    state: string | null;
+    state_id: number | null;
+    country: string;
+    country_id: number;
+    postcode: string;
+    mobile: string;
+    shipping: number;
+    billing: number;
+}
+export interface Country {
+    id: number;
+    name: string;
+    emoji: string;
+}
+export interface User {
+    id: number;
+    fullname: string;
+    firstname: string;
+    lastname: string;
+    email: string;
+    avatar: string;
+    country_id: number | null;
+    country: Country | null;
+    state_id: number | null;
+    state: string | null;
+    suburb: string | null;
+    dob: string | null;
+    phone: string | null;
+    address: string | null;
+    mobile: string | null;
+    company: string | null;
+    addresses: Address[];
+    created_at: string;
+}
+export interface AuthState {
+    user: User | null;
+    token: string | null;
+    isAuthenticated: false;
+    _hydrated: false;
+}
+export interface AuthResponse {
+    status: string;
+    message: string;
+    data: any | null;
+}
+export declare const useAuthStore: import("pinia").StoreDefinition<"auth", AuthState, {
+    getUser: (state: AuthState) => User | null;
+    getToken: (state: AuthState) => string | null;
+    isLoggedIn: (state: AuthState) => boolean;
+    isHydrated: (state: AuthState) => boolean;
+}, {}>;