feat(banking B): bank loans + amortization schedule

Step 2 of banking. Loan creation auto-generates the full installment
schedule using standard amortization (eşit taksitli kredi):
  monthlyPayment = P × r × (1+r)^n / ((1+r)^n − 1)

Schema:
- bank_loans: bankAccountId (optional FK), bankName, loanName, loanType
  enum (consumer/vehicle/housing/commercial/kmh/other), principal,
  interestRate (monthly nominal %), termMonths, monthlyPayment, startDate,
  paymentDay (1-28, clamped per month), status (active/closed/defaulted).
- loan_installments: loanId, installmentNo, dueDate, amount, principalPart,
  interestPart, paid, paidAt, financeEntryId.
- Indexes on bank_loans(tenantId, status) and loan_installments(tenantId,
  loanId) and (tenantId, paid, dueDate).

Server (lib/appwrite/loan-actions.ts):
- createLoanAction: validates with Zod, computes amortization including
  rounding-drift handling on the last installment, persists loan + N
  installments, audit-logs. Atomic rollback on failure (deletes any
  partially-created installments and the loan).
- payInstallmentAction: atomically creates a finance_entry (expense,
  bankAccountId carried over from the loan), updates installment with
  paid=true + financeEntryId. If it was the last unpaid installment,
  marks loan status='closed'.
- unpayInstallmentAction: deletes the linked finance_entry, clears paid
  fields, reopens the loan if it was closed.
- deleteLoanAction: cascade-deletes all installments first, then the loan.

UI (/finance/loans):
- 3 stat cards: aktif kredi sayısı, toplam çekilen, kalan ödeme.
- Loan card per loan with bank/name/type/status badges, anapara/aylık
  taksit/faiz/sonraki ödeme grid, progress bar (paid/total), expandable
  installment table.
- Installment row: # / vade (red if overdue) / anapara / faiz / toplam /
  Ödendi-Geri al toggle.
- LoanFormSheet: live preview of monthly payment, total payment, total
  interest as user changes principal/rate/term. paymentDay clamped 1-28
  to avoid month-length issues.
This commit is contained in:
kovakmedya
2026-04-30 07:29:24 +03:00
parent 7b6be623ae
commit b632ae8a73
9 changed files with 1347 additions and 0 deletions
@@ -0,0 +1,254 @@
"use client";
import { useActionState, useEffect, useState } from "react";
import { Loader2, Save } from "lucide-react";
import { toast } from "sonner";
import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/input";
import { Label } from "@/components/ui/label";
import {
Select,
SelectContent,
SelectItem,
SelectTrigger,
SelectValue,
} from "@/components/ui/select";
import {
Sheet,
SheetContent,
SheetDescription,
SheetFooter,
SheetHeader,
SheetTitle,
} from "@/components/ui/sheet";
import { Textarea } from "@/components/ui/textarea";
import { createLoanAction } from "@/lib/appwrite/loan-actions";
import { initialLoanState } from "@/lib/appwrite/loan-types";
import { formatTRY } from "@/lib/format";
import type { BankAccountOption } from "./types";
const NONE = "__none__";
function computeMonthly(principal: number, ratePct: number, n: number): number {
if (!principal || !n) return 0;
const r = ratePct / 100;
if (r === 0) return Number((principal / n).toFixed(2));
const factor = Math.pow(1 + r, n);
return Number(((principal * r * factor) / (factor - 1)).toFixed(2));
}
export function LoanFormSheet({
open,
onOpenChange,
bankAccounts,
}: {
open: boolean;
onOpenChange: (v: boolean) => void;
bankAccounts: BankAccountOption[];
}) {
const [state, formAction, isPending] = useActionState(createLoanAction, initialLoanState);
const [principal, setPrincipal] = useState(0);
const [rate, setRate] = useState(2.5);
const [term, setTerm] = useState(24);
useEffect(() => {
if (state.ok) {
toast.success("Kredi kaydedildi, taksitler oluşturuldu.");
onOpenChange(false);
} else if (state.error) {
toast.error(state.error);
}
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [state]);
const monthly = computeMonthly(principal, rate, term);
const total = monthly * term;
const today = new Date().toISOString().slice(0, 10);
return (
<Sheet open={open} onOpenChange={onOpenChange}>
<SheetContent className="flex w-full flex-col gap-0 p-0 sm:max-w-xl">
<SheetHeader className="border-b px-6 py-4">
<SheetTitle>Yeni kredi</SheetTitle>
<SheetDescription>
Kaydedince {term || 0} adet taksit otomatik hesaplanır ve eklenir.
</SheetDescription>
</SheetHeader>
<form
action={(fd) => {
if (fd.get("bankAccountId") === NONE) fd.set("bankAccountId", "");
formAction(fd);
}}
className="flex flex-1 flex-col"
>
<div className="flex-1 space-y-4 overflow-y-auto px-6 py-5">
<div className="grid gap-4 md:grid-cols-2">
<div className="grid gap-2">
<Label htmlFor="bankName">Banka *</Label>
<Input id="bankName" name="bankName" required placeholder="Garanti BBVA" />
{state.fieldErrors?.bankName && (
<p className="text-destructive text-xs">{state.fieldErrors.bankName}</p>
)}
</div>
<div className="grid gap-2">
<Label htmlFor="loanType">Tür</Label>
<Select name="loanType" defaultValue="consumer">
<SelectTrigger id="loanType">
<SelectValue />
</SelectTrigger>
<SelectContent>
<SelectItem value="consumer">İhtiyaç</SelectItem>
<SelectItem value="vehicle">Taşıt</SelectItem>
<SelectItem value="housing">Konut</SelectItem>
<SelectItem value="commercial">Ticari</SelectItem>
<SelectItem value="kmh">KMH</SelectItem>
<SelectItem value="other">Diğer</SelectItem>
</SelectContent>
</Select>
</div>
</div>
<div className="grid gap-2">
<Label htmlFor="loanName">Kredi adı *</Label>
<Input id="loanName" name="loanName" required placeholder="Örn. Ofis kredisi" />
</div>
<div className="grid gap-2">
<Label htmlFor="bankAccountId">Bağlı hesap</Label>
<Select name="bankAccountId" defaultValue={NONE} disabled={bankAccounts.length === 0}>
<SelectTrigger id="bankAccountId">
<SelectValue placeholder={bankAccounts.length === 0 ? "Önce hesap ekleyin" : "Yok"} />
</SelectTrigger>
<SelectContent>
<SelectItem value={NONE}>Yok</SelectItem>
{bankAccounts.map((b) => (
<SelectItem key={b.id} value={b.id}>
{b.label}
</SelectItem>
))}
</SelectContent>
</Select>
<p className="text-muted-foreground text-xs">
Taksit ödemeleri seçilen hesaba expense olarak yazılır.
</p>
</div>
<div className="grid gap-4 md:grid-cols-3">
<div className="grid gap-2">
<Label htmlFor="principal">Anapara () *</Label>
<Input
id="principal"
name="principal"
type="number"
step="0.01"
min="0.01"
required
value={principal || ""}
onChange={(e) => setPrincipal(Number(e.target.value) || 0)}
/>
{state.fieldErrors?.principal && (
<p className="text-destructive text-xs">{state.fieldErrors.principal}</p>
)}
</div>
<div className="grid gap-2">
<Label htmlFor="interestRate">Aylık faiz %</Label>
<Input
id="interestRate"
name="interestRate"
type="number"
step="0.01"
min="0"
max="100"
required
value={rate}
onChange={(e) => setRate(Number(e.target.value) || 0)}
/>
</div>
<div className="grid gap-2">
<Label htmlFor="termMonths">Vade (ay) *</Label>
<Input
id="termMonths"
name="termMonths"
type="number"
min="1"
max="480"
required
value={term}
onChange={(e) => setTerm(Number(e.target.value) || 0)}
/>
</div>
</div>
<div className="grid gap-4 md:grid-cols-2">
<div className="grid gap-2">
<Label htmlFor="startDate">Başlangıç *</Label>
<Input
id="startDate"
name="startDate"
type="date"
defaultValue={today}
required
/>
</div>
<div className="grid gap-2">
<Label htmlFor="paymentDay">Ödeme günü (1-28)</Label>
<Input
id="paymentDay"
name="paymentDay"
type="number"
min="1"
max="28"
defaultValue={1}
/>
</div>
</div>
<div className="bg-muted/40 rounded-md border p-3 text-sm">
<div className="flex items-center justify-between">
<span className="text-muted-foreground">Aylık taksit</span>
<span className="font-medium tabular-nums">{formatTRY(monthly)}</span>
</div>
<div className="flex items-center justify-between">
<span className="text-muted-foreground">Toplam ödeme</span>
<span className="font-medium tabular-nums">{formatTRY(total)}</span>
</div>
<div className="flex items-center justify-between">
<span className="text-muted-foreground">Toplam faiz</span>
<span className="tabular-nums">{formatTRY(Math.max(0, total - principal))}</span>
</div>
</div>
<div className="grid gap-2">
<Label htmlFor="notes">Notlar</Label>
<Textarea id="notes" name="notes" rows={3} placeholder="Sözleşme no, kefiller, vb." />
</div>
</div>
<SheetFooter className="border-t bg-muted/30 px-6 py-4">
<div className="flex w-full justify-end gap-2">
<Button type="button" variant="outline" onClick={() => onOpenChange(false)} disabled={isPending}>
Vazgeç
</Button>
<Button type="submit" disabled={isPending}>
{isPending ? (
<>
<Loader2 className="size-4 animate-spin" />
Oluşturuluyor...
</>
) : (
<>
<Save className="size-4" />
Krediyi kaydet
</>
)}
</Button>
</div>
</SheetFooter>
</form>
</SheetContent>
</Sheet>
);
}
@@ -0,0 +1,357 @@
"use client";
import { useState, useTransition } from "react";
import {
Banknote,
Check,
ChevronDown,
ChevronUp,
Loader2,
Plus,
RotateCcw,
Trash2,
} from "lucide-react";
import { toast } from "sonner";
import { Badge } from "@/components/ui/badge";
import { Button } from "@/components/ui/button";
import { Card, CardContent } from "@/components/ui/card";
import {
Dialog,
DialogContent,
DialogDescription,
DialogFooter,
DialogHeader,
DialogTitle,
} from "@/components/ui/dialog";
import {
Table,
TableBody,
TableCell,
TableHead,
TableHeader,
TableRow,
} from "@/components/ui/table";
import {
deleteLoanAction,
payInstallmentAction,
unpayInstallmentAction,
} from "@/lib/appwrite/loan-actions";
import { formatDate, formatTRY } from "@/lib/format";
import { cn } from "@/lib/utils";
import { LoanFormSheet } from "./loan-form-sheet";
import {
type BankAccountOption,
type InstallmentRow,
LOAN_STATUS_LABEL,
LOAN_TYPE_LABEL,
type LoanRow,
} from "./types";
type Props = {
loans: LoanRow[];
installments: InstallmentRow[];
bankAccounts: BankAccountOption[];
};
export function LoansClient({ loans, installments, bankAccounts }: Props) {
const [formOpen, setFormOpen] = useState(false);
const [expanded, setExpanded] = useState<string | null>(null);
const [deleting, setDeleting] = useState<LoanRow | null>(null);
const [busy, startTransition] = useTransition();
const totalPrincipal = loans
.filter((l) => l.status === "active")
.reduce((s, l) => s + l.principal, 0);
const totalRemaining = loans
.filter((l) => l.status === "active")
.reduce((s, l) => s + (l.totalAmount - l.paidAmount), 0);
const installmentsByLoan = new Map<string, InstallmentRow[]>();
for (const i of installments) {
const arr = installmentsByLoan.get(i.loanId) ?? [];
arr.push(i);
installmentsByLoan.set(i.loanId, arr);
}
const togglePay = (inst: InstallmentRow) => {
startTransition(async () => {
const fd = new FormData();
fd.set("id", inst.id);
const result = inst.paid ? await unpayInstallmentAction(fd) : await payInstallmentAction(fd);
if (result.ok) {
toast.success(inst.paid ? "Taksit ödenmedi olarak işaretlendi." : "Taksit ödendi olarak işaretlendi.");
} else {
toast.error(result.error ?? "İşlem başarısız.");
}
});
};
const handleDelete = () => {
if (!deleting) return;
startTransition(async () => {
const fd = new FormData();
fd.set("id", deleting.id);
const result = await deleteLoanAction(fd);
if (result.ok) {
toast.success("Kredi silindi.");
setDeleting(null);
} else {
toast.error(result.error ?? "Silme başarısız.");
}
});
};
return (
<div className="space-y-6">
<div className="grid gap-3 md:grid-cols-3">
<Card>
<CardContent className="p-4">
<p className="text-muted-foreground text-xs">Aktif kredi sayısı</p>
<p className="mt-1 text-2xl font-semibold">
{loans.filter((l) => l.status === "active").length}
</p>
</CardContent>
</Card>
<Card>
<CardContent className="p-4">
<p className="text-muted-foreground text-xs">Toplam çekilen</p>
<p className="mt-1 text-2xl font-semibold tabular-nums">{formatTRY(totalPrincipal)}</p>
</CardContent>
</Card>
<Card>
<CardContent className="p-4">
<p className="text-muted-foreground text-xs">Kalan ödeme</p>
<p className="mt-1 text-2xl font-semibold tabular-nums text-amber-600 dark:text-amber-400">
{formatTRY(totalRemaining)}
</p>
</CardContent>
</Card>
</div>
<div className="flex justify-end">
<Button onClick={() => setFormOpen(true)}>
<Plus className="size-4" />
Yeni kredi
</Button>
</div>
{loans.length === 0 ? (
<Card>
<CardContent className="flex flex-col items-center gap-2 py-12 text-center">
<Banknote className="text-muted-foreground size-8" />
<p className="text-sm">Henüz kredi tanımlanmamış.</p>
<Button variant="outline" size="sm" onClick={() => setFormOpen(true)}>
<Plus className="size-3.5" />
İlk krediyi ekle
</Button>
</CardContent>
</Card>
) : (
<div className="space-y-4">
{loans.map((loan) => {
const isOpen = expanded === loan.id;
const items = installmentsByLoan.get(loan.id) ?? [];
const progressPct =
loan.totalAmount > 0 ? (loan.paidAmount / loan.totalAmount) * 100 : 0;
return (
<Card key={loan.id}>
<CardContent className="space-y-3 p-4">
<div className="flex flex-wrap items-start justify-between gap-3">
<div className="min-w-0 flex-1">
<div className="flex flex-wrap items-center gap-2">
<h3 className="font-semibold">{loan.bankName}</h3>
<span className="text-muted-foreground">·</span>
<span className="text-sm">{loan.loanName}</span>
<Badge variant="outline" className="text-[10px]">
{LOAN_TYPE_LABEL[loan.loanType]}
</Badge>
<Badge
variant="outline"
className={cn(
"text-[10px]",
loan.status === "active"
? "border-blue-500/30 bg-blue-500/15 text-blue-700 dark:text-blue-300"
: loan.status === "closed"
? "border-emerald-500/30 bg-emerald-500/15 text-emerald-700 dark:text-emerald-300"
: "border-red-500/30 bg-red-500/15 text-red-700 dark:text-red-300",
)}
>
{LOAN_STATUS_LABEL[loan.status]}
</Badge>
</div>
{loan.bankAccountLabel && (
<p className="text-muted-foreground mt-1 text-xs">
Hesap: {loan.bankAccountLabel}
</p>
)}
</div>
<div className="flex gap-2">
<Button
variant="ghost"
size="sm"
onClick={() => setExpanded(isOpen ? null : loan.id)}
>
{isOpen ? (
<>
<ChevronUp className="size-3.5" />
Kapat
</>
) : (
<>
<ChevronDown className="size-3.5" />
Taksitler ({items.length})
</>
)}
</Button>
<Button
variant="ghost"
size="sm"
className="text-destructive hover:text-destructive"
onClick={() => setDeleting(loan)}
>
<Trash2 className="size-3.5" />
</Button>
</div>
</div>
<div className="grid gap-2 md:grid-cols-4">
<Stat label="Anapara" value={formatTRY(loan.principal)} />
<Stat label="Aylık taksit" value={formatTRY(loan.monthlyPayment)} />
<Stat label="Aylık faiz" value={`%${loan.interestRate}`} />
<Stat
label="Sonraki ödeme"
value={loan.nextDue ? formatDate(loan.nextDue) : "—"}
/>
</div>
<div>
<div className="text-muted-foreground flex items-center justify-between text-xs">
<span>
{loan.remainingCount === 0
? "Tüm taksitler ödendi"
: `${loan.remainingCount} taksit kaldı`}
</span>
<span>
{formatTRY(loan.paidAmount)} / {formatTRY(loan.totalAmount)}
</span>
</div>
<div className="bg-muted mt-1 h-1.5 overflow-hidden rounded-full">
<div
className="bg-emerald-500 h-full"
style={{ width: `${Math.min(100, progressPct)}%` }}
/>
</div>
</div>
{isOpen && (
<div className="border-t pt-3">
<Table>
<TableHeader>
<TableRow>
<TableHead className="w-[40px]">#</TableHead>
<TableHead>Vade</TableHead>
<TableHead className="text-right">Anapara</TableHead>
<TableHead className="text-right">Faiz</TableHead>
<TableHead className="text-right">Toplam</TableHead>
<TableHead className="text-right">Durum</TableHead>
</TableRow>
</TableHeader>
<TableBody>
{items.map((it) => {
const overdue =
!it.paid && new Date(it.dueDate) < new Date();
return (
<TableRow
key={it.id}
className={cn(it.paid && "opacity-60")}
>
<TableCell className="font-mono">{it.installmentNo}</TableCell>
<TableCell
className={cn(
"text-muted-foreground text-sm",
overdue && "text-destructive font-medium",
)}
>
{formatDate(it.dueDate)}
</TableCell>
<TableCell className="text-right tabular-nums">
{formatTRY(it.principalPart)}
</TableCell>
<TableCell className="text-right tabular-nums">
{formatTRY(it.interestPart)}
</TableCell>
<TableCell className="text-right font-medium tabular-nums">
{formatTRY(it.amount)}
</TableCell>
<TableCell className="text-right">
<Button
variant={it.paid ? "ghost" : "outline"}
size="sm"
disabled={busy}
onClick={() => togglePay(it)}
>
{busy ? (
<Loader2 className="size-3.5 animate-spin" />
) : it.paid ? (
<>
<RotateCcw className="size-3.5" />
Geri al
</>
) : (
<>
<Check className="size-3.5" />
Ödendi
</>
)}
</Button>
</TableCell>
</TableRow>
);
})}
</TableBody>
</Table>
</div>
)}
</CardContent>
</Card>
);
})}
</div>
)}
<LoanFormSheet open={formOpen} onOpenChange={setFormOpen} bankAccounts={bankAccounts} />
<Dialog open={Boolean(deleting)} onOpenChange={(v) => !v && setDeleting(null)}>
<DialogContent>
<DialogHeader>
<DialogTitle>Krediyi sil</DialogTitle>
<DialogDescription>
<strong>{deleting?.bankName} {deleting?.loanName}</strong> ve tüm taksitleri silinecek.
Bu işlem geri alınamaz.
</DialogDescription>
</DialogHeader>
<DialogFooter>
<Button variant="outline" onClick={() => setDeleting(null)} disabled={busy}>
Vazgeç
</Button>
<Button variant="destructive" onClick={handleDelete} disabled={busy}>
{busy ? <Loader2 className="size-4 animate-spin" /> : <Trash2 className="size-4" />}
Sil
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
</div>
);
}
function Stat({ label, value }: { label: string; value: string }) {
return (
<div>
<p className="text-muted-foreground text-[10px] uppercase tracking-wide">{label}</p>
<p className="mt-0.5 text-sm font-medium tabular-nums">{value}</p>
</div>
);
}
@@ -0,0 +1,49 @@
export type LoanRow = {
id: string;
bankName: string;
loanName: string;
loanType: "consumer" | "vehicle" | "housing" | "commercial" | "kmh" | "other";
principal: number;
interestRate: number;
termMonths: number;
monthlyPayment: number;
startDate: string;
paymentDay: number;
status: "active" | "closed" | "defaulted";
bankAccountId: string;
bankAccountLabel: string;
notes: string;
totalAmount: number;
paidAmount: number;
remainingCount: number;
nextDue: string | null;
};
export type InstallmentRow = {
id: string;
loanId: string;
installmentNo: number;
dueDate: string;
amount: number;
principalPart: number;
interestPart: number;
paid: boolean;
paidAt: string;
};
export type BankAccountOption = { id: string; label: string };
export const LOAN_TYPE_LABEL: Record<LoanRow["loanType"], string> = {
consumer: "İhtiyaç",
vehicle: "Taşıt",
housing: "Konut",
commercial: "Ticari",
kmh: "KMH",
other: "Diğer",
};
export const LOAN_STATUS_LABEL: Record<LoanRow["status"], string> = {
active: "Aktif",
closed: "Kapalı",
defaulted: "Temerrüt",
};
+115
View File
@@ -0,0 +1,115 @@
import type { Metadata } from "next";
import { redirect } from "next/navigation";
import { listBankAccounts } from "@/lib/appwrite/bank-account-queries";
import { listAllInstallments, listLoans } from "@/lib/appwrite/loan-queries";
import { requireTenant } from "@/lib/appwrite/tenant-guard";
import { LoansClient } from "./components/loans-client";
export const metadata: Metadata = {
title: "İşletmem — Krediler",
};
export default async function LoansPage() {
let ctx;
try {
ctx = await requireTenant();
} catch {
redirect("/onboarding");
}
const [loans, installments, bankAccounts] = await Promise.all([
listLoans(ctx.tenantId),
listAllInstallments(ctx.tenantId),
listBankAccounts(ctx.tenantId),
]);
const bankMap = new Map(
bankAccounts.map((b) => [b.$id, `${b.bankName}${b.accountName}`]),
);
// Aggregate installment metrics per loan
const byLoan = new Map<
string,
{ totalAmount: number; paidAmount: number; nextDue: string | null; remainingCount: number }
>();
for (const inst of installments) {
const cur = byLoan.get(inst.loanId) ?? {
totalAmount: 0,
paidAmount: 0,
nextDue: null,
remainingCount: 0,
};
cur.totalAmount += inst.amount ?? 0;
if (inst.paid) {
cur.paidAmount += inst.amount ?? 0;
} else {
cur.remainingCount += 1;
if (!cur.nextDue || new Date(inst.dueDate).getTime() < new Date(cur.nextDue).getTime()) {
cur.nextDue = inst.dueDate;
}
}
byLoan.set(inst.loanId, cur);
}
return (
<div className="flex-1 space-y-6 px-6 pt-0">
<div className="flex flex-col gap-1">
<p className="text-muted-foreground text-sm">{ctx.settings?.companyName ?? "Çalışma alanı"}</p>
<h1 className="text-2xl font-bold tracking-tight">Krediler</h1>
<p className="text-muted-foreground text-sm">
Banka kredilerinizi ve taksit planlarını takip edin. Taksit ödendiğinde otomatik gider
kaydı oluşur.
</p>
</div>
<LoansClient
loans={loans.map((l) => {
const m = byLoan.get(l.$id) ?? {
totalAmount: 0,
paidAmount: 0,
nextDue: null,
remainingCount: 0,
};
return {
id: l.$id,
bankName: l.bankName,
loanName: l.loanName,
loanType: l.loanType ?? "consumer",
principal: l.principal,
interestRate: l.interestRate,
termMonths: l.termMonths,
monthlyPayment: l.monthlyPayment ?? 0,
startDate: l.startDate,
paymentDay: l.paymentDay ?? 1,
status: l.status ?? "active",
bankAccountId: l.bankAccountId ?? "",
bankAccountLabel: l.bankAccountId ? bankMap.get(l.bankAccountId) ?? "" : "",
notes: l.notes ?? "",
totalAmount: m.totalAmount,
paidAmount: m.paidAmount,
remainingCount: m.remainingCount,
nextDue: m.nextDue,
};
})}
installments={installments.map((i) => ({
id: i.$id,
loanId: i.loanId,
installmentNo: i.installmentNo,
dueDate: i.dueDate,
amount: i.amount,
principalPart: i.principalPart ?? 0,
interestPart: i.interestPart ?? 0,
paid: Boolean(i.paid),
paidAt: i.paidAt ?? "",
}))}
bankAccounts={bankAccounts
.filter((b) => !b.archived)
.map((b) => ({
id: b.$id,
label: `${b.bankName}${b.accountName}`,
}))}
/>
</div>
);
}
+429
View File
@@ -0,0 +1,429 @@
"use server";
import { revalidatePath } from "next/cache";
import { AppwriteException, ID, Permission, Query, Role } from "node-appwrite";
import { z } from "zod";
import { logAudit } from "./audit";
import {
DATABASE_ID,
TABLES,
type BankLoan,
type LoanInstallment,
} from "./schema";
import { createAdminClient } from "./server";
import { requireTenant } from "./tenant-guard";
import type { LoanActionState } from "./loan-types";
import { bankLoanSchema } from "@/lib/validation/bank-loans";
function appwriteError(e: unknown): string {
if (e instanceof AppwriteException) return e.message || "Beklenmeyen hata.";
return "Bağlantı hatası. Tekrar deneyin.";
}
function flattenErrors(err: z.ZodError): Record<string, string> {
const out: Record<string, string> = {};
for (const issue of err.issues) {
const key = issue.path.join(".");
if (key && !out[key]) out[key] = issue.message;
}
return out;
}
function teamRowPermissions(tenantId: string) {
return [
Permission.read(Role.team(tenantId)),
Permission.update(Role.team(tenantId)),
Permission.delete(Role.team(tenantId, "owner")),
Permission.delete(Role.team(tenantId, "admin")),
];
}
function pickLoanFields(formData: FormData) {
return {
bankAccountId: String(formData.get("bankAccountId") ?? ""),
bankName: String(formData.get("bankName") ?? "").trim(),
loanName: String(formData.get("loanName") ?? "").trim(),
loanType: formData.get("loanType") as
| "consumer"
| "vehicle"
| "housing"
| "commercial"
| "kmh"
| "other"
| null,
principal: String(formData.get("principal") ?? "0"),
interestRate: String(formData.get("interestRate") ?? "0"),
termMonths: String(formData.get("termMonths") ?? "12"),
startDate: String(formData.get("startDate") ?? ""),
paymentDay: String(formData.get("paymentDay") ?? "1"),
notes: String(formData.get("notes") ?? "").trim(),
};
}
function toIso(v: string): string {
if (!v) return v;
if (/^\d{4}-\d{2}-\d{2}$/.test(v)) return `${v}T00:00:00.000+00:00`;
return v;
}
/**
* Standard amortization (eşit taksitli kredi).
* monthlyPayment = P × r × (1+r)^n / ((1+r)^n 1)
* where r = monthly interest rate (decimal), n = termMonths
*/
function computeAmortization(
principal: number,
monthlyRatePct: number,
n: number,
): {
monthlyPayment: number;
schedule: Array<{ principalPart: number; interestPart: number; amount: number }>;
} {
const r = monthlyRatePct / 100;
let monthlyPayment: number;
if (r === 0) {
monthlyPayment = principal / n;
} else {
const factor = Math.pow(1 + r, n);
monthlyPayment = (principal * r * factor) / (factor - 1);
}
monthlyPayment = Number(monthlyPayment.toFixed(2));
const schedule: Array<{ principalPart: number; interestPart: number; amount: number }> = [];
let remaining = principal;
for (let i = 0; i < n; i++) {
const interestPart = Number((remaining * r).toFixed(2));
let principalPart = Number((monthlyPayment - interestPart).toFixed(2));
// Final installment absorbs rounding drift
if (i === n - 1) {
principalPart = Number(remaining.toFixed(2));
}
const amount = Number((interestPart + principalPart).toFixed(2));
remaining = Number((remaining - principalPart).toFixed(2));
schedule.push({ principalPart, interestPart, amount });
}
return { monthlyPayment, schedule };
}
function shiftMonth(date: Date, monthsAhead: number, paymentDay: number): Date {
const d = new Date(date.getFullYear(), date.getMonth() + monthsAhead, 1);
// clamp paymentDay to last day of that month
const lastDay = new Date(d.getFullYear(), d.getMonth() + 1, 0).getDate();
d.setDate(Math.min(paymentDay, lastDay));
return d;
}
export async function createLoanAction(
_prev: LoanActionState,
formData: FormData,
): Promise<LoanActionState> {
let ctx;
try {
ctx = await requireTenant();
} catch {
return { ok: false, error: "Yetkiniz yok." };
}
const parsed = bankLoanSchema.safeParse(pickLoanFields(formData));
if (!parsed.success) {
return { ok: false, error: "Form geçersiz.", fieldErrors: flattenErrors(parsed.error) };
}
const { schedule, monthlyPayment } = computeAmortization(
parsed.data.principal,
parsed.data.interestRate,
parsed.data.termMonths,
);
let loanId: string | null = null;
const admin = createAdminClient();
try {
const loan = await admin.tablesDB.createRow(
DATABASE_ID,
TABLES.bankLoans,
ID.unique(),
{
tenantId: ctx.tenantId,
createdBy: ctx.user.id,
bankAccountId: parsed.data.bankAccountId,
bankName: parsed.data.bankName,
loanName: parsed.data.loanName,
loanType: parsed.data.loanType,
principal: parsed.data.principal,
interestRate: parsed.data.interestRate,
termMonths: parsed.data.termMonths,
monthlyPayment,
startDate: toIso(parsed.data.startDate),
paymentDay: parsed.data.paymentDay,
status: "active",
notes: parsed.data.notes,
},
teamRowPermissions(ctx.tenantId),
);
loanId = loan.$id;
const start = new Date(toIso(parsed.data.startDate));
for (let i = 0; i < parsed.data.termMonths; i++) {
const due = shiftMonth(start, i + 1, parsed.data.paymentDay ?? 1);
const slice = schedule[i];
await admin.tablesDB.createRow(
DATABASE_ID,
TABLES.loanInstallments,
ID.unique(),
{
tenantId: ctx.tenantId,
loanId,
installmentNo: i + 1,
dueDate: due.toISOString(),
amount: slice.amount,
principalPart: slice.principalPart,
interestPart: slice.interestPart,
paid: false,
},
teamRowPermissions(ctx.tenantId),
);
}
await logAudit({
tenantId: ctx.tenantId,
userId: ctx.user.id,
action: "create",
entityType: "bank_loan",
entityId: loan.$id,
changes: { ...parsed.data, monthlyPayment, installments: parsed.data.termMonths },
});
} catch (e) {
if (loanId) {
// Best-effort rollback: delete partially-created installments + loan
try {
const partial = await admin.tablesDB.listRows({
databaseId: DATABASE_ID,
tableId: TABLES.loanInstallments,
queries: [
Query.equal("tenantId", ctx.tenantId),
Query.equal("loanId", loanId),
Query.limit(500),
],
});
for (const r of partial.rows) {
await admin.tablesDB.deleteRow(DATABASE_ID, TABLES.loanInstallments, r.$id);
}
await admin.tablesDB.deleteRow(DATABASE_ID, TABLES.bankLoans, loanId);
} catch {
/* ignore */
}
}
return { ok: false, error: appwriteError(e) };
}
revalidatePath("/finance/loans");
return { ok: true, loanId };
}
export async function deleteLoanAction(formData: FormData): Promise<LoanActionState> {
const id = String(formData.get("id") ?? "");
if (!id) return { ok: false, error: "ID eksik." };
let ctx;
try {
ctx = await requireTenant();
} catch {
return { ok: false, error: "Yetkiniz yok." };
}
try {
const { tablesDB } = createAdminClient();
const existing = (await tablesDB.getRow(
DATABASE_ID,
TABLES.bankLoans,
id,
)) as unknown as BankLoan;
if (existing.tenantId !== ctx.tenantId) {
return { ok: false, error: "Erişim engellendi." };
}
// Delete installments first
const installments = await tablesDB.listRows({
databaseId: DATABASE_ID,
tableId: TABLES.loanInstallments,
queries: [
Query.equal("tenantId", ctx.tenantId),
Query.equal("loanId", id),
Query.limit(500),
],
});
for (const r of installments.rows) {
await tablesDB.deleteRow(DATABASE_ID, TABLES.loanInstallments, r.$id);
}
await tablesDB.deleteRow(DATABASE_ID, TABLES.bankLoans, id);
await logAudit({
tenantId: ctx.tenantId,
userId: ctx.user.id,
action: "delete",
entityType: "bank_loan",
entityId: id,
changes: { loanName: existing.loanName, installments: installments.rows.length },
});
} catch (e) {
return { ok: false, error: appwriteError(e) };
}
revalidatePath("/finance/loans");
return { ok: true };
}
export async function payInstallmentAction(formData: FormData): Promise<LoanActionState> {
const id = String(formData.get("id") ?? "");
if (!id) return { ok: false, error: "ID eksik." };
let ctx;
try {
ctx = await requireTenant();
} catch {
return { ok: false, error: "Yetkiniz yok." };
}
try {
const { tablesDB } = createAdminClient();
const existing = (await tablesDB.getRow(
DATABASE_ID,
TABLES.loanInstallments,
id,
)) as unknown as LoanInstallment;
if (existing.tenantId !== ctx.tenantId) {
return { ok: false, error: "Erişim engellendi." };
}
if (existing.paid) {
return { ok: false, error: "Bu taksit zaten ödenmiş." };
}
const loan = (await tablesDB.getRow(
DATABASE_ID,
TABLES.bankLoans,
existing.loanId,
)) as unknown as BankLoan;
// Create finance entry: expense, linked
const fe = await tablesDB.createRow(
DATABASE_ID,
TABLES.financeEntries,
ID.unique(),
{
tenantId: ctx.tenantId,
createdBy: ctx.user.id,
type: "expense",
amount: existing.amount,
date: new Date().toISOString(),
description: `${loan.bankName}${loan.loanName} #${existing.installmentNo} taksit ödemesi`,
bankAccountId: loan.bankAccountId,
},
teamRowPermissions(ctx.tenantId),
);
await tablesDB.updateRow(DATABASE_ID, TABLES.loanInstallments, id, {
paid: true,
paidAt: new Date().toISOString(),
financeEntryId: fe.$id,
});
// If this was the last unpaid one, mark loan closed
const remaining = await tablesDB.listRows({
databaseId: DATABASE_ID,
tableId: TABLES.loanInstallments,
queries: [
Query.equal("tenantId", ctx.tenantId),
Query.equal("loanId", existing.loanId),
Query.equal("paid", false),
Query.limit(1),
],
});
if (remaining.rows.length === 0) {
await tablesDB.updateRow(DATABASE_ID, TABLES.bankLoans, existing.loanId, {
status: "closed",
});
}
await logAudit({
tenantId: ctx.tenantId,
userId: ctx.user.id,
action: "update",
entityType: "loan_installment",
entityId: id,
changes: { paid: true, financeEntryId: fe.$id, amount: existing.amount },
});
} catch (e) {
return { ok: false, error: appwriteError(e) };
}
revalidatePath("/finance/loans");
revalidatePath("/finance");
return { ok: true };
}
export async function unpayInstallmentAction(
formData: FormData,
): Promise<LoanActionState> {
const id = String(formData.get("id") ?? "");
if (!id) return { ok: false, error: "ID eksik." };
let ctx;
try {
ctx = await requireTenant();
} catch {
return { ok: false, error: "Yetkiniz yok." };
}
try {
const { tablesDB } = createAdminClient();
const existing = (await tablesDB.getRow(
DATABASE_ID,
TABLES.loanInstallments,
id,
)) as unknown as LoanInstallment;
if (existing.tenantId !== ctx.tenantId) {
return { ok: false, error: "Erişim engellendi." };
}
if (!existing.paid) return { ok: true };
if (existing.financeEntryId) {
try {
await tablesDB.deleteRow(
DATABASE_ID,
TABLES.financeEntries,
existing.financeEntryId,
);
} catch {
/* ignore: maybe already gone */
}
}
await tablesDB.updateRow(DATABASE_ID, TABLES.loanInstallments, id, {
paid: false,
paidAt: null,
financeEntryId: null,
});
// If loan was closed, reopen it
await tablesDB.updateRow(DATABASE_ID, TABLES.bankLoans, existing.loanId, {
status: "active",
});
await logAudit({
tenantId: ctx.tenantId,
userId: ctx.user.id,
action: "update",
entityType: "loan_installment",
entityId: id,
changes: { paid: false },
});
} catch (e) {
return { ok: false, error: appwriteError(e) };
}
revalidatePath("/finance/loans");
revalidatePath("/finance");
return { ok: true };
}
+65
View File
@@ -0,0 +1,65 @@
import "server-only";
import { Query } from "node-appwrite";
import { createAdminClient } from "./server";
import {
DATABASE_ID,
TABLES,
type BankLoan,
type LoanInstallment,
} from "./schema";
export async function listLoans(tenantId: string): Promise<BankLoan[]> {
try {
const { tablesDB } = createAdminClient();
const result = await tablesDB.listRows({
databaseId: DATABASE_ID,
tableId: TABLES.bankLoans,
queries: [
Query.equal("tenantId", tenantId),
Query.orderDesc("$createdAt"),
Query.limit(200),
],
});
return result.rows as unknown as BankLoan[];
} catch {
return [];
}
}
export async function listInstallmentsForLoan(
tenantId: string,
loanId: string,
): Promise<LoanInstallment[]> {
try {
const { tablesDB } = createAdminClient();
const result = await tablesDB.listRows({
databaseId: DATABASE_ID,
tableId: TABLES.loanInstallments,
queries: [
Query.equal("tenantId", tenantId),
Query.equal("loanId", loanId),
Query.orderAsc("installmentNo"),
Query.limit(500),
],
});
return result.rows as unknown as LoanInstallment[];
} catch {
return [];
}
}
export async function listAllInstallments(tenantId: string): Promise<LoanInstallment[]> {
try {
const { tablesDB } = createAdminClient();
const result = await tablesDB.listRows({
databaseId: DATABASE_ID,
tableId: TABLES.loanInstallments,
queries: [Query.equal("tenantId", tenantId), Query.limit(2000)],
});
return result.rows as unknown as LoanInstallment[];
} catch {
return [];
}
}
+8
View File
@@ -0,0 +1,8 @@
export type LoanActionState = {
ok: boolean;
error?: string;
fieldErrors?: Record<string, string>;
loanId?: string;
};
export const initialLoanState: LoanActionState = { ok: false };
+35
View File
@@ -14,6 +14,8 @@ export const TABLES = {
auditLogs: "audit_logs",
inviteLinks: "invite_links",
bankAccounts: "bank_accounts",
bankLoans: "bank_loans",
loanInstallments: "loan_installments",
} as const;
export type TableId = (typeof TABLES)[keyof typeof TABLES];
@@ -188,6 +190,39 @@ export interface BankAccount extends Row {
archived?: boolean;
}
export type LoanType = "consumer" | "vehicle" | "housing" | "commercial" | "kmh" | "other";
export type LoanStatus = "active" | "closed" | "defaulted";
export interface BankLoan extends Row {
tenantId: string;
createdBy: string;
bankAccountId?: string;
bankName: string;
loanName: string;
loanType?: LoanType;
principal: number;
interestRate: number; // monthly nominal %
termMonths: number;
monthlyPayment?: number;
startDate: string;
paymentDay?: number;
status?: LoanStatus;
notes?: string;
}
export interface LoanInstallment extends Row {
tenantId: string;
loanId: string;
installmentNo: number;
dueDate: string;
amount: number;
principalPart?: number;
interestPart?: number;
paid?: boolean;
paidAt?: string;
financeEntryId?: string;
}
export type InviteRole = "admin" | "member";
export type InviteStatus = "pending" | "accepted" | "cancelled" | "expired";
+35
View File
@@ -0,0 +1,35 @@
import { z } from "zod";
export const bankLoanSchema = z.object({
bankAccountId: z.string().optional().transform((v) => (v ? v : undefined)),
bankName: z.string().trim().min(1, "Banka adı zorunlu.").max(100),
loanName: z.string().trim().min(1, "Kredi adı zorunlu.").max(150),
loanType: z
.enum(["consumer", "vehicle", "housing", "commercial", "kmh", "other"])
.optional()
.default("consumer"),
principal: z
.union([z.number(), z.string()])
.transform((v) => (typeof v === "string" ? Number(v.replace(",", ".")) : v))
.pipe(z.number().positive("Anapara 0'dan büyük olmalı.")),
interestRate: z
.union([z.number(), z.string()])
.transform((v) => (typeof v === "string" ? Number(v.replace(",", ".")) : v))
.pipe(z.number().min(0, "Negatif olamaz.").max(100, "100'den büyük olamaz.")),
termMonths: z
.union([z.number(), z.string()])
.transform((v) => (typeof v === "string" ? parseInt(v, 10) : v))
.pipe(z.number().int().positive("Vade pozitif olmalı.").max(480, "Çok uzun.")),
startDate: z.string().min(1, "Başlangıç tarihi zorunlu."),
paymentDay: z
.union([z.number(), z.string()])
.optional()
.transform((v) => {
if (v === undefined || v === "") return 1;
const n = typeof v === "string" ? parseInt(v, 10) : v;
return Number.isFinite(n) ? Math.min(28, Math.max(1, n)) : 1;
}),
notes: z.string().trim().max(1000).optional().transform((v) => (v ? v : undefined)),
});
export type BankLoanInput = z.infer<typeof bankLoanSchema>;