Cleaned up api path structure.

Author: digitalnomad91

src/app/api/notifications/get-public-key/route.ts

@@ -0,0 +1,7 @@
+import { NextResponse } from 'next/server'
+
+export async function GET() {
+  return NextResponse.json({
+    publicKey: process.env.NEXT_PUBLIC_VAPID_PUBLIC_KEY,
+  })
+}

src/app/api/notifications/mass-notification/route.ts

@@ -0,0 +1,42 @@
+import { NextResponse } from 'next/server'
+import { PrismaClient } from '@prisma/client'
+import webpush, { WebPushError } from 'web-push'
+import { messaging } from 'firebase-admin'
+import { sendNotification, SubscriptionRecord } from '../../../../lib/notifications'
+
+const prisma = new PrismaClient()
+
+export async function POST(request: Request) {
+  try {
+    const { title, body, url } = await request.json()
+
+    if (!title || !body || !url) {
+      return NextResponse.json({ error: 'Missing required fields' }, { status: 400 })
+    }
+
+    // Retrieve all subscriptions for sending notifications
+    const subscriptions = await prisma.subscription.findMany()
+
+    // Build your unified payload object
+    const notificationPayload = {
+      title: `${title}`,
+      body: body,
+      url: url,
+      icon: 'https://new.codebuilder.org/images/logo2.png',
+      badge: 'https://new.codebuilder.org/images/logo2.png',
+    }
+
+    // Loop and send notifications concurrently
+    const notificationPromises = subscriptions.map((sub) =>
+      sendNotification(sub, notificationPayload)
+    )
+
+    // Wait for all notifications to complete
+    await Promise.all(notificationPromises)
+
+    return NextResponse.json({ success: true, message: 'Notifications sent successfully' })
+  } catch (error) {
+    console.error('Error sending notifications:', error)
+    return NextResponse.json({ error: 'Internal Server Error' }, { status: 500 })
+  }
+}

src/app/api/notifications/subscribe/route.ts

@@ -0,0 +1,81 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { PrismaClient } from '@prisma/client'
+
+const prisma = new PrismaClient()
+
+export async function POST(req: NextRequest) {
+  try {
+    const subscription = await req.json()
+
+    console.log('Subscription data:', subscription)
+
+    // Validate required fields
+    if (!subscription.endpoint || !subscription.type) {
+      return NextResponse.json({ error: 'Invalid subscription data.' }, { status: 400 })
+    }
+
+    if (subscription.type === 'fcm') {
+      if (!subscription.keys?.token) {
+        return NextResponse.json(
+          { error: 'Invalid FCM subscription data: missing token.' },
+          { status: 400 }
+        )
+      }
+    } else if (subscription.type === 'web') {
+      if (!subscription.keys?.p256dh || !subscription.keys?.auth) {
+        return NextResponse.json(
+          { error: 'Invalid web-push subscription data: missing keys.' },
+          { status: 400 }
+        )
+      }
+    }
+
+    // Get the IP address from the headers
+    const forwardedFor = req.headers.get('x-forwarded-for') || ''
+    const ipAddress = forwardedFor.split(',')[0].trim() || 'Unknown'
+
+    // Serialize keys if necessary
+    const keys = subscription.keys ?? {}
+
+    // Declare the variable outside the if-else block
+    let newSubscription
+
+    // Save the subscription to the database
+    const existingSubscription = await prisma.subscription.findFirst({
+      where: {
+        endpoint: subscription.endpoint,
+        type: subscription.type,
+      },
+    })
+
+    if (existingSubscription) {
+      // Update the existing record
+      newSubscription = await prisma.subscription.update({
+        where: { id: existingSubscription.id },
+        data: { ipAddress, keys },
+      })
+    } else {
+      // Create a new record
+      newSubscription = await prisma.subscription.create({
+        data: {
+          type: subscription.type,
+          endpoint: subscription.endpoint,
+          ipAddress,
+          keys,
+        },
+      })
+    }
+
+    // Respond with the new subscription
+    return NextResponse.json(
+      { message: 'Subscription added.', data: newSubscription },
+      { status: 201 }
+    )
+  } catch (error) {
+    console.log(error.stack)
+    console.log('Error saving subscription:', error)
+    return NextResponse.json({ error: 'Failed to save subscription.' }, { status: 500 })
+  } finally {
+    await prisma.$disconnect()
+  }
+}

src/app/api/reddit/messages/fetch/route.ts

@@ -0,0 +1,17 @@
+import { NextResponse } from 'next/server'
+import { checkRedditMessages } from '@/lib/reddit'
+
+export async function GET() {
+  try {
+    const newMessages = await checkRedditMessages()
+    return NextResponse.json({
+      success: true,
+      count: newMessages.length,
+      messages: newMessages,
+    })
+  } catch (error) {
+    return NextResponse.json({ success: false, error: error.message }, { status: 500 })
+  }
+}
+
+export const dynamic = 'force-dynamic'

src/app/api/reddit/messages/route.ts

@@ -0,0 +1,15 @@
+import { NextResponse } from 'next/server'
+import prisma from '@/lib/db'
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url)
+  const type = searchParams.get('type')
+
+  const messages = await prisma.redditMessage.findMany({
+    where: type ? { type } : undefined,
+    orderBy: { createdAt: 'desc' },
+    take: 50,
+  })
+
+  return NextResponse.json(messages)
+}

src/app/api/reddit/posts/fetch/route.ts

@@ -0,0 +1,73 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { fetchRedditPosts } from '@/lib/reddit'
+import webpush from 'web-push'
+import { sendNotification } from '@/lib/notifications'
+import prisma from '@/lib/db'
+
+// List of subreddits to monitor for new posts
+const SUBREDDITS = [
+  'forhire',
+  'jobs4bitcoins',
+  'freelance',
+  'remotejs',
+  'jobs4dogecoins',
+  'jobs4crypto',
+]
+
+// Set up web-push VAPID keys for push notifications
+webpush.setVapidDetails(
+  'mailto:[email protected]',
+  process.env.NEXT_PUBLIC_VAPID_PUBLIC_KEY!,
+  process.env.VAPID_PRIVATE_KEY!
+)
+
+export async function GET(req: NextRequest) {
+  try {
+    // Fetch posts from the specified subreddits
+    const posts = await fetchRedditPosts(SUBREDDITS)
+
+    // Retrieve all subscriptions for sending notifications
+    const subscriptions = await prisma.subscription.findMany()
+
+    for (const post of posts) {
+      // Check if the post is marked with '[Hiring]'
+      if (!post.title.includes('[Hiring]')) continue
+
+      // Ensure the post is not already in the database
+      const existingPost = await prisma.post.findUnique({
+        where: { url: post.url },
+      })
+      if (existingPost) continue
+
+      // Add the post to the database if it's new
+      const createdPost = await prisma.post.create({ data: post })
+
+      // 2. Build your unified payload object
+      const notificationPayload = {
+        title: `${createdPost.title} (${createdPost.subreddit} - ${createdPost.author})`,
+        body: `${createdPost.title}`,
+        url: createdPost.url,
+        icon: 'https://new.codebuilder.org/images/logo2.png',
+        badge: 'https://new.codebuilder.org/images/logo2.png',
+      }
+
+      // 3. Loop and send notifications concurrently
+      const notificationPromises = subscriptions.map((sub) =>
+        sendNotification(sub, notificationPayload)
+      )
+
+      // 4. Wait for all notifications to complete
+      await Promise.all(notificationPromises)
+    }
+
+    // Respond with success if posts fetched and processed successfully
+    return NextResponse.json({ message: 'Posts fetched and stored successfully.' })
+  } catch (error) {
+    // Log any errors and respond with a 500 status code
+    console.log(error) //error()
+    return NextResponse.json({ error: 'An error occurred while fetching posts.' }, { status: 500 })
+  } finally {
+    // Ensure the Prisma client is disconnected after execution
+    await prisma.$disconnect()
+  }
+}

src/app/api/reddit/posts/route.ts

@@ -0,0 +1,35 @@
+import { NextRequest, NextResponse } from 'next/server'
+import prisma from '@/lib/db'
+
+export async function GET(request: NextRequest) {
+  try {
+    // Parse query parameters for pagination
+    const { searchParams } = new URL(request.url)
+    const page = parseInt(searchParams.get('page') || '1', 10)
+    const pageSize = parseInt(searchParams.get('pageSize') || '10', 10)
+
+    // Calculate skip value
+    const skip = (page - 1) * pageSize
+
+    // Fetch paginated posts from Prisma
+    const posts = await prisma.post.findMany({
+      orderBy: { createdAt: 'desc' },
+      skip,
+      take: pageSize,
+      // select: { id: true, title: true, ... } // You can choose which fields to return
+    })
+
+    // Optionally, get the total number of posts to return along with pagination info
+    const totalCount = await prisma.post.count()
+
+    return NextResponse.json({
+      data: posts,
+      page,
+      pageSize,
+      totalCount,
+    })
+  } catch (error) {
+    // Handle any errors
+    return NextResponse.json({ error: (error as Error).message }, { status: 500 })
+  }
+}