init
This commit is contained in:
@@ -1,7 +1,6 @@
|
||||
<script lang="ts" setup>
|
||||
import 'highlight.js/styles/github-dark.css'
|
||||
import {computed, nextTick, onMounted, ref, watch} from 'vue';
|
||||
import {useRoute} from 'vue-router';
|
||||
import {computed, nextTick, ref, watch} from 'vue';
|
||||
import {storeToRefs} from 'pinia';
|
||||
import {useMessageStore} from '@/stores/message';
|
||||
import {useUserStore} from "@/stores/user.ts";
|
||||
@@ -13,25 +12,129 @@ const props = defineProps<{
|
||||
}>();
|
||||
|
||||
const channelId = computed(() => props.channelId);
|
||||
|
||||
const route = useRoute();
|
||||
const messageStore = useMessageStore();
|
||||
const userStore = useUserStore();
|
||||
const {renderMarkdown} = useMarkdown()
|
||||
|
||||
// Référence vers l'élément scrollable
|
||||
const messageContainer = ref<HTMLElement | null>(null);
|
||||
|
||||
// "messages" ici est une référence réactive liée au store
|
||||
const {messages, loading} = storeToRefs(messageStore);
|
||||
|
||||
const {messages, loading, loadingBefore, loadingAfter} = storeToRefs(messageStore);
|
||||
const newMessage = ref('');
|
||||
|
||||
const SCROLL_LOAD_THRESHOLD = 120;
|
||||
const SCROLL_BOTTOM_TOLERANCE = 4;
|
||||
const paginationLock = ref<'before' | 'after' | null>(null);
|
||||
const paginationLockScrollTop = ref(0);
|
||||
const lastScrollTop = ref(0);
|
||||
|
||||
interface ScrollAnchor {
|
||||
id: string;
|
||||
top: number;
|
||||
}
|
||||
|
||||
const scrollToBottom = async () => {
|
||||
await nextTick();
|
||||
if (messageContainer.value) {
|
||||
messageContainer.value.scrollTop = messageContainer.value.scrollHeight;
|
||||
messageStore.setAtBottom(true);
|
||||
}
|
||||
};
|
||||
|
||||
const getMessageElements = () => Array.from(
|
||||
messageContainer.value?.querySelectorAll<HTMLElement>('[data-message-id]') ?? [],
|
||||
);
|
||||
|
||||
const captureAnchor = (edge: 'top' | 'bottom'): ScrollAnchor | null => {
|
||||
const container = messageContainer.value;
|
||||
if (!container) return null;
|
||||
|
||||
const containerRect = container.getBoundingClientRect();
|
||||
const visible = getMessageElements().filter(element => {
|
||||
const rect = element.getBoundingClientRect();
|
||||
return rect.bottom > containerRect.top && rect.top < containerRect.bottom;
|
||||
});
|
||||
const element = edge === 'top' ? visible[0] : visible[visible.length - 1];
|
||||
if (!element?.dataset.messageId) return null;
|
||||
|
||||
return {
|
||||
id: element.dataset.messageId,
|
||||
top: element.getBoundingClientRect().top,
|
||||
};
|
||||
};
|
||||
|
||||
const restoreAnchor = async (anchor: ScrollAnchor | null) => {
|
||||
if (!anchor || !messageContainer.value) return;
|
||||
await nextTick();
|
||||
|
||||
const element = getMessageElements().find(item => item.dataset.messageId === anchor.id);
|
||||
if (element) {
|
||||
messageContainer.value.scrollTop += element.getBoundingClientRect().top - anchor.top;
|
||||
}
|
||||
};
|
||||
|
||||
const updateScrollState = () => {
|
||||
const container = messageContainer.value;
|
||||
if (!container) return;
|
||||
|
||||
const distanceFromBottom = container.scrollHeight - container.scrollTop - container.clientHeight;
|
||||
messageStore.setAtBottom(distanceFromBottom <= SCROLL_BOTTOM_TOLERANCE);
|
||||
};
|
||||
|
||||
const setPaginationLock = (direction: 'before' | 'after') => {
|
||||
if (!messageContainer.value) return;
|
||||
paginationLock.value = direction;
|
||||
paginationLockScrollTop.value = messageContainer.value.scrollTop;
|
||||
lastScrollTop.value = messageContainer.value.scrollTop;
|
||||
};
|
||||
|
||||
const loadBefore = async () => {
|
||||
const anchor = captureAnchor('top');
|
||||
const change = await messageStore.fetchBefore(channelId.value);
|
||||
if (change) {
|
||||
await restoreAnchor(anchor);
|
||||
setPaginationLock('before');
|
||||
}
|
||||
};
|
||||
|
||||
const loadAfter = async () => {
|
||||
const anchor = captureAnchor('bottom');
|
||||
const change = await messageStore.fetchAfter(channelId.value);
|
||||
if (change) {
|
||||
await restoreAnchor(anchor);
|
||||
setPaginationLock('after');
|
||||
}
|
||||
};
|
||||
|
||||
const handleScroll = async () => {
|
||||
const container = messageContainer.value;
|
||||
if (!container) return;
|
||||
|
||||
const currentScrollTop = container.scrollTop;
|
||||
const scrollDelta = currentScrollTop - lastScrollTop.value;
|
||||
lastScrollTop.value = currentScrollTop;
|
||||
|
||||
if (paginationLock.value === 'after') {
|
||||
if (scrollDelta < -1 || currentScrollTop > paginationLockScrollTop.value + 2) {
|
||||
paginationLock.value = null;
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
} else if (paginationLock.value === 'before') {
|
||||
if (scrollDelta > 1 || currentScrollTop < paginationLockScrollTop.value - 2) {
|
||||
paginationLock.value = null;
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
updateScrollState();
|
||||
|
||||
if (container.scrollTop <= SCROLL_LOAD_THRESHOLD && !loadingBefore.value) {
|
||||
await loadBefore();
|
||||
} else {
|
||||
const distanceFromBottom = container.scrollHeight - container.scrollTop - container.clientHeight;
|
||||
if (distanceFromBottom <= SCROLL_LOAD_THRESHOLD && !loadingAfter.value) {
|
||||
await loadAfter();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
@@ -39,47 +142,53 @@ const sendMessage = async () => {
|
||||
if (!newMessage.value.trim()) return;
|
||||
|
||||
const content = newMessage.value;
|
||||
const wasAtBottom = messageStore.isAtBottom;
|
||||
|
||||
try {
|
||||
await messageStore.sendMessage(channelId.value, content);
|
||||
newMessage.value = ''; // On vide le champ après succès
|
||||
await scrollToBottom();
|
||||
newMessage.value = '';
|
||||
if (wasAtBottom) await scrollToBottom();
|
||||
} catch (e) {
|
||||
// Gérer l'erreur (ex: notification toast)
|
||||
console.error('Erreur lors de l\'envoi du message:', e);
|
||||
}
|
||||
};
|
||||
|
||||
onMounted(() => {
|
||||
if (channelId.value) {
|
||||
messageStore.fetchMessages(channelId.value);
|
||||
// Only explicit initial loads and realtime messages received while at the
|
||||
// bottom request an automatic scroll. Pagination restores its own anchor.
|
||||
watch(messages, async () => {
|
||||
if (messageStore.consumeScrollToBottomRequest()) {
|
||||
await scrollToBottom();
|
||||
}
|
||||
});
|
||||
}, {deep: true, flush: 'post'});
|
||||
|
||||
watch(channelId, (newChannelId) => {
|
||||
watch(channelId, async (newChannelId) => {
|
||||
if (newChannelId) {
|
||||
messageStore.fetchMessages(newChannelId);
|
||||
await messageStore.fetchMessages(newChannelId);
|
||||
}
|
||||
}, {immediate: true})
|
||||
|
||||
// Scroll automatique quand la liste des messages change (nouveaux messages reçus)
|
||||
watch(messages, () => {
|
||||
scrollToBottom();
|
||||
}, {deep: true});
|
||||
</script>
|
||||
|
||||
<template>
|
||||
<!-- Conteneur principal prenant toute la hauteur -->
|
||||
<v-container class="pa-0 fill-height d-flex flex-column" fluid>
|
||||
|
||||
<!-- Zone des messages (scrollable) -->
|
||||
<div
|
||||
ref="messageContainer"
|
||||
class="flex-grow-1 overflow-y-auto w-100 message-container"
|
||||
@scroll.passive="handleScroll"
|
||||
>
|
||||
<v-progress-linear v-if="loadingBefore" color="primary" indeterminate />
|
||||
|
||||
<v-progress-circular
|
||||
v-if="loading && !messages.length"
|
||||
class="d-block mx-auto mt-4"
|
||||
color="primary"
|
||||
indeterminate
|
||||
/>
|
||||
|
||||
<v-list bg-color="transparent" lines="three">
|
||||
<v-list-item
|
||||
v-for="msg in messages"
|
||||
:key="msg.id"
|
||||
:data-message-id="msg.id"
|
||||
class="px-4 py-1"
|
||||
>
|
||||
<template v-slot:prepend>
|
||||
@@ -98,9 +207,10 @@ watch(messages, () => {
|
||||
</div>
|
||||
</v-list-item>
|
||||
</v-list>
|
||||
|
||||
<v-progress-linear v-if="loadingAfter" color="primary" indeterminate />
|
||||
</div>
|
||||
|
||||
<!-- Zone de saisie fixe en bas -->
|
||||
<v-sheet class="pa-4 flex-shrink-0" width="100%">
|
||||
<v-textarea
|
||||
v-model="newMessage"
|
||||
@@ -126,13 +236,11 @@ watch(messages, () => {
|
||||
</template>
|
||||
</v-textarea>
|
||||
</v-sheet>
|
||||
|
||||
</v-container>
|
||||
</template>
|
||||
|
||||
<style scoped>
|
||||
.message-container {
|
||||
/* Assure que la zone gère son scroll indépendamment */
|
||||
height: 0;
|
||||
}
|
||||
|
||||
|
||||
+255
-39
@@ -2,7 +2,12 @@ import {defineStore} from "pinia";
|
||||
import {useApi} from "@/composables/useApi.ts";
|
||||
import {onGatewayEvent} from "@/plugins/events.ts";
|
||||
|
||||
interface Message {
|
||||
// Change this value to adjust the maximum number of messages kept in the DOM.
|
||||
// Directional loads automatically use half of this window.
|
||||
export const MESSAGE_WINDOW_SIZE = 50;
|
||||
export const MESSAGE_SHIFT_SIZE = Math.max(1, Math.floor(MESSAGE_WINDOW_SIZE / 2));
|
||||
|
||||
export interface Message {
|
||||
id: string;
|
||||
channel_id: string;
|
||||
user_id: string;
|
||||
@@ -12,78 +17,289 @@ interface Message {
|
||||
reply_to_id: string | null;
|
||||
}
|
||||
|
||||
interface MessagePage {
|
||||
messages: Message[];
|
||||
oldest_id: string | null;
|
||||
newest_id: string | null;
|
||||
has_more_before: boolean;
|
||||
has_more_after: boolean;
|
||||
}
|
||||
|
||||
interface WindowChange {
|
||||
addedIds: string[];
|
||||
removedIds: string[];
|
||||
}
|
||||
|
||||
function compareMessages(left: Message, right: Message): number {
|
||||
if (left.id < right.id) return -1;
|
||||
if (left.id > right.id) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
function mergeMessages(messages: Message[]): Message[] {
|
||||
const byId = new Map<string, Message>();
|
||||
for (const message of messages) {
|
||||
byId.set(message.id, message);
|
||||
}
|
||||
return Array.from(byId.values()).sort(compareMessages);
|
||||
}
|
||||
|
||||
async function requestPage(
|
||||
channelId: string,
|
||||
params: { limit: number; before_id?: string; after_id?: string },
|
||||
): Promise<MessagePage> {
|
||||
const query = new URLSearchParams({
|
||||
channel_id: channelId,
|
||||
limit: String(params.limit),
|
||||
});
|
||||
|
||||
if (params.before_id) query.set("before_id", params.before_id);
|
||||
if (params.after_id) query.set("after_id", params.after_id);
|
||||
|
||||
const response = await useApi().get(`/messages?${query.toString()}`);
|
||||
if (!response.ok) {
|
||||
throw new Error(`Message loading failed (${response.status})`);
|
||||
}
|
||||
|
||||
return response.json() as Promise<MessagePage>;
|
||||
}
|
||||
|
||||
export const useMessageStore = defineStore("message", {
|
||||
state: () => ({
|
||||
messages: [] as Message[],
|
||||
activeChannelId: null as string | null,
|
||||
oldestId: null as string | null,
|
||||
newestId: null as string | null,
|
||||
hasMoreBefore: false,
|
||||
hasMoreAfter: false,
|
||||
loading: false,
|
||||
loadingBefore: false,
|
||||
loadingAfter: false,
|
||||
isAtBottom: true,
|
||||
scrollToBottomRequested: false,
|
||||
requestVersion: 0,
|
||||
}),
|
||||
|
||||
actions: {
|
||||
async fetchMessages(channel_id: string) {
|
||||
updateBoundaries(page: MessagePage) {
|
||||
this.oldestId = page.oldest_id ?? this.messages[0]?.id ?? null;
|
||||
this.newestId = page.newest_id ?? this.messages[this.messages.length - 1]?.id ?? null;
|
||||
this.hasMoreBefore = page.has_more_before;
|
||||
this.hasMoreAfter = page.has_more_after;
|
||||
},
|
||||
|
||||
updateLocalBoundaries() {
|
||||
this.oldestId = this.messages[0]?.id ?? null;
|
||||
this.newestId = this.messages[this.messages.length - 1]?.id ?? null;
|
||||
},
|
||||
|
||||
async fetchMessages(channelId: string) {
|
||||
const requestVersion = ++this.requestVersion;
|
||||
this.activeChannelId = channelId;
|
||||
this.messages = [];
|
||||
this.oldestId = null;
|
||||
this.newestId = null;
|
||||
this.hasMoreBefore = false;
|
||||
this.hasMoreAfter = false;
|
||||
this.isAtBottom = true;
|
||||
this.loading = true;
|
||||
|
||||
// Query params
|
||||
let params = new URLSearchParams();
|
||||
params.append("channel_id", channel_id);
|
||||
const queryString = params.toString();
|
||||
|
||||
try {
|
||||
const api = useApi();
|
||||
// Utilisation du paramètre pour cibler le channel
|
||||
const response = await api.get(`/messages${queryString ? `?${queryString}` : ""}`);
|
||||
this.messages = await response.json();
|
||||
const page = await requestPage(channelId, {limit: MESSAGE_WINDOW_SIZE});
|
||||
if (requestVersion !== this.requestVersion || this.activeChannelId !== channelId) return;
|
||||
|
||||
this.messages = mergeMessages(page.messages).slice(-MESSAGE_WINDOW_SIZE);
|
||||
this.updateBoundaries(page);
|
||||
this.scrollToBottomRequested = true;
|
||||
} catch (error) {
|
||||
if (requestVersion === this.requestVersion) {
|
||||
console.error("Erreur lors du chargement des messages:", error);
|
||||
}
|
||||
} finally {
|
||||
if (requestVersion === this.requestVersion) {
|
||||
this.loading = false;
|
||||
}
|
||||
}
|
||||
},
|
||||
async sendMessage(channelId: string, content: string) {
|
||||
const api = useApi();
|
||||
console.log("channelId", channelId);
|
||||
try {
|
||||
// Envoi au serveur pour persistance
|
||||
const response = await api.post('/messages', {
|
||||
channel_id: channelId,
|
||||
content: content,
|
||||
reply_to_id: null
|
||||
});
|
||||
const newMessage = await response.json();
|
||||
|
||||
// Ajout local immédiat (optimistic update)
|
||||
// this.messages.push(newMessage);
|
||||
async fetchBefore(channelId: string): Promise<WindowChange | null> {
|
||||
if (
|
||||
this.activeChannelId !== channelId ||
|
||||
!this.oldestId ||
|
||||
!this.hasMoreBefore ||
|
||||
this.loadingBefore ||
|
||||
this.loadingAfter
|
||||
) return null;
|
||||
|
||||
const requestVersion = this.requestVersion;
|
||||
const previousIds = new Set(this.messages.map(message => message.id));
|
||||
this.loadingBefore = true;
|
||||
|
||||
try {
|
||||
const page = await requestPage(channelId, {
|
||||
limit: MESSAGE_SHIFT_SIZE,
|
||||
before_id: this.oldestId,
|
||||
});
|
||||
if (requestVersion !== this.requestVersion || this.activeChannelId !== channelId) return null;
|
||||
|
||||
const incoming = mergeMessages(page.messages);
|
||||
const merged = mergeMessages([...incoming, ...this.messages]);
|
||||
this.messages = merged.slice(0, MESSAGE_WINDOW_SIZE);
|
||||
this.updateBoundaries(page);
|
||||
this.oldestId = this.messages[0]?.id ?? null;
|
||||
this.newestId = this.messages[this.messages.length - 1]?.id ?? null;
|
||||
|
||||
return {
|
||||
addedIds: incoming.filter(message => !previousIds.has(message.id)).map(message => message.id),
|
||||
removedIds: merged.slice(0, -MESSAGE_WINDOW_SIZE).map(message => message.id),
|
||||
};
|
||||
} catch (error) {
|
||||
console.error("Erreur lors du chargement des messages précédents:", error);
|
||||
return null;
|
||||
} finally {
|
||||
if (requestVersion === this.requestVersion) {
|
||||
this.loadingBefore = false;
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
async fetchAfter(channelId: string): Promise<WindowChange | null> {
|
||||
if (
|
||||
this.activeChannelId !== channelId ||
|
||||
!this.newestId ||
|
||||
!this.hasMoreAfter ||
|
||||
this.loadingBefore ||
|
||||
this.loadingAfter
|
||||
) return null;
|
||||
|
||||
const requestVersion = this.requestVersion;
|
||||
const previousIds = new Set(this.messages.map(message => message.id));
|
||||
this.loadingAfter = true;
|
||||
|
||||
try {
|
||||
const page = await requestPage(channelId, {
|
||||
limit: MESSAGE_SHIFT_SIZE,
|
||||
after_id: this.newestId,
|
||||
});
|
||||
if (requestVersion !== this.requestVersion || this.activeChannelId !== channelId) return null;
|
||||
|
||||
const incoming = mergeMessages(page.messages);
|
||||
const merged = mergeMessages([...this.messages, ...incoming]);
|
||||
this.messages = merged.slice(-MESSAGE_WINDOW_SIZE);
|
||||
this.updateBoundaries(page);
|
||||
this.oldestId = this.messages[0]?.id ?? null;
|
||||
this.newestId = this.messages[this.messages.length - 1]?.id ?? null;
|
||||
|
||||
return {
|
||||
addedIds: incoming.filter(message => !previousIds.has(message.id)).map(message => message.id),
|
||||
removedIds: merged.slice(0, Math.max(0, merged.length - MESSAGE_WINDOW_SIZE)).map(message => message.id),
|
||||
};
|
||||
} catch (error) {
|
||||
console.error("Erreur lors du chargement des messages suivants:", error);
|
||||
return null;
|
||||
} finally {
|
||||
if (requestVersion === this.requestVersion) {
|
||||
this.loadingAfter = false;
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
async sendMessage(channelId: string, content: string) {
|
||||
try {
|
||||
const response = await useApi().post("/messages", {
|
||||
channel_id: channelId,
|
||||
content,
|
||||
reply_to_id: null,
|
||||
});
|
||||
if (!response.ok) {
|
||||
throw new Error(`Message sending failed (${response.status})`);
|
||||
}
|
||||
|
||||
const newMessage = await response.json() as Message;
|
||||
this.addRealtimeMessage(newMessage);
|
||||
return newMessage;
|
||||
} catch (error) {
|
||||
console.error("Erreur lors de l'envoi du message:", error);
|
||||
throw error;
|
||||
}
|
||||
},
|
||||
|
||||
addRealtimeMessage(message: Message) {
|
||||
if (message.channel_id !== this.activeChannelId) return;
|
||||
|
||||
const existingIndex = this.messages.findIndex(current => current.id === message.id);
|
||||
if (existingIndex !== -1) {
|
||||
this.messages[existingIndex] = message;
|
||||
return;
|
||||
}
|
||||
|
||||
if (!this.isAtBottom && this.newestId && message.id > this.newestId) {
|
||||
this.hasMoreAfter = true;
|
||||
return;
|
||||
}
|
||||
|
||||
this.messages = mergeMessages([...this.messages, message]).slice(-MESSAGE_WINDOW_SIZE);
|
||||
this.updateLocalBoundaries();
|
||||
this.hasMoreAfter = false;
|
||||
if (this.isAtBottom) {
|
||||
this.scrollToBottomRequested = true;
|
||||
}
|
||||
},
|
||||
|
||||
updateMessage(message: Message) {
|
||||
if (message.channel_id !== this.activeChannelId) return;
|
||||
const index = this.messages.findIndex(current => current.id === message.id);
|
||||
if (index !== -1) this.messages[index] = message;
|
||||
},
|
||||
|
||||
removeMessage(id: string) {
|
||||
const index = this.messages.findIndex(message => message.id === id);
|
||||
if (index === -1) return;
|
||||
this.messages.splice(index, 1);
|
||||
this.updateLocalBoundaries();
|
||||
},
|
||||
|
||||
setAtBottom(value: boolean) {
|
||||
this.isAtBottom = value;
|
||||
},
|
||||
|
||||
consumeScrollToBottomRequest() {
|
||||
const requested = this.scrollToBottomRequested;
|
||||
this.scrollToBottomRequested = false;
|
||||
return requested;
|
||||
},
|
||||
|
||||
reset() {
|
||||
this.requestVersion += 1;
|
||||
this.messages = [];
|
||||
}
|
||||
}
|
||||
this.activeChannelId = null;
|
||||
this.oldestId = null;
|
||||
this.newestId = null;
|
||||
this.hasMoreBefore = false;
|
||||
this.hasMoreAfter = false;
|
||||
this.loading = false;
|
||||
this.loadingBefore = false;
|
||||
this.loadingAfter = false;
|
||||
this.isAtBottom = true;
|
||||
this.scrollToBottomRequested = false;
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
onGatewayEvent("Message", (payload) => {
|
||||
const store = useMessageStore();
|
||||
|
||||
switch (payload.action) {
|
||||
case "add":
|
||||
const exists = store.messages.some(m => m.id === payload.content.id);
|
||||
if (!exists) {
|
||||
store.messages.push(payload.content);
|
||||
}
|
||||
store.addRealtimeMessage(payload.content as Message);
|
||||
break;
|
||||
case "update":
|
||||
const updateIndex = store.messages.findIndex(m => m.id === payload.content.id);
|
||||
if (updateIndex !== -1) {
|
||||
store.messages[updateIndex] = payload.content;
|
||||
}
|
||||
store.updateMessage(payload.content as Message);
|
||||
break;
|
||||
case "remove":
|
||||
const removeIndex = store.messages.findIndex(m => m.id === payload.content);
|
||||
if (removeIndex !== -1) {
|
||||
store.messages.splice(removeIndex, 1);
|
||||
}
|
||||
store.removeMessage(String(payload.content));
|
||||
break;
|
||||
default:
|
||||
console.warn("Action non gérée :", payload.action);
|
||||
}
|
||||
})
|
||||
});
|
||||
|
||||
@@ -1,12 +1,16 @@
|
||||
pub use sea_orm_migration::prelude::*;
|
||||
|
||||
mod m20220101_000001_create_table;
|
||||
mod m20260808_000002_add_message_channel_id_id_index;
|
||||
|
||||
pub struct Migrator;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl MigratorTrait for Migrator {
|
||||
fn migrations() -> Vec<Box<dyn MigrationTrait>> {
|
||||
vec![Box::new(m20220101_000001_create_table::Migration)]
|
||||
vec![
|
||||
Box::new(m20220101_000001_create_table::Migration),
|
||||
Box::new(m20260808_000002_add_message_channel_id_id_index::Migration),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
use sea_orm_migration::prelude::*;
|
||||
|
||||
#[derive(DeriveMigrationName)]
|
||||
pub struct Migration;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl MigrationTrait for Migration {
|
||||
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
|
||||
manager
|
||||
.create_index(
|
||||
Index::create()
|
||||
.name("idx_message_channel_id_id")
|
||||
.table(Alias::new("message"))
|
||||
.col(Alias::new("channel_id"))
|
||||
.col(Alias::new("id"))
|
||||
.to_owned(),
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
|
||||
manager
|
||||
.drop_index(
|
||||
Index::drop()
|
||||
.name("idx_message_channel_id_id")
|
||||
.table(Alias::new("message"))
|
||||
.to_owned(),
|
||||
)
|
||||
.await
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,215 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Generate test messages directly in the project's SQLite database."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import random
|
||||
import sqlite3
|
||||
import time
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
WORD_POOL = (
|
||||
"message", "canal", "serveur", "utilisateur", "test", "donnee", "histoire",
|
||||
"discussion", "contenu", "generation", "curseur", "fenetre", "lecture",
|
||||
"chargement", "conversation", "exemple", "texte", "systeme", "application",
|
||||
"client", "serveur", "base", "requete", "resultat", "information", "session",
|
||||
"connexion", "fonction", "version", "contenu", "rapide", "simple", "aleatoire",
|
||||
"important", "nouveau", "ancien", "prochain", "precedent", "visible", "local",
|
||||
"distant", "stable", "chronologique", "variable", "longueur", "performance",
|
||||
"validation", "operation", "transaction", "historique", "position", "defilement",
|
||||
)
|
||||
MESSAGE_MARKER_FORMAT = "[{number:04d}]"
|
||||
|
||||
|
||||
def positive_int(value: str) -> int:
|
||||
parsed = int(value)
|
||||
if parsed <= 0:
|
||||
raise argparse.ArgumentTypeError("must be greater than zero")
|
||||
return parsed
|
||||
|
||||
|
||||
def parse_uuid(value: str, option_name: str) -> uuid.UUID:
|
||||
try:
|
||||
return uuid.UUID(value)
|
||||
except ValueError as error:
|
||||
raise argparse.ArgumentTypeError(f"{option_name} is not a valid UUID: {value}") from error
|
||||
|
||||
|
||||
def next_uuid(previous: uuid.UUID | None) -> uuid.UUID:
|
||||
"""Return a UUID v7 strictly greater than the previous generated ID."""
|
||||
generated = uuid.uuid7()
|
||||
if previous is not None and generated.int <= previous.int:
|
||||
generated = uuid.UUID(int=previous.int + 1)
|
||||
return generated
|
||||
|
||||
|
||||
def random_message(
|
||||
rng: random.Random,
|
||||
min_words: int,
|
||||
max_words: int,
|
||||
marker: str,
|
||||
) -> str:
|
||||
# The marker itself counts as one word in the requested range.
|
||||
body_count = rng.randint(max(0, min_words - 1), max_words - 1)
|
||||
body = " ".join(rng.choices(WORD_POOL, k=body_count))
|
||||
return f"{marker} {body}".rstrip()
|
||||
|
||||
|
||||
def build_parser() -> argparse.ArgumentParser:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument(
|
||||
"--db",
|
||||
type=Path,
|
||||
default=Path("oxspeak.db"),
|
||||
help="SQLite database path (default: oxspeak.db)",
|
||||
)
|
||||
parser.add_argument("--channel-id", required=True, help="target channel UUID")
|
||||
parser.add_argument("--user-id", required=True, help="author user UUID")
|
||||
parser.add_argument(
|
||||
"--count",
|
||||
required=True,
|
||||
type=positive_int,
|
||||
help="number of messages to insert",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--min-words",
|
||||
type=positive_int,
|
||||
default=10,
|
||||
help="minimum number of words per message (default: 10)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--max-words",
|
||||
type=positive_int,
|
||||
default=500,
|
||||
help="maximum number of words per message (default: 500)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--seed",
|
||||
type=int,
|
||||
default=None,
|
||||
help="optional seed to reproduce generated contents",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--batch-size",
|
||||
type=positive_int,
|
||||
default=500,
|
||||
help="number of rows inserted per batch (default: 500)",
|
||||
)
|
||||
return parser
|
||||
|
||||
|
||||
def ensure_target_exists(
|
||||
connection: sqlite3.Connection,
|
||||
table: str,
|
||||
identifier: bytes,
|
||||
label: str,
|
||||
) -> None:
|
||||
row = connection.execute(
|
||||
f'SELECT 1 FROM "{table}" WHERE id = ? LIMIT 1',
|
||||
(identifier,),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise ValueError(f"{label} does not exist in the database")
|
||||
|
||||
|
||||
def generate_messages(
|
||||
database: Path,
|
||||
channel_id: uuid.UUID,
|
||||
user_id: uuid.UUID,
|
||||
count: int,
|
||||
batch_size: int,
|
||||
min_words: int,
|
||||
max_words: int,
|
||||
seed: int | None,
|
||||
) -> None:
|
||||
started_at = time.monotonic()
|
||||
connection = sqlite3.connect(database)
|
||||
connection.execute("PRAGMA foreign_keys = ON")
|
||||
connection.execute("PRAGMA busy_timeout = 5000")
|
||||
|
||||
try:
|
||||
ensure_target_exists(connection, "channel", channel_id.bytes, "channel")
|
||||
ensure_target_exists(connection, "user", user_id.bytes, "user")
|
||||
|
||||
previous_id: uuid.UUID | None = None
|
||||
inserted = 0
|
||||
rng = random.Random(seed)
|
||||
|
||||
connection.execute("BEGIN")
|
||||
try:
|
||||
while inserted < count:
|
||||
current_batch_size = min(batch_size, count - inserted)
|
||||
rows = []
|
||||
|
||||
for offset in range(current_batch_size):
|
||||
message_id = next_uuid(previous_id)
|
||||
previous_id = message_id
|
||||
message_number = inserted + offset + 1
|
||||
marker = MESSAGE_MARKER_FORMAT.format(number=message_number)
|
||||
content = random_message(rng, min_words, max_words, marker)
|
||||
created_at = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
|
||||
rows.append(
|
||||
(
|
||||
message_id.bytes,
|
||||
channel_id.bytes,
|
||||
user_id.bytes,
|
||||
content,
|
||||
created_at,
|
||||
None,
|
||||
None,
|
||||
)
|
||||
)
|
||||
|
||||
connection.executemany(
|
||||
"""
|
||||
INSERT INTO message
|
||||
(id, channel_id, user_id, content, created_at, updated_at, reply_to_id)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?)
|
||||
""",
|
||||
rows,
|
||||
)
|
||||
inserted += current_batch_size
|
||||
|
||||
connection.commit()
|
||||
except Exception:
|
||||
connection.rollback()
|
||||
raise
|
||||
finally:
|
||||
connection.close()
|
||||
|
||||
elapsed = time.monotonic() - started_at
|
||||
print(f"Inserted {count} messages into {database} in {elapsed:.2f}s")
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = build_parser()
|
||||
args = parser.parse_args()
|
||||
|
||||
if args.max_words < args.min_words:
|
||||
parser.error("--max-words must be greater than or equal to --min-words")
|
||||
|
||||
try:
|
||||
channel_id = parse_uuid(args.channel_id, "--channel-id")
|
||||
user_id = parse_uuid(args.user_id, "--user-id")
|
||||
generate_messages(
|
||||
database=args.db,
|
||||
channel_id=channel_id,
|
||||
user_id=user_id,
|
||||
count=args.count,
|
||||
batch_size=args.batch_size,
|
||||
min_words=args.min_words,
|
||||
max_words=args.max_words,
|
||||
seed=args.seed,
|
||||
)
|
||||
except (OSError, sqlite3.Error, ValueError) as error:
|
||||
parser.error(str(error))
|
||||
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
+12
-12
@@ -14,6 +14,15 @@ pub struct MessageResponse {
|
||||
pub reply_to_id: Option<Uuid>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, ToSchema)]
|
||||
pub struct MessagePageResponse {
|
||||
pub messages: Vec<MessageResponse>,
|
||||
pub oldest_id: Option<Uuid>,
|
||||
pub newest_id: Option<Uuid>,
|
||||
pub has_more_before: bool,
|
||||
pub has_more_after: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize, ToSchema)]
|
||||
pub struct CreateMessageRequest {
|
||||
pub channel_id: Uuid,
|
||||
@@ -26,19 +35,10 @@ pub struct UpdateMessageRequest {
|
||||
pub content: String,
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(Debug, serde::Deserialize, utoipa::IntoParams)]
|
||||
pub struct MessageQueryParams {
|
||||
pub channel_id: Option<uuid::Uuid>,
|
||||
pub channel_id: Uuid,
|
||||
pub before_id: Option<Uuid>,
|
||||
pub after_id: Option<Uuid>,
|
||||
pub limit: Option<u64>,
|
||||
}
|
||||
|
||||
impl Default for MessageQueryParams {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
channel_id: None,
|
||||
before_id: None,
|
||||
limit: Some(50),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,9 +1,18 @@
|
||||
use super::types::MessageFilter;
|
||||
use crate::models::{channel, message};
|
||||
use crate::models::message;
|
||||
use crate::repositories::{AnyResult, RepositoryContext};
|
||||
use event_bus::Scope;
|
||||
use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QueryOrder, QuerySelect};
|
||||
use std::sync::Arc;
|
||||
use uuid::Uuid;
|
||||
|
||||
const DEFAULT_MESSAGE_LIMIT: u64 = 20;
|
||||
pub const MAX_MESSAGE_LIMIT: u64 = 100;
|
||||
|
||||
pub struct MessagePage {
|
||||
pub messages: Vec<message::Model>,
|
||||
pub has_more_before: bool,
|
||||
pub has_more_after: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct MessageRepository {
|
||||
@@ -21,7 +30,11 @@ impl MessageRepository {
|
||||
.await?)
|
||||
}
|
||||
|
||||
pub async fn filter(&self, filter: MessageFilter) -> AnyResult<Vec<message::Model>> {
|
||||
pub async fn filter(&self, filter: MessageFilter) -> AnyResult<MessagePage> {
|
||||
let limit = filter
|
||||
.limit
|
||||
.unwrap_or(DEFAULT_MESSAGE_LIMIT)
|
||||
.clamp(1, MAX_MESSAGE_LIMIT);
|
||||
let mut query = message::Entity::find();
|
||||
|
||||
if let Some(channel_id) = filter.channel_id {
|
||||
@@ -32,11 +45,80 @@ impl MessageRepository {
|
||||
query = query.filter(message::Column::Id.lt(before_id));
|
||||
}
|
||||
|
||||
if let Some(limit) = filter.limit {
|
||||
query = query.order_by_desc(message::Column::Id).limit(limit);
|
||||
if let Some(after_id) = filter.after_id {
|
||||
query = query
|
||||
.filter(message::Column::Id.gt(after_id))
|
||||
.order_by_asc(message::Column::Id);
|
||||
} else {
|
||||
query = query.order_by_desc(message::Column::Id);
|
||||
}
|
||||
|
||||
Ok(query.all(&self.context.db).await?)
|
||||
let mut messages = query.limit(limit + 1).all(&self.context.db).await?;
|
||||
let has_more_in_direction = messages.len() > limit as usize;
|
||||
messages.truncate(limit as usize);
|
||||
|
||||
// Queries that walk backwards are executed in descending order so the
|
||||
// database can stop as soon as it has found the requested rows. The UI
|
||||
// always receives chronological order.
|
||||
if filter.after_id.is_none() {
|
||||
messages.reverse();
|
||||
}
|
||||
|
||||
let (has_more_before, has_more_after) = if filter.after_id.is_some() {
|
||||
let has_messages_before = self
|
||||
.exists_on_or_before(filter.channel_id, filter.after_id.unwrap())
|
||||
.await?;
|
||||
(has_messages_before, has_more_in_direction)
|
||||
} else if filter.before_id.is_some() {
|
||||
let has_messages_after = self
|
||||
.exists_on_or_after(filter.channel_id, filter.before_id.unwrap())
|
||||
.await?;
|
||||
(has_more_in_direction, has_messages_after)
|
||||
} else {
|
||||
(has_more_in_direction, false)
|
||||
};
|
||||
|
||||
Ok(MessagePage {
|
||||
messages,
|
||||
has_more_before,
|
||||
has_more_after,
|
||||
})
|
||||
}
|
||||
|
||||
async fn exists_on_or_before(&self, channel_id: Option<Uuid>, id: Uuid) -> AnyResult<bool> {
|
||||
let mut query = message::Entity::find()
|
||||
.select_only()
|
||||
.column(message::Column::Id)
|
||||
.filter(message::Column::Id.lte(id));
|
||||
|
||||
if let Some(channel_id) = channel_id {
|
||||
query = query.filter(message::Column::ChannelId.eq(channel_id));
|
||||
}
|
||||
|
||||
Ok(query
|
||||
.limit(1)
|
||||
.into_tuple::<Uuid>()
|
||||
.one(&self.context.db)
|
||||
.await?
|
||||
.is_some())
|
||||
}
|
||||
|
||||
async fn exists_on_or_after(&self, channel_id: Option<Uuid>, id: Uuid) -> AnyResult<bool> {
|
||||
let mut query = message::Entity::find()
|
||||
.select_only()
|
||||
.column(message::Column::Id)
|
||||
.filter(message::Column::Id.gte(id));
|
||||
|
||||
if let Some(channel_id) = channel_id {
|
||||
query = query.filter(message::Column::ChannelId.eq(channel_id));
|
||||
}
|
||||
|
||||
Ok(query
|
||||
.limit(1)
|
||||
.into_tuple::<Uuid>()
|
||||
.one(&self.context.db)
|
||||
.await?
|
||||
.is_some())
|
||||
}
|
||||
|
||||
pub async fn get_by_channel(&self, channel_id: uuid::Uuid) -> AnyResult<Vec<message::Model>> {
|
||||
|
||||
@@ -24,6 +24,7 @@ pub struct ServerTree {
|
||||
pub struct MessageFilter {
|
||||
pub channel_id: Option<uuid::Uuid>,
|
||||
pub before_id: Option<uuid::Uuid>,
|
||||
pub after_id: Option<uuid::Uuid>,
|
||||
pub limit: Option<u64>,
|
||||
}
|
||||
|
||||
|
||||
@@ -1,21 +1,25 @@
|
||||
use crate::domain::dto::message::{CreateMessageRequest, MessageQueryParams, MessageResponse, UpdateMessageRequest};
|
||||
use crate::core::state::AppState;
|
||||
use crate::domain::dto::message::{
|
||||
CreateMessageRequest, MessagePageResponse, MessageQueryParams, MessageResponse,
|
||||
UpdateMessageRequest,
|
||||
};
|
||||
use crate::http::context::CurrentUser;
|
||||
use crate::http::error::HTTPError;
|
||||
use crate::routes::message::mapper;
|
||||
use axum::{
|
||||
Json,
|
||||
extract::{Path, Query, State},
|
||||
http::StatusCode,
|
||||
Json,
|
||||
};
|
||||
use uuid::Uuid;
|
||||
|
||||
/// Liste tous les messages
|
||||
/// Liste une fenêtre paginée de messages
|
||||
#[utoipa::path(
|
||||
get,
|
||||
path = "/messages",
|
||||
responses(
|
||||
(status = 200, description = "Liste des messages récupérée avec succès", body = [MessageResponse]),
|
||||
(status = 200, description = "Fenêtre de messages récupérée avec succès", body = MessagePageResponse),
|
||||
(status = 400, description = "Curseurs incompatibles ou canal manquant"),
|
||||
(status = 500, description = "Erreur interne du serveur")
|
||||
),
|
||||
params(
|
||||
@@ -26,15 +30,29 @@ use uuid::Uuid;
|
||||
pub async fn get_all(
|
||||
State(state): State<AppState>,
|
||||
Query(filters): Query<MessageQueryParams>,
|
||||
) -> Result<Json<Vec<MessageResponse>>, HTTPError> {
|
||||
) -> Result<Json<MessagePageResponse>, HTTPError> {
|
||||
if filters.before_id.is_some() && filters.after_id.is_some() {
|
||||
return Err(HTTPError::BadRequest(
|
||||
"before_id and after_id cannot be used together".to_string(),
|
||||
));
|
||||
}
|
||||
|
||||
let params = mapper::query_params_to_message_filter(filters);
|
||||
let messages = state.repositories.message.filter(params).await?;
|
||||
Ok(Json(
|
||||
messages
|
||||
let page = state.repositories.message.filter(params).await?;
|
||||
let oldest_id = page.messages.first().map(|message| message.id);
|
||||
let newest_id = page.messages.last().map(|message| message.id);
|
||||
|
||||
Ok(Json(MessagePageResponse {
|
||||
messages: page
|
||||
.messages
|
||||
.into_iter()
|
||||
.map(mapper::message_model_to_message_response)
|
||||
.collect(),
|
||||
))
|
||||
oldest_id,
|
||||
newest_id,
|
||||
has_more_before: page.has_more_before,
|
||||
has_more_after: page.has_more_after,
|
||||
}))
|
||||
}
|
||||
|
||||
/// Récupère un message par son ID
|
||||
@@ -105,7 +123,11 @@ pub async fn create(
|
||||
))?;
|
||||
}
|
||||
|
||||
let message = state.services.message.create_message(payload.channel_id, user.id, payload.content).await?;
|
||||
let message = state
|
||||
.services
|
||||
.message
|
||||
.create_message(payload.channel_id, user.id, payload.content)
|
||||
.await?;
|
||||
Ok((
|
||||
StatusCode::CREATED,
|
||||
Json(mapper::message_model_to_message_response(message)),
|
||||
@@ -150,7 +172,11 @@ pub async fn update(
|
||||
return Err(HTTPError::Forbidden);
|
||||
}
|
||||
|
||||
let message = state.services.message.update_message(id, payload.content).await?;
|
||||
let message = state
|
||||
.services
|
||||
.message
|
||||
.update_message(id, payload.content)
|
||||
.await?;
|
||||
|
||||
Ok(Json(mapper::message_model_to_message_response(message)))
|
||||
}
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
use crate::models::message;
|
||||
use crate::repositories::types::MessageFilter;
|
||||
use crate::domain::dto::message::{
|
||||
CreateMessageRequest, MessageQueryParams, MessageResponse, UpdateMessageRequest,
|
||||
};
|
||||
use crate::models::message;
|
||||
use crate::repositories::types::MessageFilter;
|
||||
use chrono::Utc;
|
||||
use sea_orm::Set;
|
||||
use uuid::Uuid;
|
||||
@@ -48,8 +48,9 @@ pub fn update_request_to_am(
|
||||
|
||||
pub fn query_params_to_message_filter(params: MessageQueryParams) -> MessageFilter {
|
||||
MessageFilter {
|
||||
channel_id: params.channel_id,
|
||||
channel_id: Some(params.channel_id),
|
||||
before_id: params.before_id,
|
||||
after_id: params.after_id,
|
||||
limit: params.limit,
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user