@devvistatech/devvista-kit 0.0.1

package/app/api/gallery-data/route.ts

@@ -0,0 +1,661 @@
+// app/api/gallery-data/route.ts
+import { NextRequest, NextResponse } from "next/server";
+import { getAuth } from "@clerk/nextjs/server";
+
+export const revalidate = 0; 
+
+interface StrapiUser {
+  id: number;
+  username: string;
+  email: string;
+  authId: string;
+  authProvider: string;
+  businessAdminId?: string;
+  userRole?: string;
+  firstName?: string;
+  lastName?: string;
+  businessId?: string[] | null;
+  dateJoined?: string;
+  businessOwner?: boolean;
+  userStatus?: string;
+  timezone?: string | null;
+  language?: string | null;
+  isVerified?: boolean;
+  businessTitle?: string | null;
+  userTitle?: string | null;
+  number?: string | null;
+  address?: {
+    zip: string;
+    city: string;
+    state: string;
+    street: string;
+    country: string;
+  } | null;
+  websiteUrl?: string | null;
+  primaryBusinessColor?: string | null;
+  secondaryBusinessColor?: string | null;
+  logoImage?: string | null;
+}
+
+interface UploadedImage {
+  id: number;
+  documentId: string;
+  title?: string;
+  description?: string;
+  url: string;
+  createdAt: string;
+  category?: "none" | "indoor" | "outdoor" | "commercial";
+}
+
+const CONTENT_API_URL = process.env.STRAPI_CONTENT_API_URL || "";
+const BASE_URL = process.env.STRAPI_API_URL || "";
+const UPLOAD_API_URL = `${BASE_URL}/api/upload`;
+const STRAPI_API_TOKEN = process.env.STRAPI_API_TOKEN || "";
+const STRAPI_USER_LIST_API_URL = process.env.STRAPI_USER_LIST_API_URL || "";
+const ADMIN_BUSINESS_ID = process.env.ADMIN_BUSINESS_ID || "";
+
+async function verifyUser(request: NextRequest): Promise<StrapiUser | null> {
+  const { userId } = getAuth(request);
+
+  if (!userId) {
+    console.error("verifyUser: No userId found in request");
+    return null;
+  }
+
+  try {
+    if (!STRAPI_USER_LIST_API_URL || !STRAPI_API_TOKEN) {
+      console.error("verifyUser: Missing environment variables", {
+        STRAPI_USER_LIST_API_URL,
+        STRAPI_API_TOKEN: !!STRAPI_API_TOKEN,
+      });
+      return null;
+    }
+
+    const response = await fetch(
+      `${STRAPI_USER_LIST_API_URL}?filters[authId][$eq]=${userId}&populate=*`,
+      {
+        headers: {
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+          "Content-Type": "application/json",
+        },
+        cache: "no-store",
+      }
+    );
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error("verifyUser failed:", { status: response.status, errorText });
+      return null;
+    }
+
+    const userData = await response.json();
+
+    if (!userData || !Array.isArray(userData.data) || userData.data.length === 0) {
+      console.error("verifyUser: No user found or invalid response for authId:", {
+        userId,
+        data: userData,
+      });
+      return null;
+    }
+
+    const strapiUser = userData.data.find((user: any) => user.authId === userId);
+
+    if (!strapiUser) {
+      console.error("verifyUser: No user found for authId", { userId });
+      return null;
+    }
+
+    return {
+      id: strapiUser.id,
+      username: strapiUser.username || "Unknown",
+      email: strapiUser.email || "",
+      authId: strapiUser.authId,
+      authProvider: strapiUser.authProvider,
+      businessAdminId: strapiUser.businessAdminId,
+      userRole: strapiUser.userRole,
+      firstName: strapiUser.firstName,
+      lastName: strapiUser.lastName,
+      businessId: strapiUser.businessId,
+      dateJoined: strapiUser.dateJoined,
+      businessOwner: strapiUser.businessOwner,
+      userStatus: strapiUser.userStatus,
+      timezone: strapiUser.timezone,
+      language: strapiUser.language,
+      isVerified: strapiUser.isVerified,
+      businessTitle: strapiUser.businessTitle,
+      userTitle: strapiUser.userTitle,
+      number: strapiUser.number,
+      address: strapiUser.address,
+      websiteUrl: strapiUser.websiteUrl,
+      primaryBusinessColor: strapiUser.primaryBusinessColor,
+      secondaryBusinessColor: strapiUser.secondaryBusinessColor,
+      logoImage: strapiUser.logoImage,
+    };
+  } catch (error) {
+    console.error("verifyUser error:", error);
+    return null;
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    if (!CONTENT_API_URL || !STRAPI_API_TOKEN) {
+      console.error(
+        "Missing environment variables:",
+        !CONTENT_API_URL && "STRAPI_CONTENT_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(
+      `${CONTENT_API_URL}?publicationState=live&populate=image&fields[0]=title&fields[1]=description&fields[2]=createdAt&fields[3]=category&pagination[pageSize]=100&t=${Date.now()}`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+        },
+        cache: "no-store",
+      }
+    );
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error("GET /api/gallery-data: Fetch images failed:", { status: response.status, errorText });
+      return NextResponse.json(
+        { error: `Failed to fetch images: ${errorText}` },
+        { status: response.status }
+      );
+    }
+
+    const result = await response.json();
+    let allImages = result.data;
+
+    if (result.meta?.pagination?.total > 100) {
+      const totalPages = result.meta.pagination.pageCount;
+      for (let page = 2; page <= totalPages; page++) {
+        const nextPageResponse = await fetch(
+          `${CONTENT_API_URL}?publicationState=live&populate=image&fields[0]=title&fields[1]=description&fields[2]=createdAt&fields[3]=category&pagination[page]=${page}&pagination[pageSize]=100&t=${Date.now()}`,
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+            },
+          }
+        );
+        const nextPageResult = await nextPageResponse.json();
+        allImages = [...allImages, ...nextPageResult.data];
+      }
+    }
+
+    const images: UploadedImage[] = allImages
+      .map((item: any) => {
+        const image = item.image;
+        if (!image || !image.url) {
+          console.warn(`Image missing for item ${item.id}:`, JSON.stringify(item, null, 2));
+          return null;
+        }
+        const rawUrl = image.url || "";
+        const imageUrl = rawUrl.startsWith("http") ? rawUrl : `${BASE_URL}${rawUrl}`;
+        return {
+          id: item.id,
+          documentId: item.documentId,
+          title: item.title || "",
+          description: item.description || "",
+          url: imageUrl,
+          createdAt: item.createdAt,
+          category: item.category || "none",
+        };
+      })
+      .filter((image: UploadedImage | null): image is UploadedImage => image !== null)
+      .sort((a: UploadedImage, b: UploadedImage) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+
+    return NextResponse.json({
+      data: images,
+      meta: result.meta,
+    });
+  } catch (error) {
+    console.error("GET /api/gallery-data: Error:", error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "An error occurred while fetching images" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: NextRequest) {
+  const { userId } = getAuth(request);
+  if (!userId) {
+    console.error("POST /api/gallery-data: No userId, returning 401");
+    return NextResponse.json({ error: "Unauthorized: No user ID" }, { status: 401 });
+  }
+
+  const user = await verifyUser(request);
+
+  if (!user || user.businessAdminId !== ADMIN_BUSINESS_ID || user.userRole !== "admin") {
+    console.error("POST /api/gallery-data: Unauthorized access attempt", {
+      authId: user?.authId,
+      businessAdminId: user?.businessAdminId,
+      envBusinessAdminId: ADMIN_BUSINESS_ID,
+      userRole: user?.userRole,
+    });
+    return NextResponse.json({ error: "Unauthorized: Only admins can upload images" }, { status: 403 });
+  }
+
+  try {
+    if (!CONTENT_API_URL || !UPLOAD_API_URL || !STRAPI_API_TOKEN) {
+      console.error(
+        "Missing environment variables:",
+        !CONTENT_API_URL && "STRAPI_CONTENT_API_URL",
+        !UPLOAD_API_URL && "UPLOAD_API_URL",
+        !STRAPI_API_TOKEN && "STRAPI_API_TOKEN"
+      );
+      return NextResponse.json(
+        { error: "Server configuration error: Missing required environment variables" },
+        { status: 500 }
+      );
+    }
+
+    const formData = await request.formData();
+    const file = formData.get("file") as File | null;
+    const title = formData.get("title") as string | null;
+    const description = formData.get("description") as string | null;
+    const category = formData.get("category") as UploadedImage["category"] | null;
+
+    if (!file) {
+      console.error("POST /api/gallery-data: No file provided");
+      return NextResponse.json({ error: "No file provided" }, { status: 400 });
+    }
+
+    if (!["image/jpeg", "image/png", "image/gif"].includes(file.type)) {
+      console.error("POST /api/gallery-data: Invalid file type", { fileType: file.type });
+      return NextResponse.json({ error: "Only JPEG, PNG, or GIF images are allowed" }, { status: 400 });
+    }
+
+    const validCategory = category && ["none", "indoor", "outdoor", "commercial"].includes(category) ? category : "none";
+
+    const uploadFormData = new FormData();
+    uploadFormData.append("files", file);
+
+    const uploadResponse = await fetch(UPLOAD_API_URL, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+      },
+      body: uploadFormData,
+    });
+
+    if (!uploadResponse.ok) {
+      const errorText = await uploadResponse.text();
+      console.error("POST /api/gallery-data: Upload failed:", { status: uploadResponse.status, errorText });
+      return NextResponse.json(
+        { error: `Failed to upload image: ${errorText}` },
+        { status: uploadResponse.status }
+      );
+    }
+
+    const uploadResult = await uploadResponse.json();
+    const uploadedFileId = uploadResult[0]?.id;
+    const uploadedFileUrl = uploadResult[0]?.url;
+    if (!uploadedFileId || !uploadedFileUrl) {
+      console.error("POST /api/gallery-data: Invalid upload response", { uploadResult });
+      return NextResponse.json({ error: "Invalid upload response" }, { status: 500 });
+    }
+
+    const payload = {
+      data: {
+        image: uploadedFileId,
+        title: title || `Image ${new Date().toISOString()}`,
+        description: description || "",
+        category: validCategory,
+        publishedAt: new Date().toISOString(),
+      },
+    };
+
+    const createResponse = await fetch(CONTENT_API_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (!createResponse.ok) {
+      const errorData = await createResponse.json();
+      let errorMessage = `Failed to create content entry: ${createResponse.status} - ${errorData.error?.message || "Unknown error"}`;
+      if (errorData.error?.details) {
+        errorMessage += `\nDetails: ${JSON.stringify(errorData.error.details, null, 2)}`;
+      }
+      console.error("POST /api/gallery-data: Create content failed", { errorMessage });
+      return NextResponse.json({ error: errorMessage }, { status: createResponse.status });
+    }
+
+    const filesResponse = await fetch(
+      `${CONTENT_API_URL}?publicationState=live&populate=image&fields[0]=title&fields[1]=description&fields[2]=createdAt&fields[3]=category&pagination[pageSize]=100&t=${Date.now()}`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+        },
+        cache: "no-store",
+      }
+    );
+
+    if (!filesResponse.ok) {
+      const errorText = await filesResponse.text();
+      console.error("POST /api/gallery-data: Refetch images failed:", { status: filesResponse.status, errorText });
+      return NextResponse.json(
+        { error: `Failed to refetch images: ${errorText}` },
+        { status: filesResponse.status }
+      );
+    }
+
+    const filesResult = await filesResponse.json();
+    const images: UploadedImage[] = filesResult.data
+      .map((item: any) => {
+        const image = item.image;
+        if (!image || !image.url) {
+          console.warn(`Image missing for item ${item.id}:`, JSON.stringify(item, null, 2));
+          return null;
+        }
+        const rawUrl = image.url || "";
+        const imageUrl = rawUrl.startsWith("http") ? rawUrl : `${BASE_URL}${rawUrl}`;
+        return {
+          id: item.id,
+          documentId: item.documentId,
+          title: item.title || "",
+          description: item.description || "",
+          url: imageUrl,
+          createdAt: item.createdAt,
+          category: item.category || "none",
+        };
+      })
+      .filter((image: UploadedImage | null): image is UploadedImage => image !== null)
+      .sort((a: UploadedImage, b: UploadedImage) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+
+    return NextResponse.json({
+      data: images,
+      meta: filesResult.meta,
+      newImageUrl: uploadedFileUrl,
+    });
+  } catch (error) {
+    console.error("POST /api/gallery-data: Error:", error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to upload image" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PUT(request: NextRequest) {
+  const { userId } = getAuth(request);
+  if (!userId) {
+    console.error("PUT /api/gallery-data: No userId, returning 401");
+    return NextResponse.json({ error: "Unauthorized: No user ID" }, { status: 401 });
+  }
+
+  const user = await verifyUser(request);
+
+  if (!user || user.businessAdminId !== ADMIN_BUSINESS_ID || user.userRole !== "admin") {
+    console.error("PUT /api/gallery-data: Unauthorized access attempt", {
+      authId: user?.authId,
+      businessAdminId: user?.businessAdminId,
+      envBusinessAdminId: ADMIN_BUSINESS_ID,
+      userRole: user?.userRole,
+    });
+    return NextResponse.json({ error: "Unauthorized: Only admins can edit images" }, { status: 403 });
+  }
+
+  try {
+    if (!CONTENT_API_URL || !STRAPI_API_TOKEN) {
+      console.error(
+        "Missing environment variables:",
+        !CONTENT_API_URL && "STRAPI_CONTENT_API_URL",
+        !STRAPI_API_TOKEN && "STRAPI_API_TOKEN"
+      );
+      return NextResponse.json(
+        { error: "Server configuration error: Missing required environment variables" },
+        { status: 500 }
+      );
+    }
+
+    const { documentId, title, description, category } = await request.json();
+
+    if (!documentId) {
+      console.error("PUT /api/gallery-data: Document ID is required");
+      return NextResponse.json({ error: "Document ID is required" }, { status: 400 });
+    }
+
+    const validCategory = category && ["none", "indoor", "outdoor", "commercial"].includes(category) ? category : "none";
+
+    const payload = {
+      data: {
+        title: title || `Image ${new Date().toISOString()}`,
+        description: description || "",
+        category: validCategory,
+      },
+    };
+
+    const updateResponse = await fetch(`${CONTENT_API_URL}/${documentId}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (!updateResponse.ok) {
+      const errorData = await updateResponse.json();
+      let errorMessage = `Failed to update content entry: ${updateResponse.status} - ${errorData.error?.message || "Unknown error"}`;
+      if (errorData.error?.details) {
+        errorMessage += `\nDetails: ${JSON.stringify(errorData.error.details, null, 2)}`;
+      }
+      console.error("PUT /api/gallery-data: Update content failed", { errorMessage });
+      return NextResponse.json({ error: errorMessage }, { status: updateResponse.status });
+    }
+
+    const filesResponse = await fetch(
+      `${CONTENT_API_URL}?publicationState=live&populate=image&fields[0]=title&fields[1]=description&fields[2]=createdAt&fields[3]=category&pagination[pageSize]=100&t=${Date.now()}`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+        },
+        cache: "no-store",
+      }
+    );
+
+    if (!filesResponse.ok) {
+      const errorText = await filesResponse.text();
+      console.error("PUT /api/gallery-data: Refetch images failed:", { status: filesResponse.status, errorText });
+      return NextResponse.json(
+        { error: `Failed to refetch images: ${errorText}` },
+        { status: filesResponse.status }
+      );
+    }
+
+    const filesResult = await filesResponse.json();
+    const images: UploadedImage[] = filesResult.data
+      .map((item: any) => {
+        const image = item.image;
+        if (!image || !image.url) {
+          console.warn(`Image missing for item ${item.id}:`, JSON.stringify(item, null, 2));
+          return null;
+        }
+        const rawUrl = image.url || "";
+        const imageUrl = rawUrl.startsWith("http") ? rawUrl : `${BASE_URL}${rawUrl}`;
+        return {
+          id: item.id,
+          documentId: item.documentId,
+          title: item.title || "",
+          description: item.description || "",
+          url: imageUrl,
+          createdAt: item.createdAt,
+          category: item.category || "none",
+        };
+      })
+      .filter((image: UploadedImage | null): image is UploadedImage => image !== null)
+      .sort((a: UploadedImage, b: UploadedImage) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+
+    return NextResponse.json({
+      data: images,
+      meta: filesResult.meta,
+    });
+  } catch (error) {
+    console.error("PUT /api/gallery-data: Error:", error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to update image" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(request: NextRequest) {
+  const { userId } = getAuth(request);
+  if (!userId) {
+    console.error("DELETE /api/gallery-data: No userId, returning 401");
+    return NextResponse.json({ error: "Unauthorized: No user ID" }, { status: 401 });
+  }
+
+  const user = await verifyUser(request);
+
+  if (!user || user.businessAdminId !== ADMIN_BUSINESS_ID || user.userRole !== "admin") {
+    console.error("DELETE /api/gallery-data: Unauthorized access attempt", {
+      authId: user?.authId,
+      businessAdminId: user?.businessAdminId,
+      envBusinessAdminId: ADMIN_BUSINESS_ID,
+      userRole: user?.userRole,
+    });
+    return NextResponse.json({ error: "Unauthorized: Only admins can delete images" }, { status: 403 });
+  }
+
+  try {
+    if (!CONTENT_API_URL || !STRAPI_API_TOKEN) {
+      console.error(
+        "Missing environment variables:",
+        !CONTENT_API_URL && "STRAPI_CONTENT_API_URL",
+        !STRAPI_API_TOKEN && "STRAPI_API_TOKEN"
+      );
+      return NextResponse.json(
+        { error: "Server configuration error: Missing required environment variables" },
+        { status: 500 }
+      );
+    }
+
+    const { documentId } = await request.json();
+    if (!documentId) {
+      console.error("DELETE /api/gallery-data: Document ID is required");
+      return NextResponse.json({ error: "Document ID is required" }, { status: 400 });
+    }
+
+    const docResponse = await fetch(`${CONTENT_API_URL}/${documentId}?populate=image`, {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+      },
+    });
+
+    if (!docResponse.ok) {
+      const errorText = await docResponse.text();
+      console.error("DELETE /api/gallery-data: Fetch document failed:", { status: docResponse.status, errorText });
+      return NextResponse.json(
+        { error: `Failed to fetch content: ${errorText}` },
+        { status: docResponse.status }
+      );
+    }
+
+    const docData = await docResponse.json();
+    const uploadFileId = docData.data?.image?.id;
+
+    const deleteDocResponse = await fetch(`${CONTENT_API_URL}/${documentId}`, {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+      },
+    });
+
+    if (!deleteDocResponse.ok) {
+      const errorText = await deleteDocResponse.text();
+      console.error("DELETE /api/gallery-data: Delete document failed:", { status: deleteDocResponse.status, errorText });
+      return NextResponse.json(
+        { error: `Failed to delete content: ${errorText}` },
+        { status: deleteDocResponse.status }
+      );
+    }
+
+    if (uploadFileId) {
+      const deleteFileResponse = await fetch(`${UPLOAD_API_URL}/files/${uploadFileId}`, {
+        method: "DELETE",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+        },
+      });
+
+      if (!deleteFileResponse.ok) {
+        const errorText = await deleteFileResponse.text();
+        console.warn(`DELETE /api/gallery-data: Failed to delete associated file: ${deleteFileResponse.status} - ${errorText}`);
+      }
+    }
+
+    const filesResponse = await fetch(
+      `${CONTENT_API_URL}?publicationState=live&populate=image&fields[0]=title&fields[1]=description&fields[2]=createdAt&fields[3]=category&pagination[pageSize]=100&t=${Date.now()}`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+        },
+        cache: "no-store",
+      }
+    );
+
+    if (!filesResponse.ok) {
+      const errorText = await filesResponse.text();
+      console.error("DELETE /api/gallery-data: Refetch images failed:", { status: filesResponse.status, errorText });
+      return NextResponse.json(
+        { error: `Failed to refetch images: ${errorText}` },
+        { status: filesResponse.status }
+      );
+    }
+
+    const filesResult = await filesResponse.json();
+    const images: UploadedImage[] = filesResult.data
+      .map((item: any) => {
+        const image = item.image;
+        if (!image || !image.url) {
+          console.warn(`Image missing for item ${item.id}:`, JSON.stringify(item, null, 2));
+          return null;
+        }
+        const rawUrl = image.url || "";
+        const imageUrl = rawUrl.startsWith("http") ? rawUrl : `${BASE_URL}${rawUrl}`;
+        return {
+          id: item.id,
+          documentId: item.documentId,
+          title: item.title || "",
+          description: item.description || "",
+          url: imageUrl,
+          createdAt: item.createdAt,
+          category: item.category || "none",
+        };
+      })
+      .filter((image: UploadedImage | null): image is UploadedImage => image !== null)
+      .sort((a: UploadedImage, b: UploadedImage) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+
+    return NextResponse.json({
+      data: images,
+      meta: filesResult.meta,
+    });
+  } catch (error) {
+    console.error("DELETE /api/gallery-data: Error:", error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to delete image" },
+      { status: 500 }
+    );
+  }
+}