bug fix 41

src/app/api/messaging/mentorship/accept/route.ts

@@ -0,0 +1,87 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { db } from "@/db";
+import { mentorshipRequests, mentors, messages } from "@/db/schema";
+import { eq, and } from "drizzle-orm";
+import { v4 as uuidv4 } from "uuid";
+
+export async function POST(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const requestId = body.request_id || body.requestId;
+        const welcomeMessage = body.message || "Welcome! I'm excited to be your mentor.";
+
+        if (!requestId) {
+            return NextResponse.json({ error: "Request ID required" }, { status: 400 });
+        }
+
+        // Find the mentor record for this user
+        const mentorRecord = await db
+            .select({ id: mentors.id })
+            .from(mentors)
+            .where(eq(mentors.userId, user.id))
+            .limit(1);
+
+        if (!mentorRecord[0]) {
+            return NextResponse.json({ error: "You are not registered as a mentor" }, { status: 403 });
+        }
+
+        const mentorId = mentorRecord[0].id;
+
+        // Find the mentorship request
+        const mentorshipRequest = await db
+            .select()
+            .from(mentorshipRequests)
+            .where(
+                and(
+                    eq(mentorshipRequests.id, requestId),
+                    eq(mentorshipRequests.mentorId, mentorId),
+                    eq(mentorshipRequests.status, "pending")
+                )
+            )
+            .limit(1);
+
+        if (!mentorshipRequest[0]) {
+            return NextResponse.json({ error: "Request not found or already processed" }, { status: 404 });
+        }
+
+        const req = mentorshipRequest[0];
+
+        // Update request status to accepted
+        await db
+            .update(mentorshipRequests)
+            .set({ status: "accepted" })
+            .where(eq(mentorshipRequests.id, requestId));
+
+        // Send welcome message
+        if (welcomeMessage) {
+            await db.insert(messages).values({
+                id: uuidv4(),
+                senderId: user.id,
+                receiverId: req.menteeId,
+                content: `[Mentorship Welcome] ${welcomeMessage}`,
+                read: false,
+                timestamp: new Date().toISOString(),
+            });
+        }
+
+        console.log("[Accept Mentorship] Request", requestId, "accepted by mentor", user.id);
+
+        return NextResponse.json({ 
+            success: true, 
+            message: "Mentorship request accepted" 
+        });
+
+    } catch (error: any) {
+        console.error("POST /api/messaging/mentorship/accept error:", error);
+        return NextResponse.json({ 
+            error: "Internal server error",
+            details: error.message 
+        }, { status: 500 });
+    }
+}

src/app/api/messaging/mentorship/decline/route.ts

@@ -0,0 +1,87 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { db } from "@/db";
+import { mentorshipRequests, mentors, messages } from "@/db/schema";
+import { eq, and } from "drizzle-orm";
+import { v4 as uuidv4 } from "uuid";
+
+export async function POST(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const requestId = body.request_id || body.requestId;
+        const declineReason = body.reason || body.message || "";
+
+        if (!requestId) {
+            return NextResponse.json({ error: "Request ID required" }, { status: 400 });
+        }
+
+        // Find the mentor record for this user
+        const mentorRecord = await db
+            .select({ id: mentors.id })
+            .from(mentors)
+            .where(eq(mentors.userId, user.id))
+            .limit(1);
+
+        if (!mentorRecord[0]) {
+            return NextResponse.json({ error: "You are not registered as a mentor" }, { status: 403 });
+        }
+
+        const mentorId = mentorRecord[0].id;
+
+        // Find the mentorship request
+        const mentorshipRequest = await db
+            .select()
+            .from(mentorshipRequests)
+            .where(
+                and(
+                    eq(mentorshipRequests.id, requestId),
+                    eq(mentorshipRequests.mentorId, mentorId),
+                    eq(mentorshipRequests.status, "pending")
+                )
+            )
+            .limit(1);
+
+        if (!mentorshipRequest[0]) {
+            return NextResponse.json({ error: "Request not found or already processed" }, { status: 404 });
+        }
+
+        const req = mentorshipRequest[0];
+
+        // Update request status to declined
+        await db
+            .update(mentorshipRequests)
+            .set({ status: "declined" })
+            .where(eq(mentorshipRequests.id, requestId));
+
+        // Optionally send a message explaining the decline
+        if (declineReason) {
+            await db.insert(messages).values({
+                id: uuidv4(),
+                senderId: user.id,
+                receiverId: req.menteeId,
+                content: `[Mentorship Request Declined] ${declineReason}`,
+                read: false,
+                timestamp: new Date().toISOString(),
+            });
+        }
+
+        console.log("[Decline Mentorship] Request", requestId, "declined by mentor", user.id);
+
+        return NextResponse.json({ 
+            success: true, 
+            message: "Mentorship request declined" 
+        });
+
+    } catch (error: any) {
+        console.error("POST /api/messaging/mentorship/decline error:", error);
+        return NextResponse.json({ 
+            error: "Internal server error",
+            details: error.message 
+        }, { status: 500 });
+    }
+}

src/app/api/messaging/mentorship/requests/route.ts

@@ -1,7 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { getCurrentUser } from "@/lib/auth";
 import { db } from "@/db";
-import { mentorshipRequests, users } from "@/db/schema";
+import { mentorshipRequests, users, mentors } from "@/db/schema";
 import { eq, and } from "drizzle-orm";
 
 export async function GET(request: NextRequest) {
@@ -11,10 +11,28 @@ export async function GET(request: NextRequest) {
             return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
         }
 
+        // First, find the mentor record for this user (mentor.userId = user.id)
+        const mentorRecord = await db
+            .select({ id: mentors.id })
+            .from(mentors)
+            .where(eq(mentors.userId, user.id))
+            .limit(1);
+
+        // If no mentor record exists, return empty requests
+        if (!mentorRecord[0]) {
+            console.log("[Mentorship Requests] No mentor record found for user:", user.id);
+            return NextResponse.json({ requests: [] });
+        }
+
+        const mentorId = mentorRecord[0].id;
+        console.log("[Mentorship Requests] Found mentor record:", mentorId, "for user:", user.id);
+
+        // Now fetch requests where mentorId matches the mentor record's ID
         const requests = await db
             .select({
                 id: mentorshipRequests.id,
                 menteeId: mentorshipRequests.menteeId,
+                menteeUsername: mentorshipRequests.menteeUsername,
                 status: mentorshipRequests.status,
                 message: mentorshipRequests.message,
                 createdAt: mentorshipRequests.createdAt,
@@ -25,16 +43,18 @@ export async function GET(request: NextRequest) {
             .leftJoin(users, eq(mentorshipRequests.menteeId, users.id))
             .where(
                 and(
-                    eq(mentorshipRequests.mentorId, user.id),
+                    eq(mentorshipRequests.mentorId, mentorId),
                     eq(mentorshipRequests.status, "pending")
                 )
             );
 
+        console.log("[Mentorship Requests] Found", requests.length, "pending requests");
+
         // Transform to match frontend expectations (snake_case)
         const formattedRequests = requests.map(r => ({
             id: r.id,
             mentee_id: r.menteeId,
-            mentee_username: r.menteeName,
+            mentee_username: r.menteeUsername || r.menteeName,
             mentee_avatar: r.menteeAvatar,
             message: r.message,
             created_at: r.createdAt,