admin
e7f0070e84
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma strängvärde byggs med konkatenering i stället för att matcha mönstret.
91 lines
3.5 KiB
TypeScript
91 lines
3.5 KiB
TypeScript
import type { SupabaseClient } from '@supabase/supabase-js'
|
|
import { fetchEntryLines, type EntryLinesQuery } from '@/lib/bookkeeping/entry-lines'
|
|
|
|
/**
|
|
* Get opening balances (ingående balans) for a fiscal period.
|
|
*
|
|
* Uses the opening_balance_entry set by year-end closing when available
|
|
* (O(accounts): typically ~50 rows). Falls back to a server-side
|
|
* aggregate via the compute_prior_opening_balances RPC when no OB entry
|
|
* is set, which returns one row per balance-sheet account (class 1-2)
|
|
* regardless of how many prior journal lines there are.
|
|
*
|
|
* Returns per-account debit/credit opening balances and the OB entry ID
|
|
* (if any) so the caller can exclude it from period queries to prevent
|
|
* double-counting.
|
|
*
|
|
* NOTE: The account range filter (accountFrom/accountTo in the GL) is
|
|
* applied post-hoc by the caller, not here. This is consistent with the
|
|
* existing behavior and avoids complicating the queries for the common
|
|
* unfiltered case.
|
|
*/
|
|
export async function getOpeningBalances(
|
|
supabase: SupabaseClient,
|
|
companyId: string,
|
|
period: { period_start: string; opening_balance_entry_id: string | null } | null
|
|
): Promise<{
|
|
balances: Map<string, { debit: number; credit: number }>
|
|
obEntryId: string | null
|
|
}> {
|
|
const balances = new Map<string, { debit: number; credit: number }>()
|
|
|
|
if (!period) {
|
|
return { balances, obEntryId: null }
|
|
}
|
|
|
|
const obEntryId = period.opening_balance_entry_id
|
|
|
|
if (obEntryId) {
|
|
// Use the explicit opening balance entry (set by year-end closing).
|
|
// Typically ~50 rows: one per balance sheet account. The two-step
|
|
// entry-lines fetch verifies company_id ownership on the entry side
|
|
// (defense in depth alongside RLS) and paginates (avoids silent
|
|
// truncation). See lib/bookkeeping/entry-lines.ts.
|
|
const obLines = await fetchEntryLines<{
|
|
id: string
|
|
account_number: string
|
|
debit_amount: number
|
|
credit_amount: number
|
|
}>({
|
|
supabase,
|
|
lineColumns: 'id, account_number, debit_amount, credit_amount',
|
|
filterEntries: (q: EntryLinesQuery) =>
|
|
q.eq('id', obEntryId).eq('company_id', companyId),
|
|
attachEntriesAs: null,
|
|
})
|
|
|
|
for (const line of obLines) {
|
|
const existing = balances.get(line.account_number) || { debit: 0, credit: 0 }
|
|
existing.debit += Number(line.debit_amount) || 0
|
|
existing.credit += Number(line.credit_amount) || 0
|
|
balances.set(line.account_number, existing)
|
|
}
|
|
} else {
|
|
// Fallback: server-side aggregate of all prior posted/reversed lines.
|
|
// The RPC filters to balance-sheet accounts (class 1-2) and returns
|
|
// one row per account. P&L accounts (class 3-8) reset to zero at each
|
|
// year transition: their balances are absorbed into årets resultat
|
|
// (2099) and rolled into equity, so carrying them forward as IB would
|
|
// violate BFNAR 2013:2. Filtering them in SQL keeps the payload small
|
|
// and the round-trip count at one regardless of history size.
|
|
const { data: priorRows, error } = await supabase.rpc('compute_prior_opening_balances', {
|
|
p_company_id: companyId,
|
|
p_period_start: period.period_start,
|
|
})
|
|
if (error) throw new Error(error.message)
|
|
|
|
for (const row of (priorRows ?? []) as Array<{
|
|
account_number: string
|
|
debit: number | string
|
|
credit: number | string
|
|
}>) {
|
|
balances.set(row.account_number, {
|
|
debit: Number(row.debit) || 0,
|
|
credit: Number(row.credit) || 0,
|
|
})
|
|
}
|
|
}
|
|
|
|
return { balances, obEntryId }
|
|
}
|