@consilioweb/payload-support 0.5.1 → 0.6.0

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

@@ -0,0 +1,176 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useAI(messages, client, ticketSubject, replyBody, setReplyBody, setReplyHtml, replyEditorRef) {
+  const [clientSentiment, setClientSentiment] = useState(null);
+  const [aiReplying, setAiReplying] = useState(false);
+  const [aiRewriting, setAiRewriting] = useState(false);
+  const [showAiSummary, setShowAiSummary] = useState(false);
+  const [aiSummary, setAiSummary] = useState("");
+  const [aiGenerating, setAiGenerating] = useState(false);
+  const [aiSaving, setAiSaving] = useState(false);
+  const [aiSaved, setAiSaved] = useState(false);
+  useEffect(() => {
+    if (messages.length === 0) return;
+    const lastClientMsg = [...messages].reverse().find((m) => m.authorType === "client" || m.authorType === "email");
+    if (!lastClientMsg) return;
+    const analyze = async () => {
+      try {
+        const res = await fetch("/api/support/ai", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          credentials: "include",
+          body: JSON.stringify({ action: "sentiment", text: lastClientMsg.body.slice(0, 500) })
+        });
+        if (res.ok) {
+          const data = await res.json();
+          const raw = (data.sentiment || "").toLowerCase().trim();
+          const sentimentMap = {
+            "frustr\xE9": { emoji: "\u{1F624}", label: "Frustr\xE9", color: "#dc2626" },
+            "frustre": { emoji: "\u{1F624}", label: "Frustr\xE9", color: "#dc2626" },
+            "m\xE9content": { emoji: "\u{1F620}", label: "M\xE9content", color: "#ea580c" },
+            "mecontent": { emoji: "\u{1F620}", label: "M\xE9content", color: "#ea580c" },
+            "urgent": { emoji: "\u{1F525}", label: "Urgent", color: "#dc2626" },
+            "neutre": { emoji: "\u{1F610}", label: "Neutre", color: "#6b7280" },
+            "satisfait": { emoji: "\u{1F60A}", label: "Satisfait", color: "#16a34a" }
+          };
+          const match = Object.keys(sentimentMap).find((k) => raw.includes(k));
+          if (match) setClientSentiment(sentimentMap[match]);
+          else setClientSentiment({ emoji: "\u{1F610}", label: "Neutre", color: "#6b7280" });
+        }
+      } catch {
+      }
+    };
+    analyze();
+  }, [messages.length]);
+  const handleAiSuggestReply = async () => {
+    if (messages.length === 0) return;
+    setAiReplying(true);
+    try {
+      const res = await fetch("/api/support/ai", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({
+          action: "suggest_reply",
+          messages: messages.slice(-10).map((m) => ({ authorType: m.authorType, body: m.body })),
+          clientName: `${client?.firstName || ""} ${client?.lastName || ""}`.trim(),
+          clientCompany: client?.company
+        })
+      });
+      if (res.ok) {
+        const data = await res.json();
+        const suggestion = data.reply || "";
+        if (suggestion) {
+          setReplyBody(suggestion);
+          setReplyHtml(suggestion.replace(/\n/g, "<br/>"));
+          if (replyEditorRef.current?.setContent) {
+            replyEditorRef.current.setContent(suggestion.replace(/\n/g, "<br/>"));
+          }
+        }
+      }
+    } catch (err) {
+      console.error("AI suggest error:", err);
+    }
+    setAiReplying(false);
+  };
+  const handleAiRewrite = async () => {
+    if (!replyBody.trim()) return;
+    setAiRewriting(true);
+    try {
+      const res = await fetch("/api/support/ai", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({ action: "rewrite", text: replyBody })
+      });
+      if (res.ok) {
+        const data = await res.json();
+        const rewritten = data.rewritten || "";
+        if (rewritten) {
+          setReplyBody(rewritten);
+          setReplyHtml(rewritten.replace(/\n/g, "<br/>"));
+          if (replyEditorRef.current?.setContent) {
+            replyEditorRef.current.setContent(rewritten.replace(/\n/g, "<br/>"));
+          }
+        }
+      }
+    } catch (err) {
+      console.error("AI rewrite error:", err);
+    }
+    setAiRewriting(false);
+  };
+  const handleAiGenerate = async () => {
+    if (messages.length === 0) return;
+    setAiGenerating(true);
+    setAiSummary("");
+    setAiSaved(false);
+    try {
+      const res = await fetch("/api/support/ai", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({
+          action: "synthesis",
+          messages: messages.map((m) => ({ authorType: m.authorType, body: m.body, createdAt: m.createdAt })),
+          ticketSubject,
+          clientName: `${client?.firstName || ""} ${client?.lastName || ""}`.trim(),
+          clientCompany: client?.company
+        })
+      });
+      if (res.ok) {
+        const data = await res.json();
+        setAiSummary(data.synthesis || "Aucune r\xE9ponse g\xE9n\xE9r\xE9e");
+      } else {
+        setAiSummary("Erreur lors de la g\xE9n\xE9ration de la synth\xE8se.");
+      }
+    } catch (err) {
+      setAiSummary(`Erreur de connexion : ${err instanceof Error ? err.message : "erreur inconnue"}`);
+    } finally {
+      setAiGenerating(false);
+    }
+  };
+  const handleAiSave = async (id, fetchAll) => {
+    if (!id || !aiSummary) return;
+    setAiSaving(true);
+    try {
+      const res = await fetch("/api/ticket-messages", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({
+          ticket: id,
+          body: `\u{1F4CB} **Synth\xE8se IA (${(/* @__PURE__ */ new Date()).toLocaleDateString("fr-FR")})**
+
+${aiSummary}`,
+          authorType: "admin",
+          isInternal: true
+        })
+      });
+      if (res.ok) {
+        setAiSaved(true);
+        fetchAll();
+      }
+    } catch {
+    } finally {
+      setAiSaving(false);
+    }
+  };
+  return {
+    clientSentiment,
+    aiReplying,
+    handleAiSuggestReply,
+    aiRewriting,
+    handleAiRewrite,
+    showAiSummary,
+    setShowAiSummary,
+    aiSummary,
+    aiGenerating,
+    handleAiGenerate,
+    aiSaving,
+    aiSaved,
+    handleAiSave
+  };
+}
+
+export { useAI };

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

@@ -0,0 +1,135 @@
+"use client";
+import { useState } from 'react';
+
+function useMessageActions(id, client, fetchAll) {
+  const [togglingAuthor, setTogglingAuthor] = useState(null);
+  const [editingMsg, setEditingMsg] = useState(null);
+  const [editBody, setEditBody] = useState("");
+  const [editHtml, setEditHtml] = useState("");
+  const [savingEdit, setSavingEdit] = useState(false);
+  const [deletingMsg, setDeletingMsg] = useState(null);
+  const [resendingMsg, setResendingMsg] = useState(null);
+  const [resendSuccess, setResendSuccess] = useState(null);
+  const handleEditStart = (msg) => {
+    setEditingMsg(msg.id);
+    setEditBody(msg.body);
+    setEditHtml(msg.bodyHtml || msg.body.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\n/g, "<br />"));
+  };
+  const handleEditSave = async (msgId) => {
+    if (!editBody.trim()) return;
+    setSavingEdit(true);
+    try {
+      const res = await fetch(`/api/ticket-messages/${msgId}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({ body: editBody.trim(), ...editHtml ? { bodyHtml: editHtml } : {} })
+      });
+      if (res.ok) {
+        setEditingMsg(null);
+        setEditBody("");
+        fetchAll();
+      }
+    } catch {
+    } finally {
+      setSavingEdit(false);
+    }
+  };
+  const handleEditCancel = () => {
+    setEditingMsg(null);
+    setEditBody("");
+    setEditHtml("");
+  };
+  const handleDelete = async (msgId) => {
+    if (!window.confirm("Supprimer ce message ?")) return;
+    setDeletingMsg(msgId);
+    try {
+      const res = await fetch(`/api/ticket-messages/${msgId}`, {
+        method: "DELETE",
+        credentials: "include"
+      });
+      if (res.ok) fetchAll();
+    } catch {
+    } finally {
+      setDeletingMsg(null);
+    }
+  };
+  const handleResend = async (msgId) => {
+    setResendingMsg(msgId);
+    setResendSuccess(null);
+    try {
+      const res = await fetch("/api/support/resend-notification", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({ messageId: msgId })
+      });
+      if (res.ok) {
+        setResendSuccess(msgId);
+        setTimeout(() => setResendSuccess(null), 3e3);
+      }
+    } catch {
+    } finally {
+      setResendingMsg(null);
+    }
+  };
+  const handleToggleAuthor = async (msgId, currentType) => {
+    const newType = currentType === "admin" ? "client" : "admin";
+    setTogglingAuthor(msgId);
+    try {
+      const patchData = { authorType: newType };
+      if (newType === "client" && client) {
+        patchData.authorClient = client.id;
+      }
+      const res = await fetch(`/api/ticket-messages/${msgId}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify(patchData)
+      });
+      if (res.ok) fetchAll();
+    } catch {
+    } finally {
+      setTogglingAuthor(null);
+    }
+  };
+  const handleSplitMessage = async (msgId, ticketSubject) => {
+    const subject = prompt("Sujet du nouveau ticket :", `Split: ${ticketSubject}`);
+    if (!subject) return;
+    try {
+      const res = await fetch("/api/support/split-ticket", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({ messageId: msgId, subject })
+      });
+      if (res.ok) {
+        const data = await res.json();
+        alert(`Ticket ${data.ticketNumber} cr\xE9\xE9`);
+        fetchAll();
+      }
+    } catch {
+    }
+  };
+  return {
+    togglingAuthor,
+    editingMsg,
+    editBody,
+    editHtml,
+    setEditHtml,
+    savingEdit,
+    handleEditStart,
+    handleEditSave,
+    handleEditCancel,
+    deletingMsg,
+    handleDelete,
+    resendingMsg,
+    resendSuccess,
+    handleResend,
+    handleToggleAuthor,
+    handleSplitMessage,
+    setEditBody
+  };
+}
+
+export { useMessageActions };

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

@@ -0,0 +1,187 @@
+"use client";
+import { useRef, useState, useCallback } from 'react';
+
+function useReply(id, client, cannedResponses, ticketNumber, ticketSubject, fetchAll, handleNextTicket, replyEditorRef) {
+  const fileInputRef = useRef(null);
+  const [replyBody, setReplyBody] = useState("");
+  const [replyHtml, setReplyHtml] = useState("");
+  const [replyFiles, setReplyFiles] = useState([]);
+  const [isInternal, setIsInternal] = useState(false);
+  const [notifyClient, setNotifyClient] = useState(false);
+  const [sendAsClient, setSendAsClient] = useState(false);
+  const [sending, setSending] = useState(false);
+  const [showSchedule, setShowSchedule] = useState(false);
+  const [scheduleDate, setScheduleDate] = useState("");
+  const handleEditorFileUpload = useCallback(async (file) => {
+    if (file.size > 5 * 1024 * 1024) return null;
+    const formData = new FormData();
+    formData.append("file", file);
+    formData.append("_payload", JSON.stringify({ alt: file.name }));
+    try {
+      const res = await fetch("/api/media", { method: "POST", credentials: "include", body: formData });
+      if (res.ok) {
+        const data = await res.json();
+        return data.doc?.url || null;
+      }
+    } catch {
+    }
+    return null;
+  }, []);
+  const replaceCannedVariables = useCallback((text) => {
+    let result = text;
+    if (client) {
+      result = result.replace(/\{\{client\.firstName\}\}/g, client.firstName || "Client");
+      result = result.replace(/\{\{client\.lastName\}\}/g, client.lastName || "");
+      result = result.replace(/\{\{client\.company\}\}/g, client.company || "");
+      result = result.replace(/\{\{client\.email\}\}/g, client.email || "");
+      result = result.replace(/\{\{clientName\}\}/g, client.firstName || "Client");
+    }
+    result = result.replace(/\{\{ticket\.number\}\}/g, ticketNumber || "");
+    result = result.replace(/\{\{ticket\.subject\}\}/g, ticketSubject || "");
+    result = result.replace(/\{\{agent\.name\}\}/g, "Support");
+    return result;
+  }, [client, ticketNumber, ticketSubject]);
+  const handleCannedSelect = (e) => {
+    const selected = cannedResponses.find((cr) => String(cr.id) === e.target.value);
+    if (selected) {
+      const body = replaceCannedVariables(selected.body);
+      const html = body.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\n/g, "<br />");
+      setReplyBody(body);
+      setReplyHtml(html);
+      replyEditorRef.current?.setContent(html);
+    }
+    e.target.value = "";
+  };
+  const handleReplyFileChange = (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(", ")}`);
+      }
+      setReplyFiles((prev) => [...prev, ...newFiles.filter((f) => f.size <= maxSize)]);
+    }
+    if (fileInputRef.current) fileInputRef.current.value = "";
+  };
+  const uploadFiles = async (files) => {
+    const uploadedIds = [];
+    for (const file of files) {
+      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);
+      }
+    }
+    return uploadedIds;
+  };
+  const resetReply = () => {
+    setReplyBody("");
+    setReplyHtml("");
+    setReplyFiles([]);
+    setIsInternal(false);
+    setNotifyClient(false);
+    setSendAsClient(false);
+    replyEditorRef.current?.clear();
+  };
+  const handleSendReply = async () => {
+    if (!replyBody.trim() || !id) return;
+    setSending(true);
+    try {
+      const uploadedIds = await uploadFiles(replyFiles);
+      const finalBody = replyBody.trim() || (replyHtml ? "[Contenu enrichi]" : "");
+      const messageData = {
+        ticket: id,
+        body: finalBody,
+        ...replyHtml ? { bodyHtml: replyHtml } : {},
+        authorType: sendAsClient ? "client" : "admin",
+        isInternal,
+        skipNotification: isInternal || !notifyClient,
+        ...sendAsClient && client ? { authorClient: client.id } : {}
+      };
+      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) {
+        resetReply();
+        fetchAll();
+        if (!isInternal) handleNextTicket();
+      }
+    } catch {
+    } finally {
+      setSending(false);
+    }
+  };
+  const handleScheduleReply = async () => {
+    if (!replyBody.trim() || !id || !scheduleDate) return;
+    setSending(true);
+    try {
+      const uploadedIds = await uploadFiles(replyFiles);
+      const messageData = {
+        ticket: id,
+        body: replyBody.trim(),
+        ...replyHtml ? { bodyHtml: replyHtml } : {},
+        authorType: "admin",
+        isInternal: false,
+        skipNotification: true,
+        scheduledAt: new Date(scheduleDate).toISOString(),
+        scheduledSent: false
+      };
+      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) {
+        resetReply();
+        setShowSchedule(false);
+        setScheduleDate("");
+        fetchAll();
+      }
+    } catch {
+    } finally {
+      setSending(false);
+    }
+  };
+  return {
+    fileInputRef,
+    replyBody,
+    setReplyBody,
+    replyHtml,
+    setReplyHtml,
+    replyFiles,
+    setReplyFiles,
+    isInternal,
+    setIsInternal,
+    notifyClient,
+    setNotifyClient,
+    sendAsClient,
+    setSendAsClient,
+    sending,
+    showSchedule,
+    setShowSchedule,
+    scheduleDate,
+    setScheduleDate,
+    handleEditorFileUpload,
+    handleCannedSelect,
+    handleReplyFileChange,
+    handleSendReply,
+    handleScheduleReply
+  };
+}
+
+export { useReply };