Added backend route for getting products, added products category map…

…ping

app/api/auth/logout/route.ts

@@ -0,0 +1,9 @@
+import { USER_TOKEN } from "@lib/constants";
+import { cookies } from "next/headers";
+import { NextResponse } from "next/server";
+
+export async function POST(_: Request) {
+  cookies().delete("user_info");
+  cookies().delete(USER_TOKEN);
+  return NextResponse.json({ message: "Logged out" }, { status: 200 });
+}

app/api/interfaces.ts

@@ -0,0 +1,10 @@
+interface filtersInterface {
+  minPrice?: number;
+  maxPrice?: number;
+  skip?: number;
+  take?: number;
+  date?: "asc" | "desc" | null;
+  price?: "asc" | "desc" | null;
+}
+
+export type { filtersInterface };

app/api/products/getProducts.ts

@@ -0,0 +1,249 @@
+import prisma from "@lib/prisma";
+import { filtersInterface } from "../interfaces";
+
+export async function getMotherboards(filters?: filtersInterface) {
+  const motherboards = await prisma.motherboard.findMany({
+    take: filters?.take || 10,
+    skip: filters?.skip || 0,
+    where: {
+      price: {
+        gte: filters?.minPrice || 0,
+        lte: filters?.maxPrice || 1000000,
+      },
+    },
+    orderBy: {
+      price: filters?.price || undefined,
+      createdAt: filters?.date || undefined,
+    },
+  });
+
+  return motherboards;
+}
+
+export async function getCpus(filters?: filtersInterface) {
+  const cpus = await prisma.cpu.findMany({
+    take: filters?.take || 10,
+    skip: filters?.skip || 0,
+    where: {
+      price: {
+        gte: filters?.minPrice || 0,
+        lte: filters?.maxPrice || 1000000,
+      },
+    },
+    orderBy: {
+      price: filters?.price || undefined,
+      createdAt: filters?.date || undefined,
+    },
+  });
+
+  return cpus;
+}
+
+export async function getMemory(filters?: filtersInterface) {
+  const memory = await prisma.memory.findMany({
+    take: filters?.take || 10,
+    skip: filters?.skip || 0,
+    where: {
+      price: {
+        gte: filters?.minPrice || 0,
+        lte: filters?.maxPrice || 1000000,
+      },
+    },
+    orderBy: {
+      price: filters?.price || undefined,
+      createdAt: filters?.date || undefined,
+    },
+  });
+
+  return memory;
+}
+
+export async function getGpus(filters?: filtersInterface) {
+  const gpus = await prisma.gpu.findMany({
+    take: filters?.take || 10,
+    skip: filters?.skip || 0,
+    where: {
+      price: {
+        gte: filters?.minPrice || 0,
+        lte: filters?.maxPrice || 1000000,
+      },
+    },
+    orderBy: {
+      price: filters?.price || undefined,
+      createdAt: filters?.date || undefined,
+    },
+  });
+
+  return gpus;
+}
+
+export async function getCases(filters?: filtersInterface) {
+  const cases = await prisma.case.findMany({
+    take: filters?.take || 10,
+    skip: filters?.skip || 0,
+    where: {
+      price: {
+        gte: filters?.minPrice || 0,
+        lte: filters?.maxPrice || 1000000,
+      },
+    },
+    orderBy: {
+      price: filters?.price || undefined,
+      createdAt: filters?.date || undefined,
+    },
+  });
+
+  return cases;
+}
+
+export async function getPowerSupplies(filters?: filtersInterface) {
+  const powerSupplies = await prisma.powerSupply.findMany({
+    take: filters?.take || 10,
+    skip: filters?.skip || 0,
+    where: {
+      price: {
+        gte: filters?.minPrice || 0,
+        lte: filters?.maxPrice || 1000000,
+      },
+    },
+    orderBy: {
+      price: filters?.price || undefined,
+      createdAt: filters?.date || undefined,
+    },
+  });
+
+  return powerSupplies;
+}
+
+export async function getCpuCooling(filters?: filtersInterface) {
+  const cpuCooling = await prisma.cpuCooling.findMany({
+    take: filters?.take || 10,
+    skip: filters?.skip || 0,
+    where: {
+      price: {
+        gte: filters?.minPrice || 0,
+        lte: filters?.maxPrice || 1000000,
+      },
+    },
+    orderBy: {
+      price: filters?.price || undefined,
+      createdAt: filters?.date || undefined,
+    },
+  });
+
+  return cpuCooling;
+}
+
+export async function getHardDrives(filters?: filtersInterface) {
+  const hardDrives = await prisma.hardDrive.findMany({
+    take: filters?.take || 10,
+    skip: filters?.skip || 0,
+    where: {
+      price: {
+        gte: filters?.minPrice || 0,
+        lte: filters?.maxPrice || 1000000,
+      },
+    },
+    orderBy: {
+      price: filters?.price || undefined,
+      createdAt: filters?.date || undefined,
+    },
+  });
+
+  return hardDrives;
+}
+
+export async function getHeadsets(filters?: filtersInterface) {
+  const headsets = await prisma.headset.findMany({
+    take: filters?.take || 10,
+    skip: filters?.skip || 0,
+    where: {
+      price: {
+        gte: filters?.minPrice || 0,
+        lte: filters?.maxPrice || 1000000,
+      },
+    },
+    orderBy: {
+      price: filters?.price || undefined,
+      createdAt: filters?.date || undefined,
+    },
+  });
+
+  return headsets;
+}
+
+export async function getMice(filters?: filtersInterface) {
+  const mice = await prisma.mouse.findMany({
+    take: filters?.take || 10,
+    skip: filters?.skip || 0,
+    where: {
+      price: {
+        gte: filters?.minPrice || 0,
+        lte: filters?.maxPrice || 1000000,
+      },
+    },
+    orderBy: {
+      price: filters?.price || undefined,
+      createdAt: filters?.date || undefined,
+    },
+  });
+
+  return mice;
+}
+
+export async function getKeyboards(filters?: filtersInterface) {
+  const keyboards = await prisma.keyboard.findMany({
+    take: filters?.take || 10,
+    skip: filters?.skip || 0,
+    where: {
+      price: {
+        gte: filters?.minPrice || 0,
+        lte: filters?.maxPrice || 1000000,
+      },
+    },
+    orderBy: {
+      price: filters?.price || undefined,
+      createdAt: filters?.date || undefined,
+    },
+  });
+
+  return keyboards;
+}
+
+export async function getMonitors(filters?: filtersInterface) {
+  const monitors = await prisma.monitor.findMany({
+    take: filters?.take || 10,
+    skip: filters?.skip || 0,
+    where: {
+      price: {
+        gte: filters?.minPrice || 0,
+        lte: filters?.maxPrice || 1000000,
+      },
+    },
+    orderBy: {
+      price: filters?.price || undefined,
+      createdAt: filters?.date || undefined,
+    },
+  });
+
+  return monitors;
+}
+
+export async function getWebcams(filters?: filtersInterface) {
+  const webcams = await prisma.webcam.findMany({
+    take: filters?.take || 10,
+    skip: filters?.skip || 0,
+    where: {
+      price: {
+        gte: filters?.minPrice || 0,
+        lte: filters?.maxPrice || 1000000,
+      },
+    },
+    orderBy: {
+      price: filters?.price || undefined,
+      createdAt: filters?.date || undefined,
+    },
+  });
+
+  return webcams;
+}

app/api/products/route.ts

@@ -0,0 +1,100 @@
+import { NextResponse } from "next/server";
+import {
+  getCases,
+  getCpuCooling,
+  getCpus,
+  getGpus,
+  getHardDrives,
+  getHeadsets,
+  getKeyboards,
+  getMemory,
+  getMice,
+  getMonitors,
+  getMotherboards,
+  getPowerSupplies,
+} from "./getProducts";
+import { filtersInterface } from "../interfaces";
+
+export async function GET(req: Request) {
+  try {
+    const url = new URL(req.url);
+    const category = url.searchParams.get("category");
+    const minPrice = url.searchParams.get("minPrice") || 0;
+    const maxPrice = url.searchParams.get("maxPrice") || 1000000;
+    const skip = url.searchParams.get("skip") || 0;
+    const take = url.searchParams.get("take") || 10;
+    const date = url.searchParams.get("date") || null;
+    const price = url.searchParams.get("price") || null;
+
+    if (!category) {
+      return NextResponse.json({ error: "Provide category!" }, { status: 400 });
+    }
+
+    const filters: filtersInterface = {
+      minPrice: +minPrice,
+      maxPrice: +maxPrice,
+      skip: +skip,
+      take: +take,
+      date: date as "asc" | "desc" | null,
+      price: price as "asc" | "desc" | null,
+    };
+
+    let data: unknown;
+
+    switch (category) {
+      case "motherboards":
+        data = await getMotherboards(filters);
+        break;
+      case "cpus":
+        data = await getCpus(filters);
+        break;
+      case "memory":
+        data = await getMemory(filters);
+        break;
+      case "gpus":
+        data = await getGpus(filters);
+        break;
+      case "cases":
+        data = await getCases(filters);
+        break;
+      case "power-supply":
+        data = await getPowerSupplies(filters);
+        break;
+      case "cooling":
+        data = getCpuCooling(filters);
+        break;
+      case "storage":
+        data = getHardDrives(filters);
+        break;
+      case "headsets":
+        data = getHeadsets(filters);
+        break;
+      case "mouses":
+        data = getMice(filters);
+        break;
+      case "keyboards":
+        data = getKeyboards(filters);
+        break;
+      case "monitors":
+        data = getMonitors(filters);
+        break;
+      case "webcams":
+        data = getMonitors(filters);
+        break;
+    }
+
+    return NextResponse.json({
+      status: 200,
+      body: {
+        category,
+        data,
+      },
+    });
+  } catch (error) {
+    console.log(error);
+    return NextResponse.json(
+      { error: "Internal Server Error" },
+      { status: 500 }
+    );
+  }
+}

app/auth/login/page.tsx

@@ -50,6 +50,7 @@ export default function LoginPage(): JSX.Element {
         toast({
           title: "Succesfully logged in!",
         });
+        window.location.href = "/";
         break;
       case 401:
         toast({
@@ -124,7 +125,8 @@ export default function LoginPage(): JSX.Element {
         </Form>
       </div>
       <Image
-        className="w-full h-full shadow-lg rounded-r-lg dark:brightness-75"
+        className="w-full h-full shadow-lg rounded-r-lg dark:brightness-[.85]"
+        priority
         alt=""
         src={Bg}
       />