212 lines
9.1 KiB
TypeScript
212 lines
9.1 KiB
TypeScript
import { Between, In } from 'typeorm';
|
|
import { AppDataSource } from '../config/data-source.js';
|
|
import { Budget } from '../entities/Budget.js';
|
|
import { Expense } from '../entities/Expense.js';
|
|
import { RecurringExpense } from '../entities/RecurringExpense.js';
|
|
|
|
export type StatsFilters = { userId?: string; startDate?: string; endDate?: string; categoryIds?: string[]; tag?: string; status?: string };
|
|
export type FlatExpense = {
|
|
id: string;
|
|
amount: number;
|
|
expenseDate: string;
|
|
categoryId: string;
|
|
categoryName: string;
|
|
tags?: string[];
|
|
status?: string;
|
|
};
|
|
|
|
const labelMonth = (date: string) => date.slice(0, 7);
|
|
const labelQuarter = (date: string) => {
|
|
const [year, month] = date.split('-').map(Number);
|
|
return `${year}-Q${Math.ceil(month / 3)}`;
|
|
};
|
|
const labelYear = (date: string) => date.slice(0, 4);
|
|
|
|
export const buildBucketLabel = (date: string, bucket: 'month' | 'quarter' | 'year') =>
|
|
bucket === 'year' ? labelYear(date) : bucket === 'quarter' ? labelQuarter(date) : labelMonth(date);
|
|
|
|
export const aggregateStatistics = (expenses: FlatExpense[], bucket: 'month' | 'quarter' | 'year' = 'month') => {
|
|
const total = expenses.reduce((sum, item) => sum + item.amount, 0);
|
|
const byCategoryMap = new Map<string, { categoryId: string; categoryName: string; total: number; count: number }>();
|
|
const timelineMap = new Map<string, number>();
|
|
const byTagMap = new Map<string, number>();
|
|
const byStatusMap = new Map<string, number>();
|
|
|
|
for (const expense of expenses) {
|
|
const existing = byCategoryMap.get(expense.categoryId) ?? {
|
|
categoryId: expense.categoryId,
|
|
categoryName: expense.categoryName,
|
|
total: 0,
|
|
count: 0
|
|
};
|
|
existing.total += expense.amount;
|
|
existing.count += 1;
|
|
byCategoryMap.set(expense.categoryId, existing);
|
|
|
|
const bucketLabel = buildBucketLabel(expense.expenseDate, bucket);
|
|
timelineMap.set(bucketLabel, (timelineMap.get(bucketLabel) ?? 0) + expense.amount);
|
|
|
|
for (const tag of expense.tags ?? []) {
|
|
byTagMap.set(tag, (byTagMap.get(tag) ?? 0) + expense.amount);
|
|
}
|
|
|
|
if (expense.status) byStatusMap.set(expense.status, (byStatusMap.get(expense.status) ?? 0) + 1);
|
|
}
|
|
|
|
const byCategory = [...byCategoryMap.values()]
|
|
.sort((a, b) => b.total - a.total)
|
|
.map((item) => ({ ...item, total: Number(item.total.toFixed(2)) }));
|
|
const timeline = [...timelineMap.entries()]
|
|
.map(([label, totalValue]) => ({ label, total: Number(totalValue.toFixed(2)) }))
|
|
.sort((a, b) => a.label.localeCompare(b.label));
|
|
const byTag = [...byTagMap.entries()]
|
|
.map(([tag, totalValue]) => ({ tag, total: Number(totalValue.toFixed(2)) }))
|
|
.sort((a, b) => b.total - a.total)
|
|
.slice(0, 10);
|
|
const byStatus = [...byStatusMap.entries()]
|
|
.map(([status, count]) => ({ status, count }))
|
|
.sort((a, b) => b.count - a.count);
|
|
|
|
return {
|
|
total: Number(total.toFixed(2)),
|
|
count: expenses.length,
|
|
average: expenses.length ? Number((total / expenses.length).toFixed(2)) : 0,
|
|
byCategory,
|
|
timeline,
|
|
byTag,
|
|
byStatus,
|
|
topCategory: byCategory[0] ?? null
|
|
};
|
|
};
|
|
|
|
export const getStatistics = async (filters: StatsFilters, bucket: 'month' | 'quarter' | 'year' = 'month') => {
|
|
const repo = AppDataSource.getRepository(Expense);
|
|
const where: Record<string, unknown> = {};
|
|
if (filters.userId) where.user = { id: filters.userId };
|
|
if (filters.startDate && filters.endDate) where.expenseDate = Between(filters.startDate, filters.endDate);
|
|
else if (filters.startDate) where.expenseDate = Between(filters.startDate, '2999-12-31');
|
|
else if (filters.endDate) where.expenseDate = Between('1900-01-01', filters.endDate);
|
|
if (filters.categoryIds?.length) where.category = { id: In(filters.categoryIds) };
|
|
if (filters.status) where.status = filters.status;
|
|
|
|
const expenses = await repo.find({ where, relations: { category: true }, order: { expenseDate: 'DESC' } });
|
|
const filteredByTag = filters.tag
|
|
? expenses.filter((expense) => (expense.tags ?? []).some((tag) => tag.toLowerCase() === filters.tag!.toLowerCase()))
|
|
: expenses;
|
|
|
|
return aggregateStatistics(
|
|
filteredByTag.map((expense) => ({
|
|
id: expense.id,
|
|
amount: expense.amount,
|
|
expenseDate: expense.expenseDate,
|
|
categoryId: expense.category.id,
|
|
categoryName: expense.category.name,
|
|
tags: expense.tags ?? [],
|
|
status: expense.status
|
|
})),
|
|
bucket
|
|
);
|
|
};
|
|
|
|
const currentMonthKey = () => {
|
|
const date = new Date();
|
|
return `${date.getFullYear()}-${`${date.getMonth() + 1}`.padStart(2, '0')}`;
|
|
};
|
|
|
|
const monthRange = (monthKey: string) => {
|
|
const [yearText, monthText] = monthKey.split('-');
|
|
const year = Number(yearText);
|
|
const month = Number(monthText);
|
|
const lastDay = new Date(year, month, 0).getDate();
|
|
return { startDate: `${monthKey}-01`, endDate: `${monthKey}-${String(lastDay).padStart(2, '0')}` };
|
|
};
|
|
|
|
export const getCashflowSummary = async (userId: string) => {
|
|
const expenseRepo = AppDataSource.getRepository(Expense);
|
|
const budgetRepo = AppDataSource.getRepository(Budget);
|
|
const recurringRepo = AppDataSource.getRepository(RecurringExpense);
|
|
|
|
const currentMonth = currentMonthKey();
|
|
const currentRange = monthRange(currentMonth);
|
|
const startWindow = new Date();
|
|
startWindow.setMonth(startWindow.getMonth() - 5, 1);
|
|
const startDate = `${startWindow.getFullYear()}-${`${startWindow.getMonth() + 1}`.padStart(2, '0')}-01`;
|
|
|
|
const expenses = await expenseRepo.find({
|
|
where: { user: { id: userId }, expenseDate: Between(startDate, currentRange.endDate) },
|
|
relations: { category: true },
|
|
order: { expenseDate: 'ASC' }
|
|
});
|
|
const budgets = await budgetRepo.find({ where: { user: { id: userId }, month: currentMonth }, relations: { category: true } });
|
|
const recurring = await recurringRepo.find({ where: { user: { id: userId }, isActive: true }, relations: { category: true }, order: { nextRunDate: 'ASC' } });
|
|
|
|
const months = new Map<string, { label: string; actual: number; budget: number }>();
|
|
for (let offset = 5; offset >= 0; offset -= 1) {
|
|
const date = new Date();
|
|
date.setMonth(date.getMonth() - offset, 1);
|
|
const key = `${date.getFullYear()}-${`${date.getMonth() + 1}`.padStart(2, '0')}`;
|
|
months.set(key, { label: key, actual: 0, budget: 0 });
|
|
}
|
|
|
|
for (const expense of expenses) {
|
|
const month = expense.expenseDate.slice(0, 7);
|
|
const entry = months.get(month);
|
|
if (entry && expense.status !== 'REJECTED' && expense.status !== 'DRAFT') entry.actual += expense.amount;
|
|
}
|
|
|
|
for (const budget of budgets) {
|
|
const entry = months.get(budget.month);
|
|
if (entry) entry.budget += budget.amount;
|
|
}
|
|
|
|
const duplicateCount = expenses.filter((expense) => expense.possibleDuplicate && expense.duplicateStatus === 'OPEN' && expense.expenseDate.startsWith(currentMonth)).length;
|
|
const currentMonthExpenses = expenses.filter((expense) => expense.expenseDate.startsWith(currentMonth));
|
|
const actualCurrent = currentMonthExpenses
|
|
.filter((expense) => expense.status !== 'REJECTED' && expense.status !== 'DRAFT')
|
|
.reduce((sum, expense) => sum + expense.amount, 0);
|
|
const pendingApproval = currentMonthExpenses.filter((expense) => expense.status === 'PENDING').length;
|
|
const upcomingRecurring = recurring
|
|
.filter((item) => item.nextRunDate >= currentRange.startDate && item.nextRunDate <= currentRange.endDate)
|
|
.map((item) => ({ id: item.id, title: item.title, amount: item.amount, nextRunDate: item.nextRunDate, frequency: item.frequency }));
|
|
|
|
const totalBudget = budgets.reduce((sum, item) => sum + item.amount, 0);
|
|
const budgetUsagePercent = totalBudget ? Number(((actualCurrent / totalBudget) * 100).toFixed(1)) : 0;
|
|
const alerts = budgets
|
|
.map((budget) => {
|
|
const spent = currentMonthExpenses
|
|
.filter((expense) => expense.status !== 'REJECTED' && expense.status !== 'DRAFT')
|
|
.filter((expense) => !budget.category || expense.category.id === budget.category.id)
|
|
.reduce((sum, expense) => sum + expense.amount, 0);
|
|
const usagePercent = budget.amount ? Number(((spent / budget.amount) * 100).toFixed(1)) : 0;
|
|
return { id: budget.id, name: budget.name || budget.category?.name || 'Monthly budget', usagePercent, spent: Number(spent.toFixed(2)), amount: budget.amount };
|
|
})
|
|
.filter((item) => item.usagePercent >= 80)
|
|
.sort((a, b) => b.usagePercent - a.usagePercent);
|
|
|
|
const statusSummary = aggregateStatistics(
|
|
currentMonthExpenses.map((expense) => ({
|
|
id: expense.id,
|
|
amount: expense.amount,
|
|
expenseDate: expense.expenseDate,
|
|
categoryId: expense.category.id,
|
|
categoryName: expense.category.name,
|
|
tags: expense.tags ?? [],
|
|
status: expense.status
|
|
}))
|
|
).byStatus;
|
|
|
|
return {
|
|
currentMonth,
|
|
actualCurrent: Number(actualCurrent.toFixed(2)),
|
|
totalBudget: Number(totalBudget.toFixed(2)),
|
|
budgetUsagePercent,
|
|
duplicateCount,
|
|
pendingApproval,
|
|
forecastCurrentMonth: Number((actualCurrent + upcomingRecurring.reduce((sum, item) => sum + item.amount, 0)).toFixed(2)),
|
|
trend: [...months.values()].map((item) => ({ label: item.label, actual: Number(item.actual.toFixed(2)), budget: Number(item.budget.toFixed(2)) })),
|
|
alerts,
|
|
upcomingRecurring,
|
|
statusSummary
|
|
};
|
|
};
|