@devvistatech/devvista-kit 0.0.1

package/app/api/schedule/route.ts

@@ -0,0 +1,456 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getAuth } from "@clerk/nextjs/server";
+
+interface StrapiUser {
+  id: number;
+  username: string;
+  email: string;
+  businessAdminId?: string;
+}
+
+interface ScheduleClass {
+  id: number;
+  documentId: string;
+  title: string;
+  startTime: string;
+  endTime: string;
+  daysOfWeek: number[];
+  classDescription?: string;
+}
+
+const CALENDAR_API_URL = process.env.STRAPI_CALENDAR_API_URL || "";
+const BASE_URL = process.env.STRAPI_API_URL || "";
+const STRAPI_USER_LIST_API_URL = process.env.STRAPI_USER_LIST_API_URL || "";
+const ADMIN_BUSINESS_ID = process.env.ADMIN_BUSINESS_ID || "";
+const STRAPI_API_TOKEN = process.env.STRAPI_API_TOKEN || "";
+
+async function verifyUser(userId: string): Promise<StrapiUser | null> {
+  try {
+    const response = await fetch(
+      `${STRAPI_USER_LIST_API_URL}?filters[authId][$eq]=${userId}`,
+      {
+        headers: {
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      console.error("User verification failed:", response.status);
+      return null;
+    }
+
+    const userData = await response.json();
+    const strapiUser = userData.data?.find((user: any) => user.authId === userId);
+    if (!strapiUser) {
+      return null;
+    }
+
+    return {
+      id: strapiUser.id,
+      username: strapiUser.username,
+      email: strapiUser.email,
+      businessAdminId: strapiUser.businessAdminId,
+    };
+  } catch (error) {
+    console.error("Error verifying user:", error);
+    return null;
+  }
+}
+
+export async function GET() {
+  try {
+    if (!CALENDAR_API_URL || !STRAPI_API_TOKEN) {
+      console.error(
+        "Missing environment variables:",
+        !CALENDAR_API_URL && "STRAPI_CALENDAR_API_URL",
+        !STRAPI_API_TOKEN && "STRAPI_API_TOKEN"
+      );
+      return NextResponse.json(
+        { error: "Server configuration error: Missing required environment variables" },
+        { status: 500 }
+      );
+    }
+
+    const response = await fetch(
+      `${CALENDAR_API_URL}?pagination[pageSize]=100&fields[0]=title&fields[1]=startTime&fields[2]=endTime&fields[3]=daysOfWeek&fields[4]=classDescription&fields[5]=id&fields[6]=documentId`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+        },
+        cache: "no-store",
+      }
+    );
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return NextResponse.json(
+        { error: `Failed to fetch events: ${response.status} - ${errorText}` },
+        { status: response.status }
+      );
+    }
+
+    const result = await response.json();
+
+    const events = (result.data || []).map((event: any) => {
+      const daysOfWeekRaw = event.attributes?.daysOfWeek || event.daysOfWeek || [];
+      const daysOfWeekNumbers = Array.isArray(daysOfWeekRaw)
+        ? daysOfWeekRaw
+            .map((day: any) => {
+              if (typeof day === "number") {
+                return day;
+              }
+              if (typeof day === "string") {
+                const dayLower = day.toLowerCase();
+                switch (dayLower) {
+                  case "monday":
+                    return 1;
+                  case "tuesday":
+                    return 2;
+                  case "wednesday":
+                    return 3;
+                  case "thursday":
+                    return 4;
+                  case "friday":
+                    return 5;
+                  case "saturday":
+                    return 6;
+                  case "sunday":
+                    return 7;
+                  default:
+                    return 0;
+                }
+              }
+              return 0;
+            })
+            .filter((num: number) => num !== 0 && num >= 1 && num <= 7)
+        : [];
+
+      return {
+        id: event.id || 0,
+        documentId: event.documentId || "",
+        title: event.attributes?.title || event.title || "Untitled",
+        startTime: event.attributes?.startTime || event.startTime || "00:00",
+        endTime: event.attributes?.endTime || event.endTime || "00:00",
+        daysOfWeek: daysOfWeekNumbers,
+        classDescription: event.attributes?.classDescription || event.classDescription || "",
+      };
+    });
+
+    return NextResponse.json({ data: events });
+  } catch (error) {
+    console.error("Fetch Error:", error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "An error occurred while fetching events" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: NextRequest) {
+  const { userId } = getAuth(request);
+  if (!userId) {
+    console.error("POST /api/schedule: No userId, returning 401");
+    return NextResponse.json({ error: "Unauthorized: No user ID" }, { status: 401 });
+  }
+
+  const user = await verifyUser(userId);
+  if (!user || user.businessAdminId !== ADMIN_BUSINESS_ID) {
+    console.error("POST /api/schedule: User not authorized", {
+      strapiUser: user,
+      businessAdminId: user?.businessAdminId,
+    });
+    return NextResponse.json({ error: "Unauthorized: Only admin can create classes" }, { status: 403 });
+  }
+
+  try {
+    if (!CALENDAR_API_URL || !STRAPI_API_TOKEN) {
+      console.error(
+        "Missing environment variables:",
+        !CALENDAR_API_URL && "STRAPI_CALENDAR_API_URL",
+        !STRAPI_API_TOKEN && "STRAPI_API_TOKEN"
+      );
+      return NextResponse.json(
+        { error: "Server configuration error: Missing required environment variables" },
+        { status: 500 }
+      );
+    }
+
+    const { data: classData } = await request.json();
+    if (!classData || !classData.title || !classData.startTime || !classData.endTime || !classData.daysOfWeek) {
+      return NextResponse.json({ error: "Missing required fields" }, { status: 400 });
+    }
+
+    const response = await fetch(CALENDAR_API_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+      },
+      body: JSON.stringify({
+        data: {
+          title: classData.title,
+          startTime: classData.startTime,
+          endTime: classData.endTime,
+          daysOfWeek: classData.daysOfWeek,
+          classDescription: classData.classDescription || null,
+          publishedAt: new Date().toISOString(),
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error("POST /api/schedule: Create failed:", response.status, errorText);
+      return NextResponse.json(
+        { error: `Failed to create class: ${errorText}` },
+        { status: response.status }
+      );
+    }
+
+    const eventsResponse = await fetch(
+      `${CALENDAR_API_URL}?pagination[pageSize]=100&fields[0]=title&fields[1]=startTime&fields[2]=endTime&fields[3]=daysOfWeek&fields[4]=classDescription&fields[5]=id&fields[6]=documentId`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+        },
+        cache: "no-store",
+      }
+    );
+
+    if (!eventsResponse.ok) {
+      const errorText = await eventsResponse.text();
+      console.error("POST /api/schedule: Refetch failed:", eventsResponse.status, errorText);
+      return NextResponse.json(
+        { error: `Failed to fetch events: ${errorText}` },
+        { status: eventsResponse.status }
+      );
+    }
+
+    const result = await eventsResponse.json();
+    const events = (result.data || []).map((event: any) => ({
+      id: event.id || 0,
+      documentId: event.documentId || "",
+      title: event.attributes?.title || event.title || "Untitled",
+      startTime: event.attributes?.startTime || event.startTime || "00:00",
+      endTime: event.attributes?.endTime || event.endTime || "00:00",
+      daysOfWeek: Array.isArray(event.attributes?.daysOfWeek || event.daysOfWeek)
+        ? (event.attributes?.daysOfWeek || event.daysOfWeek).filter((num: number) => num >= 1 && num <= 7)
+        : [],
+      classDescription: event.attributes?.classDescription || event.classDescription || "",
+    }));
+
+    return NextResponse.json({ data: events });
+  } catch (error) {
+    console.error("POST /api/schedule: Error:", error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "An error occurred while creating class" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PUT(request: NextRequest) {
+  const { userId } = getAuth(request);
+  if (!userId) {
+    console.error("PUT /api/schedule: No userId, returning 401");
+    return NextResponse.json({ error: "Unauthorized: No user ID" }, { status: 401 });
+  }
+
+  const user = await verifyUser(userId);
+  if (!user || user.businessAdminId !== ADMIN_BUSINESS_ID) {
+    console.error("PUT /api/schedule: User not authorized", {
+      strapiUser: user,
+      businessAdminId: user?.businessAdminId,
+    });
+    return NextResponse.json({ error: "Unauthorized: Only admin can update classes" }, { status: 403 });
+  }
+
+  try {
+    if (!CALENDAR_API_URL || !STRAPI_API_TOKEN) {
+      console.error(
+        "Missing environment variables:",
+        !CALENDAR_API_URL && "STRAPI_CALENDAR_API_URL",
+        !STRAPI_API_TOKEN && "STRAPI_API_TOKEN"
+      );
+      return NextResponse.json(
+        { error: "Server configuration error: Missing required environment variables" },
+        { status: 500 }
+      );
+    }
+
+    const { documentId, data: classData } = await request.json();
+    if (!documentId || !classData || !classData.title || !classData.startTime || !classData.endTime || !classData.daysOfWeek) {
+      return NextResponse.json({ error: "Missing required fields" }, { status: 400 });
+    }
+
+    const response = await fetch(`${CALENDAR_API_URL}/${documentId}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+      },
+      body: JSON.stringify({
+        data: {
+          title: classData.title,
+          startTime: classData.startTime,
+          endTime: classData.endTime,
+          daysOfWeek: classData.daysOfWeek,
+          classDescription: classData.classDescription || null,
+          publishedAt: new Date().toISOString(),
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error("PUT /api/schedule: Update failed:", response.status, errorText);
+      return NextResponse.json(
+        { error: `Failed to update class: ${errorText}` },
+        { status: response.status }
+      );
+    }
+
+    const eventsResponse = await fetch(
+      `${CALENDAR_API_URL}?pagination[pageSize]=100&fields[0]=title&fields[1]=startTime&fields[2]=endTime&fields[3]=daysOfWeek&fields[4]=classDescription&fields[5]=id&fields[6]=documentId`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+        },
+        cache: "no-store",
+      }
+    );
+
+    if (!eventsResponse.ok) {
+      const errorText = await eventsResponse.text();
+      console.error("PUT /api/schedule: Refetch failed:", eventsResponse.status, errorText);
+      return NextResponse.json(
+        { error: `Failed to fetch events: ${errorText}` },
+        { status: eventsResponse.status }
+      );
+    }
+
+    const result = await eventsResponse.json();
+    const events = (result.data || []).map((event: any) => ({
+      id: event.id || 0,
+      documentId: event.documentId || "",
+      title: event.attributes?.title || event.title || "Untitled",
+      startTime: event.attributes?.startTime || event.startTime || "00:00",
+      endTime: event.attributes?.endTime || event.endTime || "00:00",
+      daysOfWeek: Array.isArray(event.attributes?.daysOfWeek || event.daysOfWeek)
+        ? (event.attributes?.daysOfWeek || event.daysOfWeek).filter((num: number) => num >= 1 && num <= 7)
+        : [],
+      classDescription: event.attributes?.classDescription || event.classDescription || "",
+    }));
+
+    return NextResponse.json({ data: events });
+  } catch (error) {
+    console.error("PUT /api/schedule: Error:", error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "An error occurred while updating class" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(request: NextRequest) {
+  const { userId } = getAuth(request);
+  if (!userId) {
+    console.error("DELETE /api/schedule: No userId, returning 401");
+    return NextResponse.json({ error: "Unauthorized: No user ID" }, { status: 401 });
+  }
+
+  const user = await verifyUser(userId);
+  if (!user || user.businessAdminId !== ADMIN_BUSINESS_ID) {
+    console.error("DELETE /api/schedule: User not authorized", {
+      strapiUser: user,
+      businessAdminId: user?.businessAdminId,
+    });
+    return NextResponse.json({ error: "Unauthorized: Only admin can delete classes" }, { status: 403 });
+  }
+
+  try {
+    if (!CALENDAR_API_URL || !STRAPI_API_TOKEN) {
+      console.error(
+        "Missing environment variables:",
+        !CALENDAR_API_URL && "STRAPI_CALENDAR_API_URL",
+        !STRAPI_API_TOKEN && "STRAPI_API_TOKEN"
+      );
+      return NextResponse.json(
+        { error: "Server configuration error: Missing required environment variables" },
+        { status: 500 }
+      );
+    }
+
+    const body = await request.json();
+    const documentId = body.documentId || body.id;
+    if (!documentId) {
+      return NextResponse.json(
+        { error: "Missing documentId or id in request body" },
+        { status: 400 }
+      );
+    }
+
+    const response = await fetch(`${CALENDAR_API_URL}/${documentId}`, {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+      },
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error("DELETE /api/schedule: Delete failed:", response.status, errorText);
+      return NextResponse.json(
+        { error: `Failed to delete class: ${errorText}` },
+        { status: response.status }
+      );
+    }
+
+    const eventsResponse = await fetch(
+      `${CALENDAR_API_URL}?pagination[pageSize]=100&fields[0]=title&fields[1]=startTime&fields[2]=endTime&fields[3]=daysOfWeek&fields[4]=classDescription&fields[5]=id&fields[6]=documentId`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+        },
+        cache: "no-store",
+      }
+    );
+
+    if (!eventsResponse.ok) {
+      const errorText = await eventsResponse.text();
+      console.error("DELETE /api/schedule: Refetch failed:", eventsResponse.status, errorText);
+      return NextResponse.json(
+        { error: `Failed to fetch events: ${errorText}` },
+        { status: eventsResponse.status }
+      );
+    }
+
+    const result = await eventsResponse.json();
+    const events = (result.data || []).map((event: any) => ({
+      id: event.id || 0,
+      documentId: event.documentId || "",
+      title: event.attributes?.title || event.title || "Untitled",
+      startTime: event.attributes?.startTime || event.startTime || "00:00",
+      endTime: event.attributes?.endTime || event.endTime || "00:00",
+      daysOfWeek: Array.isArray(event.attributes?.daysOfWeek || event.daysOfWeek)
+        ? (event.attributes?.daysOfWeek || event.daysOfWeek).filter((num: number) => num >= 1 && num <= 7)
+        : [],
+      classDescription: event.attributes?.classDescription || event.classDescription || "",
+    }));
+
+    return NextResponse.json({ data: events });
+  } catch (error) {
+    console.error("DELETE /api/schedule: Error:", error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "An error occurred while deleting class" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/sync-user/route.ts

@@ -0,0 +1,114 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getAuth } from "@clerk/nextjs/server";
+
+export async function POST(req: NextRequest) {
+  const { userId } = getAuth(req);
+  if (!userId) {
+    console.error("No userId, returning 401");
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  const clerkUserData = await req.json();
+  const STRAPI_USER_LIST_API_URL = process.env.STRAPI_USER_LIST_API_URL;
+  const STRAPI_API_TOKEN = process.env.STRAPI_API_TOKEN;
+  const CLERK_SECRET_KEY = process.env.CLERK_SECRET_KEY;
+  const ADMIN_BUSINESS_ID = process.env.ADMIN_BUSINESS_ID;
+
+  if (!STRAPI_USER_LIST_API_URL || !STRAPI_API_TOKEN || !CLERK_SECRET_KEY || !ADMIN_BUSINESS_ID) {
+    console.error("Missing environment variables:", {
+      STRAPI_USER_LIST_API_URL,
+      STRAPI_API_TOKEN: !!STRAPI_API_TOKEN,
+      CLERK_SECRET_KEY: !!CLERK_SECRET_KEY,
+      ADMIN_BUSINESS_ID,
+    });
+    return NextResponse.json(
+      { error: "Server configuration error: Missing required environment variables" },
+      { status: 500 }
+    );
+  }
+
+  try {
+    const clerkResponse = await fetch(`https://api.clerk.dev/v1/users/${userId}`, {
+      headers: { Authorization: `Bearer ${CLERK_SECRET_KEY}` },
+    });
+    if (!clerkResponse.ok) {
+      const errorText = await clerkResponse.text();
+      console.error("Clerk fetch failed:", clerkResponse.status, errorText);
+      throw new Error(`Failed to fetch Clerk user: ${clerkResponse.status}`);
+    }
+    const clerkUser = await clerkResponse.json();
+
+    const strapiUserData = {
+      authId: userId,
+      authProvider: "clerk",
+      email: clerkUser.email_addresses[0]?.email_address || clerkUserData.emailAddresses[0]?.emailAddress,
+      username: clerkUser.username || clerkUser.email_addresses[0]?.email_address.split("@")[0] || clerkUserData.emailAddresses[0]?.emailAddress.split("@")[0],
+      businessAdminId: userId === "user_30YfRvHZziqg1LzQmo3JEuvuF1Y" ? ADMIN_BUSINESS_ID : clerkUser.public_metadata?.businessAdminId || "",
+      userRole: userId === "user_30YfRvHZziqg1LzQmo3JEuvuF1Y" ? "admin" : clerkUser.public_metadata?.userRole || "user",
+      isVerified: clerkUser.email_addresses[0]?.verification?.status === "verified" || false,
+      firstName: clerkUser.first_name || "",
+      lastName: clerkUser.last_name || "",
+      businessOwner: userId === "user_30YfRvHZziqg1LzQmo3JEuvuF1Y" ? true : false,
+      userStatus: "active",
+    };
+
+    const existingUsersResponse = await fetch(
+      `${STRAPI_USER_LIST_API_URL}?filters[authId][$eq]=${userId}`,
+      {
+        headers: {
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!existingUsersResponse.ok) {
+      const errorText = await existingUsersResponse.text();
+      console.error("Strapi fetch error:", errorText);
+      throw new Error(`Failed to fetch user-lists: ${existingUsersResponse.status}`);
+    }
+
+    const existingUsers = await existingUsersResponse.json();
+    const existingUser = existingUsers.data?.find((user: any) => user.authId === userId);
+
+    let strapiUser;
+    if (existingUser) {
+      const updateUrl = `${STRAPI_USER_LIST_API_URL}/${existingUser.documentId}`;
+      const updateResponse = await fetch(updateUrl, {
+        method: "PUT",
+        headers: {
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ data: strapiUserData }),
+      });
+      const strapiUserDataResponse = await updateResponse.json();
+      if (!updateResponse.ok) {
+        console.error("Update failed:", updateResponse.status, strapiUserDataResponse);
+        throw new Error(`Failed to update user: ${updateResponse.status}`);
+      }
+      strapiUser = strapiUserDataResponse.data?.attributes || strapiUserDataResponse.data;
+    } else {
+      const createResponse = await fetch(`${STRAPI_USER_LIST_API_URL}`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ data: strapiUserData }),
+      });
+      if (!createResponse.ok) {
+        const errorText = await createResponse.text();
+        console.error("Create failed:", createResponse.status, errorText);
+        throw new Error(`Failed to create user: ${createResponse.status}`);
+      }
+      strapiUser = (await createResponse.json()).data?.attributes || (await createResponse.json()).data;
+    }
+
+    return NextResponse.json(strapiUser, { status: 200 });
+  } catch (error) {
+    console.error("Error syncing user to Strapi:", error);
+    const errorMessage = error instanceof Error ? error.message : "Failed to sync user to Strapi";
+    return NextResponse.json({ error: errorMessage }, { status: 500 });
+  }
+}