From dc6a7d72811703a9714305fae7c1d6ba08d1cec4 Mon Sep 17 00:00:00 2001 From: Alexander Ott Date: Sat, 11 Oct 2025 08:13:30 +0200 Subject: [PATCH] Modify Raiffeisenbank Bankgruppe PDF-Importer to support new transaction Closes #5072 --- .../pdf/raiffeisenbankgruppe/Kauf11.txt | 46 + .../RaiffeisenbankgruppePDFExtractorTest.java | 966 +++++++++--------- .../pdf/RaiffeisenBankgruppePDFExtractor.java | 249 ++--- 3 files changed, 668 insertions(+), 593 deletions(-) create mode 100644 name.abuchen.portfolio.tests/src/name/abuchen/portfolio/datatransfer/pdf/raiffeisenbankgruppe/Kauf11.txt diff --git a/name.abuchen.portfolio.tests/src/name/abuchen/portfolio/datatransfer/pdf/raiffeisenbankgruppe/Kauf11.txt b/name.abuchen.portfolio.tests/src/name/abuchen/portfolio/datatransfer/pdf/raiffeisenbankgruppe/Kauf11.txt new file mode 100644 index 0000000000..06d84db834 --- /dev/null +++ b/name.abuchen.portfolio.tests/src/name/abuchen/portfolio/datatransfer/pdf/raiffeisenbankgruppe/Kauf11.txt @@ -0,0 +1,46 @@ +PDFBox Version: 3.0.5 != 1.8.17 +Portfolio Performance Version: 0.80.3 +System: win32 | x86_64 | 21.0.5+11-LTS | Azul Systems, Inc. +----------------------------------------- + da + + +Raiffeisenbank Untersberg eGen +Hauptstraße 28 +5082 Grödig b + + +a +a +Abrechnung Dauerauftrag a +11111111 - 23.09.2024 a +Depotnummer: 11.111.111 +Ing. Max Mustermann Ing. Max Mustermann +Maxiz-Muster.Straße 11/1 +5011 Wohnort 11/1 +Beratung Grödig +Wir haben für Sie am 23.09.2024 unten angeführtes Geschäft abgerechnet: +Geschäftsart: Ausgabe Fonds aus Dauerauftrag Dauerauftrag-Nr.: 51 - 26.05.2021 +Auftragseingang: 20.09.2024 - 16:38:14 +Zugang: 0,256 Stk +Titel: AT0000A1TX20 Raiffeisen-MegaTr.-ESG Aktien(RZ) T +Miteigentumsanteile - Thesaurierend +Fondsgesellschaft: Raiffeisen Kapitalanlageges. m.b.H. +Kurs: 187,34 EUR +Handelsplatz: AT_F AT FONDS +Handelszeit: 20.09.2024 +Verwahrart: SV +Positionsdaten: Loco: AT Österreich +Kurswert: -47,96 EUR +Transaktionsservice Grundpreis: -1,14 EUR +Transaktionsservice variabel: -0,95 EUR +Zu Lasten IBAN AT11 1111 1111 1111 1111 -50,05 EUR +Valuta 23.09.2024 +Schlusstag: 20.09.2024 +Kassatag: 23.09.2024 +Bestand nach Buchung: +KESt-Neubestand mit Anschaffungskosten nach dem gleitenden +Durchschnittsverfahren § 27a Abs. 4 Zi 3 EStG 0,256 Stk +steuerlicher Anschaffungswert: 47,96 EUR +Steuerl. Behandlung vorbehaltlich Beurteilung durch BMF +23.09.2024 1 / 1 \ No newline at end of file diff --git a/name.abuchen.portfolio.tests/src/name/abuchen/portfolio/datatransfer/pdf/raiffeisenbankgruppe/RaiffeisenbankgruppePDFExtractorTest.java b/name.abuchen.portfolio.tests/src/name/abuchen/portfolio/datatransfer/pdf/raiffeisenbankgruppe/RaiffeisenbankgruppePDFExtractorTest.java index fdd59dbba8..f678ffb795 100644 --- a/name.abuchen.portfolio.tests/src/name/abuchen/portfolio/datatransfer/pdf/raiffeisenbankgruppe/RaiffeisenbankgruppePDFExtractorTest.java +++ b/name.abuchen.portfolio.tests/src/name/abuchen/portfolio/datatransfer/pdf/raiffeisenbankgruppe/RaiffeisenbankgruppePDFExtractorTest.java @@ -27,6 +27,7 @@ import static name.abuchen.portfolio.datatransfer.ExtractorMatchers.taxes; import static name.abuchen.portfolio.datatransfer.ExtractorMatchers.withFailureMessage; import static name.abuchen.portfolio.datatransfer.ExtractorTestUtilities.countAccountTransactions; +import static name.abuchen.portfolio.datatransfer.ExtractorTestUtilities.countAccountTransfers; import static name.abuchen.portfolio.datatransfer.ExtractorTestUtilities.countBuySell; import static name.abuchen.portfolio.datatransfer.ExtractorTestUtilities.countSecurities; import static org.hamcrest.CoreMatchers.hasItem; @@ -37,15 +38,12 @@ import java.time.LocalDateTime; import java.util.ArrayList; -import java.util.Iterator; import java.util.List; import org.junit.Test; import name.abuchen.portfolio.Messages; -import name.abuchen.portfolio.datatransfer.Extractor; import name.abuchen.portfolio.datatransfer.Extractor.BuySellEntryItem; -import name.abuchen.portfolio.datatransfer.Extractor.Item; import name.abuchen.portfolio.datatransfer.Extractor.SecurityItem; import name.abuchen.portfolio.datatransfer.Extractor.TransactionItem; import name.abuchen.portfolio.datatransfer.ImportAction.Status; @@ -61,7 +59,6 @@ import name.abuchen.portfolio.model.Security; import name.abuchen.portfolio.model.Transaction; import name.abuchen.portfolio.model.Transaction.Unit; -import name.abuchen.portfolio.money.CurrencyUnit; import name.abuchen.portfolio.money.Money; import name.abuchen.portfolio.money.Values; @@ -71,27 +68,27 @@ public class RaiffeisenbankgruppePDFExtractorTest @Test public void testWertpapierKauf01() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf01.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf01.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("DE000BAY0017")); assertNull(security.getWkn()); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("Bayer AG Namens-Aktien o.N.")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.EUR)); + assertThat(security.getCurrencyCode(), is("EUR")); // check buy sell transaction - BuySellEntry entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() + var entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(entry.getPortfolioTransaction().getType(), is(PortfolioTransaction.Type.BUY)); @@ -103,39 +100,39 @@ public void testWertpapierKauf01() assertThat(entry.getNote(), is("Auftrags-Nr.: 11441163")); assertThat(entry.getPortfolioTransaction().getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(107.26)))); + is(Money.of("EUR", Values.Amount.factorize(107.26)))); assertThat(entry.getPortfolioTransaction().getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(106.94)))); + is(Money.of("EUR", Values.Amount.factorize(106.94)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.32)))); + is(Money.of("EUR", Values.Amount.factorize(0.32)))); } @Test public void testWertpapierKauf02() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf02.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf02.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("US7475251036")); assertThat(security.getWkn(), is("883121")); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("QUALCOMM INC. REGISTERED SHARES DL -,0001")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.EUR)); + assertThat(security.getCurrencyCode(), is("EUR")); // check buy sell transaction - BuySellEntry entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() + var entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(entry.getPortfolioTransaction().getType(), is(PortfolioTransaction.Type.BUY)); @@ -147,39 +144,39 @@ public void testWertpapierKauf02() assertThat(entry.getNote(), is("Auftragsnummer 338500/63.00 | Limit billigst")); assertThat(entry.getPortfolioTransaction().getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(14399.34)))); + is(Money.of("EUR", Values.Amount.factorize(14399.34)))); assertThat(entry.getPortfolioTransaction().getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(14368.00)))); + is(Money.of("EUR", Values.Amount.factorize(14368.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(28.74 + 2.50 + 0.10)))); + is(Money.of("EUR", Values.Amount.factorize(28.74 + 2.50 + 0.10)))); } @Test public void testWertpapierKauf03() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf03.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf03.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("IE00B6YX5C33")); assertNull(security.getWkn()); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("SPDR S&P 500 UCITS ETF Registered Shares USD o.N.")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.EUR)); + assertThat(security.getCurrencyCode(), is("EUR")); // check buy sell transaction - BuySellEntry entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() + var entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(entry.getPortfolioTransaction().getType(), is(PortfolioTransaction.Type.BUY)); @@ -191,30 +188,30 @@ public void testWertpapierKauf03() assertThat(entry.getNote(), is("Auftrags-Nr.: 12345678")); assertThat(entry.getPortfolioTransaction().getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(2510.00)))); + is(Money.of("EUR", Values.Amount.factorize(2510.00)))); assertThat(entry.getPortfolioTransaction().getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(2478.00)))); + is(Money.of("EUR", Values.Amount.factorize(2478.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(4.00 + 25.00 + 3.00)))); + is(Money.of("EUR", Values.Amount.factorize(4.00 + 25.00 + 3.00)))); } @Test public void testWertpapierKauf04() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf04.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf04.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("CA1363851017")); assertNull(security.getWkn()); @@ -223,7 +220,7 @@ public void testWertpapierKauf04() assertThat(security.getCurrencyCode(), is("CAD")); // check buy sell transaction - BuySellEntry entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() + var entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(entry.getPortfolioTransaction().getType(), is(PortfolioTransaction.Type.BUY)); @@ -235,39 +232,40 @@ public void testWertpapierKauf04() assertThat(entry.getNote(), is("Auftrags-Nr.: 12345678")); assertThat(entry.getPortfolioTransaction().getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(1121.40)))); + is(Money.of("EUR", Values.Amount.factorize(1121.40)))); assertThat(entry.getPortfolioTransaction().getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(1041.48)))); + is(Money.of("EUR", Values.Amount.factorize(1041.48)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize((73.00 / 1.406) + 25.00 + 3.00)))); + is(Money.of("EUR", Values.Amount.factorize((73.00 / 1.406) + 25.00 + 3.00)))); - Unit grossValueUnit = entry.getPortfolioTransaction().getUnit(Unit.Type.GROSS_VALUE).orElseThrow(IllegalArgumentException::new); + var grossValueUnit = entry.getPortfolioTransaction().getUnit(Unit.Type.GROSS_VALUE) + .orElseThrow(IllegalArgumentException::new); assertThat(grossValueUnit.getForex(), is(Money.of("CAD", Values.Amount.factorize(1464.32)))); } @Test public void testWertpapierKauf04WithSecurityInEUR() { - Security security = new Security("Canadian Natural Resources Ltd Registered Shares o.N.", CurrencyUnit.EUR); + var security = new Security("Canadian Natural Resources Ltd Registered Shares o.N.", "EUR"); security.setIsin("CA1363851017"); security.setWkn("884437"); - Client client = new Client(); + var client = new Client(); client.addSecurity(security); - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(client); + var extractor = new RaiffeisenBankgruppePDFExtractor(client); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf04.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf04.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(1)); // check buy sell transaction - BuySellEntry entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() + var entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(entry.getPortfolioTransaction().getType(), is(PortfolioTransaction.Type.BUY)); @@ -279,39 +277,39 @@ public void testWertpapierKauf04WithSecurityInEUR() assertThat(entry.getNote(), is("Auftrags-Nr.: 12345678")); assertThat(entry.getPortfolioTransaction().getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(1121.40)))); + is(Money.of("EUR", Values.Amount.factorize(1121.40)))); assertThat(entry.getPortfolioTransaction().getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(1041.48)))); + is(Money.of("EUR", Values.Amount.factorize(1041.48)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize((73.00 / 1.406) + 25.00 + 3.00)))); + is(Money.of("EUR", Values.Amount.factorize((73.00 / 1.406) + 25.00 + 3.00)))); } @Test public void testWertpapierKauf05() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf05.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf05.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("IE00BK5BQT80")); assertNull(security.getWkn()); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("Vanguard FTSE All-World U.ETF Reg. Shs USD Acc. oN")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.EUR)); + assertThat(security.getCurrencyCode(), is("EUR")); // check buy sell transaction - BuySellEntry entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() + var entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(entry.getPortfolioTransaction().getType(), is(PortfolioTransaction.Type.BUY)); @@ -323,39 +321,39 @@ public void testWertpapierKauf05() assertThat(entry.getNote(), is("Auftrags-Nr.: 44083824")); assertThat(entry.getPortfolioTransaction().getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(18521.34)))); + is(Money.of("EUR", Values.Amount.factorize(18521.34)))); assertThat(entry.getPortfolioTransaction().getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(18472.00)))); + is(Money.of("EUR", Values.Amount.factorize(18472.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(18.47 + 30.87)))); + is(Money.of("EUR", Values.Amount.factorize(18.47 + 30.87)))); } @Test public void testWertpapierKauf06() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf06.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf06.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("IE00BK5BQT80")); assertNull(security.getWkn()); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("Vanguard FTSE All-World U.ETF Reg. Shs USD Acc. oN")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.EUR)); + assertThat(security.getCurrencyCode(), is("EUR")); // check buy sell transaction - BuySellEntry entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() + var entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(entry.getPortfolioTransaction().getType(), is(PortfolioTransaction.Type.BUY)); @@ -367,28 +365,29 @@ public void testWertpapierKauf06() assertThat(entry.getNote(), is("Auftrags-Nr.: 41601727")); assertThat(entry.getPortfolioTransaction().getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(9681.58)))); + is(Money.of("EUR", Values.Amount.factorize(9681.58)))); assertThat(entry.getPortfolioTransaction().getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(9652.00)))); + is(Money.of("EUR", Values.Amount.factorize(9652.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(9.65 + 19.93)))); + is(Money.of("EUR", Values.Amount.factorize(9.65 + 19.93)))); } @Test public void testWertpapierKauf07() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf07.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf07.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(1L)); assertThat(countBuySell(results), is(1L)); assertThat(countAccountTransactions(results), is(0L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(2)); new AssertImportActions().check(results, "CHF"); @@ -410,16 +409,17 @@ public void testWertpapierKauf07() @Test public void testWertpapierKauf08() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf08.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf08.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(1L)); assertThat(countBuySell(results), is(1L)); assertThat(countAccountTransactions(results), is(0L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(2)); new AssertImportActions().check(results, "EUR"); @@ -441,16 +441,17 @@ public void testWertpapierKauf08() @Test public void testWertpapierKauf09() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf09.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf09.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(1L)); assertThat(countBuySell(results), is(1L)); assertThat(countAccountTransactions(results), is(0L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(2)); new AssertImportActions().check(results, "EUR"); @@ -472,16 +473,17 @@ public void testWertpapierKauf09() @Test public void testWertpapierKauf10() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf10.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf10.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(1L)); assertThat(countBuySell(results), is(1L)); assertThat(countAccountTransactions(results), is(0L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(2)); new AssertImportActions().check(results, "CHF"); @@ -500,30 +502,62 @@ public void testWertpapierKauf10() hasTaxes("CHF", 3.75), hasFees("CHF", 2.35 + 80.00)))); } + @Test + public void testWertpapierKauf11() + { + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + + List errors = new ArrayList<>(); + + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kauf11.txt"), errors); + + assertThat(errors, empty()); + assertThat(countSecurities(results), is(1L)); + assertThat(countBuySell(results), is(1L)); + assertThat(countAccountTransactions(results), is(0L)); + assertThat(countAccountTransfers(results), is(0L)); + assertThat(results.size(), is(2)); + new AssertImportActions().check(results, "EUR"); + + // check security + assertThat(results, hasItem(security( // + hasIsin("AT0000A1TX20"), hasWkn(null), hasTicker(null), // + hasName("Raiffeisen-MegaTr.-ESG Aktien(RZ) T Miteigentumsanteile - Thesaurierend"), // + hasCurrencyCode("EUR")))); + + // check buy sell transaction + assertThat(results, hasItem(purchase( // + hasDate("2024-09-20T00:00"), hasShares(0.256), // + hasSource("Kauf11.txt"), // + hasNote("Dauerauftrag-Nr.: 51"), // + hasAmount("EUR", 50.05), hasGrossValue("EUR", 47.96), // + hasTaxes("EUR", 0.00), hasFees("EUR", 1.14 + 0.95)))); + } + @Test public void testWertpapierVerkauf01() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Verkauf01.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Verkauf01.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("AT0000837307")); assertNull(security.getWkn()); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("Zumtobel Group AG Inhaber-Aktien o.N.")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.EUR)); + assertThat(security.getCurrencyCode(), is("EUR")); // check buy sell transaction - BuySellEntry entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() + var entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(entry.getPortfolioTransaction().getType(), is(PortfolioTransaction.Type.SELL)); @@ -535,39 +569,39 @@ public void testWertpapierVerkauf01() assertThat(entry.getPortfolioTransaction().getShares(), is(Values.Share.factorize(4500))); assertThat(entry.getPortfolioTransaction().getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(36115.76)))); + is(Money.of("EUR", Values.Amount.factorize(36115.76)))); assertThat(entry.getPortfolioTransaction().getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(36923.18)))); + is(Money.of("EUR", Values.Amount.factorize(36923.18)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(696.65)))); + is(Money.of("EUR", Values.Amount.factorize(696.65)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(110.77)))); + is(Money.of("EUR", Values.Amount.factorize(110.77)))); } @Test public void testWertpapierVerkauf02() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Verkauf02.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Verkauf02.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("US09075V1026")); assertThat(security.getWkn(), is("A2PSR2")); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("BIONTECH SE NAM.-AKT.(SP.ADRS)1/O.N.")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.EUR)); + assertThat(security.getCurrencyCode(), is("EUR")); // check buy sell transaction - BuySellEntry entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() + var entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(entry.getPortfolioTransaction().getType(), is(PortfolioTransaction.Type.SELL)); @@ -579,39 +613,39 @@ public void testWertpapierVerkauf02() assertThat(entry.getPortfolioTransaction().getShares(), is(Values.Share.factorize(110))); assertThat(entry.getPortfolioTransaction().getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(19966.38)))); + is(Money.of("EUR", Values.Amount.factorize(19966.38)))); assertThat(entry.getPortfolioTransaction().getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(20009.00)))); + is(Money.of("EUR", Values.Amount.factorize(20009.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(40.02 + 2.50 + 0.10)))); + is(Money.of("EUR", Values.Amount.factorize(40.02 + 2.50 + 0.10)))); } @Test public void testWertpapierVerkauf03() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Verkauf03.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Verkauf03.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("US5949181045")); assertThat(security.getWkn(), is("870747")); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("MICROSOFT CORP. REGISTERED SHARES DL-,00000625")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.EUR)); + assertThat(security.getCurrencyCode(), is("EUR")); // check buy sell transaction - BuySellEntry entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() + var entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(entry.getPortfolioTransaction().getType(), is(PortfolioTransaction.Type.SELL)); @@ -623,39 +657,39 @@ public void testWertpapierVerkauf03() assertThat(entry.getPortfolioTransaction().getShares(), is(Values.Share.factorize(15))); assertThat(entry.getPortfolioTransaction().getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(4187.16)))); + is(Money.of("EUR", Values.Amount.factorize(4187.16)))); assertThat(entry.getPortfolioTransaction().getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(4197.75)))); + is(Money.of("EUR", Values.Amount.factorize(4197.75)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(10.49 + 0.10)))); + is(Money.of("EUR", Values.Amount.factorize(10.49 + 0.10)))); } @Test public void testWertpapierVerkauf04() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Verkauf04.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Verkauf04.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("DE0009848119")); assertNull(security.getWkn()); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("DWS Top Dividende Inhaber-Anteile LD")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.EUR)); + assertThat(security.getCurrencyCode(), is("EUR")); // check buy sell transaction - BuySellEntry entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() + var entry = (BuySellEntry) results.stream().filter(BuySellEntryItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(entry.getPortfolioTransaction().getType(), is(PortfolioTransaction.Type.SELL)); @@ -667,40 +701,40 @@ public void testWertpapierVerkauf04() assertThat(entry.getPortfolioTransaction().getShares(), is(Values.Share.factorize(200))); assertThat(entry.getPortfolioTransaction().getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(26000.00)))); + is(Money.of("EUR", Values.Amount.factorize(26000.00)))); assertThat(entry.getPortfolioTransaction().getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(26000.00)))); + is(Money.of("EUR", Values.Amount.factorize(26000.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(entry.getPortfolioTransaction().getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); } @Test public void testDividende01() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende01.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende01.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("DE000BAY0017")); assertNull(security.getWkn()); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("Bayer AG Namens-Aktien o.N.")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.EUR)); + assertThat(security.getCurrencyCode(), is("EUR")); // check dividends transaction - AccountTransaction transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance) - .findFirst().orElseThrow(IllegalArgumentException::new).getSubject(); + var transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance).findFirst() + .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DIVIDENDS)); @@ -709,41 +743,37 @@ public void testDividende01() assertThat(transaction.getSource(), is("Dividende01.txt")); assertNull(transaction.getNote()); - assertThat(transaction.getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(110.02)))); - assertThat(transaction.getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(180.00)))); - assertThat(transaction.getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(47.48 + 22.50)))); - assertThat(transaction.getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(110.02)))); + assertThat(transaction.getGrossValue(), is(Money.of("EUR", Values.Amount.factorize(180.00)))); + assertThat(transaction.getUnitSum(Unit.Type.TAX), is(Money.of("EUR", Values.Amount.factorize(47.48 + 22.50)))); + assertThat(transaction.getUnitSum(Unit.Type.FEE), is(Money.of("EUR", Values.Amount.factorize(0.00)))); } @Test public void testDividende02() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende02.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende02.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("US7475251036")); assertThat(security.getWkn(), is("883121")); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("QUALCOMM INC. REGISTERED SHARES DL -,0001")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.USD)); + assertThat(security.getCurrencyCode(), is("USD")); // check dividends transaction - AccountTransaction transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance) - .findFirst().orElseThrow(IllegalArgumentException::new).getSubject(); + var transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance).findFirst() + .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DIVIDENDS)); @@ -752,42 +782,37 @@ public void testDividende02() assertThat(transaction.getSource(), is("Dividende02.txt")); assertThat(transaction.getNote(), is("Abrechnungsnr. 85127406360 | Quartalsdividende")); - assertThat(transaction.getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(50.88)))); - assertThat(transaction.getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(59.86)))); - assertThat(transaction.getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(8.98)))); - assertThat(transaction.getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(50.88)))); + assertThat(transaction.getGrossValue(), is(Money.of("EUR", Values.Amount.factorize(59.86)))); + assertThat(transaction.getUnitSum(Unit.Type.TAX), is(Money.of("EUR", Values.Amount.factorize(8.98)))); + assertThat(transaction.getUnitSum(Unit.Type.FEE), is(Money.of("EUR", Values.Amount.factorize(0.00)))); - Unit grossValueUnit = transaction.getUnit(Unit.Type.GROSS_VALUE).orElseThrow(IllegalArgumentException::new); - assertThat(grossValueUnit.getForex(), - is(Money.of(CurrencyUnit.USD, Values.Amount.factorize(68.00)))); + var grossValueUnit = transaction.getUnit(Unit.Type.GROSS_VALUE).orElseThrow(IllegalArgumentException::new); + assertThat(grossValueUnit.getForex(), is(Money.of("USD", Values.Amount.factorize(68.00)))); } @Test public void testDividende02WithSecurityInEUR() { - Security security = new Security("QUALCOMM INC. REGISTERED SHARES DL -,0001", CurrencyUnit.EUR); + var security = new Security("QUALCOMM INC. REGISTERED SHARES DL -,0001", "EUR"); security.setIsin("US7475251036"); security.setWkn("883121"); - Client client = new Client(); + var client = new Client(); client.addSecurity(security); - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(client); + var extractor = new RaiffeisenBankgruppePDFExtractor(client); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende02.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende02.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(1)); // check dividends transaction - AccountTransaction transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance) - .findFirst().orElseThrow(IllegalArgumentException::new).getSubject(); + var transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance).findFirst() + .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DIVIDENDS)); @@ -796,47 +821,43 @@ public void testDividende02WithSecurityInEUR() assertThat(transaction.getSource(), is("Dividende02.txt")); assertThat(transaction.getNote(), is("Abrechnungsnr. 85127406360 | Quartalsdividende")); - assertThat(transaction.getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(50.88)))); - assertThat(transaction.getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(59.86)))); - assertThat(transaction.getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(8.98)))); - assertThat(transaction.getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); - - CheckCurrenciesAction c = new CheckCurrenciesAction(); - Account account = new Account(); - account.setCurrencyCode(CurrencyUnit.EUR); - Status s = c.process(transaction, account); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(50.88)))); + assertThat(transaction.getGrossValue(), is(Money.of("EUR", Values.Amount.factorize(59.86)))); + assertThat(transaction.getUnitSum(Unit.Type.TAX), is(Money.of("EUR", Values.Amount.factorize(8.98)))); + assertThat(transaction.getUnitSum(Unit.Type.FEE), is(Money.of("EUR", Values.Amount.factorize(0.00)))); + + var c = new CheckCurrenciesAction(); + var account = new Account(); + account.setCurrencyCode("EUR"); + var s = c.process(transaction, account); assertThat(s, is(Status.OK_STATUS)); } @Test public void testDividende03() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende03.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende03.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("US17275R1023")); assertThat(security.getWkn(), is("878841")); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("CISCO SYSTEMS INC. SHARES REGISTERED SHARES DL-,001")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.USD)); + assertThat(security.getCurrencyCode(), is("USD")); // check dividends transaction - AccountTransaction transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance) - .findFirst().orElseThrow(IllegalArgumentException::new).getSubject(); + var transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance).findFirst() + .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DIVIDENDS)); @@ -845,42 +866,38 @@ public void testDividende03() assertThat(transaction.getSource(), is("Dividende03.txt")); assertThat(transaction.getNote(), is("Abrechnungsnr. 88888888888 | Quartalsdividende")); - assertThat(transaction.getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(27.84)))); - assertThat(transaction.getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(37.68)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(27.84)))); + assertThat(transaction.getGrossValue(), is(Money.of("EUR", Values.Amount.factorize(37.68)))); assertThat(transaction.getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(5.65 + 3.69 + 0.20 + 0.30)))); - assertThat(transaction.getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(5.65 + 3.69 + 0.20 + 0.30)))); + assertThat(transaction.getUnitSum(Unit.Type.FEE), is(Money.of("EUR", Values.Amount.factorize(0.00)))); - Unit grossValueUnit = transaction.getUnit(Unit.Type.GROSS_VALUE).orElseThrow(IllegalArgumentException::new); - assertThat(grossValueUnit.getForex(), - is(Money.of(CurrencyUnit.USD, Values.Amount.factorize(38.00)))); + var grossValueUnit = transaction.getUnit(Unit.Type.GROSS_VALUE).orElseThrow(IllegalArgumentException::new); + assertThat(grossValueUnit.getForex(), is(Money.of("USD", Values.Amount.factorize(38.00)))); } @Test public void testDividende03WithSecurityInEUR() { - Security security = new Security("CISCO SYSTEMS INC. SHARES REGISTERED SHARES DL-,001", CurrencyUnit.EUR); + var security = new Security("CISCO SYSTEMS INC. SHARES REGISTERED SHARES DL-,001", "EUR"); security.setIsin("US17275R1023"); security.setWkn("878841"); - Client client = new Client(); + var client = new Client(); client.addSecurity(security); - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(client); + var extractor = new RaiffeisenBankgruppePDFExtractor(client); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende03.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende03.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(1)); // check dividends transaction - AccountTransaction transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance) - .findFirst().orElseThrow(IllegalArgumentException::new).getSubject(); + var transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance).findFirst() + .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DIVIDENDS)); @@ -889,47 +906,44 @@ public void testDividende03WithSecurityInEUR() assertThat(transaction.getSource(), is("Dividende03.txt")); assertThat(transaction.getNote(), is("Abrechnungsnr. 88888888888 | Quartalsdividende")); - assertThat(transaction.getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(27.84)))); - assertThat(transaction.getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(37.68)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(27.84)))); + assertThat(transaction.getGrossValue(), is(Money.of("EUR", Values.Amount.factorize(37.68)))); assertThat(transaction.getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(5.65 + 3.69 + 0.20 + 0.30)))); - assertThat(transaction.getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); - - CheckCurrenciesAction c = new CheckCurrenciesAction(); - Account account = new Account(); - account.setCurrencyCode(CurrencyUnit.EUR); - Status s = c.process(transaction, account); + is(Money.of("EUR", Values.Amount.factorize(5.65 + 3.69 + 0.20 + 0.30)))); + assertThat(transaction.getUnitSum(Unit.Type.FEE), is(Money.of("EUR", Values.Amount.factorize(0.00)))); + + var c = new CheckCurrenciesAction(); + var account = new Account(); + account.setCurrencyCode("EUR"); + var s = c.process(transaction, account); assertThat(s, is(Status.OK_STATUS)); } @Test public void testDividende04() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende04.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende04.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("US3703341046")); assertThat(security.getWkn(), is("853862")); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("GENERAL MILLS INC. REGISTERED SHARES DL -,10")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.USD)); + assertThat(security.getCurrencyCode(), is("USD")); // check dividends transaction - AccountTransaction transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance) - .findFirst().orElseThrow(IllegalArgumentException::new).getSubject(); + var transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance).findFirst() + .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DIVIDENDS)); @@ -938,41 +952,38 @@ public void testDividende04() assertThat(transaction.getSource(), is("Dividende04.txt")); assertThat(transaction.getNote(), is("Abrechnungsnr. 80642931040 | Quartalsdividende")); - assertThat(transaction.getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(127.60)))); - assertThat(transaction.getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(217.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(127.60)))); + assertThat(transaction.getGrossValue(), is(Money.of("EUR", Values.Amount.factorize(217.00)))); assertThat(transaction.getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(65.10 + 21.22 + 1.17 + 1.91)))); - assertThat(transaction.getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(65.10 + 21.22 + 1.17 + 1.91)))); + assertThat(transaction.getUnitSum(Unit.Type.FEE), is(Money.of("EUR", Values.Amount.factorize(0.00)))); - Unit grossValueUnit = transaction.getUnit(Unit.Type.GROSS_VALUE).orElseThrow(IllegalArgumentException::new); - assertThat(grossValueUnit.getForex(), is(Money.of(CurrencyUnit.USD, Values.Amount.factorize(216.00)))); + var grossValueUnit = transaction.getUnit(Unit.Type.GROSS_VALUE).orElseThrow(IllegalArgumentException::new); + assertThat(grossValueUnit.getForex(), is(Money.of("USD", Values.Amount.factorize(216.00)))); } @Test public void testDividende04WithSecurityInEUR() { - Security security = new Security("GENERAL MILLS INC. REGISTERED SHARES DL -,10", CurrencyUnit.EUR); + var security = new Security("GENERAL MILLS INC. REGISTERED SHARES DL -,10", "EUR"); security.setIsin("US3703341046"); security.setWkn("853862"); - Client client = new Client(); + var client = new Client(); client.addSecurity(security); - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(client); + var extractor = new RaiffeisenBankgruppePDFExtractor(client); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende04.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende04.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(1)); // check dividends transaction - AccountTransaction transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance) - .findFirst().orElseThrow(IllegalArgumentException::new).getSubject(); + var transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance).findFirst() + .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DIVIDENDS)); @@ -981,47 +992,44 @@ public void testDividende04WithSecurityInEUR() assertThat(transaction.getSource(), is("Dividende04.txt")); assertThat(transaction.getNote(), is("Abrechnungsnr. 80642931040 | Quartalsdividende")); - assertThat(transaction.getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(127.60)))); - assertThat(transaction.getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(217.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(127.60)))); + assertThat(transaction.getGrossValue(), is(Money.of("EUR", Values.Amount.factorize(217.00)))); assertThat(transaction.getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(65.10 + 21.22 + 1.17 + 1.91)))); - assertThat(transaction.getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); - - CheckCurrenciesAction c = new CheckCurrenciesAction(); - Account account = new Account(); - account.setCurrencyCode(CurrencyUnit.EUR); - Status s = c.process(transaction, account); + is(Money.of("EUR", Values.Amount.factorize(65.10 + 21.22 + 1.17 + 1.91)))); + assertThat(transaction.getUnitSum(Unit.Type.FEE), is(Money.of("EUR", Values.Amount.factorize(0.00)))); + + var c = new CheckCurrenciesAction(); + var account = new Account(); + account.setCurrencyCode("EUR"); + var s = c.process(transaction, account); assertThat(s, is(Status.OK_STATUS)); } @Test public void testDividende05() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende05.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende05.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("DE000A0D8Q49")); assertNull(security.getWkn()); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("iSh.DJ U.S.Select Div.U.ETF DE Inhaber-Anteile")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.USD)); + assertThat(security.getCurrencyCode(), is("USD")); // check dividends transaction - AccountTransaction transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance) - .findFirst().orElseThrow(IllegalArgumentException::new).getSubject(); + var transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance).findFirst() + .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DIVIDENDS)); @@ -1030,40 +1038,37 @@ public void testDividende05() assertThat(transaction.getSource(), is("Dividende05.txt")); assertNull(transaction.getNote()); - assertThat(transaction.getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(97.63)))); - assertThat(transaction.getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(109.96)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(97.63)))); + assertThat(transaction.getGrossValue(), is(Money.of("EUR", Values.Amount.factorize(109.96)))); assertThat(transaction.getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(10.00 + 0.29 + (0.64 / 1.0856))))); - assertThat(transaction.getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(1.45)))); + is(Money.of("EUR", Values.Amount.factorize(10.00 + 0.29 + (0.64 / 1.0856))))); + assertThat(transaction.getUnitSum(Unit.Type.FEE), is(Money.of("EUR", Values.Amount.factorize(1.45)))); - Unit grossValueUnit = transaction.getUnit(Unit.Type.GROSS_VALUE).orElseThrow(IllegalArgumentException::new); - assertThat(grossValueUnit.getForex(), is(Money.of(CurrencyUnit.USD, Values.Amount.factorize(119.37)))); + var grossValueUnit = transaction.getUnit(Unit.Type.GROSS_VALUE).orElseThrow(IllegalArgumentException::new); + assertThat(grossValueUnit.getForex(), is(Money.of("USD", Values.Amount.factorize(119.37)))); } @Test public void testDividende05WithSecurityInEUR() { - Security security = new Security("iSh.DJ U.S.Select Div.U.ETF DE Inhaber-Anteile", CurrencyUnit.EUR); + var security = new Security("iSh.DJ U.S.Select Div.U.ETF DE Inhaber-Anteile", "EUR"); security.setIsin("DE000A0D8Q49"); - Client client = new Client(); + var client = new Client(); client.addSecurity(security); - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(client); + var extractor = new RaiffeisenBankgruppePDFExtractor(client); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende05.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende05.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(1)); // check dividends transaction - AccountTransaction transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance) - .findFirst().orElseThrow(IllegalArgumentException::new).getSubject(); + var transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance).findFirst() + .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DIVIDENDS)); @@ -1072,47 +1077,44 @@ public void testDividende05WithSecurityInEUR() assertThat(transaction.getSource(), is("Dividende05.txt")); assertNull(transaction.getNote()); - assertThat(transaction.getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(97.63)))); - assertThat(transaction.getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(109.96)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(97.63)))); + assertThat(transaction.getGrossValue(), is(Money.of("EUR", Values.Amount.factorize(109.96)))); assertThat(transaction.getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(10.00 + 0.29 + (0.64 / 1.0856))))); - assertThat(transaction.getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(1.45)))); - - CheckCurrenciesAction c = new CheckCurrenciesAction(); - Account account = new Account(); - account.setCurrencyCode(CurrencyUnit.EUR); - Status s = c.process(transaction, account); + is(Money.of("EUR", Values.Amount.factorize(10.00 + 0.29 + (0.64 / 1.0856))))); + assertThat(transaction.getUnitSum(Unit.Type.FEE), is(Money.of("EUR", Values.Amount.factorize(1.45)))); + + var c = new CheckCurrenciesAction(); + var account = new Account(); + account.setCurrencyCode("EUR"); + var s = c.process(transaction, account); assertThat(s, is(Status.OK_STATUS)); } @Test public void testDividende06() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende06.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende06.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("DE0007664039")); assertNull(security.getWkn()); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("VOLKSWAGEN AG VORZUGSAKTIEN O.ST. O.N.")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.EUR)); + assertThat(security.getCurrencyCode(), is("EUR")); // check dividends transaction - AccountTransaction transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance) - .findFirst().orElseThrow(IllegalArgumentException::new).getSubject(); + var transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance).findFirst() + .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DIVIDENDS)); @@ -1121,41 +1123,38 @@ public void testDividende06() assertThat(transaction.getSource(), is("Dividende06.txt")); assertNull(transaction.getNote()); - assertThat(transaction.getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(813.78)))); - assertThat(transaction.getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(1334.20)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(813.78)))); + assertThat(transaction.getGrossValue(), is(Money.of("EUR", Values.Amount.factorize(1334.20)))); assertThat(transaction.getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(351.90 + 166.78 + 0.29)))); - assertThat(transaction.getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(1.45)))); + is(Money.of("EUR", Values.Amount.factorize(351.90 + 166.78 + 0.29)))); + assertThat(transaction.getUnitSum(Unit.Type.FEE), is(Money.of("EUR", Values.Amount.factorize(1.45)))); } @Test public void testDividende07() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende07.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende07.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security.getIsin(), is("DE0005557508")); assertThat(security.getWkn(), is("555750")); assertNull(security.getTickerSymbol()); assertThat(security.getName(), is("DEUTSCHE TELEKOM AG NAMENS-AKTIEN O.N.")); - assertThat(security.getCurrencyCode(), is(CurrencyUnit.EUR)); + assertThat(security.getCurrencyCode(), is("EUR")); // check dividends transaction - AccountTransaction transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance) - .findFirst().orElseThrow(IllegalArgumentException::new).getSubject(); + var transaction = (AccountTransaction) results.stream().filter(TransactionItem.class::isInstance).findFirst() + .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DIVIDENDS)); @@ -1164,31 +1163,28 @@ public void testDividende07() assertThat(transaction.getSource(), is("Dividende07.txt")); assertThat(transaction.getNote(), is("Abrechnungsnr. 66666666666")); - assertThat(transaction.getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(77.70)))); - assertThat(transaction.getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(77.70)))); - assertThat(transaction.getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); - assertThat(transaction.getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(77.70)))); + assertThat(transaction.getGrossValue(), is(Money.of("EUR", Values.Amount.factorize(77.70)))); + assertThat(transaction.getUnitSum(Unit.Type.TAX), is(Money.of("EUR", Values.Amount.factorize(0.00)))); + assertThat(transaction.getUnitSum(Unit.Type.FEE), is(Money.of("EUR", Values.Amount.factorize(0.00)))); } @Test public void testDividende08() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende08.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende08.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(1L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(1L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security assertThat(results, hasItem(security( // @@ -1208,18 +1204,19 @@ public void testDividende08() @Test public void testDividende09() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende09.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende09.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(1L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(1L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security assertThat(results, hasItem(security( // @@ -1240,24 +1237,25 @@ public void testDividende09() @Test public void testDividende09WithSecurityInEUR() { - Security security = new Security("iSh.DJ U.S.Select Div.U.ETF DE Inhaber-Anteile", CurrencyUnit.EUR); + var security = new Security("iSh.DJ U.S.Select Div.U.ETF DE Inhaber-Anteile", "EUR"); security.setIsin("DE000A0D8Q49"); - Client client = new Client(); + var client = new Client(); client.addSecurity(security); - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(client); + var extractor = new RaiffeisenBankgruppePDFExtractor(client); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende09.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende09.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(0L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(1L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(1)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check dividends transaction assertThat(results, hasItem(dividend( // @@ -1267,10 +1265,10 @@ public void testDividende09WithSecurityInEUR() hasAmount("EUR", 82.99), hasGrossValue("EUR", 97.81), // hasTaxes("EUR", (0.86 / 1.0897) + 9.29 + 0.29), hasFees("EUR", 1.45 + 3.00), // check(tx -> { - CheckCurrenciesAction c = new CheckCurrenciesAction(); - Account account = new Account(); - account.setCurrencyCode(CurrencyUnit.EUR); - Status s = c.process((AccountTransaction) tx, account); + var c = new CheckCurrenciesAction(); + var account = new Account(); + account.setCurrencyCode("EUR"); + var s = c.process((AccountTransaction) tx, account); assertThat(s, is(Status.OK_STATUS)); })))); } @@ -1278,18 +1276,19 @@ public void testDividende09WithSecurityInEUR() @Test public void testDividende10() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende10.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende10.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(1L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(1L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security assertThat(results, hasItem(security( // @@ -1309,18 +1308,19 @@ public void testDividende10() @Test public void testDividende11() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende11.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende11.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(1L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(1L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security assertThat(results, hasItem(security( // @@ -1340,18 +1340,19 @@ public void testDividende11() @Test public void testDividende12() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende12.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende12.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(1L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(1L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security assertThat(results, hasItem(security( // @@ -1372,25 +1373,26 @@ public void testDividende12() @Test public void testDividende12WithSecurityInEUR() { - Security security = new Security("iSh.DJ U.S.Select Div.U.ETF DE Inhaber-Anteile", CurrencyUnit.EUR); + var security = new Security("iSh.DJ U.S.Select Div.U.ETF DE Inhaber-Anteile", "EUR"); security.setIsin("US7475251036"); security.setWkn("883121"); - Client client = new Client(); + var client = new Client(); client.addSecurity(security); - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(client); + var extractor = new RaiffeisenBankgruppePDFExtractor(client); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende12.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende12.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(0L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(1L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(1)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check dividends transaction assertThat(results, hasItem(dividend( // @@ -1400,10 +1402,10 @@ public void testDividende12WithSecurityInEUR() hasAmount("EUR", 16.16), hasGrossValue("EUR", 21.71), // hasTaxes("EUR", 3.26 + 2.17 + 0.12), hasFees("EUR", 0.00), // check(tx -> { - CheckCurrenciesAction c = new CheckCurrenciesAction(); - Account account = new Account(); - account.setCurrencyCode(CurrencyUnit.EUR); - Status s = c.process((AccountTransaction) tx, account); + var c = new CheckCurrenciesAction(); + var account = new Account(); + account.setCurrencyCode("EUR"); + var s = c.process((AccountTransaction) tx, account); assertThat(s, is(Status.OK_STATUS)); })))); } @@ -1411,16 +1413,17 @@ public void testDividende12WithSecurityInEUR() @Test public void testDividende13() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende13.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Dividende13.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(1L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(1L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(2)); new AssertImportActions().check(results, "CHF"); @@ -1442,27 +1445,27 @@ public void testDividende13() @Test public void testKontoauszug01() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug01.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug01.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(17)); // check transaction // get transactions - Iterator iter = results.stream().filter(TransactionItem.class::isInstance).iterator(); + var iter = results.stream().filter(TransactionItem.class::isInstance).iterator(); assertThat(results.stream().filter(i -> i instanceof TransactionItem).count(), is(17L)); - Item item = iter.next(); + var item = iter.next(); // assert transaction - AccountTransaction transaction = (AccountTransaction) item.getSubject(); + var transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-01T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(42.13)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(42.13)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1472,7 +1475,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-01T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(10.01)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(10.01)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1482,7 +1485,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-01T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(79.58)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(79.58)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1492,7 +1495,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-01T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(50.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(50.00)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("Dauerauftrag")); @@ -1502,7 +1505,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-02T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(60.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(60.00)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1512,7 +1515,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-03T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(500.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(500.00)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("EURO-Überweisung")); @@ -1522,7 +1525,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-04T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(15.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(15.00)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1532,7 +1535,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-04T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(119.06)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(119.06)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("EURO-Überweisung")); @@ -1542,7 +1545,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-04T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(123.34)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(123.34)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("EURO-Überweisung")); @@ -1552,7 +1555,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-07T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(35.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(35.00)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("EURO-Überweisung")); @@ -1562,7 +1565,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-18T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(250.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(250.00)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1572,7 +1575,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DEPOSIT)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-23T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(85.65)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(85.65)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("Gutschrift")); @@ -1582,7 +1585,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DEPOSIT)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-28T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(70.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(70.00)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("Gutschrift")); @@ -1592,7 +1595,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-28T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(34.62)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(34.62)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1602,7 +1605,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DEPOSIT)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-29T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(1097.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(1097.00)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("Einnahmen")); @@ -1612,7 +1615,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.INTEREST_CHARGE)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-31T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(1.00 + 1.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(1.00 + 1.00)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("Entgelte vom 01.12.2020 - 31.12.2020")); assertThat(transaction.getAmount(), is(Values.Amount.factorize(1.00 + 1.00))); @@ -1623,7 +1626,7 @@ public void testKontoauszug01() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.FEES)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-12-31T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(1.95)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(1.95)))); assertThat(transaction.getSource(), is("Kontoauszug01.txt")); assertThat(transaction.getNote(), is("Abschluss vom 01.10.2020 bis 31.12.2020")); } @@ -1631,27 +1634,27 @@ public void testKontoauszug01() @Test public void testKontoauszug02() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug02.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug02.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(31)); // check transaction // get transactions - Iterator iter = results.stream().filter(TransactionItem.class::isInstance).iterator(); + var iter = results.stream().filter(TransactionItem.class::isInstance).iterator(); assertThat(results.stream().filter(i -> i instanceof TransactionItem).count(), is(31L)); - Item item = iter.next(); + var item = iter.next(); // assert transaction - AccountTransaction transaction = (AccountTransaction) item.getSubject(); + var transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-02T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(10.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(10.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Kartenzahlung")); @@ -1661,7 +1664,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-02T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(20.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(20.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1671,7 +1674,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-02T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(10.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(10.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1681,7 +1684,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-02T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(100.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(100.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1691,7 +1694,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-02T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(20.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(20.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Kartenzahlung")); @@ -1701,7 +1704,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-02T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(30.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(30.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1711,7 +1714,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-02T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(60.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(60.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Dauerauftrag")); @@ -1721,7 +1724,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-03T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(50.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(50.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1731,7 +1734,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-03T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(50.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(50.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1741,7 +1744,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-04T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(40.94)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(40.94)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1751,7 +1754,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-09T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(30.20)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(30.20)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Kartenzahlung")); @@ -1761,7 +1764,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-09T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(10.70)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(10.70)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Kartenzahlung")); @@ -1771,7 +1774,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-12T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(15.16)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(15.16)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Kartenzahlung")); @@ -1781,7 +1784,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-16T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(25.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(25.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Kartenzahlung")); @@ -1791,7 +1794,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-16T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(80.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(80.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Dauerauftrag")); @@ -1801,7 +1804,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-17T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(3.58)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(3.58)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Kartenzahlung")); @@ -1811,7 +1814,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-18T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(10.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(10.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1821,7 +1824,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-18T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(10.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(10.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1831,7 +1834,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-19T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(50.60)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(50.60)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Kartenzahlung")); @@ -1841,7 +1844,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-19T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(10.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(10.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1851,7 +1854,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-19T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(10.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(10.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1861,7 +1864,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-19T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(10.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(10.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1871,7 +1874,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-19T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(20.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(20.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1881,7 +1884,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-23T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(7.01)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(7.01)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Kartenzahlung")); @@ -1891,7 +1894,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-23T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(11.68)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(11.68)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Kartenzahlung")); @@ -1901,7 +1904,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-26T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(14.99)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(14.99)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1911,7 +1914,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-27T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(20.08)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(20.08)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Kartenzahlung")); @@ -1921,7 +1924,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-27T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(14.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(14.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Kartenzahlung")); @@ -1931,7 +1934,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-27T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(20.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(20.00)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Auszahlung")); @@ -1940,7 +1943,7 @@ public void testKontoauszug02() // assert transaction transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DEPOSIT)); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(1200.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(1200.00)))); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-30T00:00"))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Lohn/Gehalt")); @@ -1951,7 +1954,7 @@ public void testKontoauszug02() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.FEES)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-08-31T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(1.95)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(1.95)))); assertThat(transaction.getSource(), is("Kontoauszug02.txt")); assertThat(transaction.getNote(), is("Abschluss vom 30.07.2021 bis 31.08.2021")); } @@ -1959,27 +1962,27 @@ public void testKontoauszug02() @Test public void testKontoauszug03() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug03.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug03.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(4)); // check transaction // get transactions - Iterator iter = results.stream().filter(TransactionItem.class::isInstance).iterator(); + var iter = results.stream().filter(TransactionItem.class::isInstance).iterator(); assertThat(results.stream().filter(i -> i instanceof TransactionItem).count(), is(4L)); - Item item = iter.next(); + var item = iter.next(); // assert transaction - AccountTransaction transaction = (AccountTransaction) item.getSubject(); + var transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-11-09T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(136.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(136.00)))); assertThat(transaction.getSource(), is("Kontoauszug03.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1989,7 +1992,7 @@ public void testKontoauszug03() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-11-15T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(133.29)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(133.29)))); assertThat(transaction.getSource(), is("Kontoauszug03.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -1999,7 +2002,7 @@ public void testKontoauszug03() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-11-15T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(139.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(139.00)))); assertThat(transaction.getSource(), is("Kontoauszug03.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -2009,7 +2012,7 @@ public void testKontoauszug03() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2021-11-16T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(35.19)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(35.19)))); assertThat(transaction.getSource(), is("Kontoauszug03.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); } @@ -2017,27 +2020,27 @@ public void testKontoauszug03() @Test public void testKontoauszug04() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug04.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug04.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(4)); // check transaction // get transactions - Iterator iter = results.stream().filter(TransactionItem.class::isInstance).iterator(); + var iter = results.stream().filter(TransactionItem.class::isInstance).iterator(); assertThat(results.stream().filter(i -> i instanceof TransactionItem).count(), is(4L)); - Item item = iter.next(); + var item = iter.next(); // assert transaction - AccountTransaction transaction = (AccountTransaction) item.getSubject(); + var transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-06-08T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(4.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(4.00)))); assertThat(transaction.getSource(), is("Kontoauszug04.txt")); assertThat(transaction.getNote(), is("Überweisung SEPA")); @@ -2047,7 +2050,7 @@ public void testKontoauszug04() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-06-10T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(700.00)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(700.00)))); assertThat(transaction.getSource(), is("Kontoauszug04.txt")); assertThat(transaction.getNote(), is("Überweisung SEPA")); @@ -2057,7 +2060,7 @@ public void testKontoauszug04() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.REMOVAL)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-06-22T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(36.99)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(36.99)))); assertThat(transaction.getSource(), is("Kontoauszug04.txt")); assertThat(transaction.getNote(), is("Basislastschrift")); @@ -2067,7 +2070,7 @@ public void testKontoauszug04() transaction = (AccountTransaction) item.getSubject(); assertThat(transaction.getType(), is(AccountTransaction.Type.DEPOSIT)); assertThat(transaction.getDateTime(), is(LocalDateTime.parse("2020-06-25T00:00"))); - assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(1870.70)))); + assertThat(transaction.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(1870.70)))); assertThat(transaction.getSource(), is("Kontoauszug04.txt")); assertThat(transaction.getNote(), is("Lohn/Gehalt")); } @@ -2075,18 +2078,19 @@ public void testKontoauszug04() @Test public void testKontoauszug05() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug05.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug05.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(0L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(3L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(3)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // assert transaction assertThat(results, hasItem(deposit(hasDate("2023-06-20"), hasAmount("EUR", 26350.00), // @@ -2104,18 +2108,19 @@ public void testKontoauszug05() @Test public void testKontoauszug06() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug06.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug06.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(0L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(7L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(7)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // assert transaction assertThat(results, hasItem(removal(hasDate("2023-12-01"), hasAmount("EUR", 100.00), // @@ -2153,18 +2158,19 @@ public void testKontoauszug06() @Test public void testKontoauszug07() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug07.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug07.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(0L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(41L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(41)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // assert transaction assertThat(results, hasItem(deposit(hasDate("2024-01-02"), hasAmount("EUR", 2000.00), // @@ -2305,18 +2311,19 @@ public void testKontoauszug07() @Test public void testKontoauszug08() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug08.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Kontoauszug08.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(0L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(6L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(6)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // assert transaction assertThat(results, hasItem(deposit(hasDate("2024-04-24"), hasAmount("EUR", 5.00), // @@ -2341,19 +2348,19 @@ public void testKontoauszug08() @Test public void testDepotauszug01() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Depotauszug01.txt"), - errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Depotauszug01.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(0L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(2L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // assert transaction assertThat(results, hasItem(deposit(hasDate("2023-05-08"), hasAmount("EUR", 5000.00), // @@ -2367,36 +2374,36 @@ public void testDepotauszug01() @Test public void testEinbuchung01() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Umtausch01.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Umtausch01.txt"), errors); assertThat(errors, empty()); assertThat(results.size(), is(4)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security - Security security1 = results.stream().filter(SecurityItem.class::isInstance).findFirst() + var security1 = results.stream().filter(SecurityItem.class::isInstance).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security1.getIsin(), is("LU0392496344")); assertNull(security1.getWkn()); assertNull(security1.getTickerSymbol()); assertThat(security1.getName(), is("Lyxor MSCI Europe SmallCap ETF Inh.-An. I o.N.")); - assertThat(security1.getCurrencyCode(), is(CurrencyUnit.EUR)); + assertThat(security1.getCurrencyCode(), is("EUR")); - Security security2 = results.stream().filter(SecurityItem.class::isInstance).skip(1).findFirst() + var security2 = results.stream().filter(SecurityItem.class::isInstance).skip(1).findFirst() .orElseThrow(IllegalArgumentException::new).getSecurity(); assertThat(security2.getIsin(), is("LU2572257470")); assertNull(security2.getWkn()); assertNull(security2.getTickerSymbol()); assertThat(security2.getName(), is("AIS-MSCI Eu.SC ESG CL.NZ AMCTB Act.Nom. U.ETF EUR Dis. oN")); - assertThat(security2.getCurrencyCode(), is(CurrencyUnit.EUR)); + assertThat(security2.getCurrencyCode(), is("EUR")); // check delivery outbound (Auslieferung) transaction - PortfolioTransaction entry = (PortfolioTransaction) results.stream().filter(TransactionItem.class::isInstance) - .findFirst().orElseThrow(IllegalArgumentException::new).getSubject(); + var entry = (PortfolioTransaction) results.stream().filter(TransactionItem.class::isInstance).findFirst() + .orElseThrow(IllegalArgumentException::new).getSubject(); assertThat(entry.getType(), is(PortfolioTransaction.Type.DELIVERY_OUTBOUND)); @@ -2405,14 +2412,10 @@ public void testEinbuchung01() assertThat(entry.getSource(), is("Umtausch01.txt")); assertThat(entry.getNote(), is("Abrechnungsnummer: 46711492")); - assertThat(entry.getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); - assertThat(entry.getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); - assertThat(entry.getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); - assertThat(entry.getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + assertThat(entry.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(0.00)))); + assertThat(entry.getGrossValue(), is(Money.of("EUR", Values.Amount.factorize(0.00)))); + assertThat(entry.getUnitSum(Unit.Type.TAX), is(Money.of("EUR", Values.Amount.factorize(0.00)))); + assertThat(entry.getUnitSum(Unit.Type.FEE), is(Money.of("EUR", Values.Amount.factorize(0.00)))); // check delivery inbound (Einlieferung) transaction entry = (PortfolioTransaction) results.stream().filter(TransactionItem.class::isInstance).skip(1).findFirst() @@ -2425,37 +2428,35 @@ public void testEinbuchung01() assertThat(entry.getSource(), is("Umtausch01.txt")); assertThat(entry.getNote(), is("Abrechnungsnummer: 45664992 | Verhältnis: 1 : 1")); - assertThat(entry.getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); - assertThat(entry.getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); - assertThat(entry.getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); - assertThat(entry.getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + assertThat(entry.getMonetaryAmount(), is(Money.of("EUR", Values.Amount.factorize(0.00)))); + assertThat(entry.getGrossValue(), is(Money.of("EUR", Values.Amount.factorize(0.00)))); + assertThat(entry.getUnitSum(Unit.Type.TAX), is(Money.of("EUR", Values.Amount.factorize(0.00)))); + assertThat(entry.getUnitSum(Unit.Type.FEE), is(Money.of("EUR", Values.Amount.factorize(0.00)))); // check 1st cancellation (Amount 0,00) transaction - TransactionItem cancellation = (TransactionItem) results.stream() // + var cancellation = (TransactionItem) results.stream() // .filter(i -> i.isFailure()) // .filter(TransactionItem.class::isInstance) // .findFirst().orElseThrow(IllegalArgumentException::new); - assertThat(((PortfolioTransaction) cancellation.getSubject()).getType(), is(PortfolioTransaction.Type.DELIVERY_OUTBOUND)); + assertThat(((PortfolioTransaction) cancellation.getSubject()).getType(), + is(PortfolioTransaction.Type.DELIVERY_OUTBOUND)); assertThat(cancellation.getFailureMessage(), is(Messages.MsgErrorTransactionTypeNotSupported)); - assertThat(((Transaction) cancellation.getSubject()).getDateTime(), is(LocalDateTime.parse("2023-03-10T00:00"))); + assertThat(((Transaction) cancellation.getSubject()).getDateTime(), + is(LocalDateTime.parse("2023-03-10T00:00"))); assertThat(((Transaction) cancellation.getSubject()).getShares(), is(Values.Share.factorize(433))); assertThat(((Transaction) cancellation.getSubject()).getSource(), is("Umtausch01.txt")); assertThat(((Transaction) cancellation.getSubject()).getNote(), is("Abrechnungsnummer: 46711492")); assertThat(((Transaction) cancellation.getSubject()).getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(((Transaction) cancellation.getSubject()).getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(((Transaction) cancellation.getSubject()).getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(((Transaction) cancellation.getSubject()).getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); // check 2nd cancellation (Amount 0,00) transaction cancellation = (TransactionItem) results.stream() // @@ -2463,39 +2464,44 @@ public void testEinbuchung01() .filter(TransactionItem.class::isInstance) // .skip(1).findFirst().orElseThrow(IllegalArgumentException::new); - assertThat(((PortfolioTransaction) cancellation.getSubject()).getType(), is(PortfolioTransaction.Type.DELIVERY_INBOUND)); + assertThat(((PortfolioTransaction) cancellation.getSubject()).getType(), + is(PortfolioTransaction.Type.DELIVERY_INBOUND)); assertThat(cancellation.getFailureMessage(), is(Messages.MsgErrorTransactionTypeNotSupported)); - assertThat(((Transaction) cancellation.getSubject()).getDateTime(), is(LocalDateTime.parse("2023-03-10T00:00"))); + assertThat(((Transaction) cancellation.getSubject()).getDateTime(), + is(LocalDateTime.parse("2023-03-10T00:00"))); assertThat(((Transaction) cancellation.getSubject()).getShares(), is(Values.Share.factorize(433))); assertThat(((Transaction) cancellation.getSubject()).getSource(), is("Umtausch01.txt")); - assertThat(((Transaction) cancellation.getSubject()).getNote(), is("Abrechnungsnummer: 45664992 | Verhältnis: 1 : 1")); + assertThat(((Transaction) cancellation.getSubject()).getNote(), + is("Abrechnungsnummer: 45664992 | Verhältnis: 1 : 1")); assertThat(((Transaction) cancellation.getSubject()).getMonetaryAmount(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(((Transaction) cancellation.getSubject()).getGrossValue(), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(((Transaction) cancellation.getSubject()).getUnitSum(Unit.Type.TAX), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); assertThat(((Transaction) cancellation.getSubject()).getUnitSum(Unit.Type.FEE), - is(Money.of(CurrencyUnit.EUR, Values.Amount.factorize(0.00)))); + is(Money.of("EUR", Values.Amount.factorize(0.00)))); } @Test public void testFreierErhalt01() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "FreierErhalt01.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "FreierErhalt01.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(1L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(1L)); + assertThat(countAccountTransfers(results), is(0L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security assertThat(results, hasItem(security( // @@ -2517,18 +2523,19 @@ public void testFreierErhalt01() @Test public void testFreierErhalt02() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "FreierErhalt02.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "FreierErhalt02.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(1L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(1L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(2)); - new AssertImportActions().check(results, CurrencyUnit.EUR); + new AssertImportActions().check(results, "EUR"); // check security assertThat(results, hasItem(security( // @@ -2550,16 +2557,17 @@ public void testFreierErhalt02() @Test public void testGebuehrenbelastung011() { - RaiffeisenBankgruppePDFExtractor extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); + var extractor = new RaiffeisenBankgruppePDFExtractor(new Client()); List errors = new ArrayList<>(); - List results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Gebuehrenbelastung01.txt"), errors); + var results = extractor.extract(PDFInputFile.loadTestCase(getClass(), "Gebuehrenbelastung01.txt"), errors); assertThat(errors, empty()); assertThat(countSecurities(results), is(0L)); assertThat(countBuySell(results), is(0L)); assertThat(countAccountTransactions(results), is(1L)); + assertThat(countAccountTransfers(results), is(0L)); assertThat(results.size(), is(1)); new AssertImportActions().check(results, "CHF"); diff --git a/name.abuchen.portfolio/src/name/abuchen/portfolio/datatransfer/pdf/RaiffeisenBankgruppePDFExtractor.java b/name.abuchen.portfolio/src/name/abuchen/portfolio/datatransfer/pdf/RaiffeisenBankgruppePDFExtractor.java index ee73445f9a..5b3b00210c 100644 --- a/name.abuchen.portfolio/src/name/abuchen/portfolio/datatransfer/pdf/RaiffeisenBankgruppePDFExtractor.java +++ b/name.abuchen.portfolio/src/name/abuchen/portfolio/datatransfer/pdf/RaiffeisenBankgruppePDFExtractor.java @@ -7,7 +7,6 @@ import java.math.BigDecimal; import name.abuchen.portfolio.Messages; -import name.abuchen.portfolio.datatransfer.ExtrExchangeRate; import name.abuchen.portfolio.datatransfer.ExtractorUtils; import name.abuchen.portfolio.datatransfer.pdf.PDFParser.Block; import name.abuchen.portfolio.datatransfer.pdf.PDFParser.DocumentType; @@ -53,28 +52,29 @@ public String getLabel() private void addBuySellTransaction() { - final DocumentType type = new DocumentType("((Gesch.ftsart:|Wertpapier Abrechnung) (Kauf|Verkauf|R.cknahme Fonds).*" // + final var type = new DocumentType("((Gesch.ftsart:|Wertpapier Abrechnung) (Kauf|Verkauf|R.cknahme Fonds|Ausgabe Fonds).*" // + "|B.rse \\- (Zeichnung|Kauf))"); this.addDocumentTyp(type); - Transaction pdfTransaction = new Transaction<>(); + var pdfTransaction = new Transaction(); - Block firstRelevantLine = new Block("^.*(Auftrags\\-Nr|Auftragsnummer|Referenz).*$", "^(Der Betrag wird Ihnen|Den Gegenwert buchen|Dieser Beleg (tr.gt|wurde|wird)).*$"); + var firstRelevantLine = new Block("^.*(Auftrags\\-Nr|Dauerauftrag\\-Nr|Auftragsnummer|Referenz).*$", // + "^(Steuerl\\. Behandlung|Der Betrag wird Ihnen|Den Gegenwert buchen|Dieser Beleg (tr.gt|wurde|wird)).*$"); type.addBlock(firstRelevantLine); firstRelevantLine.set(pdfTransaction); pdfTransaction // .subject(() -> { - BuySellEntry portfolioTransaction = new BuySellEntry(); + var portfolioTransaction = new BuySellEntry(); portfolioTransaction.setType(PortfolioTransaction.Type.BUY); return portfolioTransaction; }) // Is type --> "Verkauf" change from BUY to SELL // Is type --> "Rücknahme Fonds" change from BUY to SELL - .section("type").optional() - .match("^(Gesch.ftsart:|Wertpapier Abrechnung) (?(Kauf|Verkauf|R.cknahme Fonds)) .*$") + .section("type").optional() // + .match("^(Gesch.ftsart:|Wertpapier Abrechnung) (?(Kauf|Verkauf|R.cknahme Fonds)) .*$") // .assign((t, v) -> { if ("Verkauf".equals(v.get("type")) || "Rücknahme Fonds".equals(v.get("type"))) t.setType(PortfolioTransaction.Type.SELL); @@ -90,7 +90,7 @@ private void addBuySellTransaction() .attributes("isin", "name", "name1", "currency") // .match("^Titel: (?[A-Z]{2}[A-Z0-9]{9}[0-9]) (?.*)$") // .match("^(?.*)$") // - .match("^Kurs: [\\.,\\d]+ (?[\\w]{3})$") // + .match("^Kurs: [\\.,\\d]+ (?[A-Z]{3})$") // .assign((t, v) -> { if (!v.get("name1").startsWith("Kurs:") // || !v.get("name1").startsWith("Fondsgesellschaft:")) // @@ -107,7 +107,7 @@ private void addBuySellTransaction() .attributes("name", "isin", "wkn", "name1", "currency") // .match("^St.ck [\\.,\\d]+ (?.*) (?[A-Z]{2}[A-Z0-9]{9}[0-9]) \\((?[A-Z0-9]{6})\\)$") // .match("^(?.*)$") // - .match("^Ausf.hrungskurs [\\.,\\d]+ (?[\\w]{3}) .*$") // + .match("^Ausf.hrungskurs [\\.,\\d]+ (?[A-Z]{3}) .*$") // .assign((t, v) -> { if (!v.get("name1").startsWith("Handels-/Ausführungsplatz")) v.put("name", trim(v.get("name")) + " " + trim(v.get("name1"))); @@ -124,7 +124,7 @@ private void addBuySellTransaction() .find("Wir haben für Sie .*") // .match("^[\\.'\\d]+ (?.*)$") // .match("^Valoren\\-Nr\\.: (?[A-Z0-9]{5,9}), ISIN\\-Nr\\.: (?[A-Z]{2}[A-Z0-9]{9}[0-9])$") // - .match("^Kurs (?[\\w]{3}) [\\.'\\d]+$") // + .match("^Kurs (?[A-Z]{3}) [\\.'\\d]+$") // .assign((t, v) -> t.setSecurity(getOrCreateSecurity(v)))) .oneOf( // @@ -184,7 +184,7 @@ private void addBuySellTransaction() // @formatter:on section -> section // .attributes("amount", "currency") // - .match("^(Zu (Lasten|Gunsten) .*|Ausmachender Betrag) (\\-)?(?[\\.,\\d]+)(\\-)? (?[\\w]{3}).*$") // + .match("^(Zu (Lasten|Gunsten) .*|Ausmachender Betrag) (\\-)?(?[\\.,\\d]+)(\\-)? (?[A-Z]{3}).*$") // .assign((t, v) -> { t.setAmount(asAmount(v.get("amount"))); t.setCurrencyCode(asCurrencyCode(v.get("currency"))); @@ -194,7 +194,7 @@ private void addBuySellTransaction() // @formatter:on section -> section // .attributes("currency", "amount") // - .match("^Belastung Valuta .* (?[\\w]{3}) (?[\\.'\\d]+)$") // + .match("^Belastung Valuta .* (?[A-Z]{3}) (?[\\.'\\d]+)$") // .assign((t, v) -> { t.setAmount(asAmount(v.get("amount"))); t.setCurrencyCode(asCurrencyCode(v.get("currency"))); @@ -205,14 +205,14 @@ private void addBuySellTransaction() // Devisenkurs: 1,406 (20.01.2022) -1.093,40 EUR // @formatter:on .section("termCurrency", "fxGross", "exchangeRate", "baseCurrency").optional() // - .match("^Kurswert: (\\-)?(?[\\.,\\d]+) (?[\\w]{3}).*$") // - .match("^Devisenkurs: (?[\\.,\\d]+) \\([\\d]{2}\\.[\\d]{2}\\.[\\d]{4}\\) (\\-)?[\\.,\\d]+ (?[\\w]{3}).*$") // + .match("^Kurswert: (\\-)?(?[\\.,\\d]+) (?[A-Z]{3}).*$") // + .match("^Devisenkurs: (?[\\.,\\d]+) \\([\\d]{2}\\.[\\d]{2}\\.[\\d]{4}\\) (\\-)?[\\.,\\d]+ (?[A-Z]{3}).*$") // .assign((t, v) -> { - ExtrExchangeRate rate = asExchangeRate(v); + var rate = asExchangeRate(v); type.getCurrentContext().putType(rate); - Money fxGross = Money.of(rate.getTermCurrency(), asAmount(v.get("fxGross"))); - Money gross = rate.convert(rate.getBaseCurrency(), fxGross); + var fxGross = Money.of(rate.getTermCurrency(), asAmount(v.get("fxGross"))); + var gross = rate.convert(rate.getBaseCurrency(), fxGross); checkAndSetGrossUnit(gross, fxGross, t, type.getCurrentContext()); }) @@ -226,6 +226,13 @@ private void addBuySellTransaction() .match("^.*(?Auftrags\\-Nr\\.: [\\d]+).*$") // .assign((t, v) -> t.setNote(trim(v.get("note")))), // @formatter:off + // Geschäftsart: Ausgabe Fonds aus Dauerauftrag Dauerauftrag-Nr.: 51 - 26.05.2021 + // @formatter:on + section -> section // + .attributes("note") // + .match("^.*(?Dauerauftrag\\-Nr\\.: [\\d]+).*$") // + .assign((t, v) -> t.setNote(trim(v.get("note")))), + // @formatter:off // Auftragsnummer 464088/93.00 // @formatter:on section -> section // @@ -254,19 +261,19 @@ private void addBuySellTransaction() private void addDividendeTransaction() { - final DocumentType type = new DocumentType("(Ertrag|Dividendengutschrift|Kapitaltransaktion|Ertragsgutschrift nach .*)"); + final var type = new DocumentType("(Ertrag|Dividendengutschrift|Kapitaltransaktion|Ertragsgutschrift nach .*)"); this.addDocumentTyp(type); - Transaction pdfTransaction = new Transaction<>(); + var pdfTransaction = new Transaction(); - Block firstRelevantLine = new Block("^.*(Private Banking|Abrechnungsnr|Gesch.ftsart|Anlageverm.gen).*$", "^(Den Betrag buchen|Der Betrag wird|Dieser Beleg (tr.gt|wurde|wird)).*$"); + var firstRelevantLine = new Block("^.*(Private Banking|Abrechnungsnr|Gesch.ftsart|Anlageverm.gen).*$", "^(Den Betrag buchen|Der Betrag wird|Dieser Beleg (tr.gt|wurde|wird)).*$"); type.addBlock(firstRelevantLine); firstRelevantLine.set(pdfTransaction); pdfTransaction // .subject(() -> { - AccountTransaction accountTransaction = new AccountTransaction(); + var accountTransaction = new AccountTransaction(); accountTransaction.setType(AccountTransaction.Type.DIVIDENDS); return accountTransaction; }) @@ -281,7 +288,7 @@ private void addDividendeTransaction() .attributes("isin", "name", "name1", "currency") // .match("^Titel: (?[A-Z]{2}[A-Z0-9]{9}[0-9]) (?.*)$") // .match("^(?.*) \\- Aussch.ttung$") // - .match("^(Dividende|Ertrag): [\\.,\\d]+ (?[\\w]{3})$") // + .match("^(Dividende|Ertrag): [\\.,\\d]+ (?[A-Z]{3})$") // .assign((t, v) -> { if (!v.get("name1").startsWith("Dividende:") // || !v.get("name1").startsWith("Ertrag:") // @@ -299,7 +306,7 @@ private void addDividendeTransaction() .attributes("isin", "name", "name1", "currency") // .match("^Titel: (?[A-Z]{2}[A-Z0-9]{9}[0-9]) (?.*)$") // .match("^(?.*)$") // - .match("^(Dividende|Ertrag): [\\.,\\d]+ (?[\\w]{3})$") // + .match("^(Dividende|Ertrag): [\\.,\\d]+ (?[A-Z]{3})$") // .assign((t, v) -> { if (!v.get("name1").startsWith("Dividende:") // || !v.get("name1").startsWith("Ertrag:") // @@ -321,7 +328,7 @@ private void addDividendeTransaction() .attributes("name", "isin", "wkn", "name1", "currency") // .match("^St.ck [\\.,\\d]+ (?.*) (?[A-Z]{2}[A-Z0-9]{9}[0-9]) \\((?[A-Z0-9]{6})\\)$") // .match("^(?.*)$") // - .match("^Zahlbarkeitstag [\\d]{2}\\.[\\d]{2}\\.[\\d]{4} (Dividende|Ertrag) .* [\\.,\\d]+ (?[\\w]{3})$") // + .match("^Zahlbarkeitstag [\\d]{2}\\.[\\d]{2}\\.[\\d]{4} (Dividende|Ertrag) .* [\\.,\\d]+ (?[A-Z]{3})$") // .assign((t, v) -> { if (!v.get("name1").startsWith("Zahlbarkeitstag")) v.put("name", trim(v.get("name")) + " " + trim(v.get("name1"))); @@ -339,7 +346,7 @@ private void addDividendeTransaction() .find("Depotposition.*") // .match("^[\\.'\\d]+ (?.*)$") // .match("^Valoren\\-Nr\\.: (?[A-Z0-9]{5,9}), ISIN (?[A-Z]{2}[A-Z0-9]{9}[0-9]).*$") // - .match("^(Dividende|Ertrag) (?[\\w]{3}) [\\.'\\d]+.*$") // + .match("^(Dividende|Ertrag) (?[A-Z]{3}) [\\.'\\d]+.*$") // .assign((t, v) -> t.setSecurity(getOrCreateSecurity(v)))) .oneOf( // @@ -397,7 +404,7 @@ private void addDividendeTransaction() // @formatter:on section -> section // .attributes("amount", "currency") // - .match("^(Zu Gunsten .*|Ausmachender Betrag) (?[\\.,\\d]+)(\\+)? (?[\\w]{3}).*$") // + .match("^(Zu Gunsten .*|Ausmachender Betrag) (?[\\.,\\d]+)(\\+)? (?[A-Z]{3}).*$") // .assign((t, v) -> { t.setAmount(asAmount(v.get("amount"))); t.setCurrencyCode(asCurrencyCode(v.get("currency"))); @@ -407,7 +414,7 @@ private void addDividendeTransaction() // @formatter:on section -> section // .attributes("amount", "currency") // - .match("^Zu Lasten .* \\-(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^Zu Lasten .* \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> { // @formatter:off // If the amount is negative, then it is taxes. @@ -422,7 +429,7 @@ private void addDividendeTransaction() // @formatter:on section -> section // .attributes("amount", "currency") // - .match("^Gutschrift Valuta .* (?[\\w]{3}) (?[\\.,\\d]+).*$") // + .match("^Gutschrift Valuta .* (?[A-Z]{3}) (?[\\.,\\d]+).*$") // .assign((t, v) -> { t.setAmount(asAmount(v.get("amount"))); t.setCurrencyCode(asCurrencyCode(v.get("currency"))); @@ -435,14 +442,14 @@ private void addDividendeTransaction() // @formatter:on section -> section // .attributes("baseCurrency", "termCurrency", "exchangeRate", "fxGross", "gross") // - .match("^Devisenkurs (?[\\w]{3}) \\/ (?[\\w]{3}) ([\\s]+)?(?[\\.,\\d]+)$") // - .match("^Dividendengutschrift (?[\\.,\\d]+) [\\w]{3} (?[\\.,\\d]+)\\+ [\\w]{3}$") // + .match("^Devisenkurs (?[A-Z]{3}) \\/ (?[A-Z]{3}) ([\\s]+)?(?[\\.,\\d]+)$") // + .match("^Dividendengutschrift (?[\\.,\\d]+) [A-Z]{3} (?[\\.,\\d]+)\\+ [A-Z]{3}$") // .assign((t, v) -> { - ExtrExchangeRate rate = asExchangeRate(v); + var rate = asExchangeRate(v); type.getCurrentContext().putType(rate); - Money gross = Money.of(rate.getBaseCurrency(), asAmount(v.get("gross"))); - Money fxGross = Money.of(rate.getTermCurrency(), asAmount(v.get("fxGross"))); + var gross = Money.of(rate.getBaseCurrency(), asAmount(v.get("gross"))); + var fxGross = Money.of(rate.getTermCurrency(), asAmount(v.get("fxGross"))); checkAndSetGrossUnit(gross, fxGross, t, type.getCurrentContext()); }), @@ -452,14 +459,14 @@ private void addDividendeTransaction() // @formatter:on section -> section // .attributes("fxGross", "termCurrency", "exchangeRate", "baseCurrency") // - .match("^Bruttoertrag: (?[\\.,\\d]+) (?[\\w]{3}).*$") // - .match("^Devisenkurs: (?[\\.,\\d]+) \\([\\d]{2}\\.[\\d]{2}\\.[\\d]{4}\\) [\\.,\\d]+ (?[\\w]{3}).*$") // + .match("^Bruttoertrag: (?[\\.,\\d]+) (?[A-Z]{3}).*$") // + .match("^Devisenkurs: (?[\\.,\\d]+) \\([\\d]{2}\\.[\\d]{2}\\.[\\d]{4}\\) [\\.,\\d]+ (?[A-Z]{3}).*$") // .assign((t, v) -> { - ExtrExchangeRate rate = asExchangeRate(v); + var rate = asExchangeRate(v); type.getCurrentContext().putType(rate); - Money fxGross = Money.of(rate.getTermCurrency(), asAmount(v.get("fxGross"))); - Money gross = rate.convert(rate.getBaseCurrency(), fxGross); + var fxGross = Money.of(rate.getTermCurrency(), asAmount(v.get("fxGross"))); + var gross = rate.convert(rate.getBaseCurrency(), fxGross); checkAndSetGrossUnit(gross, fxGross, t, type.getCurrentContext()); })) @@ -493,7 +500,7 @@ private void addDividendeTransaction() // @formatter:on type.getCurrentContext().remove("noTax"); - TransactionItem item = new TransactionItem(t); + var item = new TransactionItem(t); return item; }); @@ -504,19 +511,19 @@ private void addDividendeTransaction() private void addFeeTransaction() { - final DocumentType type = new DocumentType("Geb.hrenbelastung Depot"); + final var type = new DocumentType("Geb.hrenbelastung Depot"); this.addDocumentTyp(type); - Transaction pdfTransaction = new Transaction<>(); + var pdfTransaction = new Transaction(); - Block firstRelevantLine = new Block("^Anlageverm.gen.*$"); + var firstRelevantLine = new Block("^Anlageverm.gen.*$"); type.addBlock(firstRelevantLine); firstRelevantLine.set(pdfTransaction); pdfTransaction // .subject(() -> { - AccountTransaction accountTransaction = new AccountTransaction(); + var accountTransaction = new AccountTransaction(); accountTransaction.setType(AccountTransaction.Type.FEES); return accountTransaction; }) @@ -525,7 +532,7 @@ private void addFeeTransaction() // Belastung Valuta 30.09.2024 CHF 100.04 // @formatter:on .section("date", "amount", "currency") // - .match("^Belastung Valuta (?[\\d]{2}\\.[\\d]{2}\\.[\\d]{4}) (?[\\w]{3}) (?[\\.'\\d]+).*$") + .match("^Belastung Valuta (?[\\d]{2}\\.[\\d]{2}\\.[\\d]{4}) (?[A-Z]{3}) (?[\\.'\\d]+).*$") .assign((t, v) -> { t.setDateTime(asDate(v.get("date"))); t.setAmount(asAmount(v.get("amount"))); @@ -556,7 +563,7 @@ private void addFeeTransaction() .assign((t, v) -> t.setNote(concatenate(t.getNote(), trim(v.get("note")), " | "))) .wrap((t, ctx) -> { - TransactionItem item = new TransactionItem(t); + var item = new TransactionItem(t); if (t.getCurrencyCode() != null && t.getAmount() == 0) item.setFailureMessage(Messages.MsgErrorTransactionTypeNotSupported); @@ -567,19 +574,19 @@ private void addFeeTransaction() private void addDeliveryInOutBoundTransaction() { - final DocumentType type = new DocumentType("Gesch.ftsart: (Einbuchung|Ausbuchung)"); + final var type = new DocumentType("Gesch.ftsart: (Einbuchung|Ausbuchung)"); this.addDocumentTyp(type); - Transaction pdfTransaction = new Transaction<>(); + var pdfTransaction = new Transaction(); - Block firstRelevantLine = new Block("^Abrechnungsnummer\\/\\-datum:.*$"); + var firstRelevantLine = new Block("^Abrechnungsnummer\\/\\-datum:.*$"); type.addBlock(firstRelevantLine); firstRelevantLine.set(pdfTransaction); pdfTransaction // .subject(() -> { - PortfolioTransaction portfolioTransaction = new PortfolioTransaction(); + var portfolioTransaction = new PortfolioTransaction(); portfolioTransaction.setType(PortfolioTransaction.Type.DELIVERY_INBOUND); return portfolioTransaction; }) @@ -620,7 +627,7 @@ private void addDeliveryInOutBoundTransaction() // Zu Gunsten IBAN AT44 3400 0000 0123 4567 0,00 EUR // @formatter:on .section("amount", "currency") // - .match("^Zu (Lasten|Gunsten) IBAN .* (\\-)?(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^Zu (Lasten|Gunsten) IBAN .* (\\-)?(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> { t.setCurrencyCode(asCurrencyCode(v.get("currency"))); t.setAmount(asAmount(v.get("amount"))); @@ -644,7 +651,7 @@ private void addDeliveryInOutBoundTransaction() }) .wrap((t, ctx) -> { - TransactionItem item = new TransactionItem(t); + var item = new TransactionItem(t); if (ctx.getString(FAILURE) != null) item.setFailureMessage(ctx.getString(FAILURE)); @@ -658,19 +665,19 @@ private void addDeliveryInOutBoundTransaction() private void addNonImportableTransaction() { - final DocumentType type = new DocumentType("Gesch.ftsart: Freier Erhalt"); // + final var type = new DocumentType("Gesch.ftsart: Freier Erhalt"); // this.addDocumentTyp(type); - Transaction pdfTransaction = new Transaction<>(); + var pdfTransaction = new Transaction(); - Block firstRelevantLine = new Block("^Gesch.ftsart: Freier Erhalt$"); + var firstRelevantLine = new Block("^Gesch.ftsart: Freier Erhalt$"); type.addBlock(firstRelevantLine); firstRelevantLine.set(pdfTransaction); pdfTransaction // .subject(() -> { - PortfolioTransaction portfolioTransaction = new PortfolioTransaction(); + var portfolioTransaction = new PortfolioTransaction(); portfolioTransaction.setType(PortfolioTransaction.Type.DELIVERY_INBOUND); return portfolioTransaction; }) @@ -705,7 +712,7 @@ private void addNonImportableTransaction() // @formatter:on section -> section // .attributes("amount", "currency") // - .match("^Zu (Lasten|Gunsten) IBAN .* (\\-)?(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^Zu (Lasten|Gunsten) IBAN .* (\\-)?(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> { v.getTransactionContext().put(FAILURE, Messages.MsgErrorTransactionTypeNotSupported); @@ -717,7 +724,7 @@ private void addNonImportableTransaction() // @formatter:on section -> section // .attributes("currency") // - .match("^Verrechnung: IBAN .* (?[\\w]{3})$") // + .match("^Verrechnung: IBAN .* (?[A-Z]{3})$") // .assign((t, v) -> { v.getTransactionContext().put(FAILURE, Messages.MsgErrorTransactionTypeNotSupported); @@ -743,7 +750,7 @@ private void addNonImportableTransaction() }) .wrap((t, ctx) -> { - TransactionItem item = new TransactionItem(t); + var item = new TransactionItem(t); if (ctx.getString(FAILURE) != null) item.setFailureMessage(ctx.getString(FAILURE)); @@ -754,13 +761,13 @@ private void addNonImportableTransaction() private void addAccountStatementTransactions() { - final DocumentType type = new DocumentType("(Kontokorrent|Privatkonto|Tagesgeld Plus)", // + final var type = new DocumentType("(Kontokorrent|Privatkonto|Tagesgeld Plus)", // documentContext -> documentContext // // @formatter:off // EUR-Konto Kontonummer 12364567 // @formatter:on .section("currency") // - .match("^(?[\\w]{3})\\-Konto Kontonummer .*$") // + .match("^(?[A-Z]{3})\\-Konto Kontonummer .*$") // .assign((ctx, v) -> ctx.put("currency", asCurrencyCode(v.get("currency")))) // @formatter:off @@ -775,12 +782,12 @@ private void addAccountStatementTransactions() this.addDocumentTyp(type); - Block depositRemovalBlock = new Block("^[\\d]{2}\\.[\\d]{2}\\. [\\d]{2}\\.[\\d]{2}\\. .* [S|H]$"); + var depositRemovalBlock = new Block("^[\\d]{2}\\.[\\d]{2}\\. [\\d]{2}\\.[\\d]{2}\\. .* [S|H]$"); type.addBlock(depositRemovalBlock); depositRemovalBlock.set(new Transaction() .subject(() -> { - AccountTransaction accountTransaction = new AccountTransaction(); + var accountTransaction = new AccountTransaction(); accountTransaction.setType(AccountTransaction.Type.REMOVAL); return accountTransaction; }) @@ -895,12 +902,12 @@ private void addAccountStatementTransactions() return null; })); - Block interestBlock = new Block("^[\\d]{2}\\.[\\d]{2}\\. [\\d]{2}\\.[\\d]{2}\\. Abschluss.* [S|H]$"); + var interestBlock = new Block("^[\\d]{2}\\.[\\d]{2}\\. [\\d]{2}\\.[\\d]{2}\\. Abschluss.* [S|H]$"); type.addBlock(interestBlock); interestBlock.set(new Transaction() .subject(() -> { - AccountTransaction accountTransaction = new AccountTransaction(); + var accountTransaction = new AccountTransaction(); accountTransaction.setType(AccountTransaction.Type.INTEREST); return accountTransaction; }) @@ -952,7 +959,7 @@ private void addAccountStatementTransactions() .documentContext("currency") // .match("^[\\d]{2}\\.[\\d]{2}\\. [\\d]{2}\\.[\\d]{2}\\. Kapitalertrags(s)?teuer .* (?[\\.,\\d]+) S$") // .assign((t, v) -> { - Money tax = Money.of(asCurrencyCode(v.get("currency")), asAmount(v.get("tax"))); + var tax = Money.of(asCurrencyCode(v.get("currency")), asAmount(v.get("tax"))); t.addUnit(new Unit(Unit.Type.TAX, tax)); if (t.getType() == AccountTransaction.Type.INTEREST) @@ -968,7 +975,7 @@ private void addAccountStatementTransactions() .documentContext("currency") // .match("^[\\d]{2}\\.[\\d]{2}\\. [\\d]{2}\\.[\\d]{2}\\. Solid\\.\\-Zuschlag .* (?[\\.,\\d]+) S$") // .assign((t, v) -> { - Money tax = Money.of(asCurrencyCode(v.get("currency")), asAmount(v.get("tax"))); + var tax = Money.of(asCurrencyCode(v.get("currency")), asAmount(v.get("tax"))); t.addUnit(new Unit(Unit.Type.TAX, tax)); if (t.getType() == AccountTransaction.Type.INTEREST) @@ -984,7 +991,7 @@ private void addAccountStatementTransactions() .documentContext("currency") // .match("^[\\d]{2}\\.[\\d]{2}\\. [\\d]{2}\\.[\\d]{2}\\. Kirchensteuer .* (?[\\.,\\d]+) S$") // .assign((t, v) -> { - Money tax = Money.of(asCurrencyCode(v.get("currency")), asAmount(v.get("tax"))); + var tax = Money.of(asCurrencyCode(v.get("currency")), asAmount(v.get("tax"))); t.addUnit(new Unit(Unit.Type.TAX, tax)); if (t.getType() == AccountTransaction.Type.INTEREST) @@ -999,12 +1006,12 @@ private void addAccountStatementTransactions() return null; })); - Block feesBlock = new Block("^[\\d]{2}\\.[\\d]{2}\\. [\\d]{2}\\.[\\d]{2}\\. .* [S|H]$"); + var feesBlock = new Block("^[\\d]{2}\\.[\\d]{2}\\. [\\d]{2}\\.[\\d]{2}\\. .* [S|H]$"); type.addBlock(feesBlock); feesBlock.set(new Transaction() .subject(() -> { - AccountTransaction accountTransaction = new AccountTransaction(); + var accountTransaction = new AccountTransaction(); accountTransaction.setType(AccountTransaction.Type.FEES); return accountTransaction; }) @@ -1075,13 +1082,13 @@ private void addAccountStatementTransactions() private void addDepotStatementTransaction() { - final DocumentType type = new DocumentType("Auszug .*[\\d]+\\/[\\d]+ vom [\\d]{2}\\.[\\d]{2}\\.[\\d]{4}", // + final var type = new DocumentType("Auszug .*[\\d]+\\/[\\d]+ vom [\\d]{2}\\.[\\d]{2}\\.[\\d]{4}", // documentContext -> documentContext // // @formatter:off // Datum Buchungstext Wert Betrag EUR // @formatter:on .section("currency") // - .match("^Datum Buchungstext .* (?[\\w]{3})$") // + .match("^Datum Buchungstext .* (?[A-Z]{3})$") // .assign((ctx, v) -> ctx.put("currency", asCurrencyCode(v.get("currency")))) // @formatter:off @@ -1096,12 +1103,12 @@ private void addDepotStatementTransaction() // @formatter:off // 08.05 Gutschrift 0805 5.000,00 // @formatter:on - Block depositBlock = new Block("^[\\d]{2}\\.[\\d]{2} Gutschrift .* [\\d]{4} .* [\\.,\\d]+$"); + var depositBlock = new Block("^[\\d]{2}\\.[\\d]{2} Gutschrift .* [\\d]{4} .* [\\.,\\d]+$"); type.addBlock(depositBlock); depositBlock.set(new Transaction() .subject(() -> { - AccountTransaction t = new AccountTransaction(); + var t = new AccountTransaction(); t.setType(AccountTransaction.Type.DEPOSIT); return t; }) @@ -1127,7 +1134,7 @@ private > void addTaxesSectionsTransaction(T transactio transaction // .section("n").optional() // - .match("^Zu (?Lasten) .* \\-[\\.,\\d]+ [\\w]{3}.*$") // + .match("^Zu (?Lasten) .* \\-[\\.,\\d]+ [A-Z]{3}.*$") // .match("^Belastung KESt bei aussch.ttungsgleichen Erträgen .*$") // .assign((t, v) -> type.getCurrentContext().putBoolean("noTax", true)); @@ -1137,7 +1144,7 @@ private > void addTaxesSectionsTransaction(T transactio // Kapitalertragsteuer 24,51 % auf 15,08 EUR 3,69- EUR // @formatter:on .section("tax", "currency").optional() // - .match("^Kapitalertragsteuer [\\.,\\d]+([\\s]+)?% .* (?[\\.,\\d]+)\\- (?[\\w]{3})$") // + .match("^Kapitalertragsteuer [\\.,\\d]+([\\s]+)?% .* (?[\\.,\\d]+)\\- (?[A-Z]{3})$") // .assign((t, v) -> { if (!type.getCurrentContext().getBoolean("noTax")) processTaxEntries(t, v, type); @@ -1147,7 +1154,7 @@ private > void addTaxesSectionsTransaction(T transactio // Solidaritätszuschlag 5,5 % auf 3,69 EUR 0,20- EUR // @formatter:on .section("tax", "currency").optional() // - .match("^Solidarit.tszuschlag [\\.,\\d]+([\\s]+)?% .* (?[\\.,\\d]+)\\- (?[\\w]{3})$") // + .match("^Solidarit.tszuschlag [\\.,\\d]+([\\s]+)?% .* (?[\\.,\\d]+)\\- (?[A-Z]{3})$") // .assign((t, v) -> { if (!type.getCurrentContext().getBoolean("noTax")) processTaxEntries(t, v, type); @@ -1157,7 +1164,7 @@ private > void addTaxesSectionsTransaction(T transactio // Kirchensteuer 8 % auf 3,69 EUR 0,30- EUR // @formatter:on .section("tax", "currency").optional() // - .match("^Kirchensteuer [\\.,\\d]+([\\s]+)?% .* (?[\\.,\\d]+)\\- (?[\\w]{3})$") // + .match("^Kirchensteuer [\\.,\\d]+([\\s]+)?% .* (?[\\.,\\d]+)\\- (?[A-Z]{3})$") // .assign((t, v) -> { if (!type.getCurrentContext().getBoolean("noTax")) processTaxEntries(t, v, type); @@ -1167,7 +1174,7 @@ private > void addTaxesSectionsTransaction(T transactio // Quellensteuer: -47,48 EUR // @formatter:on .section("tax", "currency").optional() // - .match("^Quellensteuer: \\-(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^Quellensteuer: \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> { if (!type.getCurrentContext().getBoolean("noTax")) processTaxEntries(t, v, type); @@ -1177,7 +1184,7 @@ private > void addTaxesSectionsTransaction(T transactio // Auslands-KESt: -22,50 EUR // @formatter:on .section("tax", "currency").optional() // - .match("^Auslands\\-KESt: \\-(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^Auslands\\-KESt: \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> { if (!type.getCurrentContext().getBoolean("noTax")) processTaxEntries(t, v, type); @@ -1187,7 +1194,7 @@ private > void addTaxesSectionsTransaction(T transactio // KESt ausländische Dividende: -0,64 USD // @formatter:on .section("tax", "currency").optional() // - .match("^KESt ausl.ndische Dividende: \\-(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^KESt ausl.ndische Dividende: \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> { if (!type.getCurrentContext().getBoolean("noTax")) processTaxEntries(t, v, type); @@ -1197,7 +1204,7 @@ private > void addTaxesSectionsTransaction(T transactio // KESt: -10,00 EUR // @formatter:on .section("tax", "currency").optional() // - .match("^KESt: \\-(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^KESt: \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> { if (!type.getCurrentContext().getBoolean("noTax")) processTaxEntries(t, v, type); @@ -1207,7 +1214,7 @@ private > void addTaxesSectionsTransaction(T transactio // Umsatzsteuer: -0,29 EUR // @formatter:on .section("tax", "currency").optional() // - .match("^Umsatzsteuer: \\-(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^Umsatzsteuer: \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> { if (!type.getCurrentContext().getBoolean("noTax")) processTaxEntries(t, v, type); @@ -1217,7 +1224,7 @@ private > void addTaxesSectionsTransaction(T transactio // Kursgewinn-KESt: -696,65 EUR // @formatter:on .section("tax", "currency").optional() // - .match("^Kursgewinn\\-KESt: \\-(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^Kursgewinn\\-KESt: \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> { if (!type.getCurrentContext().getBoolean("noTax")) processTaxEntries(t, v, type); @@ -1227,7 +1234,7 @@ private > void addTaxesSectionsTransaction(T transactio // Verrechnungssteuer 35 % CHF -211.58 // @formatter:on .section("tax", "currency").optional() // - .match("^Verrechnungssteuer [\\.,\\d]+([\\s]+)?% .*(?[\\w]{3}) \\-(?[\\.'\\d]+).*$") // + .match("^Verrechnungssteuer [\\.,\\d]+([\\s]+)?% .*(?[A-Z]{3}) \\-(?[\\.'\\d]+).*$") // .assign((t, v) -> { if (!type.getCurrentContext().getBoolean("noTax")) processTaxEntries(t, v, type); @@ -1237,7 +1244,7 @@ private > void addTaxesSectionsTransaction(T transactio // Umsatzabgabe CHF -3.75 // @formatter:on .section("tax", "currency").optional() // - .match("^Umsatzabgabe (?[\\w]{3}) \\-(?[\\.'\\d]+).*$") // + .match("^Umsatzabgabe (?[A-Z]{3}) \\-(?[\\.'\\d]+).*$") // .assign((t, v) -> { if (!type.getCurrentContext().getBoolean("noTax")) processTaxEntries(t, v, type); @@ -1247,7 +1254,7 @@ private > void addTaxesSectionsTransaction(T transactio // Einbehaltene Quellensteuer 15 % auf 68,00 USD 8,98- EUR // @formatter:on .section("withHoldingTax", "currency").optional() // - .match("^Einbehaltene Quellensteuer [\\.,\\d]+ % .* [\\.,\\d]+ [\\w]{3} (?[\\.,\\d]+)\\- (?[\\w]{3})$") // + .match("^Einbehaltene Quellensteuer [\\.,\\d]+ % .* [\\.,\\d]+ [A-Z]{3} (?[\\.,\\d]+)\\- (?[A-Z]{3})$") // .assign((t, v) -> { if (!type.getCurrentContext().getBoolean("noTax")) processWithHoldingTaxEntries(t, v, "withHoldingTax", type); @@ -1257,7 +1264,7 @@ private > void addTaxesSectionsTransaction(T transactio // Anrechenbare Quellensteuer 15 % auf 59,86 EUR 8,98 EUR // @formatter:on .section("creditableWithHoldingTax", "currency").optional() // - .match("^Anrechenbare Quellensteuer [\\.,\\d]+ % .* [\\.,\\d]+ [\\w]{3} (?[\\.,\\d]+) (?[\\w]{3})$") // + .match("^Anrechenbare Quellensteuer [\\.,\\d]+ % .* [\\.,\\d]+ [A-Z]{3} (?[\\.,\\d]+) (?[A-Z]{3})$") // .assign((t, v) -> { if (!type.getCurrentContext().getBoolean("noTax")) processWithHoldingTaxEntries(t, v, "creditableWithHoldingTax", type); @@ -1272,94 +1279,108 @@ private > void addFeesSectionsTransaction(T transaction // Serviceentgelt: -0,32 EUR // @formatter:on .section("fee", "currency").optional() // - .match("^Serviceentgelt: \\-(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^Serviceentgelt: \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> processFeeEntries(t, v, type)) // @formatter:off // Provision 0,2000 % vom Kurswert 28,74- EUR // @formatter:on .section("fee", "currency").optional() // - .match("^Provision [\\.,\\d]+ % .* (?[\\.,\\d]+)\\- (?[\\w]{3}).*$") // + .match("^Provision [\\.,\\d]+ % .* (?[\\.,\\d]+)\\- (?[A-Z]{3}).*$") // .assign((t, v) -> processFeeEntries(t, v, type)) // @formatter:off // Provision 1,50- EUR // @formatter:on .section("fee", "currency").optional() // - .match("^Provision (?[\\.,\\d]+)\\- (?[\\w]{3})$") // + .match("^Provision (?[\\.,\\d]+)\\- (?[A-Z]{3})$") // .assign((t, v) -> processFeeEntries(t, v, type)) // @formatter:off // Eigene Spesen 2,50- EUR // @formatter:on .section("fee", "currency").optional() // - .match("^Eigene Spesen (?[\\.,\\d]+)\\- (?[\\w]{3}).*$") // + .match("^Eigene Spesen (?[\\.,\\d]+)\\- (?[A-Z]{3}).*$") // .assign((t, v) -> processFeeEntries(t, v, type)) // @formatter:off // Übertragungs-/Liefergebühr 0,10- EUR // @formatter:on .section("fee", "currency").optional() // - .match("^.bertragungs\\-\\/Liefergeb.hr (?[\\.,\\d]+)\\- (?[\\w]{3}).*$") // + .match("^.bertragungs\\-\\/Liefergeb.hr (?[\\.,\\d]+)\\- (?[A-Z]{3}).*$") // .assign((t, v) -> processFeeEntries(t, v, type)) // @formatter:off // Handelsortentgelt inkl. Fremdspesen: -4,00 EUR // @formatter:on .section("fee", "currency").optional() // - .match("^Handelsortentgelt inkl\\. Fremdspesen: \\-(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^Handelsortentgelt inkl\\. Fremdspesen: \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> processFeeEntries(t, v, type)) // @formatter:off // Gebühren: -25,00 EUR // @formatter:on .section("fee", "currency").optional() // - .match("^Geb.hren: \\-(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^Geb.hren: \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> processFeeEntries(t, v, type)) // @formatter:off // Orderleitgebühr: -3,00 EUR // @formatter:on .section("fee", "currency").optional() // - .match("^Orderleitgeb.hr: \\-(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^Orderleitgeb.hr: \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> processFeeEntries(t, v, type)) // @formatter:off // Inkassogebühr: -1,45 EUR // @formatter:on .section("fee", "currency").optional() // - .match("^Inkassogeb.hr: \\-(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^Inkassogeb.hr: \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> processFeeEntries(t, v, type)) // @formatter:off // Zahlungsverkehr-Transaktionsgebühr: -3,00 EUR // @formatter:on .section("fee", "currency").optional() // - .match("^Zahlungsverkehr\\-Transaktionsgeb.hr: \\-(?[\\.,\\d]+) (?[\\w]{3}).*$") // + .match("^Zahlungsverkehr\\-Transaktionsgeb.hr: \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> processFeeEntries(t, v, type)) // @formatter:off // Börsengebühr CHF -2.35 // @formatter:on .section("currency", "fee").optional() // - .match("^B.rsengeb.hr (?[\\w]{3}) \\-(?[\\.'\\d]+).*$") // + .match("^B.rsengeb.hr (?[A-Z]{3}) \\-(?[\\.'\\d]+).*$") // + .assign((t, v) -> processFeeEntries(t, v, type)) + + // @formatter:off + // Transaktionsservice Grundpreis: -1,14 EUR + // @formatter:on + .section("fee", "currency").optional() // + .match("^Transaktionsservice Grundpreis: \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // + .assign((t, v) -> processFeeEntries(t, v, type)) + + // @formatter:off + // Transaktionsservice variabel: -0,95 EUR + // @formatter:on + .section("fee", "currency").optional() // + .match("^Transaktionsservice variabel: \\-(?[\\.,\\d]+) (?[A-Z]{3}).*$") // .assign((t, v) -> processFeeEntries(t, v, type)) // @formatter:off // Courtage CHF -3.17 // @formatter:on .section("fee", "currency").optional() // - .match("^Courtage (?[\\w]{3}) \\-(?[\\.'\\d]+).*$") // + .match("^Courtage (?[A-Z]{3}) \\-(?[\\.'\\d]+).*$") // .assign((t, v) -> processFeeEntries(t, v, type)); } @Override protected long asAmount(String value) { - String language = "de"; - String country = "DE"; + var language = "de"; + var country = "DE"; - int apostrophe = value.indexOf("\'"); + var apostrophe = value.indexOf("\'"); if (apostrophe >= 0) { language = "de"; @@ -1367,8 +1388,8 @@ protected long asAmount(String value) } else { - int lastDot = value.lastIndexOf("."); - int lastComma = value.lastIndexOf(","); + var lastDot = value.lastIndexOf("."); + var lastComma = value.lastIndexOf(","); // returns the greater of two int values if (Math.max(lastDot, lastComma) == lastDot) @@ -1384,10 +1405,10 @@ protected long asAmount(String value) @Override protected BigDecimal asExchangeRate(String value) { - String language = "de"; - String country = "DE"; + var language = "de"; + var country = "DE"; - int apostrophe = value.indexOf("\'"); + var apostrophe = value.indexOf("\'"); if (apostrophe >= 0) { language = "de"; @@ -1395,8 +1416,8 @@ protected BigDecimal asExchangeRate(String value) } else { - int lastDot = value.lastIndexOf("."); - int lastComma = value.lastIndexOf(","); + var lastDot = value.lastIndexOf("."); + var lastComma = value.lastIndexOf(","); // returns the greater of two int values if (Math.max(lastDot, lastComma) == lastDot) @@ -1421,12 +1442,12 @@ protected BigDecimal asExchangeRate(String value) */ private void dateTranactionHelper(AccountTransaction t, ParsedData v) { - final String SPECIAL_NR = "01"; - final int THRESHOLD_MONTH = 3; + final var SPECIAL_NR = "01"; + final var THRESHOLD_MONTH = 3; - String nr = v.get("nr"); - int month = Integer.parseInt(v.get("month")); - int year = Integer.parseInt(v.get("year")); + var nr = v.get("nr"); + var month = Integer.parseInt(v.get("month")); + var year = Integer.parseInt(v.get("year")); if (SPECIAL_NR.equals(nr) && month < THRESHOLD_MONTH) {