first commit

app/api/collections/[collection]/route.ts

@@ -0,0 +1,59 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDatabase } from '@/lib/db/mongodb';
+
+const ALLOWED_COLLECTIONS = [
+  'accessroles', 'aclentries', 'actions', 'agentcategories', 'agents',
+  'assistants', 'balances', 'banners', 'conversations', 'conversationtags',
+  'files', 'groups', 'keys', 'memoryentries', 'messages', 'pluginauths',
+  'presets', 'projects', 'promptgroups', 'prompts', 'roles', 'sessions',
+  'sharedlinks', 'tokens', 'toolcalls', 'transactions', 'users'
+];
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ collection: string }> }
+) {
+  const { collection } = await params;
+  
+  try {
+    
+    if (!ALLOWED_COLLECTIONS.includes(collection)) {
+      return NextResponse.json(
+        { error: 'Collection non autorisée' },
+        { status: 400 }
+      );
+    }
+
+    const { searchParams } = new URL(request.url);
+    const page = parseInt(searchParams.get('page') || '1');
+    const limit = parseInt(searchParams.get('limit') || '20');
+    const filter = JSON.parse(searchParams.get('filter') || '{}');
+
+    const db = await getDatabase();
+    const skip = (page - 1) * limit;
+
+    const [data, total] = await Promise.all([
+      db.collection(collection)
+        .find(filter)
+        .skip(skip)
+        .limit(limit)
+        .sort({ createdAt: -1 })
+        .toArray(),
+      db.collection(collection).countDocuments(filter)
+    ]);
+
+    return NextResponse.json({
+      data,
+      total,
+      page,
+      limit,
+      totalPages: Math.ceil(total / limit)
+    });
+  } catch (error) {
+    console.error(`Erreur lors de la récupération de ${collection}:`, error);
+    return NextResponse.json(
+      { error: 'Erreur serveur' },
+      { status: 500 }
+    );
+  }
+}

app/api/metrics/route.ts

@@ -0,0 +1,75 @@
+import { NextResponse } from "next/server";
+import { getDatabase } from "@/lib/db/mongodb";
+
+export async function GET() {
+  try {
+    const db = await getDatabase();
+
+    // Récupérer toutes les données nécessaires en parallèle
+    const [users, conversations, transactions, balances] = await Promise.all([
+      db.collection("users").find({}).toArray(),
+      db.collection("conversations").find({}).toArray(),
+      db.collection("transactions").find({}).toArray(),
+      db.collection("balances").find({}).toArray(),
+    ]);
+
+    // Calculer les utilisateurs actifs (dernière semaine)
+    const oneWeekAgo = new Date();
+    oneWeekAgo.setDate(oneWeekAgo.getDate() - 7);
+    const activeUsers = users.filter((user) => {
+      const lastActivity = new Date(user.updatedAt || user.createdAt);
+      return lastActivity >= oneWeekAgo;
+    }).length;
+
+    // Calculer les administrateurs
+    const totalAdmins = users.filter(user => user.role === 'ADMIN').length;
+
+    // Calculer les conversations actives (dernière semaine)
+    const activeConversations = conversations.filter((conv) => {
+      const lastActivity = new Date(conv.updatedAt || conv.createdAt);
+      return lastActivity >= oneWeekAgo;
+    }).length;
+
+    // Calculer le total des messages
+    const totalMessages = conversations.reduce(
+      (sum, conv) => sum + (Array.isArray(conv.messages) ? conv.messages.length : 0),
+      0
+    );
+
+    // Calculer le total des tokens depuis les transactions
+    const totalTokensConsumed = transactions.reduce((sum, transaction) => {
+      return sum + Math.abs(Number(transaction.rawAmount) || 0);
+    }, 0);
+
+    // Calculer le total des crédits depuis balances
+    const totalCredits = balances.reduce((sum, balance) => {
+      return sum + (Number(balance.tokenCredits) || 0);
+    }, 0);
+
+    // Récupérer les transactions récentes (dernières 10)
+    const recentTransactions = transactions
+      .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+      .slice(0, 10)
+      .map(transaction => ({
+        _id: transaction._id,
+        description: `Transaction ${transaction.tokenType} - ${transaction.model}`,
+        amount: transaction.rawAmount,
+        type: transaction.rawAmount > 0 ? 'credit' : 'debit',
+        createdAt: transaction.createdAt
+      }));
+
+    return NextResponse.json({
+      totalUsers: users.length,
+      activeUsers,
+      totalAdmins,
+      totalCredits,
+      activeConversations,
+      totalMessages: totalMessages,
+      totalTokensConsumed,
+      recentTransactions
+    });
+  } catch (error) {
+    console.error("Erreur lors du calcul des métriques:", error);
+    return NextResponse.json({ error: "Erreur serveur" }, { status: 500 });
+  }
+}

app/api/stats/route.ts

@@ -0,0 +1,61 @@
+import { NextResponse } from "next/server";
+import { getDatabase } from "@/lib/db/mongodb";
+
+export async function GET() {
+  try {
+    const db = await getDatabase();
+
+    // Récupérer toutes les transactions
+    const transactions = await db.collection("transactions").find({}).toArray();
+
+    // Calculer les tokens par jour (7 derniers jours)
+    const dailyStats = [];
+    const today = new Date();
+    const dayNames = ["Dim", "Lun", "Mar", "Mer", "Jeu", "Ven", "Sam"];
+    
+    for (let i = 6; i >= 0; i--) {
+      const date = new Date(today);
+      date.setDate(date.getDate() - i);
+      date.setHours(0, 0, 0, 0);
+      
+      const nextDate = new Date(date);
+      nextDate.setDate(nextDate.getDate() + 1);
+      
+      const dayTransactions = transactions.filter(transaction => {
+        const transactionDate = new Date(transaction.createdAt);
+        return transactionDate >= date && transactionDate < nextDate;
+      });
+      
+      const totalTokens = dayTransactions.reduce((sum, transaction) => {
+        return sum + Math.abs(Number(transaction.rawAmount) || 0);
+      }, 0);
+      
+      dailyStats.push({
+        name: dayNames[date.getDay()],
+        value: totalTokens
+      });
+    }
+
+    // Calculer la répartition par modèle (vraies données)
+    const modelStats = new Map<string, number>();
+    
+    transactions.forEach(transaction => {
+      const model = transaction.model || "Inconnu";
+      const tokens = Math.abs(Number(transaction.rawAmount) || 0);
+      modelStats.set(model, (modelStats.get(model) || 0) + tokens);
+    });
+
+    // Convertir en array et trier par usage
+    const modelData = Array.from(modelStats.entries())
+      .map(([name, value]) => ({ name, value }))
+      .sort((a, b) => b.value - a.value);
+
+    return NextResponse.json({
+      dailyTokens: dailyStats,
+      modelDistribution: modelData
+    });
+  } catch (error) {
+    console.error("Erreur lors du calcul des statistiques:", error);
+    return NextResponse.json({ error: "Erreur serveur" }, { status: 500 });
+  }
+}

app/api/user-activity/route.ts

@@ -0,0 +1,36 @@
+import { NextResponse } from "next/server";
+import { getDatabase } from "@/lib/db/mongodb";
+
+export async function GET() {
+  try {
+    const db = await getDatabase();
+
+    // Récupérer tous les utilisateurs
+    const users = await db.collection("users").find({}).toArray();
+
+    // Calculer les utilisateurs actifs (dernière semaine)
+    const oneWeekAgo = new Date();
+    oneWeekAgo.setDate(oneWeekAgo.getDate() - 7);
+
+    let activeUsers = 0;
+    let inactiveUsers = 0;
+
+    users.forEach(user => {
+      const lastActivity = new Date(user.updatedAt || user.createdAt);
+      if (lastActivity >= oneWeekAgo) {
+        activeUsers++;
+      } else {
+        inactiveUsers++;
+      }
+    });
+
+    return NextResponse.json({
+      activeUsers,
+      inactiveUsers,
+      totalUsers: users.length
+    });
+  } catch (error) {
+    console.error("Erreur lors du calcul de l'activité des utilisateurs:", error);
+    return NextResponse.json({ error: "Erreur serveur" }, { status: 500 });
+  }
+}