add pusblish to open ai for files

Author: marcolivierbouch

app/(dashboard)/dashboard/chatbots/[chatbotId]/columns.tsx

@@ -1,5 +1,3 @@
-"use server"
-
 import { notFound, redirect } from "next/navigation"
 import { Chatbot, User } from "@prisma/client"
 
@@ -56,11 +54,24 @@ export default async function ChatbotPage({ params }: ChatbotSettingsProps) {
         const crawlerFiles = await db.crawlerFile.findMany({
             where: {
                 crawlerId: crawler.id,
-            }
+            },
         })
         files.push(...crawlerFiles)
     }
 
+    const openAIFiles = await db.openAIFile.findMany({
+        select: {
+            id: true,
+            fileId: true,
+            openAIFileId: true,
+        },
+        where: {
+            fileId: {
+                in: files.map((file) => file.id),
+            }
+        },
+    })
+
     return (
         <DashboardShell>
             <DashboardHeader heading="Chatbot" text="Configure your chatbot here">
@@ -88,7 +99,13 @@ export default async function ChatbotPage({ params }: ChatbotSettingsProps) {
                             <p className="text-muted-foreground">
                                 Here&apos;s all of your files
                             </p>
-                            { /** <DataTable data={files} columns={columns} /> */}
+                            <div>
+                                {openAIFiles.map((file) => (
+                                    <div key={file.id}>
+                                        <p>{file.openAIFileId}</p>
+                                    </div>
+                                ))}
+                            </div>
                         </div>
                     </div>
                 </>

app/(dashboard)/dashboard/chatbots/[chatbotId]/page.tsx

@@ -6,6 +6,7 @@ import { getCurrentUser } from "@/lib/session"
 import { DashboardHeader } from "@/components/header"
 import { DashboardShell } from "@/components/shell"
 import { UserNameForm } from "@/components/user-name-form"
+import { OpenAIForm } from "@/components/openai-config-form"
 
 export const metadata = {
     title: "Settings",
@@ -29,6 +30,10 @@ export default async function SettingsPage() {
                 <div className="grid gap-10">
                     <UserNameForm user={{ id: user.id, name: user.name || "" }} />
                 </div>
+                <div className="grid gap-10">
+                    <OpenAIForm user={{ id: user.id, name: user.name || "" }} />
+                </div>
+
             </div>
         </DashboardShell>
     )

app/(dashboard)/dashboard/settings/page.tsx

@@ -0,0 +1,90 @@
+import { getServerSession } from "next-auth/next"
+import { z } from "zod"
+
+import { authOptions } from "@/lib/auth"
+import { db } from "@/lib/db"
+import OpenAI from "openai"
+
+
+
+const routeContextSchema = z.object({
+    params: z.object({
+        crawlerId: z.string(),
+        fileId: z.string(),
+    }),
+})
+
+async function verifyCurrentUserHasAccessToCrawler(crawlerId: string) {
+    const session = await getServerSession(authOptions)
+
+    const count = await db.crawler.count({
+        where: {
+            userId: session?.user?.id,
+            id: crawlerId,
+        },
+    })
+
+    return count > 0
+}
+
+export async function POST(
+    req: Request,
+    context: z.infer<typeof routeContextSchema>
+) {
+    try {
+        const session = await getServerSession(authOptions)
+
+        // Validate the route params.
+        const { params } = routeContextSchema.parse(context)
+
+        if (!(await verifyCurrentUserHasAccessToCrawler(params.crawlerId))) {
+            return new Response(null, { status: 403 })
+        }
+
+        const crawlerFile = await db.crawlerFile.findUnique({
+            where: {
+                id: params.fileId
+            },
+            select: {
+                blobUrl: true
+            }
+        })
+
+        if (!crawlerFile) {
+            return new Response(null, { status: 404 })
+        }
+
+        const openAIConfig = await db.openAIConfig.findUnique({
+            select: {
+                globalAPIKey: true,
+                id: true,
+            },
+            where: {
+                userId: session?.user?.id
+            }
+        })
+        const openai = new OpenAI({
+            apiKey: openAIConfig?.globalAPIKey
+        })
+
+        const file = await openai.files.create(
+            { file: await fetch(crawlerFile.blobUrl), purpose: 'assistants' }
+        )
+
+        await db.openAIFile.create({
+            data: {
+                fileId: params.fileId,
+                openAIFileId: file.id
+            }
+        })
+
+        return new Response(null, { status: 204 })
+    } catch (error) {
+        console.log(error)
+        if (error instanceof z.ZodError) {
+            return new Response(JSON.stringify(error.issues), { status: 422 })
+        }
+
+        return new Response(null, { status: 500 })
+    }
+}

app/api/crawlers/[crawlerId]/files/[fileId]/publish/route.ts

@@ -5,6 +5,7 @@ import { del } from '@vercel/blob';
 import { authOptions } from "@/lib/auth"
 import { db } from "@/lib/db"
 
+
 const routeContextSchema = z.object({
     params: z.object({
         crawlerId: z.string(),
@@ -42,14 +43,42 @@ export async function DELETE(
                 id: params.fileId
             },
             select: {
-                blobUrl: true
+                blobUrl: true,
+                OpenAIFile: {
+                    select: {
+                        id: true,
+                        openAIFileId: true
+                    }
+                }
             }
         })
 
         if (!crawlerFile) {
             return new Response(null, { status: 404 })
         }
 
+        // TODO: Delete OpenAI file
+        //import OpenAI from "openai"
+        //if (crawlerFile.OpenAIFile) {
+        //    const session = await getServerSession(authOptions)
+        //    const clientConfig = await db.openAIConfig.findFirst({
+        //        where: {
+        //            userId: session?.user?.id
+        //        }
+        //    })
+
+        //    const client = new OpenAI({
+        //        apiKey: clientConfig?.globalAPIKey,
+        //    })
+
+        //    console.log(crawlerFile.OpenAIFile)
+
+        //    await client.files.del(
+        //        fileId: crawlerFile.OpenAIFile.openAIFileId
+        //    )
+        //}
+
+
         await del(crawlerFile.blobUrl)
 
         await db.crawlerFile.delete({
@@ -60,6 +89,7 @@ export async function DELETE(
 
         return new Response(null, { status: 204 })
     } catch (error) {
+        console.log(error)
         if (error instanceof z.ZodError) {
             return new Response(JSON.stringify(error.issues), { status: 422 })
         }

app/api/crawlers/[crawlerId]/files/[fileId]/route.ts

@@ -0,0 +1,56 @@
+import { getServerSession } from "next-auth/next"
+import { z } from "zod"
+
+import { authOptions } from "@/lib/auth"
+import { db } from "@/lib/db"
+import { openAIConfigSchema } from "@/lib/validations/openaiConfig"
+
+const routeContextSchema = z.object({
+    params: z.object({
+        userId: z.string(),
+    }),
+})
+
+export async function PATCH(
+    req: Request,
+    context: z.infer<typeof routeContextSchema>
+) {
+    try {
+        // Validate the route context.
+        const { params } = routeContextSchema.parse(context)
+
+        // Ensure user is authentication and has access to this user.
+        const session = await getServerSession(authOptions)
+        if (!session?.user || params.userId !== session?.user.id) {
+            return new Response(null, { status: 403 })
+        }
+
+        // Get the request body and validate it.
+        const body = await req.json()
+        const payload = openAIConfigSchema.parse(body)
+
+        // Update the user.
+        await db.openAIConfig.upsert({
+            where: {
+                userId: session.user.id,
+            },
+            create: {
+                userId: session.user.id,
+                ...payload
+            },
+            update: {
+                ...payload
+            }
+        })
+
+
+        return new Response(null, { status: 200 })
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            return new Response(JSON.stringify(error.issues), { status: 422 })
+        }
+        console.error(error)
+
+        return new Response(null, { status: 500 })
+    }
+}