Å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.
211 lines
8.5 KiB
TypeScript
211 lines
8.5 KiB
TypeScript
import type { SupabaseClient } from '@supabase/supabase-js'
|
||
import { resolveCompanyEntityType, resultClosingAccounts } from '@/lib/company/entity-type'
|
||
import { createJournalEntry } from '@/lib/bookkeeping/engine'
|
||
import { getOpeningBalances } from '@/lib/reports/opening-balances'
|
||
import { roundOre, ORE_TOLERANCE } from '@/lib/bokslut/rounding'
|
||
import { createLogger } from '@/lib/logger'
|
||
import type { JournalEntry, CreateJournalEntryLineInput } from '@/types'
|
||
|
||
const log = createLogger('result-appropriation-service')
|
||
|
||
/** Årets resultat (current-year result, aktiebolag). */
|
||
export const RESULT_ACCOUNT = '2099'
|
||
/** Vinst eller förlust från föregående år. */
|
||
export const PRIOR_RESULT_ACCOUNT = '2098'
|
||
|
||
export interface ResultAppropriationPlan {
|
||
periodId: string
|
||
periodName: string
|
||
/** entry_date for the omföring: the new period's first day. */
|
||
periodStart: string
|
||
/** The form's "årets resultat" account (AB 2099, ideell förening 2069). */
|
||
resultAccount: string
|
||
/** Where last year's result is carried (AB 2098, ideell förening 2068). */
|
||
priorResultAccount: string
|
||
/** Net result-account IB balance, credit-positive (a profit is > 0, a loss is < 0). */
|
||
net: number
|
||
/** Absolute, öre-rounded amount that moves between the two accounts. */
|
||
amount: number
|
||
direction: 'profit' | 'loss'
|
||
/** Balanced lines for the omföring verifikat. */
|
||
lines: CreateJournalEntryLineInput[]
|
||
}
|
||
|
||
/**
|
||
* Read-only computation of the year-open omföring (no writes). Returns the plan
|
||
* to move 2099 "Årets resultat" onto 2098 "Vinst eller förlust från föregående
|
||
* år", or null when there is nothing to do.
|
||
*
|
||
* Returns null when:
|
||
* - the company is not an aktiebolag (enskild firma books to 2010, no 2099),
|
||
* - the period already has a POSTED result_appropriation entry (idempotency;
|
||
* a reversed one has been stornoed, no longer moves any balance, and must
|
||
* not block re-planning: the year-end undo flow reverses the omföring and
|
||
* the subsequent re-run has to be able to post a fresh one), or
|
||
* - 2099 carries no balance (within ORE_TOLERANCE).
|
||
*
|
||
* Shared by generateResultAppropriation (which posts the plan) and the
|
||
* retroactive catch-up script (which previews it in dry-run) so the preview
|
||
* and the committed entry can never diverge.
|
||
*/
|
||
export async function planResultAppropriation(
|
||
supabase: SupabaseClient,
|
||
companyId: string,
|
||
periodId: string,
|
||
): Promise<ResultAppropriationPlan | null> {
|
||
// Aktiebolag only. Same resolution as previewYearEndClosing's closing-account
|
||
// decision, so the omföring runs exactly when the result was posted to 2099.
|
||
const { data: settings } = await supabase
|
||
.from('company_settings')
|
||
.select('entity_type')
|
||
.eq('company_id', companyId)
|
||
.maybeSingle()
|
||
const entityType = await resolveCompanyEntityType(supabase, companyId, settings?.entity_type)
|
||
// Only forms that close into a dedicated "årets resultat" account carry it
|
||
// forward: AB 2099 -> 2098, ideell förening 2069 -> 2068. An enskild firma
|
||
// closes straight into 2010 and has nothing to reclassify.
|
||
const accounts = resultClosingAccounts(entityType)
|
||
if (!accounts.priorYearCarry) return null
|
||
const resultAccount = accounts.closing
|
||
const priorResultAccount = accounts.priorYearCarry
|
||
|
||
// Idempotency: never plan a second omföring for a period that already has a
|
||
// LIVE one. Deliberately posted-only: a reversed omföring is storno-cancelled
|
||
// (net zero effect on 2099), so it must not block the re-run after an
|
||
// administrative year-end undo (scripts/undo-year-end-closing.ts).
|
||
const { data: existing } = await supabase
|
||
.from('journal_entries')
|
||
.select('id')
|
||
.eq('company_id', companyId)
|
||
.eq('fiscal_period_id', periodId)
|
||
.eq('source_type', 'result_appropriation')
|
||
.eq('status', 'posted')
|
||
.limit(1)
|
||
.maybeSingle()
|
||
if (existing) return null
|
||
|
||
const { data: period } = await supabase
|
||
.from('fiscal_periods')
|
||
.select('period_start, name, opening_balance_entry_id')
|
||
.eq('id', periodId)
|
||
.eq('company_id', companyId)
|
||
.single()
|
||
if (!period) throw new Error('Fiscal period not found')
|
||
|
||
// Read 2099 from the period's INGÅENDE BALANS only: the carried-forward
|
||
// prior result that the IB entry mirrored from last year's UB: NOT the full
|
||
// trial balance. The omföring must reclassify exactly that carried amount;
|
||
// scoping to IB makes it correct even when the period already has current-year
|
||
// 2099 activity (e.g. the retroactive catch-up script running mid-year, where
|
||
// closing = IB + activity would over/under-reclassify). getOpeningBalances
|
||
// reads the committed opening_balance entry, falling back to a server-side
|
||
// aggregate of prior posted lines when none is set. credit − debit is positive
|
||
// for a profit (2099 is credit-normal).
|
||
const { balances } = await getOpeningBalances(supabase, companyId, period)
|
||
const ibResult = balances.get(resultAccount)
|
||
const net = ibResult ? roundOre(ibResult.credit - ibResult.debit) : 0
|
||
if (Math.abs(net) < ORE_TOLERANCE) return null
|
||
|
||
const amount = roundOre(Math.abs(net))
|
||
const lines: CreateJournalEntryLineInput[] =
|
||
net > 0
|
||
? [
|
||
// Profit: move the credit balance off the result account onto the carry.
|
||
{
|
||
account_number: resultAccount,
|
||
debit_amount: amount,
|
||
credit_amount: 0,
|
||
line_description: 'Omföring av föregående års resultat',
|
||
},
|
||
{
|
||
account_number: priorResultAccount,
|
||
debit_amount: 0,
|
||
credit_amount: amount,
|
||
line_description: 'Föregående års resultat',
|
||
},
|
||
]
|
||
: [
|
||
// Loss: move the debit balance off the result account onto the carry.
|
||
{
|
||
account_number: priorResultAccount,
|
||
debit_amount: amount,
|
||
credit_amount: 0,
|
||
line_description: 'Föregående års resultat',
|
||
},
|
||
{
|
||
account_number: resultAccount,
|
||
debit_amount: 0,
|
||
credit_amount: amount,
|
||
line_description: 'Omföring av föregående års resultat',
|
||
},
|
||
]
|
||
|
||
return {
|
||
periodId,
|
||
periodName: period.name,
|
||
periodStart: period.period_start,
|
||
resultAccount,
|
||
priorResultAccount,
|
||
net,
|
||
amount,
|
||
direction: net > 0 ? 'profit' : 'loss',
|
||
lines,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Omföring av föregående års resultat: reclassify 2099 at new-year open.
|
||
*
|
||
* After a new fiscal year's opening balances are generated, account 2099
|
||
* "Årets resultat" carries the prior year's result forward (the IB entry is a
|
||
* faithful mirror of the prior period's UB). Per BAS practice the prior result
|
||
* must not remain on 2099: each year must start with 2099 = 0 so it only ever
|
||
* holds the *current* year's result. This posts the year-open reclassification
|
||
* as a SEPARATE verifikat in the new period:
|
||
*
|
||
* profit (2099 has a credit balance): Dr 2099 / Cr 2098
|
||
* loss (2099 has a debit balance): Dr 2098 / Cr 2099
|
||
*
|
||
* It is deliberately NOT folded into the opening-balance entry. The IB entry
|
||
* must stay a faithful mirror of the prior UB, or validateBalanceContinuity():
|
||
* which reads IB solely from the period's opening_balance entry, would flag
|
||
* 2099 and 2098 as discrepancies and executeYearEndClosing would self-reverse.
|
||
* A standalone entry is invisible to that check.
|
||
*
|
||
* The further disposition 2098 → 2091 (balanserat resultat) / 2898 (utdelning)
|
||
* is the bolagsstämma's decision and is intentionally left to a separate step.
|
||
*
|
||
* Idempotent / AB-only: see planResultAppropriation for the no-op conditions.
|
||
* Powers both executeYearEndClosing (steady state) and the retroactive
|
||
* catch-up script (clears any accumulated 2099 in a company's open period).
|
||
*/
|
||
export async function generateResultAppropriation(
|
||
supabase: SupabaseClient,
|
||
companyId: string,
|
||
userId: string,
|
||
periodId: string,
|
||
): Promise<JournalEntry | null> {
|
||
const plan = await planResultAppropriation(supabase, companyId, periodId)
|
||
if (!plan) return null
|
||
|
||
const entry = await createJournalEntry(supabase, companyId, userId, {
|
||
fiscal_period_id: periodId,
|
||
entry_date: plan.periodStart,
|
||
description: `Omföring av föregående års resultat (${plan.resultAccount} → ${plan.priorResultAccount})`,
|
||
source_type: 'result_appropriation',
|
||
voucher_series: 'A',
|
||
lines: plan.lines,
|
||
})
|
||
|
||
log.info('Posted result appropriation omföring', {
|
||
operation: 'result_appropriation.post',
|
||
companyId,
|
||
entityType: 'journal_entry',
|
||
entityId: entry.id,
|
||
amount: plan.amount,
|
||
direction: plan.direction,
|
||
})
|
||
|
||
return entry
|
||
}
|