Round 18: Seating Chart, Student Avatars, Newsletter, Badges, Deep Styling Polish

src/app/api/newsletters/[id]/route.ts

@@ -0,0 +1,123 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { db } from '@/lib/db';
+
+// GET /api/newsletters/[id] — get single newsletter
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+    const newsletter = await db.newsletter.findUnique({
+      where: { id },
+      include: {
+        author: { select: { id: true, firstName: true, lastName: true } },
+      },
+    });
+
+    if (!newsletter || newsletter.deletedAt) {
+      return NextResponse.json({ error: 'Newsletter not found' }, { status: 404 });
+    }
+
+    return NextResponse.json(newsletter);
+  } catch (error) {
+    console.error('Error fetching newsletter:', error);
+    return NextResponse.json({ error: 'Failed to fetch newsletter' }, { status: 500 });
+  }
+}
+
+// PUT /api/newsletters/[id] — update newsletter
+export async function PUT(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+    const body = await req.json();
+
+    const existing = await db.newsletter.findUnique({ where: { id } });
+    if (!existing || existing.deletedAt) {
+      return NextResponse.json({ error: 'Newsletter not found' }, { status: 404 });
+    }
+
+    const data: Record<string, unknown> = {};
+    if (body.title !== undefined) data.title = body.title;
+    if (body.content !== undefined) data.content = body.content;
+    if (body.summary !== undefined) data.summary = body.summary;
+    if (body.imageUrl !== undefined) data.imageUrl = body.imageUrl;
+    if (body.category !== undefined) data.category = body.category;
+    if (body.tags !== undefined) data.tags = JSON.stringify(body.tags);
+
+    const newsletter = await db.newsletter.update({
+      where: { id },
+      data,
+      include: {
+        author: { select: { id: true, firstName: true, lastName: true } },
+      },
+    });
+
+    return NextResponse.json(newsletter);
+  } catch (error) {
+    console.error('Error updating newsletter:', error);
+    return NextResponse.json({ error: 'Failed to update newsletter' }, { status: 500 });
+  }
+}
+
+// POST /api/newsletters/[id] — publish/unpublish newsletter
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+    const body = await req.json();
+
+    const existing = await db.newsletter.findUnique({ where: { id } });
+    if (!existing || existing.deletedAt) {
+      return NextResponse.json({ error: 'Newsletter not found' }, { status: 404 });
+    }
+
+    const isPublished = body.action === 'publish' ? true : body.action === 'unpublish' ? false : !existing.isPublished;
+
+    const newsletter = await db.newsletter.update({
+      where: { id },
+      data: {
+        isPublished,
+        publishedAt: isPublished ? new Date() : null,
+      },
+      include: {
+        author: { select: { id: true, firstName: true, lastName: true } },
+      },
+    });
+
+    return NextResponse.json(newsletter);
+  } catch (error) {
+    console.error('Error toggling newsletter publish:', error);
+    return NextResponse.json({ error: 'Failed to toggle newsletter' }, { status: 500 });
+  }
+}
+
+// DELETE /api/newsletters/[id] — soft delete newsletter
+export async function DELETE(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+
+    const existing = await db.newsletter.findUnique({ where: { id } });
+    if (!existing || existing.deletedAt) {
+      return NextResponse.json({ error: 'Newsletter not found' }, { status: 404 });
+    }
+
+    await db.newsletter.update({
+      where: { id },
+      data: { deletedAt: new Date() },
+    });
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error('Error deleting newsletter:', error);
+    return NextResponse.json({ error: 'Failed to delete newsletter' }, { status: 500 });
+  }
+}

src/app/api/newsletters/route.ts

@@ -0,0 +1,85 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { db } from '@/lib/db';
+
+// GET /api/newsletters — list newsletters
+export async function GET(req: NextRequest) {
+  try {
+    const { searchParams } = new URL(req.url);
+    const schoolId = searchParams.get('schoolId');
+    const published = searchParams.get('published');
+    const category = searchParams.get('category');
+    const limit = parseInt(searchParams.get('limit') || '20');
+    const offset = parseInt(searchParams.get('offset') || '0');
+
+    if (!schoolId) {
+      return NextResponse.json({ error: 'schoolId required' }, { status: 400 });
+    }
+
+    const where: Record<string, unknown> = {
+      schoolId,
+      deletedAt: null,
+    };
+
+    if (published === 'true') {
+      where.isPublished = true;
+    } else if (published === 'false') {
+      where.isPublished = false;
+    }
+
+    if (category) {
+      where.category = category;
+    }
+
+    const [newsletters, total] = await Promise.all([
+      db.newsletter.findMany({
+        where,
+        orderBy: [{ publishedAt: 'desc' }, { createdAt: 'desc' }],
+        skip: offset,
+        take: limit,
+        include: {
+          author: { select: { id: true, firstName: true, lastName: true } },
+        },
+      }),
+      db.newsletter.count({ where }),
+    ]);
+
+    return NextResponse.json({ newsletters, total });
+  } catch (error) {
+    console.error('Error fetching newsletters:', error);
+    return NextResponse.json({ error: 'Failed to fetch newsletters' }, { status: 500 });
+  }
+}
+
+// POST /api/newsletters — create newsletter
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { schoolId, authorId, title, content, summary, imageUrl, category, tags, isDemo } = body;
+
+    if (!schoolId || !authorId || !title || !content) {
+      return NextResponse.json({ error: 'schoolId, authorId, title, content required' }, { status: 400 });
+    }
+
+    const newsletter = await db.newsletter.create({
+      data: {
+        schoolId,
+        authorId,
+        title,
+        content,
+        summary: summary || null,
+        imageUrl: imageUrl || null,
+        category: category || 'general',
+        tags: tags ? JSON.stringify(tags) : null,
+        isDemo: isDemo || false,
+      },
+      include: {
+        author: { select: { id: true, firstName: true, lastName: true } },
+      },
+    });
+
+    return NextResponse.json(newsletter, { status: 201 });
+  } catch (error) {
+    console.error('Error creating newsletter:', error);
+    return NextResponse.json({ error: 'Failed to create newsletter' }, { status: 500 });
+  }
+}

src/app/api/students/[id]/details/route.ts

@@ -23,6 +23,8 @@ export async function GET(
         lastName: true,
         dateOfBirth: true,
         externalId: true,
+        avatarUrl: true,
+        avatarInitials: true,
         createdAt: true,
         schoolId: true,
         school: { select: { id: true, name: true } },

src/app/api/students/route.ts

@@ -143,6 +143,7 @@ export async function PUT(request: Request) {
         .optional()
         .transform((v) => (v ? new Date(v) : v === null ? null : undefined)),
       externalId: z.string().nullable().optional(),
+      avatarUrl: z.string().nullable().optional(),
     });
 
     const parsed = updateSchema.safeParse(body);