3 and 4 completed

apps/admin/src/app/api/recommendations/generate/route.ts

@@ -6,7 +6,7 @@ import log from "@/lib/logger";
 
 export async function POST(req: Request) {
   try {
-    const { userId, useExternalModel } = await req.json();
+    const { userId, useExternalModel, modelProvider } = await req.json();
 
     if (!userId) {
       return NextResponse.json(
@@ -43,7 +43,78 @@ export async function POST(req: Request) {
 
     let parsedResponse;
 
-    if (useExternalModel) {
+    // Determine which AI provider to use
+    const provider =
+      modelProvider || (useExternalModel ? "deepseek" : "ollama");
+
+    if (provider === "openai") {
+      // Use OpenAI
+      const openaiApiKey = process.env.OPENAI_API_KEY;
+
+      if (!openaiApiKey) {
+        return NextResponse.json(
+          { error: "OpenAI API key not configured" },
+          { status: 500 },
+        );
+      }
+
+      log.debug("Using OpenAI model", { userId });
+
+      const openaiResponse = await fetch(
+        "https://api.openai.com/v1/chat/completions",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${openaiApiKey}`,
+          },
+          body: JSON.stringify({
+            model: "gpt-4o-mini",
+            messages: [
+              {
+                role: "system",
+                content:
+                  'You are a professional fitness trainer and nutritionist. Always respond with valid JSON only, no markdown or code blocks. The response must have this exact structure: {"recommendationText": "string", "activityPlan": "string", "dietPlan": "string"}',
+              },
+              {
+                role: "user",
+                content: prompt,
+              },
+            ],
+            temperature: 0.7,
+            max_tokens: 1500,
+            response_format: { type: "json_object" },
+          }),
+        },
+      );
+
+      if (!openaiResponse.ok) {
+        const errorText = await openaiResponse.text();
+        log.error("OpenAI API request failed", new Error(errorText), {
+          status: openaiResponse.status,
+        });
+        return NextResponse.json(
+          { error: "Failed to generate recommendation from OpenAI" },
+          { status: 500 },
+        );
+      }
+
+      const openaiData = await openaiResponse.json();
+      log.debug("Received OpenAI response", { openaiData });
+
+      try {
+        const content = openaiData.choices[0].message.content;
+        parsedResponse = JSON.parse(content);
+      } catch (e) {
+        log.error("Failed to parse OpenAI response", e, {
+          response: openaiData,
+        });
+        return NextResponse.json(
+          { error: "Invalid response format from OpenAI" },
+          { status: 500 },
+        );
+      }
+    } else if (provider === "deepseek") {
       // Use DeepSeek AI
       const deepseekApiKey = process.env.DEEPSEEK_API_KEY;
 
@@ -203,11 +274,12 @@ export async function POST(req: Request) {
       id: crypto.randomUUID(),
       userId,
       fitnessProfileId: profile.id,
-      type: "ai_plan",
       recommendationText: parsedResponse.recommendationText,
       activityPlan: parsedResponse.activityPlan,
       dietPlan: parsedResponse.dietPlan,
       status: "pending",
+      generatedAt: new Date(),
+      updatedAt: new Date(),
     });
 
     return NextResponse.json(recommendation);

apps/admin/src/app/api/users/statistics/route.ts

@@ -0,0 +1,295 @@
+import { NextRequest, NextResponse } from "next/server";
+import { auth } from "@clerk/nextjs/server";
+import Database from "better-sqlite3";
+import log from "@/lib/logger";
+
+const db = new Database("./data/fitai.db");
+
+interface WeeklyStats {
+  week: string; // ISO week start date
+  checkIns: number;
+  goalsCompleted: number;
+  avgProgress: number;
+}
+
+interface GoalStats {
+  total: number;
+  active: number;
+  completed: number;
+  avgProgress: number;
+  byType: Record<string, number>;
+}
+
+interface AttendanceStats {
+  totalCheckIns: number;
+  currentStreak: number;
+  longestStreak: number;
+  thisWeek: number;
+  thisMonth: number;
+  recentCheckIns: Array<{
+    id: string;
+    checkInTime: string;
+    checkOutTime: string | null;
+    type: string;
+    duration?: number; // in minutes
+  }>;
+}
+
+interface DashboardStatistics {
+  goals: GoalStats;
+  attendance: AttendanceStats;
+  weeklyTrend: WeeklyStats[];
+}
+
+// GET - Fetch dashboard statistics for authenticated user
+export async function GET(request: NextRequest) {
+  try {
+    const { userId } = await auth();
+
+    if (!userId) {
+      return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+    }
+
+    log.debug("Fetching statistics for user", { userId });
+
+    // Get goal statistics
+    const goals = db
+      .prepare(
+        `SELECT 
+          goal_type as goalType,
+          status,
+          progress,
+          target_value as targetValue,
+          current_value as currentValue
+         FROM fitness_goals 
+         WHERE user_id = ?`,
+      )
+      .all(userId) as Array<{
+      goalType: string;
+      status: string;
+      progress: number;
+      targetValue: number | null;
+      currentValue: number | null;
+    }>;
+
+    const activeGoals = goals.filter((g) => g.status === "active");
+    const completedGoals = goals.filter((g) => g.status === "completed");
+
+    const goalsByType: Record<string, number> = {};
+    goals.forEach((goal) => {
+      goalsByType[goal.goalType] = (goalsByType[goal.goalType] || 0) + 1;
+    });
+
+    const avgProgress =
+      activeGoals.length > 0
+        ? activeGoals.reduce((sum, g) => sum + (g.progress || 0), 0) /
+          activeGoals.length
+        : 0;
+
+    const goalStats: GoalStats = {
+      total: goals.length,
+      active: activeGoals.length,
+      completed: completedGoals.length,
+      avgProgress: Math.round(avgProgress),
+      byType: goalsByType,
+    };
+
+    // Get attendance statistics
+    const attendanceRecords = db
+      .prepare(
+        `SELECT 
+          id,
+          check_in_time as checkInTime,
+          check_out_time as checkOutTime,
+          type
+         FROM attendance 
+         WHERE user_id = ?
+         ORDER BY check_in_time DESC`,
+      )
+      .all(userId) as Array<{
+      id: string;
+      checkInTime: string;
+      checkOutTime: string | null;
+      type: string;
+    }>;
+
+    const totalCheckIns = attendanceRecords.length;
+
+    // Get recent check-ins (last 10)
+    const recentCheckIns = attendanceRecords.slice(0, 10).map((record) => {
+      let duration: number | undefined;
+      if (record.checkOutTime) {
+        const checkIn = new Date(record.checkInTime).getTime();
+        const checkOut = new Date(record.checkOutTime).getTime();
+        duration = Math.round((checkOut - checkIn) / (1000 * 60)); // minutes
+      }
+      return {
+        ...record,
+        duration,
+      };
+    });
+
+    // Calculate this week's check-ins
+    const now = new Date();
+    const startOfWeek = new Date(now);
+    startOfWeek.setDate(now.getDate() - now.getDay()); // Sunday
+    startOfWeek.setHours(0, 0, 0, 0);
+
+    const thisWeekCheckIns = attendanceRecords.filter(
+      (r) => new Date(r.checkInTime) >= startOfWeek,
+    ).length;
+
+    // Calculate this month's check-ins
+    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+    const thisMonthCheckIns = attendanceRecords.filter(
+      (r) => new Date(r.checkInTime) >= startOfMonth,
+    ).length;
+
+    // Calculate current streak (consecutive days with check-ins)
+    let currentStreak = 0;
+    let longestStreak = 0;
+    let tempStreak = 0;
+    let lastDate: Date | null = null;
+
+    const sortedRecords = [...attendanceRecords].sort(
+      (a, b) =>
+        new Date(b.checkInTime).getTime() - new Date(a.checkInTime).getTime(),
+    );
+
+    const uniqueDays = new Set<string>();
+    sortedRecords.forEach((record) => {
+      const date = new Date(record.checkInTime);
+      const dateStr = date.toISOString().split("T")[0];
+      uniqueDays.add(dateStr);
+    });
+
+    const sortedDays = Array.from(uniqueDays).sort().reverse();
+
+    for (let i = 0; i < sortedDays.length; i++) {
+      const currentDate = new Date(sortedDays[i]);
+
+      if (lastDate === null) {
+        tempStreak = 1;
+        currentStreak = 1;
+      } else {
+        const dayDiff = Math.floor(
+          (lastDate.getTime() - currentDate.getTime()) / (1000 * 60 * 60 * 24),
+        );
+
+        if (dayDiff === 1) {
+          tempStreak++;
+          if (i === 0 || currentStreak > 0) {
+            currentStreak = tempStreak;
+          }
+        } else {
+          if (currentStreak === 0) {
+            currentStreak = 0;
+          }
+          tempStreak = 1;
+        }
+      }
+
+      longestStreak = Math.max(longestStreak, tempStreak);
+      lastDate = currentDate;
+    }
+
+    // Check if streak is still active (last check-in was today or yesterday)
+    if (sortedDays.length > 0) {
+      const lastCheckIn = new Date(sortedDays[0]);
+      const today = new Date();
+      today.setHours(0, 0, 0, 0);
+      const yesterday = new Date(today);
+      yesterday.setDate(yesterday.getDate() - 1);
+
+      lastCheckIn.setHours(0, 0, 0, 0);
+
+      if (
+        lastCheckIn.getTime() !== today.getTime() &&
+        lastCheckIn.getTime() !== yesterday.getTime()
+      ) {
+        currentStreak = 0;
+      }
+    }
+
+    const attendanceStats: AttendanceStats = {
+      totalCheckIns,
+      currentStreak,
+      longestStreak,
+      thisWeek: thisWeekCheckIns,
+      thisMonth: thisMonthCheckIns,
+      recentCheckIns,
+    };
+
+    // Calculate weekly trend (last 8 weeks)
+    const weeklyTrend: WeeklyStats[] = [];
+    for (let i = 7; i >= 0; i--) {
+      const weekStart = new Date(now);
+      weekStart.setDate(now.getDate() - now.getDay() - i * 7);
+      weekStart.setHours(0, 0, 0, 0);
+
+      const weekEnd = new Date(weekStart);
+      weekEnd.setDate(weekStart.getDate() + 7);
+
+      const weekCheckIns = attendanceRecords.filter((r) => {
+        const checkInDate = new Date(r.checkInTime);
+        return checkInDate >= weekStart && checkInDate < weekEnd;
+      }).length;
+
+      const weekGoalsCompleted = db
+        .prepare(
+          `SELECT COUNT(*) as count
+           FROM fitness_goals
+           WHERE user_id = ?
+           AND status = 'completed'
+           AND completed_date >= ?
+           AND completed_date < ?`,
+        )
+        .get(userId, weekStart.toISOString(), weekEnd.toISOString()) as {
+        count: number;
+      };
+
+      const weekActiveGoals = db
+        .prepare(
+          `SELECT progress
+           FROM fitness_goals
+           WHERE user_id = ?
+           AND status = 'active'
+           AND created_at < ?`,
+        )
+        .all(userId, weekEnd.toISOString()) as Array<{ progress: number }>;
+
+      const weekAvgProgress =
+        weekActiveGoals.length > 0
+          ? weekActiveGoals.reduce((sum, g) => sum + (g.progress || 0), 0) /
+            weekActiveGoals.length
+          : 0;
+
+      weeklyTrend.push({
+        week: weekStart.toISOString().split("T")[0],
+        checkIns: weekCheckIns,
+        goalsCompleted: weekGoalsCompleted.count,
+        avgProgress: Math.round(weekAvgProgress),
+      });
+    }
+
+    const statistics: DashboardStatistics = {
+      goals: goalStats,
+      attendance: attendanceStats,
+      weeklyTrend,
+    };
+
+    log.debug("Statistics calculated successfully", {
+      userId,
+      totalGoals: goalStats.total,
+      totalCheckIns,
+    });
+
+    return NextResponse.json({ statistics });
+  } catch (error) {
+    log.error("Failed to fetch statistics", error);
+    return NextResponse.json(
+      { error: "Failed to fetch statistics" },
+      { status: 500 },
+    );
+  }
+}

apps/admin/src/app/recommendations/page.tsx

@@ -39,15 +39,17 @@ export default function RecommendationsPage() {
 
   const fetchData = async () => {
     try {
-      // Fetch users
+      // Fetch users - API returns { success: true, data: { users: [...] }, meta: {...} }
       const usersRes = await fetch("/api/users");
-      const usersData = await usersRes.json();
-      setUsers(usersData.users || []);
+      const usersResult = await usersRes.json();
+      const usersArray = usersResult.data?.users || usersResult.users || [];
+      setUsers(usersArray);
 
-      // Fetch pending recommendations
+      // Fetch pending recommendations - API returns { success: true, data: { recommendations: [...] }, meta: {...} }
       const recsRes = await fetch("/api/recommendations");
-      const recsData = await recsRes.json();
-      const allRecs = recsData.recommendations || [];
+      const recsResult = await recsRes.json();
+      const allRecs =
+        recsResult.data?.recommendations || recsResult.recommendations || [];
       setPendingRecommendations(
         allRecs.filter((r: Recommendation) => r.status === "pending"),
       );