From 6fed804a02280742f328c7f5a3252bd57e7552de Mon Sep 17 00:00:00 2001 From: xEsiah Date: Thu, 22 Oct 2026 10:11:39 +0200 Subject: [PATCH] feat(chat,files): edit messages, pin several of them, drag-and-drop upload Chat messages can now be rewritten by their author only, at any time, with a "(edited)" marker whose tooltip carries the full date and time down to the second. The edit is enforced by the SQL filter on user_id, so a message of someone else answers 404, exactly like a message that does not exist. Several messages can be pinned at once in the same chat room. Pinning is open to every member of the room: it is a reading convenience, not a way to take over someone else's content. A dedicated GET on /chat/pins is required because the id cursor only reports recent messages, and pinning an old one would otherwise stay invisible. The message list is synchronised with two cursors: the id one for new messages, a timestamp one for rewrites. The server computes that timestamp before running the query and returns it as-is, in the very frame used by edited_at, so the client never converts it and cannot drift by a timezone offset. Files can now be dropped on the current folder or on any sub-folder card. The drop zone only reacts to file drags, and the pointer moving from a child element to another no longer makes the overlay flicker. A deleted message leaves the pinned list, and its physical file is removed from the disk as before. --- .../migrations/009_chat_edits_and_pins.sql | 25 ++ backend/src/routes/chat.ts | 170 ++++++++++- docs/api.md | 39 ++- docs/security.md | 21 ++ frontend/src/components/FolderChat.tsx | 276 ++++++++++++++++-- frontend/src/components/icons.tsx | 8 + frontend/src/lib/api.ts | 37 ++- frontend/src/lib/i18n.tsx | 14 + frontend/src/pages/Browser.tsx | 140 ++++++++- 9 files changed, 697 insertions(+), 33 deletions(-) create mode 100644 backend/migrations/009_chat_edits_and_pins.sql diff --git a/backend/migrations/009_chat_edits_and_pins.sql b/backend/migrations/009_chat_edits_and_pins.sql new file mode 100644 index 0000000..e21e0fd --- /dev/null +++ b/backend/migrations/009_chat_edits_and_pins.sql @@ -0,0 +1,25 @@ +-- 009_chat_edits_and_pins.sql +-- +-- 1. Edition des messages : `edited_at` enregistre l'instant de la derniere +-- modification. NULL signifie que le message n'a jamais ete edite, donc +-- l'interface n'affiche aucune mention. La colonne est posee par le +-- serveur, jamais par le client. +-- +-- `edited_at` suit exactement la convention de `created_at` (meme horloge +-- de la base, meme cadran) : les deux colonnes doivent afficher la meme +-- heure relative l'une a l'autre, sinon la mention « (modifié) » paraitrait +-- anterieure au message qu'elle annote. +-- +-- 2. Epinglage : `is_pinned` marque les messages mis de cote dans le salon. +-- Plusieurs messages peuvent etre epingles en meme temps. L'index sert a +-- retrouver les epingles d'un dossier sans parcourir tout le salon. +-- +-- L'index sur `edited_at` sert au curseur `editedAfter` de la lecture +-- incrementale : il rattrape les messages reecrits dont le curseur +-- d'identifiant ne peut pas dire grand-chose. + +ALTER TABLE chat_messages + ADD COLUMN edited_at DATETIME(3) NULL AFTER created_at, + ADD COLUMN is_pinned TINYINT(1) NOT NULL DEFAULT 0 AFTER edited_at, + ADD KEY idx_chat_messages_pinned (folder_id, is_pinned, id), + ADD KEY idx_chat_messages_edited (folder_id, edited_at); diff --git a/backend/src/routes/chat.ts b/backend/src/routes/chat.ts index aaa3b3c..d86d967 100644 --- a/backend/src/routes/chat.ts +++ b/backend/src/routes/chat.ts @@ -30,11 +30,21 @@ const sendInput = z.object({ body: z.string().trim().min(1, "Message vide.").max(2000, "Message trop long."), }); +/** Meme borne que l'envoi : un message edite ne peut pas devenir plus long. */ +const editInput = z.object({ + body: z.string().trim().min(1, "Message vide.").max(2000, "Message trop long."), +}); + +/** Horodatage renvoye tel quel par le serveur : `AAAA-MM-JJTHH:MM:SS.ffffff`. */ +const DATETIME_CURSOR = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,6})?$/; + interface MessageRow { id: number; user_id: string | null; body: string; created_at: string; + edited_at: string | null; + is_pinned: number; first_name: string | null; last_name: string | null; avatar_updated_at: Date | null; @@ -42,7 +52,7 @@ interface MessageRow { /** Auteur joint a la ligne : meme jointure que la lecture, pour la reponse du POST. */ const SELECT_MESSAGE = ` - SELECT m.id, m.user_id, m.body, m.created_at, + SELECT m.id, m.user_id, m.body, m.created_at, m.edited_at, m.is_pinned, u.first_name, u.last_name, ua.updated_at AS avatar_updated_at FROM chat_messages m LEFT JOIN users u ON u.id = m.user_id @@ -55,6 +65,8 @@ const publicMessage = (row: MessageRow) => ({ last_name: row.last_name, body: row.body, created_at: row.created_at, + edited_at: row.edited_at, + is_pinned: row.is_pinned === 1, has_avatar: row.user_id !== null && row.avatar_updated_at !== null, avatar_updated_at: row.avatar_updated_at, }); @@ -181,6 +193,30 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => { const limit = Math.min(200, Math.max(1, Number(context.req.query("limit")) || 50)); const after = Math.max(0, Number(context.req.query("after")) || 0); + /** + * Curseur d'edition. Le curseur `after` ne voit que les messages plus + * recents : une reecriture d'un ancien message y resterait invisible. + * + * Le curseur est un horodatage de la base, dans le meme cadran que la + * colonne `edited_at` : le client le renvoie tel quel, sans conversion. + * Comparer une chaine ISO (UTC) a un DATETIME stocke en heure locale + * decalerait la fenetre de la difference de fuseau. + * + * Il est calcule AVANT la requete : une edition survenue entre les deux + * porte un horodatage posterieur au curseur, elle sera donc vue au tour + * suivant plutot que perdue. + */ + // `cursor` est un mot reserve en MariaDB : l'alias est renomme. + const cursorRow = await db.one<{ chat_cursor: string }>( + "SELECT DATE_FORMAT(CURRENT_TIMESTAMP(3), '%Y-%m-%dT%H:%i:%s.%f') AS chat_cursor", + ); + const serverCursor = cursorRow?.chat_cursor ?? "1970-01-01T00:00:00.000000"; + const editedAfterRaw = context.req.query("editedAfter"); + const editedSince = + typeof editedAfterRaw === "string" && DATETIME_CURSOR.test(editedAfterRaw) + ? editedAfterRaw + : serverCursor; + // `after` sert a la synchronisation incrementale (polling) : on ne remonte // que les messages posterieurs au dernier connu, dans l'ordre du temps. // Sans `after` : les `limit` derniers, remis dans l'ordre croissant. @@ -188,10 +224,12 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => { after > 0 ? await db.query( `${SELECT_MESSAGE} - WHERE m.folder_id = ? AND m.deleted_at IS NULL AND m.id > ? + WHERE m.folder_id = ? AND m.deleted_at IS NULL + AND ( m.id > ? + OR ( m.edited_at IS NOT NULL AND m.edited_at >= ? ) ) ORDER BY m.id ASC LIMIT ${limit}`, - [folderId, after], + [folderId, after, editedSince], ) : ( await db.query( @@ -206,7 +244,7 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => { const newest = rows.reduce((max, row) => Math.max(max, row.id), 0); await markRead(folderId, user.id, newest); - return context.json({ messages: rows.map(publicMessage) }); + return context.json({ messages: rows.map(publicMessage), cursor: serverCursor }); }); app.post("/api/cloud/folders/:folderId/chat/messages", requireAuth, async (context) => { @@ -233,6 +271,122 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => { return context.json({ message: publicMessage(row) }, 201); }); + /** + * Edition d'un message. Seul l'auteur peut modifier ce qu'il a ecrit : le + * filtre `user_id = ?` est porte par la requete SQL, donc un message d'autrui + * est indistinguishable d'un message inexistant. Le gestionnaire du dossier + * peut supprimer un message, mais pas le reecrire a la place de son auteur. + */ + app.patch( + "/api/cloud/folders/:folderId/chat/messages/:id", + requireAuth, + async (context) => { + const user = currentUser(context); + const folderId = context.req.param("folderId") ?? ""; + const id = Number(context.req.param("id")); + await assertFolder(folderId); + if (!(await canRead(db, user, folderId))) throw AppError.notFound("Dossier introuvable."); + if (!Number.isSafeInteger(id) || id <= 0) throw AppError.notFound("Message introuvable."); + + if (!limiter.allow(user.id)) { + throw AppError.unprocessable("Vous envoyez des messages trop rapidement."); + } + + const parsed = editInput.safeParse(await context.req.json().catch(() => null)); + if (!parsed.success) { + throw AppError.badRequest(parsed.error.issues[0]?.message ?? "Message invalide."); + } + + const result = await db.exec( + `UPDATE chat_messages + SET body = ?, edited_at = CURRENT_TIMESTAMP(3) + WHERE id = ? AND folder_id = ? AND user_id = ? AND deleted_at IS NULL`, + [parsed.data.body, id, folderId, user.id], + ); + if (result.affectedRows === 0) throw AppError.notFound("Message introuvable."); + + await audit( + db, + context, + user, + "chat.edit", + "message", + String(id), + { folderId }, + config.TRUST_PROXY, + ); + const row = await db.required(`${SELECT_MESSAGE} WHERE m.id = ?`, [id]); + return context.json({ message: publicMessage(row) }); + }, + ); + + /** + * Epinglage d'un message. Bascule atomique en base : le salon compte + * plusieurs participants, deux clics croises ne doivent pas laisser le + * message dans un etat incoherent. Tout membre du salon peut epingler. + */ + app.put( + "/api/cloud/folders/:folderId/chat/messages/:id/pin", + requireAuth, + async (context) => { + const user = currentUser(context); + const folderId = context.req.param("folderId") ?? ""; + const id = Number(context.req.param("id")); + await assertFolder(folderId); + if (!(await canRead(db, user, folderId))) throw AppError.notFound("Dossier introuvable."); + if (!Number.isSafeInteger(id) || id <= 0) throw AppError.notFound("Message introuvable."); + + if (!limiter.allow(user.id)) { + throw AppError.unprocessable("Vous envoyez des messages trop rapidement."); + } + + const result = await db.exec( + "UPDATE chat_messages SET is_pinned = 1 - is_pinned WHERE id = ? AND folder_id = ? AND deleted_at IS NULL", + [id, folderId], + ); + if (result.affectedRows === 0) throw AppError.notFound("Message introuvable."); + + const row = await db.required<{ is_pinned: number }>( + "SELECT is_pinned FROM chat_messages WHERE id = ?", + [id], + ); + const pinned = row.is_pinned === 1; + await audit( + db, + context, + user, + pinned ? "chat.pin" : "chat.unpin", + "message", + String(id), + { folderId }, + config.TRUST_PROXY, + ); + return context.json({ pinned }); + }, + ); + + /** + * Messages epingles du salon. Relu a chaque tour de synchronisation : le + * curseur `after` ne remonte que les messages plus recents, donc un + * epinglage pose sur un ancien message resterait invisible sans cette lecture + * dediee. + */ + app.get("/api/cloud/folders/:folderId/chat/pins", requireAuth, async (context) => { + const user = currentUser(context); + const folderId = context.req.param("folderId") ?? ""; + await assertFolder(folderId); + if (!(await canRead(db, user, folderId))) throw AppError.notFound("Dossier introuvable."); + + const rows = await db.query( + `${SELECT_MESSAGE} + WHERE m.folder_id = ? AND m.is_pinned = 1 AND m.deleted_at IS NULL + ORDER BY m.id DESC + LIMIT 50`, + [folderId], + ); + return context.json({ messages: rows.map(publicMessage) }); + }); + app.delete( "/api/cloud/folders/:folderId/chat/messages/:id", requireAuth, @@ -254,7 +408,13 @@ export const registerChatRoutes = (app: App, db: Db, config: Config): void => { throw AppError.notFound("Message introuvable."); } - await db.exec("UPDATE chat_messages SET deleted_at = UTC_TIMESTAMP(3) WHERE id = ?", [id]); + // Un message retire quitte aussi les epingles : le laisser marque ferait + // apparaitre un epingle fantome dans le bandeau. `deleted_at` suit la + // meme horloge que `created_at`. + await db.exec( + "UPDATE chat_messages SET deleted_at = CURRENT_TIMESTAMP(3), is_pinned = 0 WHERE id = ?", + [id], + ); await audit(db, context, user, "chat.delete", "message", String(id), { folderId }, config.TRUST_PROXY); return context.json({ ok: true }); }, diff --git a/docs/api.md b/docs/api.md index 2933365..1f27284 100644 --- a/docs/api.md +++ b/docs/api.md @@ -78,8 +78,11 @@ identifiant (`after`), sans WebSocket. | Méthode | Chemin | Garde | | --- | --- | --- | | GET | `/api/cloud/folders/:folderId/chat/members` | `requireAuth` + `canRead` | -| GET | `/api/cloud/folders/:folderId/chat/messages?after=&limit=` | `requireAuth` + `canRead` | +| GET | `/api/cloud/folders/:folderId/chat/messages?after=&limit=&editedAfter=` | `requireAuth` + `canRead` | | POST | `/api/cloud/folders/:folderId/chat/messages` | `requireAuth` + `canRead` (limiteur 20 / 10 s par compte) | +| PATCH | `/api/cloud/folders/:folderId/chat/messages/:id` | `requireAuth` + `canRead` + **auteur du message** (limiteur 20 / 10 s par compte) | +| PUT | `/api/cloud/folders/:folderId/chat/messages/:id/pin` | `requireAuth` + `canRead` (limiteur 20 / 10 s par compte) | +| GET | `/api/cloud/folders/:folderId/chat/pins` | `requireAuth` + `canRead` | | DELETE | `/api/cloud/folders/:folderId/chat/messages/:id` | `requireAuth` + `canRead` (auteur ou gestionnaire du dossier, soft-delete) | `GET .../chat/members` renvoie les membres du salon, c'est-à-dire les comptes qui @@ -87,6 +90,35 @@ ont accès au dossier : propriétaire, titulaires d'une permission nominative no expirée, rôle global `admin`, et tous les comptes actifs si le dossier est `public` (prénom, nom, rôle, présence d'avatar, `last_login_at`). +**Édition.** `PATCH .../chat/messages/:id` réécrit le corps du message et pose +`edited_at`. Seul l'auteur peut le faire, sans limite de temps : le filtre +`user_id` est porté par la requête SQL, donc un message d'autrui renvoie le +même `404` qu'un message inexistant. Le gestionnaire du dossier peut supprimer +un message, mais pas le réécrire à la place de son auteur. + +**Épinglage.** `PUT .../chat/messages/:id/pin` bascule `is_pinned` en base +(bascule atomique, safe face à deux clics croisés). Plusieurs messages peuvent +être épinglés en même temps dans un même salon. Tout membre du salon peut +épingler et désépingler, y compris un message qu'il n'a pas écrit. La lecture +dédiée `GET .../chat/pins` est nécessaire parce que le curseur `after` ne +remonte que les messages plus récents : un épinglage posé sur un ancien +message resterait invisible sans elle. + +**Synchronisation.** `GET .../chat/messages` accepte deux curseurs : `after` +(identifiant, messages plus récents) et `editedAfter` (horodatage, messages +réécrits depuis). Le second rattrape les réécritures d'anciens messages, que le +premier ne peut pas voir. `edited_at` est null pour un message jamais modifié. + +Le curseur d'édition est un horodatage de la base au format +`AAAA-MM-JJTHH:MM:SS.ffffff`, et non un horodatage ISO : il est renvoyé tel quel +par la réponse (`cursor`) et doit être renvoyé tel quel par le client. Comparer +une chaîne ISO (UTC) à un `DATETIME` stocké en heure locale décalerait la +fenêtre de la différence de fuseau. Le serveur calcule son curseur **avant** la +requête de lecture : une réécriture survenue entre les deux porte un +horodatage postérieur au curseur, elle sera donc vue au tour suivant plutôt que +perdue. Une valeur qui ne respecte pas le format est ignorée, le serveur +utilise alors le sien. + ### Administration (`role_slug = admin`) | Méthode | Chemin | @@ -163,10 +195,13 @@ par fichier, dérive refusée au démarrage. | `005_storage_location_realign.sql` | réalignement des emplacements | | `006_public_folder.sql` | `folders.access_type` / `is_system`, dossier `Public` | | `007_chat.sql` | `chat_messages` (salon global, auteur `ON DELETE SET NULL`) | +| `008_user_preferences.sql` | préférences d'affichage, `user_file_stars`, `chat_reads` | +| `009_chat_edits_and_pins.sql` | `chat_messages.edited_at`, `chat_messages.is_pinned`, index `idx_chat_messages_pinned`, `idx_chat_messages_edited` | Tables actives : `users, user_sessions, folders, folder_permissions, files, media_metadata, file_variants, user_avatars, chat_messages, storage_locations, -settings, password_reset_tokens, email_change_requests, audit_logs`. +settings, password_reset_tokens, email_change_requests, audit_logs, +user_file_stars, chat_reads`. ## Erreurs métier diff --git a/docs/security.md b/docs/security.md index e903619..ebf7449 100644 --- a/docs/security.md +++ b/docs/security.md @@ -32,6 +32,27 @@ en-tête (`backend/src/access.ts`). Lecture : propriétaire, permission `write`/`admin`. **404 plutôt que 403** : jamais d'indice sur l'existence d'une ressource. +### Discussion + +Le salon d'un dossier est ouvert à qui a accès au dossier (`canRead`). L'accès +en lecture et l'envoi de messages se distinguent de l'**édition** : + +- l'édition d'un message (`PATCH .../chat/messages/:id`) est réservée à son + **auteur**, sans limite de temps. Le filtre `user_id` est porté par la + requête SQL : un message d'autrui répond `404`, comme un message inexistant, + sans rien laisser deviner. Le gestionnaire du dossier peut supprimer un + message mais pas le réécrire à la place de son auteur ; +- l'épinglage (`PUT .../chat/messages/:id/pin`) est ouvert à tout membre du + salon : c'est une mise de côté de lecture, pas une prise de contrôle du + contenu ; +- la suppression est un soft-delete (`deleted_at`), un message retiré quitte + aussi les épingles ; +- `edited_at` est posé par le serveur, jamais reçu du client : un client ne + peut pas dater sa propre modification. + +Chaque écriture dans le salon passe par le limiteur de débit (20 requêtes +d'écriture par compte sur 10 s), édition et épinglage compris. + ### Courriel Nodemailer (`backend/src/lib/mail.ts`) avec `SMTP_HOST`. `PUBLIC_ORIGIN` diff --git a/frontend/src/components/FolderChat.tsx b/frontend/src/components/FolderChat.tsx index 22ae76d..0735bc2 100644 --- a/frontend/src/components/FolderChat.tsx +++ b/frontend/src/components/FolderChat.tsx @@ -8,7 +8,14 @@ import { type KeyboardEvent as ReactKeyboardEvent, } from "react"; import { Button, Spinner, cn } from "../ui/index.js"; -import { ApiError, api, formatDate, type ChatMember, type ChatMessage } from "../lib/api.js"; +import { + ApiError, + api, + formatDate, + formatDateTimeSeconds, + type ChatMember, + type ChatMessage, +} from "../lib/api.js"; import { useI18n } from "../lib/i18n.js"; import { getLocale } from "../lib/locale.js"; import { useSession } from "../lib/session.js"; @@ -16,7 +23,16 @@ import { useConfirm } from "./confirm.js"; import { Avatar } from "./Avatar.js"; import { IconAction } from "./IconAction.js"; import { Alert, Badge, EmptyState } from "./feedback.js"; -import { ChatIcon, CloseIcon, SendIcon, TrashIcon, UsersIcon } from "./icons.js"; +import { + ArrowRightIcon, + ChatIcon, + CloseIcon, + PenIcon, + PinIcon, + SendIcon, + TrashIcon, + UsersIcon, +} from "./icons.js"; const MAX_LENGTH = 2000; const POLL_MESSAGES_MS = 4000; @@ -63,15 +79,25 @@ export const FolderChat = ({ folder, onClose }: { folder: ChatFolder; onClose: ( const [members, setMembers] = useState([]); const [messages, setMessages] = useState([]); + const [pins, setPins] = useState([]); + const [pinsOpen, setPinsOpen] = useState(false); const [loading, setLoading] = useState(true); const [error, setError] = useState(null); const [draft, setDraft] = useState(""); const [sending, setSending] = useState(false); const [deletingId, setDeletingId] = useState(null); + const [pinningId, setPinningId] = useState(null); + const [editingId, setEditingId] = useState(null); + const [editDraft, setEditDraft] = useState(""); + const [savingEdit, setSavingEdit] = useState(false); const [membersOpen, setMembersOpen] = useState(false); const scrollRef = useRef(null); const lastIdRef = useRef(0); + // Curseur d'edition : horodatage delivre par le serveur, renvoye tel quel. + // Le curseur d'identifiant ne voit que les messages plus recents, ce second + // curseur rattrape les reecritures d'anciens messages. + const editedSinceRef = useRef(null); // Tant que l'utilisateur reste au bas de la conversation, chaque nouveau // message le ramene en bas ; s'il remonte lire l'historique, on ne le force // pas a redescendre. @@ -86,9 +112,27 @@ export const FolderChat = ({ folder, onClose }: { folder: ChatFolder; onClose: ( (incoming: ChatMessage[]) => { if (incoming.length === 0) return; setMessages((previous) => { - const known = new Set(previous.map((message) => message.id)); - const fresh = incoming.filter((message) => !known.has(message.id)); - return fresh.length > 0 ? [...previous, ...fresh] : previous; + const index = new Map(previous.map((message) => [message.id, message])); + let changed = false; + for (const message of incoming) { + const known = index.get(message.id); + if (!known) { + index.set(message.id, message); + changed = true; + continue; + } + // Un message deja connu peut avoir ete reecrit ou change d'etat + // d'epinglage : on ne remplace que si la version recue est plus + // recente, pour ne pas ecraser une edition locale toute recente. + const knownEdited = known.edited_at ? Date.parse(known.edited_at) : 0; + const incomingEdited = message.edited_at ? Date.parse(message.edited_at) : 0; + if (incomingEdited > knownEdited || message.is_pinned !== known.is_pinned) { + index.set(message.id, { ...known, ...message }); + changed = true; + } + } + if (!changed) return previous; + return [...index.values()].sort((a, b) => a.id - b.id); }); lastIdRef.current = Math.max(lastIdRef.current, MAX_ID(incoming)); if (stickToBottomRef.current) queueMicrotask(scrollToBottom); @@ -105,17 +149,22 @@ export const FolderChat = ({ folder, onClose }: { folder: ChatFolder; onClose: ( let active = true; setLoading(true); setMessages([]); + setPins([]); lastIdRef.current = 0; + editedSinceRef.current = null; void (async () => { try { - const [memberResult, messageResult] = await Promise.all([ + const [memberResult, messageResult, pinResult] = await Promise.all([ api.chatMembers(folderId), api.chatMessages(folderId, 0, 50), + api.chatPins(folderId), ]); if (!active) return; setMembers(memberResult.members); setMessages(messageResult.messages); + setPins(pinResult.messages); lastIdRef.current = MAX_ID(messageResult.messages); + editedSinceRef.current = messageResult.cursor; setError(null); } catch (caught) { if (!active) return; @@ -138,8 +187,15 @@ export const FolderChat = ({ folder, onClose }: { folder: ChatFolder; onClose: ( const poll = async () => { if (document.hidden) return; try { - const { messages: fresh } = await api.chatMessages(folderId, lastIdRef.current, 100); - mergeMessages(fresh); + const [result, pinResult] = await Promise.all([ + api.chatMessages(folderId, lastIdRef.current, 100, editedSinceRef.current), + api.chatPins(folderId), + ]); + // Le curseur avance avec la reponse : le serveur le calcule avant la + // requete, une edition survenue entre les deux sera vue au tour suivant. + editedSinceRef.current = result.cursor; + mergeMessages(result.messages); + setPins(pinResult.messages); } catch { /* le prochain cycle retentera */ } @@ -194,7 +250,7 @@ export const FolderChat = ({ folder, onClose }: { folder: ChatFolder; onClose: ( mergeMessages([message]); setDraft(""); } catch (caught) { - setError(caught instanceof ApiError ? caught.message : t("Envoi impossible.")); + setError(caught instanceof ApiError ? caught.message : t("Envoi du message impossible.")); } finally { setSending(false); } @@ -214,6 +270,8 @@ export const FolderChat = ({ folder, onClose }: { folder: ChatFolder; onClose: ( try { await api.chatDeleteMessage(folderId, message.id); setMessages((previous) => previous.filter((item) => item.id !== message.id)); + // Un message retire disparait aussi des epingles. + setPins((previous) => previous.filter((item) => item.id !== message.id)); } catch (caught) { setError(caught instanceof ApiError ? caught.message : t("Suppression impossible.")); } finally { @@ -221,6 +279,58 @@ export const FolderChat = ({ folder, onClose }: { folder: ChatFolder; onClose: ( } }; + const startEdit = (message: ChatMessage) => { + setEditingId(message.id); + setEditDraft(message.body); + }; + + const cancelEdit = () => { + setEditingId(null); + setEditDraft(""); + }; + + const saveEdit = async (message: ChatMessage) => { + const body = editDraft.trim(); + if (!body || savingEdit) return; + setSavingEdit(true); + setError(null); + try { + const { message: updated } = await api.chatEditMessage(folderId, message.id, body); + mergeMessages([updated]); + setPins((previous) => + previous.map((item) => (item.id === updated.id ? { ...item, ...updated } : item)), + ); + cancelEdit(); + } catch (caught) { + setError(caught instanceof ApiError ? caught.message : t("Modification impossible.")); + } finally { + setSavingEdit(false); + } + }; + + const togglePin = async (message: ChatMessage) => { + if (pinningId !== null) return; + setPinningId(message.id); + setError(null); + try { + const { pinned } = await api.chatTogglePin(folderId, message.id); + const updated = { ...message, is_pinned: pinned }; + mergeMessages([updated]); + setPins((previous) => + pinned + ? [updated, ...previous.filter((item) => item.id !== updated.id)] + : previous.filter((item) => item.id !== updated.id), + ); + // Le bandeau s'ouvre quand on epingle : c'est le moment ou l'utilisateur + // veut voir ce qu'il vient de mettre de cote. + if (pinned) setPinsOpen(true); + } catch (caught) { + setError(caught instanceof ApiError ? caught.message : t("Épinglage impossible.")); + } finally { + setPinningId(null); + } + }; + const onComposerKeyDown = (event: ReactKeyboardEvent) => { if (event.key === "Enter" && !event.shiftKey) { event.preventDefault(); @@ -241,7 +351,9 @@ export const FolderChat = ({ folder, onClose }: { folder: ChatFolder; onClose: ( GROUP_WINDOW_MS; const own = message.user_id === user?.id; const canDelete = own; - return { message, newDay, continuation, own, canDelete }; + // Seul l'auteur peut reecrire son message, sans limite de temps. + const canEdit = own; + return { message, newDay, continuation, own, canDelete, canEdit }; }), [messages, user?.id], ); @@ -337,6 +449,49 @@ export const FolderChat = ({ folder, onClose }: { folder: ChatFolder; onClose: ( ) : null} + {pins.length > 0 ? ( +
+ + {pinsOpen ? ( +
    + {pins.map((pin) => ( +
  • +

    + + {fullName(pin, t("Compte supprimé"))} + + + {timeOf(pin.created_at)} + +

    +

    + {pin.body} +

    +
  • + ))} +
+ ) : null} +
+ ) : null} +
) : (
    - {rendered.map(({ message, newDay, continuation, own, canDelete }) => ( + {rendered.map( + ({ message, newDay, continuation, own, canDelete, canEdit }) => (
  1. {newDay ? (
    @@ -389,7 +545,10 @@ export const FolderChat = ({ folder, onClose }: { folder: ChatFolder; onClose: ( {continuation ? null : (

    {fullName(message, t("Compte supprimé"))} @@ -398,12 +557,88 @@ export const FolderChat = ({ folder, onClose }: { folder: ChatFolder; onClose: (

    )} -

    - {message.body} -

    + {editingId === message.id ? ( +
    +