clean

components/dashboard/dashboard-users-list.tsx

@@ -12,6 +12,7 @@ import {
   LibreChatConversation,
   LibreChatTransaction,
   LibreChatBalance,
+  LibreChatMessage,
 } from "@/lib/types";
 
 interface DashboardUser {
@@ -37,21 +38,28 @@ export function DashboardUsersList() {
   const [topUsers, setTopUsers] = useState<DashboardUser[]>([]);
   const [isLoading, setIsLoading] = useState(true);
 
-  const { data: users, loading: usersLoading } = useCollection<LibreChatUser>('users');
+  // Récupérer toutes les données nécessaires
-  const { data: conversations, loading: conversationsLoading } = useCollection<LibreChatConversation>('conversations');
+  const { data: users, loading: usersLoading } = useCollection<LibreChatUser>("users");
-  const { data: transactions, loading: transactionsLoading } = useCollection<LibreChatTransaction>('transactions');
+  const { data: conversations, loading: conversationsLoading } = useCollection<LibreChatConversation>("conversations");
-  const { data: balances, loading: balancesLoading } = useCollection<LibreChatBalance>('balances');
+  const { data: transactions, loading: transactionsLoading } = useCollection<LibreChatTransaction>("transactions");
+  const { data: balances, loading: balancesLoading } = useCollection<LibreChatBalance>("balances");
+  const { data: messages, loading: messagesLoading } = useCollection<LibreChatMessage>("messages");
+  const { data: tokens, loading: tokensLoading } = useCollection("tokens");
+  const { data: toolcalls, loading: toolcallsLoading } = useCollection("toolcalls");
 
   const processUsers = useCallback(() => {
-    if (!users?.length || !conversations?.length || !transactions?.length || !balances?.length) {
+    if (!users?.length || !conversations?.length || !balances?.length || !messages?.length) {
       return;
     }
 
     console.log("🔄 Processing users data...");
     console.log("Users:", users.length);
     console.log("Conversations:", conversations.length);
-    console.log("Transactions:", transactions.length);
+    console.log("Transactions:", transactions?.length || 0);
     console.log("Balances:", balances.length);
+    console.log("Messages:", messages.length);
+    console.log("Tokens collection:", tokens?.length || 0);
+    console.log("Toolcalls collection:", toolcalls?.length || 0);
 
     const processedUsers: DashboardUser[] = [];
 
@@ -61,17 +69,46 @@ export function DashboardUsersList() {
         (conv: LibreChatConversation) => conv.user === user._id
       );
 
-      // Obtenir les transactions de l'utilisateur
+      // Obtenir les messages de l'utilisateur
-      const userTransactions = transactions.filter(
+      const userMessages = messages.filter(
-        (trans: LibreChatTransaction) => trans.user === user._id
+        (msg: LibreChatMessage) => msg.user === user._id
       );
 
-      // Calculer les tokens consommés
+      // Calculer les tokens depuis les messages
-      const totalTokens = userTransactions.reduce(
+      const totalTokensFromMessages = userMessages.reduce(
-        (sum: number, trans: LibreChatTransaction) => sum + (trans.rawAmount || 0),
+        (sum: number, msg: LibreChatMessage) => sum + (msg.tokenCount || 0),
         0
       );
 
+      // Calculer les tokens depuis les conversations de l'utilisateur
+      const userConversationIds = userConversations.map(conv => conv.conversationId);
+      const conversationMessages = messages.filter(
+        (msg: LibreChatMessage) => userConversationIds.includes(msg.conversationId)
+      );
+      
+      const totalTokensFromConversations = conversationMessages.reduce(
+        (sum: number, msg: LibreChatMessage) => sum + (msg.tokenCount || 0),
+        0
+      );
+
+      // Vérifier les collections tokens et toolcalls
+      let tokensFromTokensCollection = 0;
+      let tokensFromToolcalls = 0;
+
+      if (tokens?.length) {
+        const userTokens = tokens.filter((token: any) => token.user === user._id || token.userId === user._id);
+        tokensFromTokensCollection = userTokens.reduce((sum: number, token: any) => {
+          return sum + (token.amount || token.tokens || token.count || 0);
+        }, 0);
+      }
+
+      if (toolcalls?.length) {
+        const userToolcalls = toolcalls.filter((toolcall: any) => toolcall.user === user._id || toolcall.userId === user._id);
+        tokensFromToolcalls = userToolcalls.reduce((sum: number, toolcall: any) => {
+          return sum + (toolcall.tokens || toolcall.tokenCount || 0);
+        }, 0);
+      }
+
       // Obtenir les balances de l'utilisateur
       const userBalances = balances.filter(
         (balance: LibreChatBalance) => balance.user === user._id
@@ -99,6 +136,45 @@ export function DashboardUsersList() {
       const latestBalance = sortedBalances[0];
       const credits = latestBalance ? latestBalance.tokenCredits || 0 : 0;
 
+      // Calculer les tokens consommés depuis les crédits
+      const INITIAL_CREDITS = 5000000;
+      const creditsUsed = INITIAL_CREDITS - credits;
+      const tokensFromCredits = creditsUsed > 0 ? creditsUsed : 0;
+
+      // Prendre la valeur la plus élevée (plus précise)
+      const totalTokens = Math.max(
+        totalTokensFromMessages,
+        totalTokensFromConversations,
+        tokensFromTokensCollection,
+        tokensFromToolcalls,
+        tokensFromCredits
+      );
+
+      // Log de débogage très détaillé
+      console.log(`👤 User ${user.name || user.email}:`, {
+        conversations: userConversations.length,
+        userMessages: userMessages.length,
+        conversationMessages: conversationMessages.length,
+        tokensFromMessages: totalTokensFromMessages,
+        tokensFromConversations: totalTokensFromConversations,
+        tokensFromTokensCollection: tokensFromTokensCollection,
+        tokensFromToolcalls: tokensFromToolcalls,
+        currentCredits: credits,
+        creditsUsed: creditsUsed,
+        tokensFromCredits: tokensFromCredits,
+        finalTokens: totalTokens,
+        messagesSample: userMessages.slice(0, 2).map(m => ({ 
+          tokenCount: m.tokenCount, 
+          model: m.model,
+          isCreatedByUser: m.isCreatedByUser,
+          conversationId: m.conversationId
+        })),
+        conversationsSample: userConversations.slice(0, 2).map(c => ({
+          conversationId: c.conversationId,
+          messagesCount: c.messages?.length || 0
+        }))
+      });
+
       // Ajouter l'utilisateur seulement s'il a des données significatives
       if (userConversations.length > 0 || totalTokens > 0 || credits > 0) {
         processedUsers.push({
@@ -119,17 +195,17 @@ export function DashboardUsersList() {
     console.log("✅ Top 5 users processed:", sortedUsers);
     setTopUsers(sortedUsers);
     setIsLoading(false);
-  }, [users, conversations, transactions, balances]);
+  }, [users, conversations, transactions, balances, messages, tokens, toolcalls]);
 
   useEffect(() => {
-    const allDataLoaded = !usersLoading && !conversationsLoading && !transactionsLoading && !balancesLoading;
+    const allDataLoaded = !usersLoading && !conversationsLoading && !balancesLoading && !messagesLoading && !tokensLoading && !toolcallsLoading;
     
     if (allDataLoaded) {
       processUsers();
     } else {
       setIsLoading(true);
     }
-  }, [usersLoading, conversationsLoading, transactionsLoading, balancesLoading, processUsers]);
+  }, [usersLoading, conversationsLoading, balancesLoading, messagesLoading, tokensLoading, toolcallsLoading, processUsers]);
 
   if (isLoading) {
     return (