feat: implement CSV import

Author: ksambhi

collection/app/(app)/CSVImport.tsx

@@ -1,5 +1,8 @@
 "use client";
 
+import { CSVFormValues, importCsv } from "@/lib/crud/importCsv";
+import { StatusReturn } from "@/lib/types";
+import { isValidAcademicYear } from "@docsoc/eactivities";
 import {
     Alert,
     Badge,
@@ -19,8 +22,9 @@ import "@mantine/dropzone/styles.css";
 import { useForm } from "@mantine/form";
 import { useDisclosure } from "@mantine/hooks";
 import { RootItem } from "@prisma/client";
-import React from "react";
+import React, { useState, useTransition } from "react";
 import {
+    FaCircleCheck,
     FaCircleXmark,
     FaDownload,
     FaTable,
@@ -29,22 +33,21 @@ import {
 } from "react-icons/fa6";
 import useSWR from "swr";
 
-interface FormValues {
-    csv: File[];
-    productId: string;
-    academicYear: string;
-}
-
 interface CSVImportFormProp {
     /** Undefiend treated as loading UI */
     productsByAcademicYear: Record<string, RootItem[]>;
 }
 
 const CSVImportForm: React.FC<CSVImportFormProp> = ({ productsByAcademicYear }) => {
-    const form = useForm<FormValues>({
+    const [isPending, startTransition] = useTransition();
+    const [formState, setFormState] = useState<StatusReturn>({
+        status: "pending",
+    });
+    const form = useForm<CSVFormValues>({
         mode: "controlled",
         initialValues: {
-            productId: "",
+            productId:
+                productsByAcademicYear[Object.keys(productsByAcademicYear)[0]][0].id.toString(10),
             csv: [],
             academicYear: Object.keys(productsByAcademicYear)[0],
         },
@@ -76,9 +79,42 @@ const CSVImportForm: React.FC<CSVImportFormProp> = ({ productsByAcademicYear })
         </Badge>
     ));
 
+    const formHandler = (values: CSVFormValues) => {
+        const productId = parseInt(values.productId, 10);
+        const academicYear = values.academicYear;
+        if (!productId || !academicYear) {
+            return;
+        }
+
+        if (values.csv.length === 0) {
+            form.setFieldError("csv", "Please select a CSV file to import.");
+            return;
+        }
+
+        if (!isValidAcademicYear(academicYear)) {
+            form.setFieldError("academicYear", "Invalid academic year.");
+            return;
+        }
+
+        startTransition(async () => {
+            const csvString = await values.csv[0].text();
+            const res = await importCsv(csvString, productId, academicYear);
+            setFormState(res);
+        });
+    };
+
     return (
-        <form>
+        <form onSubmit={form.onSubmit(formHandler)}>
             <Stack gap="md">
+                {formState.status === "success" ? (
+                    <Alert color="green" icon={<FaCircleCheck />} title="Success">
+                        {formState.message ?? "Data imported successfully"}
+                    </Alert>
+                ) : formState.status === "error" ? (
+                    <Alert color="red" icon={<FaCircleXmark />} title="Error">
+                        {formState.error}
+                    </Alert>
+                ) : null}
                 <NativeSelect
                     label="Academic year"
                     name="academicYear"
@@ -165,7 +201,12 @@ const CSVImportForm: React.FC<CSVImportFormProp> = ({ productsByAcademicYear })
                         {selectedFiles}
                     </Stack>
                 )}
-                <Button type="submit" color="green" leftSection={<FaDownload />}>
+                <Button
+                    type="submit"
+                    color="green"
+                    leftSection={<FaDownload />}
+                    loading={isPending}
+                >
                     Import data
                 </Button>
             </Stack>

collection/lib/crud/importCsv.ts

@@ -0,0 +1,163 @@
+"use server";
+
+import { AcademicYear } from "@docsoc/eactivities";
+import { createLogger } from "@docsoc/util";
+import { parse } from "csv-parse";
+import { revalidatePath, revalidateTag } from "next/cache";
+
+import prisma from "../db";
+import { StatusReturn } from "../types";
+
+const logger = createLogger("collection.importCsv");
+
+async function importFile(fileContents: string, itemId: number, academicYear: AcademicYear) {
+    logger.info("Importing file for: ", itemId);
+
+    const iter = parse(fileContents, {
+        columns: true,
+    });
+
+    // 0: Prep academic year
+    const academicYearDB = await prisma.academicYear.upsert({
+        where: {
+            year: academicYear,
+        },
+        update: {},
+        create: {
+            year: academicYear,
+        },
+    });
+
+    const academicYearReference = academicYearDB.year;
+
+    for await (const record of iter) {
+        logger.debug(`Record: ${JSON.stringify(record)}`);
+
+        // 1: If user exists, get user
+        const user = await prisma.imperialStudent.upsert({
+            where: {
+                shortcode: record["Login"],
+            },
+            update: {
+                cid: record["CID/Card Number"],
+                firstName: record["First Name"],
+                lastName: record["Surname"],
+                email: record["Email"],
+            },
+            create: {
+                cid: record["CID/Card Number"],
+                shortcode: record["Login"],
+                firstName: record["First Name"],
+                lastName: record["Surname"],
+                email: record["Email"],
+            },
+        });
+
+        // 2: Create order
+        // If already exists, skip
+        const orderNo = parseInt(record["Order No"]);
+        const dateString = record["Date"];
+        const [day, month, year] = dateString.split("/");
+        const isoDateString = `${year}-${month}-${day}`;
+        const date = new Date(isoDateString);
+        const order = await prisma.order.upsert({
+            where: {
+                orderNo: orderNo,
+            },
+            update: {},
+            create: {
+                orderDate: date,
+                orderNo: orderNo,
+                academicYearReference: {
+                    connect: {
+                        year: academicYearReference,
+                    },
+                },
+                ImperialStudent: {
+                    connect: {
+                        id: user.id,
+                    },
+                },
+            },
+        });
+
+        // 3: Create variant if needed
+        const variant = record["Product Name"];
+        const quantity = parseInt(record["Quantity"]);
+
+        const varientDB = await prisma.variant.upsert({
+            where: {
+                variantName_rootItemId: {
+                    rootItemId: itemId,
+                    variantName: variant,
+                },
+            },
+            update: {},
+            create: {
+                variantName: variant,
+                RootItem: {
+                    connect: {
+                        id: itemId,
+                    },
+                },
+            },
+        });
+
+        // Add order item
+        // kip if this orderId already exists for this user & variant
+        if (
+            await prisma.orderItem.findFirst({
+                where: {
+                    orderId: order.id,
+                    variantId: varientDB.id,
+                },
+            })
+        ) {
+            continue;
+        }
+
+        // Else, create order item
+        await prisma.orderItem.create({
+            data: {
+                orderId: order.id,
+                variantId: varientDB.id,
+                quantity: quantity,
+                collected: false,
+            },
+        });
+    }
+}
+export interface CSVFormValues {
+    csv: File[];
+    productId: string;
+    academicYear: string;
+}
+
+export async function importCsv(
+    fileContents: string,
+    productId: number,
+    academicYear: AcademicYear,
+): Promise<StatusReturn> {
+    const product = await prisma.rootItem.findUnique({
+        where: {
+            id: productId,
+        },
+    });
+
+    try {
+        await importFile(fileContents, productId, academicYear);
+    } catch (e: any) {
+        return {
+            status: "error",
+            error: e.message ?? e.toString(),
+        };
+    }
+
+    revalidatePath("/");
+    revalidateTag("purchases:*");
+
+    return {
+        status: "success",
+        message: `Data imported for ${product?.name} in ${academicYear}`,
+    };
+}

collection/lib/types.ts

@@ -1,8 +1,12 @@
 export type StatusReturn =
     | {
           status: "success";
+          message?: string;
       }
     | {
           status: "error";
           error: string;
+      }
+    | {
+          status: "pending";
       };

package-lock.json

@@ -71,13 +71,15 @@
     ],
     "dependencies": {
         "@docsoc/eactivities": "^1.2.1",
+        "@docsoc/util": "^1.2.0",
         "@mantine/core": "^7.12.0",
         "@mantine/dropzone": "^7.12.1",
         "@mantine/form": "^7.12.0",
         "@mantine/hooks": "^7.12.0",
         "@prisma/client": "^5.18.0",
         "@tanstack/react-table": "^8.20.1",
         "axios": "^1.6.0",
+        "csv-parse": "^5.5.6",
         "mkdirp": "^3.0.1",
         "next": "^14.2.5",
         "next-auth": "^5.0.0-beta.20",