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

package/dist/runtime/composables/useTikTokDatalayer.js

@@ -0,0 +1,165 @@
+import { useCompanyProfile } from "../stores/useCompanyProfile.js";
+const getTtq = () => {
+  if (process.client && typeof window !== "undefined" && window.ttq) {
+    return window.ttq;
+  }
+  return null;
+};
+export function TikTok_page_view(to) {
+  const ttq = getTtq();
+  if (ttq) {
+    ttq.page();
+  }
+}
+export function TikTok_view_item(product, price = 0, rp = 0) {
+  const ttq = getTtq();
+  if (!ttq || !product) return;
+  let discount = rp > price ? Number((rp - price).toFixed(2)) : 0;
+  ttq.track("ViewContent", {
+    type: "product",
+    contents: [{
+      content_id: "SKU_" + product?.sku,
+      content_type: "product",
+      quantity: 1,
+      description: product?.category,
+      content_name: product?.name,
+      price: Number(rp) > 0 ? Number(rp) : Number(price),
+      currency: useCompanyProfile().profile?.currencyCode,
+      value: price
+    }]
+  });
+}
+export function TikTok_add_to_cart(lastitem = "") {
+  const ttq = getTtq();
+  if (!ttq || !lastitem) return;
+  let price = lastitem.pricefloat;
+  let discount = lastitem.rpfloat > lastitem.pricefloat ? Number((lastitem.rpfloat - lastitem.pricefloat).toFixed(2)) : 0;
+  const ecomarceCartItems = [{
+    content_id: "SKU_" + lastitem.sku,
+    content_type: "product",
+    content_name: lastitem.name,
+    price,
+    quantity: 1,
+    discount,
+    location_id: "online store"
+  }];
+  ttq.track("AddToCart", {
+    contents: ecomarceCartItems,
+    value: price,
+    currency: useCompanyProfile().profile?.currencyCode
+  });
+}
+export function TikTok_view_cart(cart = "") {
+  const ttq = getTtq();
+  if (!ttq || !cart?.items) return;
+  const ecomarceCartItems = Object.values(cart.items).map((item) => {
+    let price = item.pricefloat;
+    let discount = item.rpfloat > item.pricefloat ? Number((item.rpfloat - item.pricefloat).toFixed(2)) : 0;
+    return {
+      content_id: "SKU_" + item.sku,
+      content_name: item.name,
+      content_type: "product",
+      quantity: item.qty,
+      price,
+      discount,
+      item_category: item.category
+    };
+  });
+  ttq.track("ViewCart", {
+    contents: ecomarceCartItems,
+    value: cart.totals.total,
+    currency: useCompanyProfile().profile?.currencyCode
+  });
+}
+export function TikTok_remove_from_cart(lastitem = "") {
+  const ttq = getTtq();
+  if (!ttq || !lastitem) return;
+  let price = lastitem.pricefloat;
+  let discount = lastitem.rpfloat > lastitem.pricefloat ? Number((lastitem.rpfloat - lastitem.pricefloat).toFixed(2)) : 0;
+  const ecomarceCartItems = [{
+    content_id: "SKU_" + lastitem.sku,
+    content_type: "product",
+    content_name: lastitem.name,
+    price,
+    quantity: lastitem.qty || 1,
+    discount,
+    location_id: "online store"
+  }];
+  ttq.track("RemoveFromCart", {
+    contents: ecomarceCartItems,
+    value: price,
+    currency: useCompanyProfile().profile?.currencyCode
+  });
+}
+export function TikTok_begin_checkout(cart = "") {
+  const ttq = getTtq();
+  if (!ttq || !cart?.items) return;
+  const ecomarceCartItems = Object.values(cart.items).map((item) => {
+    let price = item.pricefloat;
+    let discount = item.rpfloat > item.pricefloat ? Number((item.rpfloat - item.pricefloat).toFixed(2)) : 0;
+    return {
+      content_id: "SKU_" + item.sku,
+      content_name: item.name,
+      content_type: "product",
+      quantity: item.qty,
+      price,
+      discount,
+      item_category: item.category
+    };
+  });
+  ttq.track("InitiateCheckout", {
+    contents: ecomarceCartItems,
+    value: cart.totals.total,
+    currency: useCompanyProfile().profile?.currencyCode
+  });
+}
+export function TikTok_add_payment_info(cart = "", payment_type = "") {
+  const ttq = getTtq();
+  if (!ttq || !cart?.items) return;
+  const ecomarceCartItems = Object.values(cart.items).map((item) => {
+    let price = item.pricefloat;
+    let discount = item.rpfloat > item.pricefloat ? Number((item.rpfloat - item.pricefloat).toFixed(2)) : 0;
+    return {
+      content_id: "SKU_" + item.sku,
+      content_name: item.name,
+      content_type: "product",
+      quantity: item.qty,
+      price,
+      discount,
+      item_category: item.category
+    };
+  });
+  ttq.track("AddPaymentInfo", {
+    contents: ecomarceCartItems,
+    payment_type,
+    value: cart.totals.total,
+    currency: useCompanyProfile().profile?.currencyCode
+  });
+}
+export function TikTok_purchase(orderData = "", cart = "") {
+  const ttq = getTtq();
+  if (!ttq || !cart?.items || !orderData) return;
+  const purchaseitems = Object.values(cart.items).map((item) => {
+    let price = item.pricefloat;
+    let discount = item.rpfloat > item.pricefloat ? Number((item.rpfloat - item.pricefloat).toFixed(2)) : 0;
+    return {
+      content_id: "SKU_" + item.sku,
+      content_name: item.name,
+      content_type: "product",
+      quantity: item.qty,
+      price,
+      discount,
+      item_category: item.category
+    };
+  });
+  ttq.track("Purchase", {
+    contents: purchaseitems,
+    value: orderData.grandtotalFloat,
+    currency: useCompanyProfile().profile?.currencyCode,
+    transaction_id: orderData.order_no,
+    affiliation: "online Store",
+    tax: orderData.tax,
+    shipping: orderData.shipping,
+    coupon: orderData.vouchercode
+  });
+}

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

@@ -0,0 +1,16 @@
+import { type WebForm, type WebFormData } from '../stores/webforms.js';
+export interface ApiResponse<T> {
+    status: string;
+    message: string | Record<string, string[]> | null;
+    data: T | null;
+}
+export declare function useWebforms(): {
+    fetchWebform: (id: number) => Promise<ApiResponse<WebForm>>;
+    submitInquiry: (formData: WebFormData, recaptchaToken?: string) => Promise<ApiResponse<any>>;
+    webform: import("vue").ComputedRef<{
+        id: number;
+    } | null>;
+    webFormReturn: import("vue").ComputedRef<any>;
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<string | null>;
+};

package/dist/runtime/composables/useWebforms.js

@@ -0,0 +1,75 @@
+import { computed } from "vue";
+import { useWebformsStore } from "../stores/webforms.js";
+import { useApi } from "../utils/api.js";
+function formatErrorMessage(message) {
+  if (!message) return "An error occurred";
+  if (typeof message === "string") {
+    return message;
+  }
+  const errorMessages = [];
+  for (const [field, errors] of Object.entries(message)) {
+    if (Array.isArray(errors)) {
+      errorMessages.push(...errors);
+    } else {
+      errorMessages.push(String(errors));
+    }
+  }
+  return errorMessages.join(", ");
+}
+export function useWebforms() {
+  const store = useWebformsStore();
+  const { get, post } = useApi();
+  async function fetchWebform(id) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await get(`contact-center/webforms/${id}/details`);
+      if (response.status === "Success" && response.data) {
+        store.setWebform(response.data);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Fetch webform error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to fetch webform";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function submitInquiry(formData, recaptchaToken = "") {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const data = { ...formData, recaptcha: recaptchaToken };
+      const response = await post("/contact-center/webforms/create", data);
+      if (response.status === "Success") {
+        store.setWebFormReturn(response);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Submit inquiry error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to submit inquiry";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  return {
+    fetchWebform,
+    submitInquiry,
+    webform: computed(() => store.webform),
+    webFormReturn: computed(() => store.webFormReturn),
+    loading: computed(() => store.loading),
+    error: computed(() => store.error)
+  };
+}

package/dist/runtime/middleware/flowrix.d.ts

@@ -0,0 +1,7 @@
+export declare const flowrixApi: {
+    get: (endpoint: any, config?: {}, options?: {}) => Promise<unknown>;
+    post: (endpoint: any, config?: {}, options?: {}) => Promise<unknown>;
+    put: (endpoint: any, config?: {}, options?: {}) => Promise<unknown>;
+    patch: (endpoint: any, config?: {}, options?: {}) => Promise<unknown>;
+    delete: (endpoint: any, config?: {}, options?: {}) => Promise<unknown>;
+};

package/dist/runtime/middleware/flowrix.js

@@ -0,0 +1,60 @@
+const isServer = typeof process !== "undefined" && process.server;
+function getCookie(name) {
+  if (process.client) {
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) return parts.pop().split(";").shift();
+    return null;
+  } else {
+    return null;
+  }
+}
+const parseCookies = (cookieString) => {
+  return Object.fromEntries(
+    cookieString.split(";").map((c) => {
+      const [key, ...v] = c.trim().split("=");
+      return [key, decodeURIComponent(v.join("="))];
+    })
+  );
+};
+async function request(method, config = {}, endpoint, options = {}) {
+  const FLOWRIX_API_KEY = config.public?.FLOWRIX_API_KEY || "";
+  const FLOWRIX_API_SECRET = config.public?.FLOWRIX_API_SECRET || "";
+  const FLOWRIX_API_ORIGIN = config.public?.FLOWRIX_API_ORIGIN || "";
+  let FLOWRIX_API_BASE = config.public?.FLOWRIX_API_BASE_V2 || "";
+  const cookiesObj = parseCookies(config.cookies || "");
+  const authToken = cookiesObj["authToken"];
+  const headers = {
+    "x-public-key": FLOWRIX_API_KEY,
+    "x-session-token": getCookie("x-session-token"),
+    "Access-Control-Expose-Headers": "x-session-token",
+    "authorization": `Bearer ${authToken}`,
+    "Origin": FLOWRIX_API_ORIGIN,
+    ...options.headers
+  };
+  try {
+    const response = await $fetch(`${FLOWRIX_API_BASE}${endpoint}`, {
+      method,
+      ...options,
+      headers,
+      onResponse({ response: response2 }) {
+        const token = response2.headers.get("x-session-token");
+        if (token) {
+          if (process.client) {
+            document.cookie = `x-session-token=${token}; path=/; max-age=3600; secure; SameSite=Lax`;
+          }
+        }
+      }
+    });
+    return response;
+  } catch (error) {
+    throw error;
+  }
+}
+export const flowrixApi = {
+  get: (endpoint, config = {}, options = {}) => request("get", config, endpoint, options),
+  post: (endpoint, config = {}, options = {}) => request("post", config, endpoint, options),
+  put: (endpoint, config = {}, options = {}) => request("put", config, endpoint, options),
+  patch: (endpoint, config = {}, options = {}) => request("patch", config, endpoint, options),
+  delete: (endpoint, config = {}, options = {}) => request("delete", config, endpoint, options)
+};

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/plugin.js

@@ -0,0 +1,5 @@
+import { defineNuxtPlugin } from "#app";
+import { setActivePinia } from "pinia";
+export default defineNuxtPlugin((nuxtApp) => {
+  setActivePinia(nuxtApp.$pinia);
+});

package/dist/runtime/plugins/persistedstate.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/plugins/persistedstate.client.js

@@ -0,0 +1,9 @@
+import piniaPluginPersistedstate from "pinia-plugin-persistedstate";
+export default defineNuxtPlugin((nuxtApp) => {
+  if (nuxtApp?.$pinia) {
+    nuxtApp.$pinia.use(piniaPluginPersistedstate);
+  } else {
+    const { $pinia } = useNuxtApp();
+    if ($pinia) $pinia.use(piniaPluginPersistedstate);
+  }
+});

package/dist/runtime/server/api/albums.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/albums.js

@@ -0,0 +1,18 @@
+import { defineEventHandler, setResponseStatus } from "h3";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async (event) => {
+  try {
+    const albums = await $fetch(`${process.env.FLOWRIX_API_BASE}albums`, {
+      method: "GET",
+      headers: {
+        "x-public-key": process.env.FLOWRIX_API_KEY,
+        "x-api-secret": process.env.FLOWRIX_API_SECRET,
+        "Origin": process.env.FLOWRIX_API_ORIGIN
+      }
+    });
+    return albums;
+  } catch (error) {
+    setResponseStatus(event, 500);
+    return { success: false, error: error.message };
+  }
+});

package/dist/runtime/server/api/auth/forgot.d.ts

@@ -0,0 +1,5 @@
+interface APIResponse {
+    token: string;
+}
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<APIResponse>>;
+export default _default;

package/dist/runtime/server/api/auth/forgot.js

@@ -0,0 +1,44 @@
+import { defineEventHandler, readBody, createError } from "h3";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const { email } = body;
+  try {
+    const response = await fetch(`${process.env.FLOWRIX_API_BASE}verify-email/`, {
+      method: "POST",
+      headers: {
+        "x-public-key": process.env.FLOWRIX_API_KEY,
+        "x-api-secret": process.env.FLOWRIX_API_SECRET,
+        "Origin": process.env.FLOWRIX_API_ORIGIN,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ email })
+    });
+    if (!response.ok) {
+      let errorMessage = ``;
+      try {
+        const errorData = await response.json();
+        console.error("Error response data:", errorData.message);
+        if (errorData.message) {
+          errorMessage += errorData.message?.email || errorData.message;
+        }
+      } catch (parseError) {
+        errorMessage += "Failed to parse error details.";
+      }
+      throw createError({
+        status: 400,
+        statusMessage: "Bad Request",
+        message: "Invalid user input",
+        data: { field: "email" }
+      });
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw createError({
+      status: 400,
+      statusMessage: "Bad Request",
+      message: "Invalid user input",
+      data: { field: "email" }
+    });
+  }
+});

package/dist/runtime/server/api/auth/login.d.ts

@@ -0,0 +1,11 @@
+interface AuthUser {
+    id: string | number;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+}
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    user: AuthUser;
+    token: string;
+}>>;
+export default _default;

package/dist/runtime/server/api/auth/login.js

@@ -0,0 +1,68 @@
+import { defineEventHandler, readBody, createError } from "h3";
+export default defineEventHandler(async (event) => {
+  try {
+    const body = await readBody(event);
+    const { email, password } = body;
+    if (!email || !password) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Email and password are required"
+      });
+    }
+    console.log("Environment check:");
+    console.log("API_BASE:", process.env.FLOWRIX_API_KEY);
+    console.log("API_KEY present:", process.env.FLOWRIX_API_SECRET);
+    console.log("API_SECRET present:", process.env.FLOWRIX_API_ORIGIN);
+    const response = await fetch(`${process.env.FLOWRIX_API_BASE}login/`, {
+      method: "POST",
+      headers: {
+        "x-public-key": process.env.FLOWRIX_API_KEY,
+        "x-api-secret": process.env.FLOWRIX_API_SECRET,
+        "Origin": process.env.FLOWRIX_API_ORIGIN,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ email, password })
+    });
+    if (!response.ok) {
+      let errorMessage = "Login failed";
+      try {
+        const errorData = await response.json();
+        console.error("Error response data:", errorData);
+        if (errorData.message) {
+          if (Array.isArray(errorData.message)) {
+            errorMessage = errorData.message.join(", ");
+          } else if (typeof errorData.message === "object") {
+            errorMessage = errorData.message.email || Object.values(errorData.message)[0] || errorMessage;
+          } else {
+            errorMessage = errorData.message;
+          }
+        }
+      } catch (parseError) {
+        console.error("Failed to parse error response:", parseError);
+        errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+      }
+      throw createError({
+        statusCode: response.status,
+        statusMessage: errorMessage
+      });
+    }
+    const data = await response.json();
+    let user;
+    let token;
+    user = data.data.user;
+    token = data.data.access_token;
+    return {
+      user,
+      token
+    };
+  } catch (error) {
+    console.error("Login error:", error);
+    if (error.statusCode || error.status) {
+      throw error;
+    }
+    throw createError({
+      statusCode: 500,
+      statusMessage: error.message || "Internal server error"
+    });
+  }
+});

package/dist/runtime/server/api/auth/logout.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    success: boolean;
+    message: string;
+}>>;
+export default _default;

package/dist/runtime/server/api/auth/logout.js

@@ -0,0 +1,23 @@
+import { defineEventHandler, getCookie, deleteCookie } from "h3";
+export default defineEventHandler(async (event) => {
+  const accessTok = getCookie(event, "auth.token");
+  try {
+    await $fetch(`${process.env.FLOWRIX_API_BASE}customer/logout`, {
+      method: "POST",
+      headers: {
+        "x-public-key": process.env.FLOWRIX_API_KEY,
+        "x-api-secret": process.env.FLOWRIX_API_SECRET,
+        "Origin": process.env.FLOWRIX_API_ORIGIN,
+        "Authorization": `Bearer ${accessTok || ""}`
+      }
+    });
+    deleteCookie(event, "auth.token");
+    deleteCookie(event, "auth.refreshToken");
+    deleteCookie(event, "auth.user");
+    deleteCookie(event, "auth.session");
+    return { success: true, message: "Logout successful" };
+  } catch (error) {
+    console.error("Error customer logout:", error);
+    return { success: false, message: "Logout failed" };
+  }
+});

package/dist/runtime/server/api/auth/register.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/auth/register.js

@@ -0,0 +1,51 @@
+import { defineEventHandler, readBody } from "h3";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const { firstname, lastname, mobile, email, email_confirmation, password, password_confirmation } = body;
+  try {
+    const response = await fetch(`${process.env.FLOWRIX_API_BASE}customer/create`, {
+      method: "POST",
+      headers: {
+        "x-public-key": process.env.FLOWRIX_API_KEY,
+        "x-api-secret": process.env.FLOWRIX_API_SECRET,
+        "Origin": process.env.FLOWRIX_API_ORIGIN,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ firstname, lastname, mobile, email, email_confirmation, password, password_confirmation })
+    });
+    if (!response.ok) {
+      let errorMessage = {};
+      let errorData;
+      try {
+        errorData = await response.json();
+        console.error("Error response data:", errorData);
+        if (errorData.message) {
+          errorMessage = errorData.message?.email || errorData.message;
+        }
+      } catch (parseError) {
+        errorMessage = "Failed to parse error details.";
+        console.error("Error parsing JSON:", parseError);
+        errorData = { message: errorMessage };
+      }
+      throw createError({
+        status: response.status,
+        message: errorMessage,
+        // Use the more specific errorMessage
+        data: { message: errorMessage, errorData }
+        // Include both messages and the raw error
+      });
+    }
+    const data = await response.json();
+    return data.data;
+  } catch (error) {
+    const statusCode = error.status || 500;
+    const message = error.message || "An unexpected error occurred";
+    const errorData = error.data || { message };
+    console.error("Final Error:", { statusCode, message, errorData });
+    throw createError({
+      status: statusCode,
+      message,
+      data: errorData
+    });
+  }
+});

package/dist/runtime/server/api/auth/session.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/auth/session.get.js

@@ -0,0 +1,46 @@
+import { defineEventHandler, getCookie, createError } from "h3";
+export default defineEventHandler(async (event) => {
+  try {
+    const authHeader = getHeader(event, "authorization");
+    const token = authHeader?.replace("Bearer ", "") || getCookie(event, "nuxt-auth.token");
+    if (!token) {
+      throw createError({
+        statusCode: 401,
+        statusMessage: "No token provided"
+      });
+    }
+    const config = useRuntimeConfig();
+    const apiBase = config.apiBase;
+    const apiKey = config.apiKey;
+    const apiSecret = config.apiSecret;
+    const apiOrigin = config.apiOrigin;
+    const response = await fetch(`${apiBase}user/session`, {
+      method: "GET",
+      headers: {
+        "x-public-key": apiKey,
+        "x-api-secret": apiSecret,
+        "Origin": apiOrigin || "",
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw createError({
+        statusCode: response.status,
+        statusMessage: "Failed to get session"
+      });
+    }
+    const data = await response.json();
+    return data.data || data.user || data;
+  } catch (error) {
+    console.error("Session error:", error);
+    if (error.statusCode || error.status) {
+      throw error;
+    }
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Invalid session"
+    });
+  }
+});

package/dist/runtime/server/api/auth/user/reset-password.d.ts

@@ -0,0 +1,5 @@
+interface APIResponse {
+    token: string;
+}
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void | APIResponse>>;
+export default _default;