ydim 1.1.5 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e5f53b42fbdc66ca0b05da68957b0621fef14c1c5123939e663895fc52b094f
-  data.tar.gz: 0b0377f58780313293f21072e5fea737b2c9fe08a555db9e2498f01954115644
+  metadata.gz: cf1f40eabcc24aeef2f6c0e5eb3a1c6d207297dc5e3009aadbf073a9ce07233d
+  data.tar.gz: 01ebd91434ee1121c038e1dfd2fc7601f354d0175d08c0c8028055cbcd04c1bf
 SHA512:
-  metadata.gz: 18304fab8af6cc62469f6443569ddd0ab667bede93f6d752d9e341cc2e18386542acd86ec056f3d8f40da93418137704f4ef18407b7633986eece916260386a8
-  data.tar.gz: f7930455ae2ce1ca4c71d979ab605f5c11d7c629e48306519a41f9dd14834c78754ab410fbf5423e60347851cc63e8eacf248d093ed5978a7cfc8eafc6db9940
+  metadata.gz: d8c31ab23b9df6679605589ba8a02e742415a0dad1fedc35b1ab307b68694024c622200da569fbaf55f74c24380fd2b19fad9bfdb5440581b4a244a380de00b7
+  data.tar.gz: 443601812147a9c983bf692deb8a4fc67c66379a2dccc21bc5eba77afb6789ccd8d9f79d65790d9486bc087223842c3844d28265ae1462707b0a5dc1c8f8fbd3

data/.github/workflows/ruby.yml

@@ -20,7 +20,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest]
-        ruby: [ '2.7', '3.0', '3.1', '3.2']
+        ruby: ['3.0', '3.1', '3.2']
     runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v3
@@ -29,3 +29,5 @@ jobs:
         ruby-version: ${{ matrix.ruby }}
         bundler-cache: true # runs 'bundle install' and caches installed gems automatically
     - run: bundle exec rake test
+      env:
+        MT_COMPAT: '1'

data/CLAUDE.md

@@ -0,0 +1,147 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project
+
+`ydim` — ywesee distributed invoice manager. A Ruby gem (GPLv2) providing a DRb daemon that
+stores debitors/invoices in PostgreSQL via ODBA, renders PDF invoices, and mails them.
+Version lives in `lib/ydim/version.rb`; changes are recorded in `History.txt`.
+
+## Commands
+
+```bash
+bundle install                       # gems come from ydim.gemspec via Gemfile
+MT_COMPAT=1 bundle exec rake test    # full suite (test/suite.rb); this is what CI runs
+MT_COMPAT=1 bundle exec ruby -Ilib -Itest test/test_invoice.rb   # a single test file
+MT_COMPAT=1 bundle exec ruby -Ilib -Itest test/test_invoice.rb -n test_add_item  # one test
+bundle exec rake                     # default: clobber + test + build gem into pkg/
+```
+
+`MT_COMPAT=1` is required — the tests use `flexmock/test_unit`, which needs minitest's
+`Minitest::Unit::TestCase` compatibility shim. Without it (or with a too-new
+flexmock/minitest) loading a test file dies with `undefined method 'teardown'`.
+CI (`.github/workflows/ruby.yml`) runs Ruby 3.0/3.1/3.2 on ubuntu; `.travis.yml` is dead.
+`Gemfile.lock` is gitignored — a stale one in the working tree will make `bundle exec` fail
+with `Bundler::GemNotFound`; delete it and re-run `bundle install`.
+
+`rake spec` exists (RSpec task) but there are no spec files.
+
+## Architecture
+
+Client/server over **DRb**, authenticated by DSA key challenge (`rrba`), persisted with
+**ODBA** (object database over `ydbi`/`ydbd-pg` → PostgreSQL).
+
+**Server side** (`lib/ydim/ydimd` is the daemon entry point, not `bin/`):
+`ydimd` wires `ODBA.storage.dbi` to a connection pool, installs `ODBA::DRbIdConv`, then
+serves a `YDIM::Server` over `druby://`. `Server#initialize` builds a **Needle registry**
+(`@serv`) — the service locator threaded through nearly every class. Registered services:
+`:auth_server`, `:clients`, `:config`, `:currency_converter`, `:factory`, `:id_server`,
+`:logger`. Anything that takes a `serv` argument (`Factory`, `AutoInvoicer`,
+`CurrencyUpdater`) reads its collaborators from this registry, so tests mock `serv` rather
+than the individual dependencies.
+
+`Server` also spawns daily background threads via `repeat_at(hour)`: AutoInvoicer,
+CurrencyUpdater, and a StatusUpdater that re-saves every invoice so derived `status` stays
+current in the DB.
+
+**Session/API surface**: `Server#login` → `RootUser#new_session` → `RootSession` wrapped in
+`ODBA::DRbWrapper`. **`RootSession` is the entire remote API** — every method a client can
+call (`create_invoice`, `add_items`, `send_invoice`, `debitors`, `collect_garbage`,
+`mark_paid`, `reconcile_camt`, …) is a public method there. Adding a client-callable
+operation means adding it to `RootSession`. `Client#method_missing` forwards everything to
+the session, so clients need no stubs.
+
+**Domain**: `Debitor` (1→n `Invoice` and `AutoInvoice`) → `Item`. `Invoice#status` is
+computed, not stored (`is_trash` / `is_paid` / `is_due` / `is_open`). `AutoInvoice` is a
+recurring template: `AutoInvoicer#run` walks all debitors daily and, when `auto.date` is
+today, calls `Factory#generate_invoice` to materialise a real `Invoice` from it (copying
+items, stamping `expiry_time`, applying the current `vat_rate`) and mails it; a month ahead
+it sends a reminder instead. `Factory` is the only place invoice IDs are allocated
+(`id_server.next_id(:invoice, config.invoice_number_start)`).
+
+**Persistence is declared in one file**: `lib/ydim/odba.rb` reopens the domain classes to
+include `ODBA::Persistable`, list `ODBA_SERIALIZABLE` ivars, and declare `odba_index`
+(e.g. `Debitor` by email/name/unique_id, `Invoice` by status/unique_id). Those indexes are
+what power `find_by_unique_id` / `search_by_status` / `search_by_exact_email` used in
+`RootSession`. New persisted classes or lookups must be registered here — and each
+`odba_index` needs a matching `ydim_<class>_<attr>` table, see `set_initial_ydim_db.sql`.
+
+**VAT**: `config.vat_rate` (currently 8.1, in `server_config.rb`) is applied when items are
+added (`RootSession#add_items`), when autoinvoices are materialised (`Factory`), and reset
+by `Invoice#suppress_vat=`. `Debitor#foreign?` (country != `config.home_country`) makes
+`Factory` suppress VAT at creation time. Changing the rate touches all of these plus the
+`texts.tax` string in pdfinvoice config.
+
+**Payment reconciliation**: `lib/ydim/camt.rb` parses ISO-20022 camt.052/053/054 statements
+(rexml only, no DB — the namespace is read off the document root, so any minor version
+works), and `lib/ydim/reconciler.rb` matches booked credits against invoices. The CLI
+(`ydim-camt`) parses client-side and sends `Camt::Entry` objects to
+`RootSession#reconcile_camt`, so the daemon never touches the files. Results carry
+`Reconciler::InvoiceRef`, not `Invoice::Info`, so a client can unmarshal them with
+`ydim/reconciler` alone instead of loading the whole server.
+
+Three rules that the real UBS data forces and that are easy to break:
+- **Filter by IBAN.** An e-banking download holds every account the login sees, private ones
+  included; `config.camt_accounts` says which are ydim's, and `Reconciler#reconcile` raises
+  rather than run without it.
+- **Dedup by `AcctSvcrRef`.** UBS re-sends the same day under a new `MsgId`; in the sample
+  set 60 of 142 entries were redeliveries.
+- **Whole digit runs only** (`Camt::Entry::TOKEN_PATTERN`) — never a substring, and never a
+  run touching a letter. TWINT credits carry the payer's phone number, and bank
+  `EndToEndId`s are hex that happens to contain 5-digit sequences.
+
+Only `:exact` and `:split` matches (invoice named *and* amount equal to the cent) are ever
+applied; everything else is reported for review.
+
+**PDF**: `lib/pdfinvoice/` is a vendored sub-library (PDF::Writer based) with its own config;
+`Invoice#pdf_invoice` maps ydim items onto it and overrides `formats`/`texts.tax` per invoice.
+
+**Mail**: `lib/ydim/mail.rb` configures `::Mail.defaults` with SMTP settings at load time.
+
+## Configuration
+
+Three independent `rclconf` config objects, all merging ARGV over defaults:
+
+| Object | Defaults defined in | YAML read from |
+| --- | --- | --- |
+| `YDIM::Server.config` (daemon) | `lib/ydim/server_config.rb` | `/etc/ydim/ydimd.yml` |
+| `YDIM::Client::CONFIG` | `lib/ydim/config.rb` | `/etc/ydim/ydim.yml` |
+| `PdfInvoice.config` | `lib/pdfinvoice/config.rb` | `~/.pdfinvoice/config.yml`, `/etc/pdfinvoice/config.yml` |
+
+Gotcha: `server_config.rb` only builds `CONFIG` with defaults — the YAML file is actually
+loaded by the `config.load(config.config)` call at the top of `lib/ydim/mail.rb`, which is
+why `mail` is required early in the daemon's require chain. Don't reorder those requires.
+Since 1.1.4/1.1.5 all server paths are rooted at `/etc/ydim` by design; keep them there.
+
+## Executables
+
+`bin/ydim-edit` and `bin/ydim-inject` are **byte-identical copies** of `lib/ydim/ydim-edit`
+and `lib/ydim/ydim-inject` (the gemspec takes executables from `bin/`, but the working
+copies live in `lib/ydim/` — see History.txt 1.0.3). Edit both, or the gem and the checkout
+diverge. Note `ydim-edit` carries its own duplicated defaults hash, separate from
+`server_config.rb`.
+
+- `ydim-edit` — IRB console with a live `$server` / `$needle` (Needle registry) against the DB.
+- `ydim-inject` — reads a YAML invoice on stdin, creates and mails it through a `Client`.
+- `ydim-camt` — reconciles a camt.053 zip/directory/file against the open invoices; reports
+  by default, books only with `--apply`. Config overrides are RCLConf's `key=value` form,
+  not `--key value`, so the OptionParser call filters those out of the file arguments.
+- `ydim_migrate_to_utf_8` — one-off LATIN1→UTF-8 DB migration (repo root, not `bin/`).
+- `get_db_ydim` — shell script pulling a nightly Postgres dump and restoring it locally.
+
+`install.rb` is a generated setup.rb-style installer; `Manifest.txt` is stale (lists
+`bin/ydimd`, `lib/ydim/smtp_tls.rb`, `README.txt` — none exist).
+
+## Testing conventions
+
+Minitest + FlexMock, no DB. `test/stub/odba.rb` replaces `ODBA.transaction` with a plain
+yield and `odba_store` with a counter, so tests that touch persistence require it
+(`require 'stub/odba'`) *before* the class under test. Tests mock the Needle registry with a
+bare `FlexMock` and stub `serv.config` / `serv.logger` individually. `test/suite.rb` just
+globs `test_*.rb`; SimpleCov is present but disabled (`if false`).
+
+## Style
+
+Existing code is hard-tabbed in the older files and two-space indented in the newer ones,
+often mixed within a single file. Match the surrounding block rather than reformatting.

data/History.txt

@@ -1,3 +1,15 @@
+=== 1.1.6 / 09.08.2026
+
+* Reconcile payments from ISO-20022 camt.053 bank statements (UBS Z53)
+  * ydim-camt reads a statement zip, directory or single xml and reports
+    which open invoices the credits settle; --apply books them
+  * RootSession#reconcile_camt and #mark_paid make this available over DRb
+  * new config camt_accounts: the IBANs ydim invoices are paid into. The
+    e-banking download also contains the private accounts, and reconciling
+    without this set is refused rather than guessed
+* Pin minitest below 6, which dropped the Minitest::Unit::TestCase shim that
+  flexmock/test_unit needs
+
 === 1.1.5/ 21.01.2023
 
 * Read ALL configuration values only from /etc/ydim

data/bin/ydim-camt

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# ydim-camt -- ydim -- 09.08.2026 -- zdavatz@ywesee.com
+#
+# Reconciles bank statements (ISO-20022 camt.053, as downloaded from UBS
+# e-banking) against the open invoices. Reports by default; only books a
+# payment when told to with --apply, and even then only when the payer named
+# the invoice and the amount matches to the cent.
+#
+#   ydim-camt ~/Downloads/statements.zip
+#   ydim-camt --apply ~/Downloads/statements.zip
+#   ydim-camt --account CH87... /var/ydim/camt/
+
+require 'openssl'
+require 'optparse'
+require 'rrba/error'
+require 'ydim/camt'
+require 'ydim/client'
+require 'ydim/config'
+require 'ydim/reconciler'
+
+options = { :apply => false, :verbose => false, :accounts => [] }
+parser = OptionParser.new { |opt|
+  opt.banner = "Usage: ydim-camt [options] <statements.zip|directory|file.xml>"
+  opt.on('--apply', 'mark unambiguously matched invoices as paid') {
+    options[:apply] = true }
+  opt.on('--account IBAN', 'account to reconcile (repeatable); ',
+    'defaults to camt_accounts from the config') { |iban|
+    options[:accounts].push(iban) }
+  opt.on('-v', '--verbose', 'also list credits that matched nothing') {
+    options[:verbose] = true }
+  opt.on('-h', '--help') { puts opt; exit }
+}
+# Every ydim executable also takes its configuration on the command line, in
+# RCLConf's "key=value" form -- those are not statements to read, they were
+# already picked up from ARGV when ydim/config was required.
+paths = parser.parse(ARGV.dup).reject { |arg| arg =~ /\A[\w.]+=/ }
+if paths.empty?
+  warn parser
+  exit 1
+end
+missing = paths.reject { |path| File.exist?(path) }
+unless missing.empty?
+  warn "no such file: #{missing.join(', ')}"
+  exit 1
+end
+
+entries = paths.flat_map { |path| YDIM::Camt.entries(path) }
+if entries.empty?
+  warn "no camt entries found in #{paths.join(', ')}"
+  exit 1
+end
+
+config = YDIM::Client::CONFIG
+accounts = options[:accounts]
+accounts = [config.camt_accounts].flatten.compact if accounts.empty?
+if accounts.empty?
+  warn "no account to reconcile: pass --account IBAN, or set camt_accounts " \
+    "in the config to the IBAN of the ywesee business account. The private " \
+    "accounts in the same download must not be matched against invoices."
+  exit 1
+end
+
+def show(match, marker)
+  ids = match.invoice_ids
+  printf("  %-11s %10.2f %s  %s  %s\n", ids.first || '?',
+    match.entry.amount.to_f, match.entry.currency,
+    match.entry.booking_date, match.entry.counterparty.to_s[0, 30])
+  ids[1..-1].to_a.each { |id| printf("  %-11s\n", id) }
+  puts "  #{' ' * 11} #{marker} #{match.reason}"
+end
+
+server = DRb::DRbObject.new(nil, config.server_url)
+client = YDIM::Client.new(config)
+key = OpenSSL::PKey::DSA.new(File.read(config.private_key))
+
+DRb.start_service
+client.login(server, key)
+begin
+  result = client.reconcile_camt(entries,
+    :apply => options[:apply], :accounts => accounts)
+
+  applicable = result.applicable
+  puts(options[:apply] ? "BOOKED AS PAID" \
+    : "MATCHED (would be marked paid with --apply)")
+  if applicable.empty?
+    puts "  none"
+  else
+    applicable.each { |match| show(match, match.applied? ? '+' : '~') }
+  end
+
+  review = result.review
+  unless review.empty?
+    puts
+    puts "REVIEW (never booked automatically)"
+    review.each { |match| show(match, '?') }
+  end
+
+  unmatched = result.unmatched
+  if options[:verbose] && !unmatched.empty?
+    puts
+    puts "UNMATCHED CREDITS"
+    unmatched.each { |match| show(match, '-') }
+  end
+
+  puts
+  summary = ["#{applicable.size} matched", "#{review.size} to review",
+    "#{unmatched.size} unmatched"]
+  summary.push("#{result.applied.size} booked") if options[:apply]
+  result.skipped.sort_by { |reason, count| reason.to_s }.each { |reason, count|
+    summary.push("#{count} #{reason.to_s.tr('_', ' ')}") if count > 0
+  }
+  puts summary.join(', ')
+  unless options[:apply] || applicable.empty?
+    puts "run again with --apply to mark the #{applicable.size} matched " \
+      "invoice(s) paid"
+  end
+ensure
+  client.logout
+end

data/bin/ydim-edit

@@ -44,7 +44,7 @@ defaults = {
 	'root_key'							=> 'root_dsa',
 	'smtp_from'							=> '',
 	'smtp_server'						=> 'localhost',
-	'vat_rate'							=> 8.0,
+	'vat_rate'							=> 8.1,
 }
 config = RCLConf::RCLConf.new(ARGV, defaults)
 config.load(config.config)

data/lib/ydim/camt.rb

@@ -0,0 +1,219 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# YDIM::Camt -- ydim -- 09.08.2026 -- zdavatz@ywesee.com
+
+require 'date'
+require 'fileutils'
+require 'rexml/document'
+require 'tmpdir'
+
+module YDIM
+  # Reader for ISO-20022 bank-to-customer statements (camt.052/053/054), as
+  # delivered by UBS and the other Swiss banks. This is pure parsing: no DB and
+  # no ODBA, so it can run on the client side. The matching of entries against
+  # invoices lives in YDIM::Reconciler.
+  module Camt
+    class Error < StandardError; end
+
+    # A single booked movement on an account (a camt <Ntry>).
+    class Entry
+      attr_accessor :account_iban, :account_currency, :amount, :currency,
+        :credit, :status, :booking_date, :value_date, :reference,
+        :counterparty, :additional_info, :source
+      attr_reader :remittance, :end_to_end_ids, :creditor_references
+      def initialize
+        @remittance = []
+        @end_to_end_ids = []
+        @creditor_references = []
+        @credit = false
+      end
+      def credit?
+        @credit
+      end
+      # ydim invoices are only ever paid into the ywesee business account --
+      # the private accounts share the same e-banking download, so entries have
+      # to be filtered by IBAN before anything is matched. An empty filter
+      # accepts everything here; refusing to run without one is the
+      # Reconciler's job, since only it knows the entries are about to be
+      # matched against invoices.
+      def account?(ibans)
+        ibans = [ibans].flatten.compact
+        ibans.empty? || ibans.any? { |iban|
+          normalize_iban(iban) == normalize_iban(@account_iban)
+        }
+      end
+      # Only BOOK entries have actually hit the account; PDNG ones can still
+      # disappear, so they must never mark an invoice as paid.
+      def booked?
+        @status.nil? || @status == 'BOOK'
+      end
+      # Money as an integer so that amounts can be compared without float
+      # rounding surprises.
+      def amount_cents
+        (@amount.to_f * 100).round
+      end
+      # Every string a payer might have put an invoice number into.
+      def texts
+        (@remittance + @end_to_end_ids + @creditor_references \
+          + [@additional_info]).compact
+      end
+      # Runs of digits found in the remittance information. Whole runs only --
+      # never substrings, or the phone number in a TWINT payment
+      # ("+41796723413") would match half the invoices in the database. A run
+      # touching a letter is machine noise rather than something a human typed:
+      # this drops the hex EndToEndIds that banks generate
+      # ("0ebf22116f364fc394da3e2776a05643" would otherwise offer up "22116"),
+      # while "RG 13363 VOM 26.6.2026" and "ISO 13368" still yield their
+      # invoice number.
+      TOKEN_PATTERN = /(?<![0-9A-Za-z])\d+(?![0-9A-Za-z])/
+      def numeric_tokens
+        texts.flat_map { |text| text.scan(TOKEN_PATTERN) }.uniq
+      end
+      # Two statements can deliver the same entry (UBS re-sends a day under a
+      # new MsgId), so entries are identified by the bank's own reference.
+      def dedup_key
+        [@account_iban, @reference || texts.join('|'), amount_cents, @credit,
+          @booking_date]
+      end
+      def to_s
+        sprintf("%s %s %s %s %s", @booking_date, @credit ? 'CRDT' : 'DBIT',
+          @currency, sprintf('%.2f', @amount.to_f), @counterparty)
+      end
+      private
+      def normalize_iban(iban)
+        iban.to_s.gsub(/\s+/, '').upcase
+      end
+    end
+
+    # A camt <Stmt> -- one account over one period.
+    class Statement
+      attr_accessor :id, :account_iban, :currency, :owner, :created_at,
+        :opening_balance, :closing_balance, :source
+      attr_reader :entries
+      def initialize
+        @entries = []
+      end
+    end
+
+    class << self
+      # Reads whatever the bank handed you: a single xml file, a directory of
+      # them, or the zip you downloaded from e-banking. Returns Statements.
+      def read(path)
+        if File.directory?(path)
+          read_files(Dir[File.join(path, '**', '*.[xX][mM][lL]')].sort)
+        elsif path =~ /\.zip\z/i
+          read_zip(path)
+        else
+          read_files([path])
+        end
+      end
+      def read_files(paths)
+        paths.flat_map { |path|
+          parse(File.read(path), File.basename(path))
+        }
+      end
+      def read_zip(path)
+        Dir.mktmpdir('ydim-camt') { |dir|
+          unless system('unzip', '-q', '-o', path, '-d', dir)
+            raise Error,
+              "unable to unzip #{path} -- extract it and pass the directory"
+          end
+          read_files(Dir[File.join(dir, '**', '*.[xX][mM][lL]')].sort)
+        }
+      end
+      # Parses one camt document into its Statements.
+      def parse(xml, source = nil)
+        doc = REXML::Document.new(xml)
+        root = doc.root or raise Error, "#{source}: not an XML document"
+        # camt.053.001.02 through .08 differ only in the namespace URI for
+        # everything we read, so take whatever the document declares.
+        ns = { 'c' => root.namespace }
+        REXML::XPath.match(doc, '//c:Stmt | //c:Rpt | //c:Ntfctn', ns).collect { |node|
+          parse_statement(node, ns, source)
+        }
+      end
+      # All entries of all statements below path, duplicates included -- the
+      # Reconciler drops those, and it can only report how many deliveries were
+      # doubled up if it gets to see them.
+      def entries(path)
+        read(path).flat_map { |stmt| stmt.entries }
+      end
+      def dedup(entries)
+        seen = {}
+        entries.select { |entry| !seen.key?(entry.dedup_key) \
+          && seen[entry.dedup_key] = true }
+      end
+
+      private
+      def parse_statement(node, ns, source)
+        stmt = Statement.new
+        stmt.source = source
+        stmt.id = text(node, 'c:Id', ns)
+        stmt.account_iban = text(node, 'c:Acct/c:Id/c:IBAN', ns)
+        stmt.currency = text(node, 'c:Acct/c:Ccy', ns)
+        stmt.owner = text(node, 'c:Acct/c:Ownr/c:Nm', ns)
+        stmt.created_at = date(text(node, 'c:CreDtTm', ns))
+        stmt.opening_balance = balance(node, ns, 'OPBD')
+        stmt.closing_balance = balance(node, ns, 'CLBD')
+        REXML::XPath.each(node, 'c:Ntry', ns) { |entry_node|
+          stmt.entries.push(parse_entry(entry_node, ns, stmt))
+        }
+        stmt
+      end
+      def parse_entry(node, ns, stmt)
+        entry = Entry.new
+        entry.source = stmt.source
+        entry.account_iban = stmt.account_iban
+        entry.account_currency = stmt.currency
+        amount = REXML::XPath.first(node, 'c:Amt', ns)
+        entry.amount = amount && amount.text.to_f
+        entry.currency = (amount && amount.attributes['Ccy']) || stmt.currency
+        entry.credit = text(node, 'c:CdtDbtInd', ns) == 'CRDT'
+        entry.status = text(node, 'c:Sts/c:Cd', ns) || text(node, 'c:Sts', ns)
+        entry.booking_date = date(text(node, 'c:BookgDt/c:Dt', ns) \
+          || text(node, 'c:BookgDt/c:DtTm', ns))
+        entry.value_date = date(text(node, 'c:ValDt/c:Dt', ns) \
+          || text(node, 'c:ValDt/c:DtTm', ns))
+        entry.reference = text(node, 'c:AcctSvcrRef', ns) \
+          || text(node, 'c:NtryRef', ns)
+        entry.additional_info = text(node, 'c:AddtlNtryInf', ns)
+        # The party on the other side: for money coming in that is the debtor,
+        # for money going out the creditor. Either can be given as a name or as
+        # loose address lines.
+        side = entry.credit? ? 'Dbtr' : 'Cdtr'
+        entry.counterparty = collect(node,
+          ".//c:#{side}/c:Pty/c:Nm | .//c:#{side}/c:Pty/c:PstlAdr/c:AdrLine",
+          ns).first
+        # An entry can bundle several transactions (a batch booking), so the
+        # remittance information of all of them counts.
+        entry.remittance.concat(collect(node, './/c:RmtInf/c:Ustrd', ns))
+        entry.remittance.concat(collect(node, './/c:Strd/c:AddtlRmtInf', ns))
+        entry.end_to_end_ids.concat(collect(node, './/c:EndToEndId', ns)\
+          .reject { |id| id == 'NOTPROVIDED' })
+        entry.creditor_references.concat(
+          collect(node, './/c:CdtrRefInf/c:Ref', ns))
+        entry
+      end
+      def balance(node, ns, code)
+        amount = REXML::XPath.first(node,
+          "c:Bal[c:Tp/c:CdOrPrtry/c:Cd='#{code}']/c:Amt", ns)
+        amount && amount.text.to_f
+      end
+      def collect(node, path, ns)
+        REXML::XPath.match(node, path, ns).collect { |el|
+          el.text.to_s.strip
+        }.reject { |str| str.empty? }.uniq
+      end
+      def text(node, path, ns)
+        el = REXML::XPath.first(node, path, ns)
+        str = el && el.text.to_s.strip
+        str unless str.nil? || str.empty?
+      end
+      def date(str)
+        Date.parse(str) if str
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/ydim/config.rb

@@ -13,6 +13,11 @@ module YDIM
 			File.join(ydim_default_dir, 'ydim.yml'),
 		]
 		defaults = {
+			# IBANs of the accounts ydim invoices are paid into -- see
+			# camt_accounts in server_config.rb. ydim-camt reconciles these and
+			# nothing else, so that the private accounts in the same e-banking
+			# download are left alone.
+			'camt_accounts'				=> [],
 			'client_url'					=> 'druby://localhost:0',
 			'config'							=> default_config_files,
 			'private_key'					=> File.join(home_dir, '.ssh', 'id_dsa'),