From 699c523caa0833243e763d12b47eb3b3462ff2f4 Mon Sep 17 00:00:00 2001 From: Gitea Actions <-2+gitea-actions@noreply.localhost> Date: Thu, 22 Oct 2026 10:52:23 +0000 Subject: [PATCH] fix(files): allow uploading to root when another user has same name (#15) Root is a personal namespace per user, so duplicate checks must scope to the current owner when uploading at root level. Subfolders keep their existing uniqueness rules. Also fixed folder creation at root with the same owner scope. --------- Co-authored-by: xEsiah Reviewed-on: https://git.cohaise.dev/Esiah/CoHaiSe-CLOUD/pulls/15 Reviewed-by: Esiah Co-authored-by: Gitea Actions <-2+gitea-actions@noreply.localhost> --- .../migrations/009_chat_edits_and_pins.sql | 25 ++ backend/src/routes/chat.ts | 170 ++++++++++- backend/src/routes/files.ts | 11 +- backend/src/routes/folders.ts | 9 +- 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 ++++++++- 11 files changed, 713 insertions(+), 37 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/backend/src/routes/files.ts b/backend/src/routes/files.ts index f12cf47..170b461 100644 --- a/backend/src/routes/files.ts +++ b/backend/src/routes/files.ts @@ -267,10 +267,17 @@ export const registerFileRoutes = (app: App, db: Db, config: Config): void => { throw AppError.payloadTooLarge("Votre quota de stockage est depasse."); } + // Un nom est unique dans un dossier, mais la racine est un espace + // personnel : chaque utilisateur y depose ses propres fichiers, et la + // liste n'en montre que les siens. Le controle de doublon doit donc + // suivre la meme regle, sinon le fichier d'un autre compte a la racine + // bloquerait un depot qui n'a rien a voir avec lui. const duplicate = await db.one( `SELECT 1 AS taken FROM files - WHERE folder_id <=> ? AND active_name = ? AND deleted_at IS NULL LIMIT 1`, - [folderId, name], + WHERE folder_id <=> ? AND active_name = ? AND deleted_at IS NULL + AND ( folder_id IS NOT NULL OR owner_id = ? ) + LIMIT 1`, + [folderId, name, user.id], ); if (duplicate) throw AppError.conflict("Ce nom existe deja ici."); diff --git a/backend/src/routes/folders.ts b/backend/src/routes/folders.ts index 24165fe..17ae818 100644 --- a/backend/src/routes/folders.ts +++ b/backend/src/routes/folders.ts @@ -159,10 +159,15 @@ export const registerFolderRoutes = (app: App, db: Db, config: Config): void => } } + // La racine est l'espace personnel de chaque compte : un dossier du meme + // nom cree par quelqu'un d'autre ne doit pas bloquer celui-ci. Dans un + // dossier, le nom reste unique pour tous ses participants. const duplicate = await db.one( `SELECT 1 AS taken FROM folders - WHERE parent_id <=> ? AND active_name = ? AND deleted_at IS NULL LIMIT 1`, - [parentId ?? null, name], + WHERE parent_id <=> ? AND active_name = ? AND deleted_at IS NULL + AND ( parent_id IS NOT NULL OR owner_id = ? ) + LIMIT 1`, + [parentId ?? null, name, user.id], ); if (duplicate) throw AppError.conflict("Ce nom existe deja ici."); 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 ? ( +
    +