flowrix 1.0.1-beta.14 → 1.0.1-beta.141

package/dist/runtime/composables/useLocation.js

@@ -1,32 +1,360 @@
-import { computed, readonly } from "vue";
-import { useCookie } from "#imports";
-export const useLocation = () => {
-  const locationCookie = useCookie("location", {
-    default: () => ({ country: "US" }),
-    // Default country
-    maxAge: 60 * 60 * 24 * 365,
-    // 1 year
-    sameSite: "lax"
+import { ref, computed, watch, nextTick } from "vue";
+import { useIpLocation } from "../stores/IpLocation.js";
+import { useCountriesStore } from "../stores/countries.js";
+import { useCompanyProfile } from "../stores/useCompanyProfile.js";
+import { useCheckoutStore } from "../stores/Checkout.js";
+export function useLocation() {
+  const locationStore = useIpLocation();
+  const countriesStore = useCountriesStore();
+  const companyProfileStore = useCompanyProfile();
+  const checkoutStore = useCheckoutStore();
+  const states = ref([]);
+  const manualLocationHeading = ref(null);
+  const locationInputs = ref({
+    country: "Australia",
+    country_id: 14,
+    zip_code: 3370,
+    region: "",
+    region_id: null
   });
-  const location = computed(() => locationCookie.value);
-  const updateLocation = (newLocation) => {
-    locationCookie.value = {
-      ...locationCookie.value,
-      ...newLocation
+  const location = computed(() => locationStore.location);
+  const countries = computed(() => {
+    const storeCountries = countriesStore.countries;
+    if (Array.isArray(storeCountries)) {
+      return storeCountries;
+    } else if (storeCountries?.data && Array.isArray(storeCountries.data)) {
+      return storeCountries.data;
+    }
+    return [];
+  });
+  const loading = computed(() => locationStore.loading);
+  const profile = computed(() => companyProfileStore.profile);
+  const companyCountryId = computed(() => profile.value?.country_id || 14);
+  const stateShortCodes = {
+    "New South Wales": "NSW",
+    "Victoria": "VIC",
+    "Queensland": "QLD",
+    "South Australia": "SA",
+    "Western Australia": "WA",
+    "Tasmania": "TAS",
+    "Northern Territory": "NT",
+    "Australian Capital Territory": "ACT"
+  };
+  const getStateShort = (stateName) => {
+    return stateShortCodes[stateName] || stateName;
+  };
+  const getStates = (countryId) => {
+    if (!countries.value || countries.value.length === 0) {
+      console.warn("No countries available");
+      return [];
+    }
+    const activeCountry = countries.value.find(
+      (country) => country.id == countryId || country.name == countryId
+    );
+    if (activeCountry && activeCountry.states) {
+      states.value = activeCountry.states;
+      return activeCountry.states;
+    } else {
+      states.value = [];
+      console.warn("No states found for country:", countryId);
+      return [];
+    }
+  };
+  const changeStates = (selectedCountry) => {
+    const country = countries.value?.find(
+      (c) => c.name === selectedCountry || c.id === selectedCountry
+    );
+    if (country) {
+      states.value = country.states || [];
+      locationInputs.value.country_id = country.id;
+      locationInputs.value.region = "";
+      locationInputs.value.region_id = null;
+      if (window.locationcountry === country.name && window.locationstate) {
+        locationInputs.value.region = window.locationstate;
+        const state = country.states?.find((s) => s.name === window.locationstate);
+        if (state) {
+          locationInputs.value.region_id = state.id;
+        }
+      }
+    } else {
+      console.warn("Country not found:", selectedCountry);
+    }
+  };
+  const updateLocationData = async (data = {}) => {
+    try {
+      const currentLocation = location.value;
+      const updateData = {
+        region: data.region || currentLocation?.region || "",
+        region_id: data.region_id || currentLocation?.region_id || null,
+        zip_code: data.zip_code || currentLocation?.zip_code || "",
+        country: data.country || currentLocation?.country_name || "Australia",
+        country_id: data.country_id || currentLocation?.country_id || companyCountryId.value
+      };
+      const country = countries.value?.find(
+        (c) => c.name === updateData.country || c.id === updateData.country_id
+      );
+      if (!country) {
+        console.error("Country not found:", updateData.country);
+        return;
+      }
+      const state = country.states?.find(
+        (s) => s.name === updateData.region || s.id === updateData.region_id
+      );
+      if (!state) {
+        console.error("State not found:", updateData.region);
+        return;
+      }
+      const newLocation = {
+        zip_code: updateData.zip_code,
+        region: state.name,
+        region_short: getStateShort(state.name),
+        region_id: state.id,
+        country_name: country.name,
+        country_id: country.id
+      };
+      locationStore.location = newLocation;
+      checkoutStore.saveToCheckoutSession(newLocation, "changelocation");
+    } catch (error) {
+      console.error("Error updating location:", error);
+    }
+  };
+  const changeLocation = async (data) => {
+    if (data && Object.keys(data).length > 0) {
+      await updateLocationData(data);
+    }
+  };
+  const checkLocationPermission = async () => {
+    try {
+      const permissionStatus = await navigator.permissions.query({
+        name: "geolocation"
+      });
+      return permissionStatus.state;
+    } catch (error) {
+      console.error("Permission check failed:", error);
+      return "error";
+    }
+  };
+  const requestBrowserLocation = async () => {
+    return new Promise((resolve) => {
+      if (!navigator.geolocation) {
+        console.log("Geolocation not supported");
+        resolve(false);
+        return;
+      }
+      navigator.geolocation.getCurrentPosition(
+        async (position) => {
+          try {
+            await processGeolocation(position);
+            resolve(true);
+          } catch (error) {
+            console.error("Error processing geolocation:", error);
+            resolve(false);
+          }
+        },
+        (error) => {
+          console.log("Geolocation denied or failed:", error.message);
+          resolve(false);
+        },
+        {
+          timeout: 1e4,
+          maximumAge: 0
+        }
+      );
+    });
+  };
+  const getBrowserLocation = async () => {
+    const success = await requestBrowserLocation();
+    if (!success) {
+      throw new Error("Browser location unavailable");
+    }
+  };
+  const processGeolocation = async (position) => {
+    const lat = position.coords.latitude;
+    const lng = position.coords.longitude;
+    const apiKey = window.GeocodingAPI;
+    if (!apiKey) {
+      throw new Error("Geocoding API key not found");
+    }
+    try {
+      const response = await fetch(
+        `https://maps.googleapis.com/maps/api/geocode/json?latlng=${lat},${lng}&key=${apiKey}`
+      );
+      const data = await response.json();
+      if (data.status !== "OK") {
+        throw new Error("Geocoding failed");
+      }
+      const locationData = extractLocationData(data.results);
+      const country = countries.value?.find((c) => c.name === locationData.country);
+      if (country) {
+        const state = country.states?.find((s) => s.name === locationData.state);
+        locationStore.location = {
+          city: locationData.city,
+          country_name: country.name,
+          country_code: locationData.country_code,
+          country_id: country.id,
+          ip: "",
+          proxy: false,
+          region: locationData.state,
+          region_short: locationData.state_short,
+          region_id: state?.id,
+          zip_code: locationData.postal_code
+        };
+      }
+    } catch (error) {
+      console.error("Geocoding error:", error);
+      throw error;
+    }
+  };
+  const extractLocationData = (results) => {
+    const data = {
+      city: "N/A",
+      country: "N/A",
+      country_code: "N/A",
+      state: "N/A",
+      state_short: "N/A",
+      postal_code: "N/A"
     };
+    for (const result of results) {
+      for (const component of result.address_components) {
+        if (component.types.includes("administrative_area_level_2")) {
+          data.city = component.long_name;
+        }
+        if (component.types.includes("country")) {
+          data.country = component.long_name;
+          data.country_code = component.short_name;
+        }
+        if (component.types.includes("administrative_area_level_1")) {
+          data.state = component.long_name;
+          data.state_short = component.short_name;
+        }
+        if (component.types.includes("postal_code")) {
+          data.postal_code = component.long_name;
+        }
+      }
+    }
+    return data;
+  };
+  const initializeCountriesAndStates = async () => {
+    try {
+      if (!countries.value || countries.value.length === 0) {
+        await countriesStore.getCountries();
+      }
+      await nextTick();
+      if (countries.value && countries.value.length > 0) {
+        getStates(companyCountryId.value);
+        const defaultCountry = countries.value.find((c) => c.id === companyCountryId.value);
+        if (defaultCountry) {
+          locationInputs.value.country = defaultCountry.name;
+          locationInputs.value.country_id = defaultCountry.id;
+        }
+      }
+    } catch (error) {
+      console.error("Error initializing countries and states:", error);
+    }
+  };
+  const getLocation = async (skipBrowserRequest = true) => {
+    try {
+      await initializeCountriesAndStates();
+      if (location.value) {
+        initLocationInputs();
+        return;
+      }
+      if (profile.value) {
+        profile.value.iplocation = true;
+      }
+      if (profile.value?.iplocation && !location.value) {
+        await locationStore.getLocation();
+      }
+      if (location.value) {
+        initLocationInputs();
+      }
+    } catch (error) {
+      console.error("Error getting location:", error);
+    }
   };
-  const updateCountry = (country, countryCode) => {
-    updateLocation({ country, countryCode });
+  const checkCurrentLocation = () => {
+    if (location.value?.region) {
+      locationInputs.value.region = location.value.region;
+      locationInputs.value.region_id = location.value.region_id || null;
+      if (location.value.country_id) {
+        getStates(location.value.country_id);
+      }
+    }
   };
-  const shippingCountry = computed(() => location.value.country);
-  const resetLocation = () => {
-    locationCookie.value = { country: "US" };
+  const initLocationInputs = () => {
+    if (location.value) {
+      locationInputs.value = {
+        country: location.value.country_name || "Australia",
+        country_id: location.value.country_id || companyCountryId.value,
+        zip_code: location.value.zip_code || 3370,
+        region: location.value.region || "",
+        region_id: location.value.region_id || null
+      };
+      if (location.value.country_id) {
+        getStates(location.value.country_id);
+      }
+    }
   };
+  const loadLocation = () => {
+    const stored = localStorage.getItem("IpLocation");
+    if (stored) {
+      try {
+        const parsed = JSON.parse(stored);
+        return parsed.location || null;
+      } catch (error) {
+        console.error("Invalid IpLocation data:", error);
+        return null;
+      }
+    }
+    return null;
+  };
+  const openLocationModal = () => {
+    const changeLocationBtn = document.querySelector(".change_location");
+    if (changeLocationBtn) {
+      changeLocationBtn.click();
+    }
+  };
+  watch(location, (newLocation) => {
+    if (newLocation) {
+      initLocationInputs();
+    }
+  });
+  watch(countries, (newCountries) => {
+    if (newCountries && newCountries.length > 0) {
+      getStates(companyCountryId.value);
+      if (locationInputs.value.country_id) {
+        const country = newCountries.find((c) => c.id === locationInputs.value.country_id);
+        if (country) {
+          locationInputs.value.country = country.name;
+        }
+      }
+    }
+  });
   return {
-    location: readonly(location),
-    shippingCountry: readonly(shippingCountry),
-    updateLocation,
-    updateCountry,
-    resetLocation
+    // State
+    states,
+    manualLocationHeading,
+    locationInputs,
+    // Computed
+    location,
+    countries,
+    loading,
+    companyCountryId,
+    // Methods
+    getStateShort,
+    getStates,
+    changeStates,
+    changeLocation,
+    updateLocationData,
+    getLocation,
+    checkCurrentLocation,
+    initLocationInputs,
+    loadLocation,
+    checkLocationPermission,
+    initializeCountriesAndStates,
+    requestBrowserLocation,
+    // NEW
+    openLocationModal
+    // NEW
   };
-};
+}

package/dist/runtime/composables/useMetaLayer.js

@@ -11,7 +11,7 @@ export function META_page_view(to) {
     fbq("trackCustom", "virtualPageView", {
       content_type: "virtualPageView",
       content_name: to.meta?.head?.meta_title,
-      currency: useCompanyProfile().profile?.currencyCode
+      currency: useCompanyProfile().profile?.data?.currencyCode
     });
   }
 }
@@ -25,7 +25,7 @@ export function META_view_item(product, price = 0, rp = 0) {
       content_name: product.name,
       discount,
       value: price,
-      currency: useCompanyProfile().profile?.currencyCode
+      currency: useCompanyProfile().profile?.data?.currencyCode
     });
   }
 }
@@ -58,7 +58,7 @@ export function META_view_item_list(listItems = []) {
         contents: ecomarceItems,
         content_type: "Items List",
         value: 0,
-        currency: useCompanyProfile().profile?.currencyCode || "GBP"
+        currency: useCompanyProfile().profile?.data?.currencyCode || "GBP"
       });
     }
   } catch (err) {
@@ -75,7 +75,7 @@ export function META_add_to_cart(lastitem = null) {
       content_name: lastitem.name,
       discount,
       value: lastitem.pricefloat,
-      currency: useCompanyProfile().profile?.currencyCode
+      currency: useCompanyProfile().profile?.data?.currencyCode
     });
   }
 }
@@ -102,7 +102,7 @@ export function META_remove_from_cart(lastitem = null) {
       contents: ecomarceCartItems,
       content_type: "Items List",
       value: lastitem?.pricefloat,
-      currency: useCompanyProfile().profile?.currencyCode
+      currency: useCompanyProfile().profile?.data?.currencyCode
     });
   }
 }
@@ -132,7 +132,7 @@ export function META_view_cart(cart = null) {
       contents: ecomarceCartItems,
       content_type: "View Cart",
       value: cart.totals.total,
-      currency: useCompanyProfile().profile?.currencyCode
+      currency: useCompanyProfile().profile?.data?.currencyCode
     });
   }
 }
@@ -161,7 +161,7 @@ export function META_begin_checkout(cart = null) {
       contents: ecomarceCartItems,
       content_type: "Checkout",
       value: cart.totals.total,
-      currency: useCompanyProfile().profile?.currencyCode
+      currency: useCompanyProfile().profile?.data?.currencyCode
     });
   }
 }
@@ -192,9 +192,9 @@ export function META_add_shipping_info(cart = null, shipping_tier = null) {
     });
     fbq("trackCustom", "add_shipping_info", {
       contents: ecomarceCartItems,
-      content_type: shipping_tier?.title || "Shipping",
+      content_type: shipping_tier?.name || "Shipping",
       value: cart.totals.total,
-      currency: useCompanyProfile().profile?.currencyCode
+      currency: useCompanyProfile().profile?.data?.currencyCode
     });
   }
 }
@@ -223,7 +223,7 @@ export function META_add_payment_info(cart = null, payment_type = "") {
       contents: ecomarceCartItems,
       content_type: payment_type || "Payment",
       value: cart.totals.total,
-      currency: useCompanyProfile().profile?.currencyCode
+      currency: useCompanyProfile().profile?.data?.currencyCode
     });
   }
 }
@@ -257,7 +257,7 @@ export function META_purchase(orderData = null, cart = null) {
       tax: orderData.tax,
       shipping: orderData.shipping,
       coupon: orderData.vouchercode,
-      currency: useCompanyProfile().profile?.currencyCode
+      currency: useCompanyProfile().profile?.data?.currencyCode
     });
   }
 }

package/dist/runtime/composables/useQuotationCheckout.d.ts

@@ -0,0 +1,78 @@
+export declare const useQuotationCheckout: () => {
+    inputData: import("vue").Ref<{
+        paymentmethod: string;
+        customertoken: string;
+        authoritytoleave: undefined;
+        register: string;
+        password: string;
+        password_confirmation: string;
+        passwordStrengthValue: string;
+        customernotes: string;
+        ewayKey: string;
+        eway_cardname: string;
+        eway_cardnumber: string;
+        eway_expirymonth: string;
+        eway_expiryyear: string;
+        eway_cvn: string;
+        till_cardname: string;
+        till_cardnumber: string;
+        till_cvn: string;
+        till_expirymonth: string;
+        till_expiryyear: string;
+        save_card_details: number;
+    }, {
+        paymentmethod: string;
+        customertoken: string;
+        authoritytoleave: undefined;
+        register: string;
+        password: string;
+        password_confirmation: string;
+        passwordStrengthValue: string;
+        customernotes: string;
+        ewayKey: string;
+        eway_cardname: string;
+        eway_cardnumber: string;
+        eway_expirymonth: string;
+        eway_expiryyear: string;
+        eway_cvn: string;
+        till_cardname: string;
+        till_cardnumber: string;
+        till_cvn: string;
+        till_expirymonth: string;
+        till_expiryyear: string;
+        save_card_details: number;
+    } | {
+        paymentmethod: string;
+        customertoken: string;
+        authoritytoleave: undefined;
+        register: string;
+        password: string;
+        password_confirmation: string;
+        passwordStrengthValue: string;
+        customernotes: string;
+        ewayKey: string;
+        eway_cardname: string;
+        eway_cardnumber: string;
+        eway_expirymonth: string;
+        eway_expiryyear: string;
+        eway_cvn: string;
+        till_cardname: string;
+        till_cardnumber: string;
+        till_cvn: string;
+        till_expirymonth: string;
+        till_expiryyear: string;
+        save_card_details: number;
+    }>;
+    publishableKey: import("vue").Ref<any, any>;
+    responseData: import("vue").Ref<any, any>;
+    QuotationData: import("vue").Ref<any, any>;
+    checkoutSession: import("vue").Ref<any, any>;
+    preference: import("vue").Ref<any, any>;
+    errorResponseData: import("vue").Ref<any, any>;
+    resetState: () => void;
+    getQuotation: (slug: string) => Promise<any>;
+    getGuestQuotation: (slug: string, query?: any) => Promise<any>;
+    GuestCheckoutQuotation: (slug: string, quotationData: any, query?: any) => Promise<any>;
+    paymentMethods: (formData: any) => Promise<any>;
+    submitCheckout: (slug: string, quotationData: any) => Promise<unknown>;
+};

package/dist/runtime/composables/useQuotationCheckout.js

@@ -0,0 +1,137 @@
+import { ref } from "vue";
+export const useQuotationCheckout = () => {
+  const publishableKey = ref({});
+  const responseData = ref([]);
+  const QuotationData = ref([]);
+  const checkoutSession = ref([]);
+  const preference = ref({ data: { fields: {} } });
+  const errorResponseData = ref([]);
+  const inputData = ref({
+    paymentmethod: "",
+    customertoken: "",
+    authoritytoleave: void 0,
+    register: "",
+    password: "",
+    password_confirmation: "",
+    passwordStrengthValue: "",
+    customernotes: "",
+    ewayKey: "",
+    eway_cardname: "",
+    eway_cardnumber: "",
+    eway_expirymonth: "",
+    eway_expiryyear: "",
+    eway_cvn: "",
+    till_cardname: "",
+    till_cardnumber: "",
+    till_cvn: "",
+    till_expirymonth: "",
+    till_expiryyear: "",
+    save_card_details: 0
+  });
+  const resetState = () => {
+    publishableKey.value = {};
+    responseData.value = [];
+    checkoutSession.value = [];
+    preference.value = [];
+    errorResponseData.value = [];
+  };
+  const getQuotation = async (slug) => {
+    try {
+      const response = await $fetch(`/api/checkout/quotation/${slug}`, {
+        method: "GET"
+      });
+      if (response) {
+        publishableKey.value = response.data;
+        QuotationData.value = response;
+      }
+      return response;
+    } catch (error) {
+      errorResponseData.value = error.data || error;
+      throw error;
+    }
+  };
+  const getGuestQuotation = async (slug, query) => {
+    try {
+      const response = await $fetch(`/api/checkout/quotation/guest/${slug}`, {
+        method: "GET",
+        query
+      });
+      if (response) {
+        publishableKey.value = response.data;
+        QuotationData.value = response;
+        responseData.value = response;
+      }
+      return response;
+    } catch (error) {
+      errorResponseData.value = error.data || error;
+      throw error;
+    }
+  };
+  const GuestCheckoutQuotation = async (slug, quotationData, query) => {
+    try {
+      responseData.value = [];
+      errorResponseData.value = [];
+      const FormData = quotationData.fields;
+      const response = await $fetch(`/api/checkout/quotation/guest/${slug}`, {
+        method: "POST",
+        body: FormData,
+        query
+      });
+      if (response) {
+        publishableKey.value = response.data;
+        responseData.value = response;
+      }
+      return response;
+    } catch (error) {
+      errorResponseData.value = error.data || error;
+      throw error;
+    }
+  };
+  const paymentMethods = async (formData) => {
+    try {
+      const response = await $fetch("/api/checkout/paymentmethod", {
+        method: "POST",
+        body: formData
+      });
+      if (response) {
+        publishableKey.value = response.data;
+      }
+      return response;
+    } catch (error) {
+      errorResponseData.value = error.data || error;
+      throw error;
+    }
+  };
+  const submitCheckout = async (slug, quotationData) => {
+    try {
+      responseData.value = [];
+      errorResponseData.value = [];
+      const response = await $fetch(`/api/checkout/quotation/submit/${slug}`, {
+        method: "POST",
+        body: quotationData
+      });
+      if (response.status == "Success") {
+        responseData.value = response.data;
+      }
+      return response;
+    } catch (error) {
+      errorResponseData.value = error.data || error;
+      throw error;
+    }
+  };
+  return {
+    inputData,
+    publishableKey,
+    responseData,
+    QuotationData,
+    checkoutSession,
+    preference,
+    errorResponseData,
+    resetState,
+    getQuotation,
+    getGuestQuotation,
+    GuestCheckoutQuotation,
+    paymentMethods,
+    submitCheckout
+  };
+};