@consilioweb/payload-support 0.5.2 → 0.6.0

package/dist/components/TicketConversation/hooks/useTicketActions.js

@@ -0,0 +1,230 @@
+"use client";
+import { useState, useRef } from 'react';
+
+function useTicketActions(id, fetchAll) {
+  const [statusUpdating, setStatusUpdating] = useState(false);
+  const [showMerge, setShowMerge] = useState(false);
+  const [mergeTarget, setMergeTarget] = useState("");
+  const [mergeTargetInfo, setMergeTargetInfo] = useState(null);
+  const [merging, setMerging] = useState(false);
+  const [mergeError, setMergeError] = useState("");
+  const [showExtMsg, setShowExtMsg] = useState(false);
+  const [extMsgBody, setExtMsgBody] = useState("");
+  const [extMsgAuthor, setExtMsgAuthor] = useState("client");
+  const [extMsgDate, setExtMsgDate] = useState("");
+  const [extMsgFiles, setExtMsgFiles] = useState([]);
+  const [sendingExtMsg, setSendingExtMsg] = useState(false);
+  const extFileInputRef = useRef(null);
+  const [showSnooze, setShowSnooze] = useState(false);
+  const [snoozeUntil, setSnoozeUntil] = useState(null);
+  const [snoozeSaving, setSnoozeSaving] = useState(false);
+  const [showNextTicket, setShowNextTicket] = useState(false);
+  const [nextTicketId, setNextTicketId] = useState(null);
+  const [nextTicketInfo, setNextTicketInfo] = useState("");
+  const handleStatusChange = async (newStatus) => {
+    if (!id) return;
+    setStatusUpdating(true);
+    try {
+      await fetch(`/api/tickets/${id}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({ status: newStatus })
+      });
+      window.location.reload();
+    } catch {
+    } finally {
+      setStatusUpdating(false);
+    }
+  };
+  const handleMergeLookup = async () => {
+    if (!mergeTarget.trim()) return;
+    setMergeTargetInfo(null);
+    setMergeError("");
+    try {
+      const searchVal = mergeTarget.trim().toUpperCase();
+      const res = await fetch(`/api/tickets?where[ticketNumber][equals]=${encodeURIComponent(searchVal)}&limit=1&depth=0`, { credentials: "include" });
+      if (res.ok) {
+        const d = await res.json();
+        if (d.docs?.length > 0) {
+          const t = d.docs[0];
+          if (String(t.id) === String(id)) {
+            setMergeError("Impossible de fusionner un ticket avec lui-m\xEAme");
+          } else {
+            setMergeTargetInfo({ id: t.id, ticketNumber: t.ticketNumber, subject: t.subject });
+          }
+        } else {
+          setMergeError("Ticket introuvable");
+        }
+      }
+    } catch {
+      setMergeError("Erreur de recherche");
+    }
+  };
+  const handleMerge = async () => {
+    if (!mergeTargetInfo || !id) return;
+    setMerging(true);
+    setMergeError("");
+    try {
+      const res = await fetch("/api/support/merge-tickets", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({ sourceTicketId: id, targetTicketId: mergeTargetInfo.id })
+      });
+      if (res.ok) {
+        window.location.href = `/admin/collections/tickets/${mergeTargetInfo.id}`;
+      } else {
+        const d = await res.json().catch(() => ({}));
+        setMergeError(d.error || "Erreur de fusion");
+      }
+    } catch {
+      setMergeError("Erreur r\xE9seau");
+    } finally {
+      setMerging(false);
+    }
+  };
+  const handleExtFileChange = (e) => {
+    if (e.target.files) {
+      const maxSize = 1 * 1024 * 1024;
+      const newFiles = Array.from(e.target.files);
+      const tooLarge = newFiles.filter((f) => f.size > maxSize);
+      if (tooLarge.length > 0) {
+        alert(`Fichier(s) trop volumineux (max 1 Mo) : ${tooLarge.map((f) => f.name).join(", ")}`);
+      }
+      setExtMsgFiles((prev) => [...prev, ...newFiles.filter((f) => f.size <= maxSize)]);
+    }
+    if (extFileInputRef.current) extFileInputRef.current.value = "";
+  };
+  const handleSendExtMsg = async () => {
+    if (!extMsgBody.trim() || !id) return;
+    setSendingExtMsg(true);
+    try {
+      const uploadedIds = [];
+      for (const file of extMsgFiles) {
+        if (file.size > 1 * 1024 * 1024) continue;
+        const formData = new FormData();
+        formData.append("file", file);
+        formData.append("_payload", JSON.stringify({ alt: file.name }));
+        const uploadRes = await fetch("/api/media", { method: "POST", credentials: "include", body: formData });
+        if (uploadRes.ok) {
+          const d = await uploadRes.json();
+          if (d.doc?.id) uploadedIds.push(d.doc.id);
+        }
+      }
+      const messageData = {
+        ticket: id,
+        body: extMsgBody.trim(),
+        authorType: extMsgAuthor,
+        isInternal: false,
+        skipNotification: true
+      };
+      if (extMsgDate) {
+        messageData.createdAt = new Date(extMsgDate).toISOString();
+      }
+      if (uploadedIds.length > 0) {
+        messageData.attachments = uploadedIds.map((mid) => ({ file: mid }));
+      }
+      const res = await fetch("/api/ticket-messages", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify(messageData)
+      });
+      if (res.ok) {
+        setExtMsgBody("");
+        setExtMsgDate("");
+        setExtMsgFiles([]);
+        setShowExtMsg(false);
+        fetchAll();
+      }
+    } catch {
+    } finally {
+      setSendingExtMsg(false);
+    }
+  };
+  const handleSnooze = async (days, customDate) => {
+    if (!id) return;
+    setSnoozeSaving(true);
+    try {
+      let newSnooze = null;
+      if (days !== null) {
+        const d = /* @__PURE__ */ new Date();
+        d.setDate(d.getDate() + days);
+        newSnooze = d.toISOString();
+      } else if (customDate) {
+        newSnooze = new Date(customDate).toISOString();
+      }
+      await fetch(`/api/tickets/${id}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({ snoozeUntil: newSnooze })
+      });
+      setSnoozeUntil(newSnooze);
+      setShowSnooze(false);
+      fetchAll();
+    } catch {
+    } finally {
+      setSnoozeSaving(false);
+    }
+  };
+  const handleNextTicket = async () => {
+    try {
+      const res = await fetch("/api/tickets?where[status][equals]=open&sort=updatedAt&limit=1&depth=0", { credentials: "include" });
+      if (res.ok) {
+        const d = await res.json();
+        if (d.docs?.length > 0 && String(d.docs[0].id) !== String(id)) {
+          setNextTicketId(d.docs[0].id);
+          setNextTicketInfo(`${d.docs[0].ticketNumber} \u2014 ${d.docs[0].subject}`);
+        } else {
+          setNextTicketId(null);
+          setNextTicketInfo("Aucun autre ticket ouvert");
+        }
+        setShowNextTicket(true);
+      }
+    } catch {
+    }
+  };
+  return {
+    statusUpdating,
+    handleStatusChange,
+    showMerge,
+    setShowMerge,
+    mergeTarget,
+    setMergeTarget,
+    mergeTargetInfo,
+    setMergeTargetInfo,
+    mergeError,
+    setMergeError,
+    merging,
+    handleMergeLookup,
+    handleMerge,
+    showExtMsg,
+    setShowExtMsg,
+    extMsgBody,
+    setExtMsgBody,
+    extMsgAuthor,
+    setExtMsgAuthor,
+    extMsgDate,
+    setExtMsgDate,
+    extMsgFiles,
+    setExtMsgFiles,
+    sendingExtMsg,
+    handleExtFileChange,
+    handleSendExtMsg,
+    showSnooze,
+    setShowSnooze,
+    snoozeUntil,
+    setSnoozeUntil,
+    snoozeSaving,
+    handleSnooze,
+    showNextTicket,
+    setShowNextTicket,
+    nextTicketId,
+    nextTicketInfo,
+    handleNextTicket
+  };
+}
+
+export { useTicketActions };

package/dist/components/TicketConversation/hooks/useTimeTracking.js

@@ -0,0 +1,122 @@
+"use client";
+import { useState, useRef, useEffect } from 'react';
+
+function useTimeTracking(id, fetchAll) {
+  const [duration, setDuration] = useState("");
+  const [timeDescription, setTimeDescription] = useState("");
+  const [addingTime, setAddingTime] = useState(false);
+  const [timeSuccess, setTimeSuccess] = useState("");
+  const [timerRunning, setTimerRunning] = useState(false);
+  const [timerSeconds, setTimerSeconds] = useState(0);
+  const [timerDescription, setTimerDescription] = useState("");
+  const timerIntervalRef = useRef(null);
+  const timerKeepAliveRef = useRef(null);
+  const handleAddTime = async () => {
+    if (!duration || !id) return;
+    setAddingTime(true);
+    setTimeSuccess("");
+    try {
+      const res = await fetch("/api/time-entries", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({
+          ticket: id,
+          duration: parseInt(duration, 10),
+          date: (/* @__PURE__ */ new Date()).toISOString(),
+          description: timeDescription.trim() || void 0
+        })
+      });
+      if (res.ok) {
+        setDuration("");
+        setTimeDescription("");
+        setTimeSuccess(`${duration} min ajout\xE9es`);
+        setTimeout(() => setTimeSuccess(""), 3e3);
+        fetchAll();
+      }
+    } catch {
+    } finally {
+      setAddingTime(false);
+    }
+  };
+  const handleTimerStart = (reset = false) => {
+    setTimerRunning(true);
+    if (reset) setTimerSeconds(0);
+    timerIntervalRef.current = setInterval(() => {
+      setTimerSeconds((prev) => prev + 1);
+    }, 1e3);
+    timerKeepAliveRef.current = setInterval(() => {
+      fetch("/api/users/me", { credentials: "include" }).catch(() => {
+      });
+    }, 5 * 60 * 1e3);
+  };
+  const handleTimerStop = () => {
+    setTimerRunning(false);
+    if (timerIntervalRef.current) {
+      clearInterval(timerIntervalRef.current);
+      timerIntervalRef.current = null;
+    }
+    if (timerKeepAliveRef.current) {
+      clearInterval(timerKeepAliveRef.current);
+      timerKeepAliveRef.current = null;
+    }
+  };
+  const handleTimerSave = async () => {
+    if (!id || timerSeconds < 60) return;
+    const minutes = Math.round(timerSeconds / 60);
+    setAddingTime(true);
+    try {
+      const res = await fetch("/api/time-entries", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({
+          ticket: id,
+          duration: minutes,
+          date: (/* @__PURE__ */ new Date()).toISOString(),
+          description: timerDescription.trim() || "Timer"
+        })
+      });
+      if (res.ok) {
+        setTimeSuccess(`${minutes} min ajout\xE9es (timer)`);
+        setTimeout(() => setTimeSuccess(""), 3e3);
+        setTimerSeconds(0);
+        setTimerDescription("");
+        fetchAll();
+      }
+    } catch {
+    } finally {
+      setAddingTime(false);
+    }
+  };
+  const handleTimerDiscard = () => {
+    setTimerSeconds(0);
+    setTimerDescription("");
+  };
+  useEffect(() => {
+    return () => {
+      if (timerIntervalRef.current) clearInterval(timerIntervalRef.current);
+      if (timerKeepAliveRef.current) clearInterval(timerKeepAliveRef.current);
+    };
+  }, []);
+  return {
+    duration,
+    setDuration,
+    timeDescription,
+    setTimeDescription,
+    addingTime,
+    timeSuccess,
+    timerRunning,
+    timerSeconds,
+    setTimerSeconds,
+    timerDescription,
+    setTimerDescription,
+    handleAddTime,
+    handleTimerStart,
+    handleTimerStop,
+    handleTimerSave,
+    handleTimerDiscard
+  };
+}
+
+export { useTimeTracking };

package/dist/components/TicketConversation/hooks/useTranslation.js

@@ -0,0 +1,70 @@
+"use client";
+import { useState, useEffect, useCallback } from 'react';
+import frTranslations from '../locales/fr.json';
+import enTranslations from '../locales/en.json';
+
+const LOCALE_STORAGE_KEY = "support_locale";
+const DEFAULT_LOCALE = "fr";
+const translations = {
+  fr: frTranslations,
+  en: enTranslations
+};
+function getNestedValue(obj, path) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current == null || typeof current !== "object") {
+      return path;
+    }
+    current = current[key];
+  }
+  if (typeof current === "string") {
+    return current;
+  }
+  return path;
+}
+function interpolate(template, vars) {
+  if (!vars) return template;
+  return template.replace(/\{\{(\w+(?:\.\w+)*)\}\}/g, (_, key) => {
+    return String(vars[key] ?? `{{${key}}}`);
+  });
+}
+function useTranslation() {
+  const [locale, setLocaleState] = useState(() => {
+    if (typeof window === "undefined") return DEFAULT_LOCALE;
+    try {
+      const stored = localStorage.getItem(LOCALE_STORAGE_KEY);
+      if (stored === "fr" || stored === "en") return stored;
+    } catch {
+    }
+    return DEFAULT_LOCALE;
+  });
+  useEffect(() => {
+    fetch("/api/support/user-prefs", { credentials: "include" }).then((r) => r.ok ? r.json() : null).then((data) => {
+      if (data?.locale && (data.locale === "fr" || data.locale === "en")) {
+        setLocaleState(data.locale);
+      }
+    }).catch(() => {
+    });
+  }, []);
+  useEffect(() => {
+    try {
+      localStorage.setItem(LOCALE_STORAGE_KEY, locale);
+    } catch {
+    }
+  }, [locale]);
+  const setLocale = useCallback((newLocale) => {
+    setLocaleState(newLocale);
+  }, []);
+  const t = useCallback(
+    (key, vars) => {
+      const dict = translations[locale] || translations[DEFAULT_LOCALE];
+      const value = getNestedValue(dict, key);
+      return interpolate(value, vars);
+    },
+    [locale]
+  );
+  return { t, locale, setLocale };
+}
+
+export { DEFAULT_LOCALE, LOCALE_STORAGE_KEY, useTranslation };