CIVICA/i — HOA / Community Association Management

CIVICA/i is a homeowner-association (HOA) / community-association management application: association and unit inventory, owner records, a recurring monthly assessment (dues) charge run and one-off special assessments, an owner receivables ledger, daily cash-receipt application, period-end delinquency aging with late fees and a lien ladder, code-violation and fine posting, reserve-fund transfers, and a balanced GL feed. The bulk of the application is ILE RPG driving keyed physical files (with one COBOL AR control report and one SQLRPGLE GL post over a DB2 for i table); the three CL job cycles orchestrate the batch programs. This manual is the reference for the operator who runs the online screens and the periodic cycles, and for the developer maintaining the application. It is grounded entirely in the committed source (hoa-app/src/sources.mjs, src/seed.mjs, and the test/cv_build.mjs / cv_cycle.mjs drivers). Everything runs in library CIVICA.

A. Overview & Architecture ↑ top

A.1 What it does

CIVICA/i manages the receivables life of a community association:

• Inventory & owners — associations (communities), the units within each, the current owner of record on each unit, and a unit account carrying the running owner-ledger balance and lien status.
• Assessment charge run (monthly) — post recurring dues to every occupied unit in an association, plus one-off special assessments (e.g. a roof levy) to a single unit, raising each owner account balance by exactly the charge.
• Cash application (daily) — apply owner receipts against their open ledger charges through a fees→interest-free waterfall (oldest-open-charge first by receipt nomination), reducing the account balance by exactly what is applied; an over-payment applies only what is owed.
• Delinquency aging, late fees & liens (period) — age every open charge into a 0/1/2/3 bucket on a 30/360 convention, assess a flat 10%-of-open late fee once per run on any delinquent account, and set the account's lien ladder (delinquent → notice → lien filed).
• Violation fines (period) — post a fine to any open code violation whose cure period has elapsed, and mark it fined.
• Reserve transfer, GL post & AR report (period) — transfer a funding percentage of each association's collected cash into its reserve fund, post a balanced DR/CR distribution into the GL, and print an AR control report reconciling the ledger.

A.2 One-layer RPG-over-keyed-files design

Unlike a SQL-PL-centred application, CIVICA/i keeps its business logic in the RPG programs themselves, operating directly on keyed DDS physical files. The design has a few deliberate properties:

• Keyed record-level I/O. Each batch program opens its files (SETLL/READ/ READE to walk, CHAIN to fetch a keyed row, UPDATE/WRITE to post) and codes the rules inline — assessment expansion, the cash waterfall, aging math, fee/fine posting — in fixed-form C-specs and /free blocks.
• Alternate access paths do the sorting. Two logical files provide alternate orderings so a program need not sort: CVUNTLF keys units by association (so *ALL assessment expansion walks a whole association), and CVLEDLF keys the ledger by due date (oldest-due-first aging).
• A durable audit trail with derived keys. Every posting program contributes to one accumulating history file, CVHIST, whose unique key is derived from a stable business key in a disjoint per-program numeric range. Re-running a program regenerates the same key, and a CHAIN(EN) guard refuses the duplicate — this is the app's idempotency mechanism (see F.2).
• One SQL surface and one COBOL surface. The GL distribution is a real DB2 for i table (CVGLDIST, created by RUNSQLSTM); CVGLPST is SQLRPGLE that reads CVHIST and writes balanced rows into it. The AR control report (CVARRPT) is hand-written ILE COBOL over the keyed ledger.

The benefit for operations: each cycle is a small, self-contained program driven from a CL wrapper, and every money movement lands both on the owner account (CVACCT.ABAL) and in the history trail, so a run's effect is fully reconstructable.

A.3 Component & flow

  SETUP/SEED             ONLINE                 BATCH (CL job cycles)
  ----------             ------                 ---------------------
  CVSETUP  (CRTxxx)      CVMENU (5250)          CVMONTH --> CVCHRUN   (assessment charge)
  CVREFLD  (seed)          opt 1 -> CVUNTIQ     CVDAILY --> CVCASHAP  (cash application)
                           opt 2 -> CVLEDIQ     CVPERIOD -> CVDELQ    (aging+fee+lien)
                                                          -> CVVFINE  (violation fines)
                                                          -> CVRESVTR (reserve transfer)
                                                          -> CVGLPST  (GL post)
                                                          -> CVARRPT  (AR control report)
            \                                  /
             \                                /
              v                              v
     CVACCT.ABAL  <-- raised by charge/fee/fine, lowered by cash --  the AR invariant
        |   \
        |    +--> CVLEDG  (owner AR open items: A/S/L/F charges, CHGOPEN reduced by cash)
        |    +--> CVHIST  (durable audit trail, one row per posting, derived key)
        +------> CVGLDIST (balanced DR/CR GL distribution)   CVRESV/CVRESVH (reserve)

A single posting event (say, the monthly charge run) flows: CVMONTH calls CVCHRUN → it walks each active assessment schedule, expands *ALL to the association's occupied units via CVUNTLF → writes a CVLEDG open-item and a CVHIST row (keyed off account+assessment id) → raises CVACCT.ABAL by the charge. The date each program processes for is a hard-coded period constant in the source (2026-09 for the charge run, 2026-09-25 for the period runs) rather than a control table — see the honest note in C.

A.4 Object inventory

The full object catalogue is 14 physical files + 2 logical files + 3 display files + 1 printer file + 1 SQL table (+ its index), driven by 10 RPG programs, 1 COBOL program and 4 CL programs, plus 1 seeder. Sections D and F expand each.

B. Online Transactions & Screens ↑ top

B.1 The command/entry line

CIVICA/i has no CICS transaction identifiers. On IBM i, each program is reached by name from a 5250 command-entry line (or a JOBQ/scheduler for the batch jobs). The operator equivalent of "type a transid and Enter" is "type a CALL command and Enter". Before invoking anything the job's library list must include CIVICA — the tested jobs run with LIBL = QSYS QGPL CIVICA QTEMP and CURLIB = CIVICA (each CL wrapper also issues its own ADDLIBLE LIB(CIVICA)).

The batch drivers and the CL wrappers take no CALL parameters. Only the three inquiry programs (CVMENU, CVUNTIQ, CVLEDIQ) are interactive; the batch programs run to completion and each DSPLYs a one-line result banner (e.g. CVCHRUN CHARGED=8 SKIP=...).

B.2 The main menu & inquiry screens

Three interactive programs share the display files CVMENUD, CVUNTD and CVLEDD. All three exit on F3 (DDS CA03).

Main menu — CVMENU / CVMENUD

A two-option menu. Key 1 to call the unit/owner inquiry, 2 for the owner-ledger inquiry; any other non-blank option shows Invalid option.. Control returns here when the called inquiry exits.

Unit / owner inquiry — CVUNTIQ / CVUNTD (plain screen)

A non-subfile inquiry. The operator keys an association and a unit and presses Enter; the program CHAINs the unit (composite key ASSOCID+UNITNO), then the owner (CVOWNER on OWNERID) and the account (CVACCT on ACCTNO = ASSOCID || UNITNO), and shows the address, unit status, owner id/name, account balance (%editc(abal:'K')) and lien status. The status line message walks Unit not found. → Unit found. → Unit and account found. as each CHAIN succeeds.

Owner-ledger inquiry — CVLEDIQ / CVLEDD (subfile screen)

The app's subfile screen. The operator keys a 10-byte account number (ASSOCID || UNITNO); the program shows the owner name, account balance and lien status, then loads a subfile (DDS record LSFL under control record LCTL, SFLPAG(5) per page, SFLSIZ(20), ROLLUP/ROLLDOWN) of the account's charge/open-item history — one row per CVLEDG charge with its sequence, type, description, amount, open balance and aging bucket. The subfile is cleared and reloaded on every enquiry pass (the *IN31 discipline: write LCTL with SFLCLR on, reload, then display), so a fresh account's items appear immediately.

Subfile columns (LSFL)

B.3 Controls & audit workflow (no four-eyes maker–checker)

Honest statement: CIVICA/i does not model a four-eyes maker–checker / separate-authorization workflow. There is no "one user posts, a second user approves" step: charges, cash, fees, fines and reserve transfers are all applied directly by the batch programs. The manual documents the control model the application does have:

• Durable audit trail (CVHIST). Every posting program writes one history row per posting — charge (A/S), cash applied (P), late fee (L), fine (F), reserve transfer (V) — carrying the account/item, amount, date, reference and a memo. This is the after-the-fact accountability trail.
• Derived-key idempotency (the re-run guard). Because each history key is derived from a stable business key (F.2), re-submitting a cycle for the same period is refused row-by-row rather than double-posting — a data-layer safety net in place of a segregation-of-duties gate.
• The AR balance invariant. CVACCT.ABAL moves only by the charge run (up), cash application (down) and fee/fine posting (up); the tests assert every account balance equals its raised-less-applied total to the cent (F.3).
• Status gating. Business rules gate by row state: the charge run skips inactive schedules and already-met special-assessment ceilings; cash application skips receipts not 'U' (unapplied); fine posting skips violations not 'O' (open) or still inside their cure period; reserve transfer skips associations that collected no cash.
• Balanced GL. CVGLPST writes DR/CR pairs so total debits equal total credits exactly, an independent integrity check on the period's charge book.

In sum, the control posture is durable audit + derived-key idempotency + a strict balance invariant + a balanced GL, rather than an approval workflow.

C. Batch Jobs & the Periodic Cycle ↑ top

CIVICA/i's processing runs as three CL job cycles rather than one monolithic nightly job: a daily cycle (cash application), a monthly cycle (assessment charge run), and a period-end cycle (aging + late fees + lien status, violation fines, reserve transfer, GL post, AR report). Each CL wrapper is parameterless: it does ADDLIBLE LIB(CIVICA), calls its program(s), and sends a completion banner.

C.1 Full batch program set

File I/O legend: I=input, U=update, O=output, WA=write/add (output-add). The CL cycles wire these together: CVDAILY→CVCASHAP; CVMONTH→CVCHRUN; CVPERIOD→CVDELQ→CVVFINE→CVRESVTR→CVGLPST→CVARRPT.

C.2 Daily / monthly / period detail

Monthly — CVMONTH / CVCHRUN

For every active assessment schedule (ASMTSTAT='A'): a *ALL schedule walks every occupied unit in the association via CVUNTLF (vacant units are skipped), posting one CVLEDG open-item (CHGTYPE 'A' regular / 'S' special) per target account, writing a CVHIST row, and raising CVACCT.ABAL by the charge. A single-unit special assessment targets just that unit's account. A special assessment's instalment counter (ASMTPOST) advances once per run and is capped at ASMTINST; a regular assessment (ASMTINST 0) has no ceiling.

Expected DSPLY against the seeded book (Meadowbrook dues to 3 occupied units +
roof special on 0103 + Harborview dues to 4 units = 8 charges over 7 accounts):
  CVCHRUN CHARGED=8 SKIP=0    8 charges posted; A000010103 gets 2 (regular + special)

Per-account charge totals: A000010101/0102 250.00; A000010103 650.00 (250 dues + 400 roof, two ledger rows); A000020201–0204 320.00 each. Each ABAL rises from 0 by exactly its total.

Daily — CVDAILY / CVCASHAP

For every receipt with RCSTAT='U' (unapplied): CHAIN the nominated charge (composite key ACCTNO+RCCHGSQ), take min(receipt amount, open), reduce CHGOPEN (fully-applied → CHGSTAT='P'), lower CVACCT.ABAL by the amount applied, write a CVHIST 'P' row (negative amount), and stamp the receipt 'A' (fully applied) or 'P' (part-applied). An over-payment applies only what is owed; the remainder stays unapplied.

Expected DSPLY (RC000001 pays A000010101 dues 250.00 in full;
RC000002 pays 150.00 of A000010102's 250.00 open):
  CVCASHAP APPLIED=2 SKIP=0   A000010101 -> 0.00; A000010102 250.00 -> 100.00

Period — CVPERIOD chain

Five programs run in order:

• CVDELQ (aging + late fee + lien). Pass 1 stamps every open charge's bucket from days overdue on a 30/360 date-serial (((yy×12)+mm)×30+dd): 0 current, 1 = 1–30, 2 = 31–60, 3 = 61+. Pass 2 walks each account, finds its worst open bucket (excluding 'L' late-fee rows), sets LIENSTAT (bucket 1→'D', 2→'N' notice, 3→'L' lien filed, none→blank), and assesses a flat 10% of the account's open balance as a late fee (once per run date, guarded by the derived history key). An account with no open charges is cleared to blank and earns no fee.
• CVVFINE (violation fines). Any 'O' violation whose cure period (VDAYS from VDT) has elapsed by the run date is fined: post a CVLEDG 'F' charge, raise ABAL, write history, and mark the violation 'F'. A violation still within cure is left open.
• CVRESVTR (reserve transfer). Per association, sum the cash actually collected this period (the 'P' history rows for that association's accounts) and transfer RPCT% into the reserve, raising RBAL and writing a CVRESVH row. Associations that collected nothing are skipped.
• CVGLPST (GL post). Sum the period's history by type (assessment / late fee / fine) and post balanced GL rows: DR 1400-OAR (owner receivable) = CR 4100-ASMT + 4300-LATE + 4400-FINE. It posts only the movement since the last close (the DR receivable already booked is the floor), so a re-run adds nothing.
• CVARRPT (AR control report). COBOL sequential pass over CVLEDG totalling raised amount, open amount, item count and overdue count.

Expected DSPLY across the period chain (seeded book, run date 2026-09-25):
  CVDELQ B0=0 B1=7 B2=0 B3=0 FEES=6   7 open charges 24d overdue -> bucket 1; 6 accounts fee'd
  CVVFINE FINED=1 SKIP=1              V1 (24d>10 cure) fined; V2 (5d, in cure) skipped
  CVRESVTR XFER=1 SKIP=1             Meadowbrook 400.00 cash x 10% = 40.00; Harborview no cash
  CVGLPST BATCH=202609 ROWS=4       DR receivable + 3 CR revenue lines, balanced
  CVARRPT ITEMS 00015               8 charges + 6 late fees + 1 fine = 15 ledger rows

Late-fee results: A000010102 → 110.00, A000010103 → 715.00, and each Harborview account 320.00 → 352.00 (all lien 'D'). A000010101 was fully settled before the close, so it earns no fee and its lien clears to blank — then later carries a 75.00 violation fine (0 → 75).

C.3 Ordering & dependencies

• MONTHLY (charge) before DAILY (cash). Cash application needs open charges to apply against; the charge run must post the period's dues first.
• DAILY (cash) before the PERIOD close. Aging late fees are 10% of the open balance and the reserve transfer funds off collected cash — both depend on the period's receipts already being applied, so run the dailies before the period-end cycle.
• Within CVPERIOD the order is fixed by the CL: aging/lien → fines → reserve → GL → AR. GL posts after fines so the fine revenue is in the period total; the reserve funds off cash collected before the GL summarises the charge book.
• Every cycle is safely re-runnable for the same period (derived-key idempotency), so a partial failure is recovered by re-submitting the CL — already-posted rows are refused, the rest complete.

D. Data Files (data dictionary) ↑ top

All files are in library CIVICA, grounded in the DDS/SQL source in hoa-app/src/sources.mjs. Dates are stored as signed numerics in YYYYMMDD form (8S 0); money is packed decimal (11P 2); the account key ACCTNO is ASSOCID || UNITNO (10A) by construction.

CVASSOC — Association master (K ASSOCID)

CVUNIT — Unit master (K ASSOCID, UNITNO)

CVUNTLF is a logical over CVUNIT keyed on ASSOCID alone (non-unique) so the charge run walks a whole association's units.

CVOWNER — Owner master (K OWNERID)

CVASMT — Assessment schedule (K ASSOCID, ASMTID)

CVLEDG — Owner AR open items (K ACCTNO, CHGSEQ)

CVLEDLF is a logical over CVLEDG keyed on CHGDUE, ACCTNO so the aging run reads oldest-due-first without sorting.

CVACCT — Unit account (K ACCTNO)

CVRCPT — Cash receipts (K RCPTNO)

CVVIOL — Code violations (K VIOLNO)

CVARC — Architectural requests (K ARCNO)

Architectural requests are inventory only in this build — the file exists and is seeded/queryable, but no batch program posts money against it.

CVRESV / CVRESVH — Reserve fund + history

CVHIST — Durable audit trail (K HSEQ)

CVGLDIST — GL distribution (SQL, PK GLSEQ)

Index CVGLDACC on (ACCT, DRCR) supports the incremental-post floor query and the reconciliation SELECTs.

Relationships

• CVUNIT.(ASSOCID) → CVASSOC.ASSOCID; CVUNIT.OWNERID → CVOWNER.OWNERID.
• CVACCT.ACCTNO = CVUNIT.ASSOCID || CVUNIT.UNITNO (one account per occupied unit).
• CVLEDG.ACCTNO → CVACCT.ACCTNO (per-account open items); CVRCPT.(ACCTNO,RCCHGSQ) names a CVLEDG row.
• CVVIOL.ACCTNO / CVARC.ACCTNO → CVACCT.ACCTNO.
• CVRESV/CVRESVH keyed by ASSOCID; CVHIST references account/violation/association by derived key; CVGLDIST is standalone.

Seeded reference book (CVREFLD)

2 associations (Meadowbrook A00001, Harborview A00002), 9 units (2 vacant, 2 rented, 5 owner-occupied), 6 owners, 3 assessment schedules (Meadowbrook dues 250.00 + roof special 400.00 on 0103, Harborview dues 320.00), 7 unit accounts (one per occupied unit, zero balance), 2 reserve funds (Meadowbrook 10%, Harborview 8%).

E. Operations Runbook ↑ top

E.1 Day-in-the-life

1. First-time / rebuild setup: CALL CIVICA/CVSETUP creates every object and compiles every program, then CALL CIVICA/CVREFLD seeds the reference book. Confirm the setup-complete banner and the seed counts (ASSOC=2 UNIT=9 OWNER=6 ASMT=3 ACCT=7).
2. Post the month's assessments: SBMJOB CMD(CALL PGM(CIVICA/CVMONTH)); check CVCHRUN CHARGED=n SKIP=m and that each occupied account's ABAL rose by its dues (plus any special).
3. Apply receipts as they arrive (daily): load CVRCPT rows (RCSTAT 'U', each naming an account + charge sequence), then SBMJOB CMD(CALL PGM(CIVICA/CVDAILY)); check CVCASHAP APPLIED=n and that balances fell by exactly what was applied.
4. Look things up: CALL CIVICA/CVMENU → option 1 (unit/owner) or 2 (owner ledger subfile) for read-only inquiry and reconciliation.

Pre-checks: confirm the job's library list includes CIVICA; confirm the seed data is loaded (the inquiries show data). Post-checks: every batch program's DSPLY banner shows the expected count; the SKIP figure accounts for anything not processed (inactive schedule, already-applied receipt, vacant unit).

E.2 Period-end close

1. Confirm the month's charge run and all daily cash runs have completed (open balances and collected cash are what aging/reserve will compute on).
2. Load any code violations to be actioned into CVVIOL (RCSTAT 'O', with a cure period VDAYS).
3. Submit the period cycle: SBMJOB CMD(CALL PGM(CIVICA/CVPERIOD)). It runs aging→fines→reserve→GL→AR and sends the period-end banner.
4. Review the DSPLY banners and reconcile:

• Aging & fees — CVDELQ B0/B1/B2/B3 bucket counts and FEES=n; each fee'd account is now LIENSTAT='D' (or N/L if deeper) with ABAL raised 10% of open.
• Fines — CVVFINE FINED=n; each fined violation is VSTAT='F' and its account carries the fine; violations still within cure stay 'O'.
• Reserve — CVRESVTR XFER=n; check CVRESVH and each CVRESV.RBAL rose by exactly RPCT% of that association's collected cash.
• GL balance — run the balance check:

SELECT DRCR, SUM(AMT) FROM CIVICA.CVGLDIST GROUP BY DRCR;
-- total D must equal total C exactly; DR 1400-OAR = 4100-ASMT + 4300-LATE + 4400-FINE

Reconciling figures (the same ones the cycle test checks against a hand-derived oracle): DR Owner Receivable = assessments (2210.00) + late fees (203.00) + fine (75.00) = 2488.00; CR Assessment Revenue 2210.00, CR Late Fee 203.00, CR Fine 75.00. CVARRPT reports the full ledger: 8 charges + 6 late fees + 1 fine = 15 items.

E.3 Failure & re-run rules

Each batch program DSPLYs a result banner with a processed count and a SKIP count. The app's safety net is derived-key idempotency: re-running a program regenerates the same CVHIST key and the CHAIN(EN) guard refuses the duplicate.

F. Developer Reference ↑ top

The complete program surface, from hoa-app/src/sources.mjs. All objects are in library CIVICA. The RPG is a mix of fixed-form C-specs and /free blocks; each program uses keyed record-level I/O against the DDS files.

F.1 Programs (10 RPG + 1 COBOL + 4 CL)

CVREFLD (RPGLE) — reference-data seeder

Writes the 2 associations, 6 owners, 9 units, 3 assessment schedules, 7 unit accounts and 2 reserve funds, then DSPLYs CVREFLD ASSOC=2 UNIT=9 OWNER=6 ASMT=3 ACCT=7.

CVCHRUN (RPGLE) — monthly assessment charge run

Walks CVASMT; subroutine ASM1 expands one schedule (*ALL via CVUNTLF, else one unit), POST1 posts a CVLEDG open-item + CVHIST row and raises CVACCT.ABAL. Re-CHAINs the schedule row by its own AKEY before advancing ASMTPOST for a special (the unit walk moved the shared record buffer). DSPLYs CVCHRUN CHARGED=n SKIP=m.

CVCASHAP (RPGLE) — daily cash application

Walks CVRCPT; subroutine CSH1 takes min(RCAMT, CHGOPEN) against the nominated charge (CKEY), reduces the open item, lowers ABAL, writes a negative-amount 'P' history row and stamps the receipt A/P. DSPLYs CVCASHAP APPLIED=n SKIP=m.

CVDELQ (RPGLE) — period aging + late fee + lien

Pass 1 stamps CHGAGE from a 30/360 day-serial; pass 2 (LF1) finds each account's worst open bucket, sets LIENSTAT, and assesses a 10%-of-open late fee (one per run date). DSPLYs CVDELQ B0=.. B1=.. B2=.. B3=.. FEES=n.

CVVFINE (RPGLE) — period violation fines

Walks CVVIOL; subroutine VF1 fines an open violation whose cure period has elapsed (30/360 day-serial), posts an 'F' ledger + history row, raises ABAL, and re-CHAINs the violation to mark it 'F'. DSPLYs CVVFINE FINED=n SKIP=m.

CVRESVTR (RPGLE) — period reserve transfer

Walks CVRESV; subroutine RSV1 sums the association's 'P' cash history, transfers RPCT%, writes a CVRESVH + 'V' history row and raises RBAL. DSPLYs CVRESVTR XFER=n SKIP=m.

CVGLPST (SQLRPGLE) — period GL post

Sums CVHIST by type, computes gross less the already-posted DR floor (SELECT SUM(AMT) ... WHERE ACCT='1400-OAR' AND DRCR='D'), and inserts balanced DR/CR rows into CVGLDIST via glrow. DSPLYs CVGLPST BATCH=202609 ROWS=n.

CVUNTIQ / CVLEDIQ / CVMENU (RPGLE) — inquiries + menu

Read-only 5250 drivers over CVUNTD (plain unit/owner), CVLEDD (ledger subfile with SFLCLR/reload discipline) and CVMENUD (routes to the two inquiries).

CVARRPT (CBLLE) — AR control report

ILE COBOL sequential read of CVLEDG, totalling RAISED, OPEN, ITEMS and OVERDUE; DISPLAYs four CVARRPT ... lines.

CVSETUP / CVDAILY / CVMONTH / CVPERIOD (CLP)

Setup (DLTF/CRTPF/CRTLF/CRTDSPF/CRTPRTF/RUNSQLSTM/CRTBNDRPG/CRTBNDCBL) and the three parameterless job-cycle wrappers, each with its completion SNDPGMMSG banner.

F.2 Key derivation & idempotency

The idempotency mechanism is a stable derived history key, one disjoint numeric range per program, so a re-run regenerates the same CVHIST.HSEQ and the CHAIN(EN) guard refuses the duplicate. No control row, no run-flag — the derived key is the guard.

"account-digits" is %dec(%subst(ACCTNO:2:9):9:0) (the numeric tail of ASSOCID||UNITNO); "receipt-digits" is the numeric tail of RCPTNO; "association-digits" the numeric tail of ASSOCID. The ranges are 10M apart so no two programs collide.

F.3 The AR balance invariant

The core correctness property the cycle test asserts to the cent: CVACCT.ABAL moves only by (up) the charge run, (down) cash application, and (up) fee/fine posting. Concretely, for the seeded book after the full cycle:

• A000010101: +250 (dues) −250 (paid) +75 (fine) = 75.00, lien blank (settled before close).
• A000010102: +250 (dues) −150 (part-paid) +10 (10% of 100 open) = 110.00, lien D.
• A000010103: +250 +400 (roof) +65 (10% of 650) = 715.00, lien D.
• A000020201–0204: +320 +32 (10% of 320) = 352.00 each, lien D.

Each RPG program re-CHAINs the account (and the schedule/violation) after any intervening file walk, because the walk moved the shared record buffer; the CHAIN reloads the whole record from disk before the in-memory field is updated. This is the discipline that keeps ABAL exact under record-level I/O.

F.4 RPG / embedded-SQL patterns

• SETLL + READ/READE loop — sequentially walk a file (*LOVAL SETLL then READ to EOF on an indicator), or walk a keyed group (WASSOC SETLL CVUNTLF + READE).
• KLIST + CHAIN(E) / CHAIN(EN) — composite-key fetch (AKEY, CKEY, UKEY); CHAIN(EN) against CVHIST is the idempotency probe (fetch without lock, act on the not-found indicator).
• Re-CHAIN after a walk — reload a record from disk after an intervening file operation moved the shared buffer, before UPDATE (the ABAL-exactness discipline).
• Embedded SQL (CVGLPST only) — EXEC SQL SELECT ... INTO for the posted-floor and max-sequence, EXEC SQL INSERT per GL row, checking sqlcod before counting a posted row.
• DSPLY result banners — every batch program DSPLYs a one-line summary the CL joblog and the tests scrape.

F.5 Status-code table (field values that gate behaviour)

CIVICA/i has no SQLSTATE application-error surface (it is not SQL-PL). Behaviour is gated by field status codes:

G. Glossary ↑ top

Assessment

A charge levied on an owner. Regular (ASMTTYPE R) = recurring monthly dues to every occupied unit; special (S) = a one-off or fixed-instalment levy (e.g. a roof fund) on a unit.

Owner ledger / open item (CVLEDG)

The receivables sub-ledger: one row per charge (assessment, late fee, fine), reduced as cash is applied (CHGOPEN). The unit's charges sit together under its account key.

Unit account (CVACCT) / ABAL

The running owner-ledger balance per unit, plus lien status. ABAL is the AR invariant: it moves only by charge (up), cash (down) and fee/fine (up).

Aging bucket

How overdue an open charge is, on a 30/360 day convention: 0 current, 1 = 1–30 days, 2 = 31–60, 3 = 61+. Stamped by CVDELQ into CHGAGE.

Late fee

A flat 10% of an account's total open balance, assessed once per aging run on any delinquent account.

Lien ladder (LIENSTAT)

Escalating collection status from the worst open bucket: D delinquent, N notice sent, L lien filed; blank when current.

Cure period

The days (VDAYS from the violation date) an owner has to fix a violation before a fine is assessed.

Reserve fund (CVRESV)

An association savings balance funded by a percentage (RPCT) of each period's collected cash, moved by CVRESVTR.

Derived key / idempotency

Each posting's CVHIST key is computed from a stable business key in a disjoint numeric range, so a re-run regenerates the same key and the CHAIN(EN) guard refuses the duplicate — the app's re-run safety (see F.2).

GL distribution (CVGLDIST)

The balanced double-entry feed: DR owner receivable = CR assessment + late-fee + fine revenue. Posted incrementally so a re-run never double-posts.

Subfile

A 5250 display construct listing many rows on one screen (DDS SFL/SFLCTL). CVLEDIQ's charge-history list is a subfile, cleared and reloaded on every enquiry.

SBMJOB

Submit Job — the IBM i command that queues a program to run as a batch job (e.g. SBMJOB CMD(CALL PGM(CIVICA/CVPERIOD))).

Logical file (LF) / alternate access path

A DDS keyed view over a PF giving a different record ordering: CVUNTLF (units by association), CVLEDLF (ledger by due date).