Add notification bell system and MOPC onboarding form

Notification System:
- Add InAppNotification and NotificationEmailSetting database models
- Create notification service with 60+ notification types for all user roles
- Add notification router with CRUD endpoints
- Build NotificationBell UI component with dropdown and unread count
- Integrate bell into admin, jury, mentor, and observer navs
- Add notification email settings admin UI in Settings > Notifications
- Add notification triggers to filtering router (complete/failed)
- Add sendNotificationEmail function to email library
- Add formatRelativeTime utility function

MOPC Onboarding Form:
- Create /apply landing page with auto-redirect for single form
- Create seed script for MOPC 2026 application form (6 steps)
- Create seed script for default notification email settings

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

src/server/routers/notification.ts

@@ -0,0 +1,221 @@
+/**
+ * Notification Router
+ *
+ * Handles in-app notification CRUD operations for users.
+ */
+
+import { z } from 'zod'
+import { router, protectedProcedure, adminProcedure } from '../trpc'
+import {
+  markNotificationAsRead,
+  markAllNotificationsAsRead,
+  getUnreadCount,
+  deleteExpiredNotifications,
+  deleteOldNotifications,
+  NotificationIcons,
+  NotificationPriorities,
+} from '../services/in-app-notification'
+
+export const notificationRouter = router({
+  /**
+   * List notifications for the current user
+   */
+  list: protectedProcedure
+    .input(
+      z.object({
+        unreadOnly: z.boolean().default(false),
+        limit: z.number().int().min(1).max(100).default(50),
+        cursor: z.string().optional(), // For infinite scroll pagination
+      })
+    )
+    .query(async ({ ctx, input }) => {
+      const { unreadOnly, limit, cursor } = input
+      const userId = ctx.user.id
+
+      const where = {
+        userId,
+        ...(unreadOnly && { isRead: false }),
+        // Don't show expired notifications
+        OR: [{ expiresAt: null }, { expiresAt: { gt: new Date() } }],
+      }
+
+      const notifications = await ctx.prisma.inAppNotification.findMany({
+        where,
+        take: limit + 1, // Fetch one extra to check if there are more
+        orderBy: { createdAt: 'desc' },
+        ...(cursor && {
+          cursor: { id: cursor },
+          skip: 1, // Skip the cursor item
+        }),
+      })
+
+      let nextCursor: string | undefined
+      if (notifications.length > limit) {
+        const nextItem = notifications.pop()
+        nextCursor = nextItem?.id
+      }
+
+      return {
+        notifications,
+        nextCursor,
+      }
+    }),
+
+  /**
+   * Get unread notification count for the current user
+   */
+  getUnreadCount: protectedProcedure.query(async ({ ctx }) => {
+    return getUnreadCount(ctx.user.id)
+  }),
+
+  /**
+   * Check if there are any urgent unread notifications
+   */
+  hasUrgent: protectedProcedure.query(async ({ ctx }) => {
+    const count = await ctx.prisma.inAppNotification.count({
+      where: {
+        userId: ctx.user.id,
+        isRead: false,
+        priority: 'urgent',
+        OR: [{ expiresAt: null }, { expiresAt: { gt: new Date() } }],
+      },
+    })
+    return count > 0
+  }),
+
+  /**
+   * Mark a single notification as read
+   */
+  markAsRead: protectedProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ ctx, input }) => {
+      await markNotificationAsRead(input.id, ctx.user.id)
+      return { success: true }
+    }),
+
+  /**
+   * Mark all notifications as read for the current user
+   */
+  markAllAsRead: protectedProcedure.mutation(async ({ ctx }) => {
+    await markAllNotificationsAsRead(ctx.user.id)
+    return { success: true }
+  }),
+
+  /**
+   * Delete a notification (user can only delete their own)
+   */
+  delete: protectedProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ ctx, input }) => {
+      await ctx.prisma.inAppNotification.deleteMany({
+        where: {
+          id: input.id,
+          userId: ctx.user.id, // Ensure user can only delete their own
+        },
+      })
+      return { success: true }
+    }),
+
+  /**
+   * Get notification email settings (admin only)
+   */
+  getEmailSettings: adminProcedure.query(async ({ ctx }) => {
+    return ctx.prisma.notificationEmailSetting.findMany({
+      orderBy: [{ category: 'asc' }, { label: 'asc' }],
+      include: {
+        updatedBy: { select: { name: true, email: true } },
+      },
+    })
+  }),
+
+  /**
+   * Update a notification email setting (admin only)
+   */
+  updateEmailSetting: adminProcedure
+    .input(
+      z.object({
+        notificationType: z.string(),
+        sendEmail: z.boolean(),
+        emailSubject: z.string().optional(),
+        emailTemplate: z.string().optional(),
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      const { notificationType, sendEmail, emailSubject, emailTemplate } = input
+
+      return ctx.prisma.notificationEmailSetting.upsert({
+        where: { notificationType },
+        update: {
+          sendEmail,
+          emailSubject,
+          emailTemplate,
+          updatedById: ctx.user.id,
+        },
+        create: {
+          notificationType,
+          category: 'custom',
+          label: notificationType,
+          sendEmail,
+          emailSubject,
+          emailTemplate,
+          updatedById: ctx.user.id,
+        },
+      })
+    }),
+
+  /**
+   * Delete expired notifications (admin cleanup)
+   */
+  deleteExpired: adminProcedure.mutation(async () => {
+    const count = await deleteExpiredNotifications()
+    return { deletedCount: count }
+  }),
+
+  /**
+   * Delete old read notifications (admin cleanup)
+   */
+  deleteOld: adminProcedure
+    .input(z.object({ olderThanDays: z.number().int().min(1).max(365).default(30) }))
+    .mutation(async ({ input }) => {
+      const count = await deleteOldNotifications(input.olderThanDays)
+      return { deletedCount: count }
+    }),
+
+  /**
+   * Get notification icon and priority mappings (for UI)
+   */
+  getMappings: protectedProcedure.query(() => {
+    return {
+      icons: NotificationIcons,
+      priorities: NotificationPriorities,
+    }
+  }),
+
+  /**
+   * Admin: Get notification statistics
+   */
+  getStats: adminProcedure.query(async ({ ctx }) => {
+    const [total, unread, byType, byPriority] = await Promise.all([
+      ctx.prisma.inAppNotification.count(),
+      ctx.prisma.inAppNotification.count({ where: { isRead: false } }),
+      ctx.prisma.inAppNotification.groupBy({
+        by: ['type'],
+        _count: true,
+        orderBy: { _count: { type: 'desc' } },
+        take: 10,
+      }),
+      ctx.prisma.inAppNotification.groupBy({
+        by: ['priority'],
+        _count: true,
+      }),
+    ])
+
+    return {
+      total,
+      unread,
+      readRate: total > 0 ? ((total - unread) / total) * 100 : 0,
+      byType: byType.map((t) => ({ type: t.type, count: t._count })),
+      byPriority: byPriority.map((p) => ({ priority: p.priority, count: p._count })),
+    }
+  }),
+})