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

package/dist/runtime/composables/Customer/useLogin.js

@@ -0,0 +1,34 @@
+import { ref } from "vue";
+import { useRouter, useRoute } from "#vue-router";
+import { useAuthStore } from "../../stores/auth.js";
+export default function() {
+  const router = useRouter();
+  const route = useRoute();
+  const email = ref("");
+  const password = ref("");
+  const logResponse = ref(null);
+  const isLoading = ref(false);
+  const CustomerLogin = async () => {
+    isLoading.value = true;
+    try {
+      const loginFields = {
+        email: email.value,
+        password: password.value
+      };
+      logResponse.value = await useAuthStore().userLogin(loginFields);
+    } catch (error) {
+      logResponse.value = { status: "Error", message: "Login failed" };
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  return {
+    router,
+    route,
+    email,
+    password,
+    CustomerLogin,
+    logResponse,
+    isLoading
+  };
+}

package/dist/runtime/composables/Customer/useOrders.d.ts

@@ -0,0 +1,29 @@
+export interface Order {
+    order_no: string;
+    order_status: string;
+    payment_method: string;
+    grandtotal: number;
+    [key: string]: any;
+}
+export declare function useOrders(): {
+    orders: import("vue").Ref<{
+        [x: string]: any;
+        order_no: string;
+        order_status: string;
+        payment_method: string;
+        grandtotal: number;
+    }[], Order[] | {
+        [x: string]: any;
+        order_no: string;
+        order_status: string;
+        payment_method: string;
+        grandtotal: number;
+    }[]>;
+    pending: import("vue").Ref<boolean, boolean>;
+    loadingInvoice: import("vue").Ref<string, string>;
+    downloadError: import("vue").Ref<string, string>;
+    loadOrders: () => Promise<void>;
+    generateInvoice: (invoiceNumber: string) => Promise<void>;
+    clearError: () => void;
+    hasOrders: () => boolean;
+};

package/dist/runtime/composables/Customer/useOrders.js

@@ -0,0 +1,56 @@
+import { ref } from "vue";
+import { useAuthStore } from "../../stores/auth.js";
+export function useOrders() {
+  const authStore = useAuthStore();
+  const orders = ref([]);
+  const pending = ref(true);
+  const loadingInvoice = ref("");
+  const downloadError = ref("");
+  const loadOrders = async () => {
+    pending.value = true;
+    downloadError.value = "";
+    try {
+      const ordersData = await authStore.fetchOrders();
+      orders.value = Array.isArray(ordersData) ? ordersData : [];
+    } catch (error) {
+      console.error("Failed to load orders:", error);
+      orders.value = [];
+      downloadError.value = "Failed to load orders. Please try again.";
+    } finally {
+      pending.value = false;
+    }
+  };
+  const generateInvoice = async (invoiceNumber) => {
+    loadingInvoice.value = invoiceNumber;
+    downloadError.value = "";
+    try {
+      const response = await authStore.downloadInvoice(invoiceNumber);
+      if (response && response.type === void 0) {
+        downloadError.value = "Invoice cannot be downloaded. Please try again...";
+      }
+    } catch (error) {
+      console.error("Invoice download error:", error);
+      downloadError.value = error.message || "Invoice cannot be downloaded. Please try again...";
+    } finally {
+      loadingInvoice.value = "";
+    }
+  };
+  const clearError = () => {
+    downloadError.value = "";
+  };
+  const hasOrders = () => {
+    return orders.value && orders.value.length > 0;
+  };
+  return {
+    // State
+    orders,
+    pending,
+    loadingInvoice,
+    downloadError,
+    // Methods
+    loadOrders,
+    generateInvoice,
+    clearError,
+    hasOrders
+  };
+}

package/dist/runtime/composables/Customer/usePasswordReset.d.ts

@@ -0,0 +1,26 @@
+export default function (timerDuration?: number): {
+    email: import("vue").Ref<string, string>;
+    resetCode: import("vue").Ref<string, string>;
+    newPassword: import("vue").Ref<string, string>;
+    confirmPassword: import("vue").Ref<string, string>;
+    showPassword: import("vue").Ref<boolean, boolean>;
+    showConfirmPassword: import("vue").Ref<boolean, boolean>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    errorMessage: import("vue").Ref<string, string>;
+    successMessage: import("vue").Ref<string, string>;
+    isCodeSent: import("vue").Ref<boolean, boolean>;
+    isCodeVerified: import("vue").Ref<boolean, boolean>;
+    currentStep: import("vue").Ref<number, number>;
+    timerCount: import("vue").Ref<number, number>;
+    isTimerActive: import("vue").Ref<boolean, boolean>;
+    formatTime: (seconds: number) => string;
+    togglePassword: (field: "newPassword" | "confirmPassword") => void;
+    handleSubmit: () => Promise<void>;
+    resetForm: () => void;
+    resendCode: () => Promise<void>;
+    startTimer: (duration?: number) => void;
+    stopTimer: () => void;
+    resetTimer: (duration?: number) => void;
+    cleanup: () => void;
+    router: any;
+};

package/dist/runtime/composables/Customer/usePasswordReset.js

@@ -0,0 +1,258 @@
+import { ref } from "vue";
+import { useRouter, useRoute } from "#vue-router";
+import { useAuthStore } from "../../stores/auth.js";
+export default function(timerDuration = 60) {
+  const router = useRouter();
+  const route = useRoute();
+  const authStore = useAuthStore();
+  const email = ref("");
+  const resetCode = ref("");
+  const newPassword = ref("");
+  const confirmPassword = ref("");
+  const showPassword = ref(false);
+  const showConfirmPassword = ref(false);
+  const isLoading = ref(false);
+  const errorMessage = ref("");
+  const successMessage = ref("");
+  const isCodeSent = ref(false);
+  const isCodeVerified = ref(false);
+  const currentStep = ref(1);
+  const verifiedToken = ref("");
+  const timerCount = ref(timerDuration);
+  const isTimerActive = ref(false);
+  const timerInterval = ref(null);
+  const validateEmail = (email2) => {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email2);
+  };
+  const togglePassword = (field) => {
+    if (field === "newPassword") {
+      showPassword.value = !showPassword.value;
+    } else {
+      showConfirmPassword.value = !showConfirmPassword.value;
+    }
+  };
+  const startTimer = (duration = timerDuration) => {
+    isTimerActive.value = true;
+    timerCount.value = duration;
+    timerInterval.value = setInterval(() => {
+      timerCount.value--;
+      if (timerCount.value <= 0) {
+        clearInterval(timerInterval.value);
+        isTimerActive.value = false;
+      }
+    }, 1e3);
+  };
+  const stopTimer = () => {
+    if (timerInterval.value) {
+      clearInterval(timerInterval.value);
+      timerInterval.value = null;
+    }
+    isTimerActive.value = false;
+  };
+  const resetTimer = (duration = timerDuration) => {
+    stopTimer();
+    timerCount.value = duration;
+  };
+  const formatTime = (seconds) => {
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${mins}:${secs < 10 ? "0" : ""}${secs}`;
+  };
+  const resendCode = async () => {
+    if (!validateEmail(email.value)) {
+      errorMessage.value = "Please enter a valid email address";
+      return;
+    }
+    isLoading.value = true;
+    errorMessage.value = "";
+    successMessage.value = "";
+    try {
+      const response = await authStore.verifyEmail(email.value.trim());
+      if (response.status === "Success") {
+        successMessage.value = "Reset code sent to your email again!";
+        errorMessage.value = "";
+        startTimer();
+      } else {
+        errorMessage.value = formatErrorMessage(response.message) || "Failed to resend reset code. Please try again.";
+        successMessage.value = "";
+      }
+    } catch (error) {
+      errorMessage.value = "An error occurred while resending code. Please try again.";
+      successMessage.value = "";
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  const sendResetCode = async () => {
+    if (!validateEmail(email.value)) {
+      errorMessage.value = "Please enter a valid email address";
+      successMessage.value = "";
+      return;
+    }
+    isLoading.value = true;
+    errorMessage.value = "";
+    successMessage.value = "";
+    try {
+      const response = await authStore.verifyEmail(email.value.trim());
+      if (response.status === "Success") {
+        successMessage.value = "Reset code sent to your email!";
+        errorMessage.value = "";
+        isCodeSent.value = true;
+        currentStep.value = 2;
+        startTimer();
+      } else {
+        errorMessage.value = formatErrorMessage(response.message) || "Failed to send reset code. Please try again.";
+        successMessage.value = "";
+      }
+    } catch (error) {
+      errorMessage.value = "An error occurred while sending reset code. Please try again.";
+      successMessage.value = "";
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  const verifyResetCode = async () => {
+    if (!resetCode.value) {
+      errorMessage.value = "Please enter the reset code";
+      successMessage.value = "";
+      return;
+    }
+    isLoading.value = true;
+    errorMessage.value = "";
+    successMessage.value = "";
+    try {
+      const response = await authStore.verifyToken(email.value.trim(), resetCode.value.trim());
+      if (response.status === "Success") {
+        verifiedToken.value = response.data?.token || response.data;
+        successMessage.value = "Code verified successfully!";
+        errorMessage.value = "";
+        isCodeVerified.value = true;
+        currentStep.value = 3;
+        stopTimer();
+      } else {
+        errorMessage.value = formatErrorMessage(response.message) || "Invalid reset code. Please try again.";
+        successMessage.value = "";
+      }
+    } catch (error) {
+      errorMessage.value = "An error occurred while verifying code. Please try again.";
+      successMessage.value = "";
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  const resetPasswordFunc = async () => {
+    if (newPassword.value !== confirmPassword.value) {
+      errorMessage.value = "Passwords do not match";
+      successMessage.value = "";
+      return;
+    }
+    if (newPassword.value.length < 8) {
+      errorMessage.value = "Password must be at least 8 characters long";
+      successMessage.value = "";
+      return;
+    }
+    isLoading.value = true;
+    errorMessage.value = "";
+    successMessage.value = "";
+    try {
+      const response = await authStore.resetPassword(
+        verifiedToken.value,
+        newPassword.value.trim(),
+        confirmPassword.value.trim()
+      );
+      if (response.status === "Success") {
+        const loginResponse = await authStore.userLogin({
+          email: email.value.trim(),
+          password: newPassword.value.trim()
+        });
+        if (loginResponse.status === "Success") {
+          resetForm();
+          successMessage.value = formatErrorMessage(response.message) || "Password reset successfully!";
+          errorMessage.value = "";
+          router.push("dashboard/profile");
+        } else {
+          successMessage.value = formatErrorMessage(response.message) || "Password reset successfully!";
+          errorMessage.value = "Password reset successful, but login failed. Please login manually.";
+          resetCode.value = "";
+          verifiedToken.value = "";
+          isCodeSent.value = false;
+          isCodeVerified.value = false;
+          currentStep.value = 1;
+        }
+      } else {
+        errorMessage.value = formatErrorMessage(response.message) || "Failed to reset password. Please try again.";
+        successMessage.value = "";
+      }
+    } catch (error) {
+      errorMessage.value = "An error occurred while resetting password. Please try again.";
+      successMessage.value = "";
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  const handleSubmit = async () => {
+    if (currentStep.value === 1) {
+      await sendResetCode();
+    } else if (currentStep.value === 2) {
+      await verifyResetCode();
+    } else {
+      await resetPasswordFunc();
+    }
+  };
+  const formatErrorMessage = (message) => {
+    if (Array.isArray(message)) {
+      return message.join(", ");
+    }
+    return message;
+  };
+  const resetForm = () => {
+    email.value = "";
+    resetCode.value = "";
+    newPassword.value = "";
+    confirmPassword.value = "";
+    showPassword.value = false;
+    showConfirmPassword.value = false;
+    isLoading.value = false;
+    errorMessage.value = "";
+    successMessage.value = "";
+    isCodeSent.value = false;
+    isCodeVerified.value = false;
+    currentStep.value = 1;
+    verifiedToken.value = "";
+    stopTimer();
+  };
+  const cleanup = () => {
+    stopTimer();
+  };
+  return {
+    // State
+    email,
+    resetCode,
+    newPassword,
+    confirmPassword,
+    showPassword,
+    showConfirmPassword,
+    isLoading,
+    errorMessage,
+    successMessage,
+    isCodeSent,
+    isCodeVerified,
+    currentStep,
+    timerCount,
+    isTimerActive,
+    formatTime,
+    // Methods
+    togglePassword,
+    handleSubmit,
+    resetForm,
+    resendCode,
+    startTimer,
+    // Export startTimer for external control
+    stopTimer,
+    // Export stopTimer for external control
+    resetTimer,
+    // Export resetTimer for external control
+    cleanup,
+    router
+  };
+}

package/dist/runtime/composables/Customer/useProfile.d.ts

@@ -0,0 +1,75 @@
+export declare function useProfile(): {
+    profile: import("vue").Ref<{
+        firstName: string;
+        lastName: string;
+        email: string;
+        phone: string;
+        mobile: string;
+        dateOfBirth: string;
+    }, {
+        firstName: string;
+        lastName: string;
+        email: string;
+        phone: string;
+        mobile: string;
+        dateOfBirth: string;
+    } | {
+        firstName: string;
+        lastName: string;
+        email: string;
+        phone: string;
+        mobile: string;
+        dateOfBirth: string;
+    }>;
+    isEditing: import("vue").Ref<boolean, boolean>;
+    loading: import("vue").Ref<boolean, boolean>;
+    errorMessage: import("vue").Ref<string, string>;
+    successMessage: import("vue").Ref<string, string>;
+    dobFormatted: import("vue").WritableComputedRef<string, string>;
+    user: import("vue").ComputedRef<{
+        id: number;
+        fullname: string;
+        firstname: string;
+        lastname: string;
+        email: string;
+        avatar: string;
+        country_id: number | null;
+        country: {
+            id: number;
+            name: string;
+            emoji: string;
+        } | 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: {
+            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;
+        }[];
+        created_at: string;
+    } | null>;
+    formatDisplayDate: (dateString: string) => string;
+    clearMessages: () => void;
+    cancelEdit: () => void;
+    updateCustomerProfile: () => Promise<void>;
+    initializeProfile: () => void;
+    resetProfile: () => void;
+};

package/dist/runtime/composables/Customer/useProfile.js

@@ -0,0 +1,106 @@
+import { ref, computed } from "vue";
+import { useAuthStore } from "../../stores/auth.js";
+export function useProfile() {
+  const authStore = useAuthStore();
+  const user = computed(() => authStore.user);
+  const profile = ref({
+    firstName: user.value?.firstname || "",
+    lastName: user.value?.lastname || "",
+    email: user.value?.email || "",
+    phone: user.value?.phone || "",
+    mobile: user.value?.mobile || "",
+    dateOfBirth: user.value?.dob || ""
+  });
+  const isEditing = ref(false);
+  const loading = ref(false);
+  const errorMessage = ref("");
+  const successMessage = ref("");
+  const formatDisplayDate = (dateString) => {
+    if (!dateString) return "";
+    const date = new Date(dateString);
+    if (isNaN(date.getTime())) return dateString;
+    const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+    const day = date.getDate();
+    const month = months[date.getMonth()];
+    const year = date.getFullYear();
+    return `${month} ${day}, ${year}`;
+  };
+  const dobFormatted = computed({
+    get() {
+      return profile.value.dateOfBirth ? new Date(profile.value.dateOfBirth).toISOString().split("T")[0] : "";
+    },
+    set(value) {
+      profile.value.dateOfBirth = value;
+    }
+  });
+  const clearMessages = () => {
+    errorMessage.value = "";
+    successMessage.value = "";
+  };
+  const resetProfile = () => {
+    profile.value = {
+      firstName: user.value?.firstname || "",
+      lastName: user.value?.lastname || "",
+      email: user.value?.email || "",
+      phone: user.value?.phone || "",
+      mobile: user.value?.mobile || "",
+      dateOfBirth: user.value?.dob || ""
+    };
+  };
+  const cancelEdit = () => {
+    isEditing.value = false;
+    resetProfile();
+    clearMessages();
+  };
+  const updateCustomerProfile = async () => {
+    if (!profile.value.firstName?.trim() || !profile.value.lastName?.trim() || !profile.value.mobile?.trim()) {
+      errorMessage.value = "First name, Last name and Mobile are required!";
+      return;
+    }
+    loading.value = true;
+    errorMessage.value = "";
+    successMessage.value = "";
+    try {
+      const requestBody = {
+        firstname: profile.value.firstName.trim(),
+        lastname: profile.value.lastName.trim(),
+        phone: profile.value.phone?.trim() || "",
+        mobile: profile.value.mobile?.trim() || "",
+        dob: profile.value.dateOfBirth || ""
+      };
+      const response = await authStore.updateProfile(requestBody);
+      if (response.status === "Success") {
+        successMessage.value = response.message || "Profile updated successfully!";
+        isEditing.value = false;
+      } else {
+        errorMessage.value = response.message || "Failed to update profile. Please try again.";
+      }
+    } catch (err) {
+      console.error("Update error:", err);
+      errorMessage.value = err.message || "Failed to update profile. Please try again.";
+    } finally {
+      loading.value = false;
+    }
+  };
+  const initializeProfile = () => {
+    resetProfile();
+  };
+  return {
+    // State
+    profile,
+    isEditing,
+    loading,
+    errorMessage,
+    successMessage,
+    // Computed
+    dobFormatted,
+    user,
+    // Methods
+    formatDisplayDate,
+    clearMessages,
+    cancelEdit,
+    updateCustomerProfile,
+    initializeProfile,
+    resetProfile
+  };
+}

package/dist/runtime/composables/Customer/useQuotations.d.ts

@@ -0,0 +1,32 @@
+export interface Quotation {
+    quotation_no: string;
+    createddate: string;
+    quotestatus: string;
+    total: number;
+    expired?: boolean;
+    converted?: boolean;
+    [key: string]: any;
+}
+export declare function useQuotations(): {
+    quotations: import("vue").Ref<{
+        [x: string]: any;
+        quotation_no: string;
+        createddate: string;
+        quotestatus: string;
+        total: number;
+        expired?: boolean | undefined;
+        converted?: boolean | undefined;
+    }[], Quotation[] | {
+        [x: string]: any;
+        quotation_no: string;
+        createddate: string;
+        quotestatus: string;
+        total: number;
+        expired?: boolean | undefined;
+        converted?: boolean | undefined;
+    }[]>;
+    pending: import("vue").Ref<boolean, boolean>;
+    loadQuotations: () => Promise<void>;
+    hasQuotations: () => boolean;
+    getQuotationStatus: (quotation: Quotation) => string;
+};

package/dist/runtime/composables/Customer/useQuotations.js

@@ -0,0 +1,40 @@
+import { ref } from "vue";
+import { useAuthStore } from "../../stores/auth.js";
+export function useQuotations() {
+  const authStore = useAuthStore();
+  const quotations = ref([]);
+  const pending = ref(true);
+  const loadQuotations = async () => {
+    pending.value = true;
+    try {
+      const quotationsData = await authStore.fetchQuotations();
+      quotations.value = Array.isArray(quotationsData) ? quotationsData : [];
+    } catch (error) {
+      console.error("Failed to load quotations:", error);
+      quotations.value = [];
+    } finally {
+      pending.value = false;
+    }
+  };
+  const hasQuotations = () => {
+    return quotations.value && quotations.value.length > 0;
+  };
+  const getQuotationStatus = (quotation) => {
+    if (quotation.expired) {
+      return "Expired";
+    } else if (quotation.converted) {
+      return "Purchased";
+    } else {
+      return "Available";
+    }
+  };
+  return {
+    // State
+    quotations,
+    pending,
+    // Methods
+    loadQuotations,
+    hasQuotations,
+    getQuotationStatus
+  };
+}