flowrix 1.0.1-beta.16 → 1.0.1-beta.160

package/dist/runtime/composables/useLocation.js

@@ -1,32 +1,339 @@
-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 { useCountriesStore } from "../stores/countries.js";
+import { useCompanyProfile } from "../stores/useCompanyProfile.js";
+import { useCheckoutStore } from "../stores/Checkout.js";
+export function useLocation(defaultLocation) {
+  const locationStore = useLocationsStore();
+  const countriesStore = useCountriesStore();
+  const companyProfileStore = useCompanyProfile();
+  const checkoutStore = useCheckoutStore();
+  const states = ref([]);
+  const manualLocationHeading = ref(null);
+  const locationInputs = ref(defaultLocation);
+  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 location = computed(() => locationCookie.value);
-  const updateLocation = (newLocation) => {
-    locationCookie.value = {
-      ...locationCookie.value,
-      ...newLocation
+  const loading = computed(() => locationStore.loading);
+  const profile = computed(() => companyProfileStore.profile);
+  const companyCountryId = computed(() => profile.value?.country_id || 14);
+  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: state.state_code,
+        region_id: state.id,
+        country_name: country.name,
+        country_id: country.id
+      };
+      locationStore.setLocation(newLocation);
+      console.log("newLocation", locationStore);
+    } 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 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 updateCountry = (country, countryCode) => {
-    updateLocation({ country, countryCode });
+  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 shippingCountry = computed(() => location.value.country);
-  const resetLocation = () => {
-    locationCookie.value = { country: "US" };
+  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
+    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
     });
   }
 }
@@ -20,12 +20,12 @@ export function META_view_item(product, price = 0, rp = 0) {
   if (fbq) {
     let discount = rp > price ? Number((rp - price).toFixed(2)) : 0;
     fbq("track", "ViewContent", {
-      content_ids: [product.sku],
+      content_ids: [product?.sku],
       content_type: "product",
-      content_name: product.name,
+      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/usePriceCalculation.d.ts

@@ -0,0 +1,33 @@
+export interface Promotion {
+    id: number;
+    labels: string | null;
+    voucherdiscounttype_id: number;
+    discounttype: number;
+    discount: number;
+    sortorder: number;
+    start_date: string | null;
+    end_date: string | null;
+    date_range_schedule: number;
+    day_time_schedule: number;
+    voucherschedule: Array<{
+        day: number;
+        start_time: string | null;
+        end_time: string | null;
+    }>;
+    includecustomers: number[];
+    includecustomertypes: number[];
+    includeproducts: number[];
+    includeoutlets: number[];
+}
+export interface PriceCalculationResult {
+    finalPrice: number;
+    originalPrice: number;
+    totalDiscount: number;
+    hasDiscount: boolean;
+    appliedPromotions: Promotion[];
+}
+export declare const usePriceCalculation: () => {
+    calculatePrice: (productId: number, price: number, promotions: Promotion[]) => PriceCalculationResult;
+    filterPromotions: (promotions: Promotion[], productId: number, customerTypeId?: number) => Promotion[];
+    calculateDiscount: (price: number, filteredPromotions: Promotion[]) => number;
+};

package/dist/runtime/composables/usePriceCalculation.js

@@ -0,0 +1,107 @@
+export const usePriceCalculation = () => {
+  const getCurrentDateUTC = () => {
+    const now = /* @__PURE__ */ new Date();
+    return now.toISOString().split("T")[0];
+  };
+  const getCurrentTimeUTC = () => {
+    const now = /* @__PURE__ */ new Date();
+    return now.toISOString().split("T")[1].split(".")[0];
+  };
+  const getISODayUTC = () => {
+    const now = /* @__PURE__ */ new Date();
+    const day = now.getUTCDay();
+    return day === 0 ? 7 : day;
+  };
+  const filterPromotions = (promotions, productId, customerTypeId = 1) => {
+    if (!promotions || !Array.isArray(promotions)) {
+      return [];
+    }
+    const currentDate = getCurrentDateUTC();
+    const currentTime = getCurrentTimeUTC();
+    const dayOfWeek = getISODayUTC();
+    return promotions.filter((p) => p.discounttype === 3).filter((p) => p.includeproducts.length === 0 || p.includeproducts.includes(productId)).filter((p) => {
+      if (p.includecustomertypes.length === 0) return true;
+      const isAllowed = p.includecustomertypes.includes(customerTypeId);
+      if (import.meta.client) {
+        console.log("Customer Type Filter:", {
+          promotionId: p.id,
+          includecustomertypes: p.includecustomertypes,
+          customerTypeId,
+          isAllowed
+        });
+      }
+      return isAllowed;
+    }).filter((p) => {
+      if (p.date_range_schedule === 0 || !p.start_date && !p.end_date) return true;
+      if (p.date_range_schedule === 1) {
+        if (p.start_date && !p.end_date) return currentDate >= p.start_date;
+        if (!p.start_date && p.end_date) return currentDate <= p.end_date;
+        if (p.start_date && p.end_date) {
+          return currentDate >= p.start_date && currentDate <= p.end_date;
+        }
+      }
+      return false;
+    }).filter((p) => {
+      if (p.day_time_schedule === 0 || p.voucherschedule.length === 0) return true;
+      const daySchedules = p.voucherschedule.filter((s) => s.day === dayOfWeek);
+      if (daySchedules.length === 0) return false;
+      return daySchedules.some((s) => {
+        if (!s.start_time && !s.end_time) return true;
+        if (s.start_time && !s.end_time) return currentTime >= s.start_time;
+        if (!s.start_time && s.end_time) return currentTime <= s.end_time;
+        if (s.start_time && s.end_time) {
+          return currentTime >= s.start_time && currentTime <= s.end_time;
+        }
+        return false;
+      });
+    }).sort((a, b) => b.sortorder - a.sortorder);
+  };
+  const calculateDiscount = (price, filteredPromotions) => {
+    const fixedDiscounts = filteredPromotions.filter((p) => p.voucherdiscounttype_id === 3).reduce((sum, p) => sum + p.discount, 0);
+    const percentageDiscounts = Math.min(
+      filteredPromotions.filter((p) => p.voucherdiscounttype_id === 2).reduce((sum, p) => sum + p.discount, 0),
+      100
+    );
+    const percentageAmount = percentageDiscounts / 100 * price;
+    const totalDiscount = fixedDiscounts + percentageAmount;
+    return Math.min(totalDiscount, price);
+  };
+  const calculatePrice = (productId, price, promotions) => {
+    const customerTypeCookie = useCookie("customer_type");
+    let customerTypeId = 1;
+    if (customerTypeCookie.value) {
+      const parsed = parseInt(customerTypeCookie.value);
+      customerTypeId = isNaN(parsed) ? 1 : parsed;
+    }
+    if (import.meta.client) {
+      console.log("Price Calculation Debug:", {
+        productId,
+        customerTypeId,
+        cookieValue: customerTypeCookie.value,
+        promotionsCount: promotions.length
+      });
+    }
+    const filteredPromotions = filterPromotions(promotions, productId, customerTypeId);
+    if (import.meta.client) {
+      console.log("Filtered Promotions:", {
+        total: promotions.length,
+        filtered: filteredPromotions.length,
+        promotions: filteredPromotions
+      });
+    }
+    const discount = calculateDiscount(price, filteredPromotions);
+    const finalPrice = Math.max(price - discount, 0);
+    return {
+      finalPrice: Math.round(finalPrice * 100) / 100,
+      originalPrice: price,
+      totalDiscount: Math.round(discount * 100) / 100,
+      hasDiscount: discount > 0,
+      appliedPromotions: filteredPromotions
+    };
+  };
+  return {
+    calculatePrice,
+    filterPromotions,
+    calculateDiscount
+  };
+};

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<any>;
+};