263 feature categories (#264)

* initial categories

* working state left and right

* update schema

* working condifintal

* working input

* working

* working v2

* working update

* mismatch interface

* done

Author: Codehagen

apps/www/src/actions/calculate-suggested-budget.ts

@@ -0,0 +1,51 @@
+"use server";
+
+import { prisma } from "@/lib/db";
+import { getCurrentUser } from "@/lib/session";
+
+export async function calculateSuggestedBudget() {
+  const user = await getCurrentUser();
+  if (!user) {
+    throw new Error("User not authenticated");
+  }
+
+  const oneMonthAgo = new Date();
+  oneMonthAgo.setMonth(oneMonthAgo.getMonth() - 1);
+
+  try {
+    const categorySums = await prisma.transaction.groupBy({
+      by: ["categoryId"],
+      where: {
+        category: {
+          userId: user.id,
+        },
+        date: {
+          gte: oneMonthAgo,
+        },
+      },
+      _sum: {
+        amount: true,
+      },
+    });
+
+    const categories = await prisma.category.findMany({
+      where: { userId: user.id },
+      select: { id: true, name: true, icon: true },
+    });
+
+    const suggestedBudget = categories.map((category) => {
+      const sum = categorySums.find((sum) => sum.categoryId === category.id);
+      return {
+        id: category.id,
+        name: category.name,
+        icon: category.icon,
+        suggestedAmount: Math.ceil(Math.abs(Number(sum?._sum?.amount ?? 0))),
+      };
+    });
+
+    return suggestedBudget;
+  } catch (error) {
+    console.error("Error calculating suggested budget:", error);
+    throw new Error("Failed to calculate suggested budget");
+  }
+}

apps/www/src/actions/create-budget.ts

@@ -0,0 +1,56 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+
+import { prisma } from "@/lib/db";
+import { getCurrentUser } from "@/lib/session";
+
+interface BudgetData {
+  budgetName: string;
+  categories: Record<string, number>;
+}
+
+export async function createBudget(data: BudgetData) {
+  const user = await getCurrentUser();
+  if (!user) {
+    throw new Error("User not authenticated");
+  }
+
+  const startDate = new Date();
+  const endDate = new Date(startDate);
+  endDate.setFullYear(endDate.getFullYear() + 5);
+
+  try {
+    const budget = await prisma.budget.create({
+      data: {
+        name: data.budgetName,
+        startDate,
+        endDate,
+        amount: Object.values(data.categories).reduce(
+          (sum, amount) => sum + amount,
+          0,
+        ),
+        userId: user.id,
+        categories: {
+          create: Object.entries(data.categories).map(
+            ([categoryId, amount]) => ({
+              amount,
+              categoryId,
+            }),
+          ),
+        },
+      },
+      include: {
+        categories: true,
+      },
+    });
+
+    // Revalidate the categories page to reflect the new budget
+    revalidatePath("/dashboard/categories");
+
+    return { success: true, data: budget };
+  } catch (error) {
+    console.error("Error creating budget:", error);
+    return { success: false, error: "Failed to create budget" };
+  }
+}

apps/www/src/actions/get-categories-review.ts

@@ -0,0 +1,23 @@
+"use server";
+
+import { prisma } from "@/lib/db";
+import { getCurrentUser } from "@/lib/session";
+
+export async function getCategoriesReview() {
+  const user = await getCurrentUser();
+  if (!user) {
+    throw new Error("User not authenticated");
+  }
+
+  try {
+    const categories = await prisma.category.findMany({
+      where: {
+        userId: user.id,
+      },
+    });
+    return categories;
+  } catch (error) {
+    console.error("Error fetching categories:", error);
+    throw new Error("Failed to fetch categories");
+  }
+}

apps/www/src/actions/get-categories.ts

@@ -1,24 +1,45 @@
 // actions/get-categories.ts
 "use server";
 
+import { Prisma } from "@prisma/client";
+
 import { prisma } from "@/lib/db";
 import { getCurrentUser } from "@/lib/session";
 
-export async function getCategories() {
+export async function getUserCategories() {
   const user = await getCurrentUser();
   if (!user) {
     throw new Error("User not authenticated");
   }
 
-  try {
-    const categories = await prisma.category.findMany({
-      where: {
-        userId: user.id,
+  const categories = await prisma.category.findMany({
+    where: {
+      userId: user.id,
+    },
+    select: {
+      id: true,
+      name: true,
+      icon: true,
+      _count: {
+        select: { transactions: true },
       },
-    });
-    return categories;
-  } catch (error) {
-    console.error("Error fetching categories:", error);
-    throw new Error("Failed to fetch categories");
-  }
+      transactions: {
+        select: {
+          amount: true,
+        },
+      },
+    },
+  });
+
+  return categories.map((category) => ({
+    id: category.id,
+    name: category.name,
+    icon: category.icon,
+    spent: category.transactions.reduce(
+      (sum, transaction) => sum + Number(transaction.amount.toString()),
+      0,
+    ),
+    budget: 0, // You'll need to add budget information to your schema and fetch it here
+    _count: category._count,
+  }));
 }

apps/www/src/actions/get-transactions-for-category.ts

@@ -0,0 +1,43 @@
+"use server";
+
+import { prisma } from "@/lib/db";
+import { getCurrentUser } from "@/lib/session";
+
+export async function getTransactionsForCategory(categoryId: string) {
+  const user = await getCurrentUser();
+  if (!user) {
+    throw new Error("User not authenticated");
+  }
+
+  const transactions = await prisma.transaction.findMany({
+    where: {
+      categoryId: categoryId,
+      category: {
+        userId: user.id,
+      },
+    },
+    select: {
+      id: true,
+      date: true,
+      description: true,
+      amount: true,
+      category: {
+        select: {
+          name: true,
+        },
+      },
+    },
+    orderBy: {
+      date: "desc",
+    },
+    take: 10, // Limit to 10 most recent transactions
+  });
+
+  return transactions.map((transaction) => ({
+    id: transaction.id,
+    date: transaction.date,
+    description: transaction.description,
+    category: transaction.category?.name,
+    amount: Number(transaction.amount), // Convert Decimal to number
+  }));
+}

apps/www/src/actions/get-user-budget.ts

@@ -0,0 +1,51 @@
+"use server";
+
+import { prisma } from "@/lib/db";
+import { getCurrentUser } from "@/lib/session";
+
+export async function getUserBudget() {
+  const user = await getCurrentUser();
+  if (!user) {
+    throw new Error("User not authenticated");
+  }
+
+  const currentDate = new Date();
+
+  // Fetch the most recent budget that includes the current date
+  const budget = await prisma.budget.findFirst({
+    where: {
+      userId: user.id,
+      startDate: { lte: currentDate },
+      endDate: { gte: currentDate },
+    },
+    include: {
+      categories: {
+        include: {
+          category: true,
+        },
+      },
+    },
+    orderBy: {
+      startDate: "desc",
+    },
+  });
+
+  if (!budget) {
+    return null; // Or you could return a default budget structure
+  }
+
+  // Transform the data to match the structure expected by your components
+  return {
+    id: budget.id,
+    name: budget.name,
+    startDate: budget.startDate,
+    endDate: budget.endDate,
+    amount: Number(budget.amount),
+    categories: budget.categories.map((cb) => ({
+      id: cb.category.id,
+      name: cb.category.name,
+      icon: cb.category.icon,
+      budget: Number(cb.amount),
+    })),
+  };
+}

apps/www/src/actions/get-user-categories.ts

@@ -0,0 +1,26 @@
+import { prisma } from "@/lib/db";
+import { getCurrentUser } from "@/lib/session";
+
+export async function getUserCategories() {
+  const user = await getCurrentUser();
+  if (!user) {
+    throw new Error("User not authenticated");
+  }
+
+  // Fetch categories associated with the user
+  const categories = await prisma.category.findMany({
+    where: {
+      userId: user.id,
+    },
+    select: {
+      id: true,
+      name: true,
+      icon: true,
+      _count: {
+        select: { transactions: true },
+      },
+    },
+  });
+
+  return categories;
+}

apps/www/src/actions/update-budget.ts

@@ -0,0 +1,47 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+
+import { prisma } from "@/lib/db";
+import { getCurrentUser } from "@/lib/session";
+
+interface UpdateBudgetData {
+  id: string;
+  budgetName: string;
+  categories: Record<string, number>;
+}
+
+export async function updateBudget(data: UpdateBudgetData) {
+  const user = await getCurrentUser();
+  if (!user) {
+    return { success: false, error: "User not authenticated" };
+  }
+
+  try {
+    const updatedBudget = await prisma.budget.update({
+      where: { id: data.id, userId: user.id },
+      data: {
+        name: data.budgetName,
+        categories: {
+          upsert: Object.entries(data.categories).map(
+            ([categoryId, amount]) => ({
+              where: { budgetId_categoryId: { budgetId: data.id, categoryId } },
+              update: { amount },
+              create: { categoryId, amount },
+            }),
+          ),
+        },
+      },
+      include: {
+        categories: true,
+      },
+    });
+
+    revalidatePath("/dashboard/categories");
+
+    return { success: true, data: updatedBudget };
+  } catch (error) {
+    console.error("Error updating budget:", error);
+    return { success: false, error: "Failed to update budget" };
+  }
+}