src/nami/beitrag/db/BeitragSepaMandat.java
@Data
public class BeitragSepaMandat {
    private int mandatId;
    private String iban;
    private String bic;
    private Date datum;
    private String kontoinhaber;
    private String strasse;
    private String plz;
    private String ort;
    private String email;
    private boolean gueltig;
}
src/nami/beitrag/db/BeitragBuchung.java
@Data
@NoArgsConstructor
public class BeitragBuchung {
    private int buchungId;
    private int mitgliedId;
    private Integer namiBuchungId;
    private String rechnungsNummer;
    private Buchungstyp typ;
    private Date datum;
    private BigDecimal betrag;
    private Halbjahr halbjahr;
    private boolean vorausberechnung;
    private String kommentar;
    private boolean storniert = false;

    /**
     * Erzeugt eine Buchung mit den aus NaMi geladenen Daten.
     * 
     * @param mitgliedId
     *            ID des Mitglieds
     * @param beitr
     *            Beitragszahlungs-Datensatz aus NaMi
     */
    public BeitragBuchung(int mitgliedId, NamiBeitragszahlung beitr) {
        this.mitgliedId = mitgliedId;

        namiBuchungId = beitr.getId();
        rechnungsNummer = beitr.getRechungsnummer();
        typ = Buchungstyp.RECHNUNG_BUNDESEBENE;

        // Datum
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.DAY_OF_MONTH, 1);
        if (beitr.getHalbjahr() == 2) {
            cal.set(Calendar.MONTH, Calendar.JULY);
        } else {
            cal.set(Calendar.MONTH, Calendar.JANUARY);
        }
        cal.set(Calendar.YEAR, beitr.getJahr());
        datum = cal.getTime();

        betrag = beitr.getValue().negate(); // negatives Vorzeichen, da Belastung
        halbjahr = beitr.getZeitraum();
        vorausberechnung = false;
        kommentar = beitr.getBuchungstext();
    }
}
src/nami/beitrag/db/BeitragRechnung.java
@Data
public class BeitragRechnung {
    private int rechnungId;
    private int mitgliedId;
    private int rechnungsNummer;
    private Date datum;
    private Date frist;
    private Rechnungsstatus status;

    /**
     * Rechnungsbetrag (d. h. Summe der enthaltenen Posten).
     * 
     * Dieses Feld steht nicht in der Datenbank, sondern wird in der SQL-Abfrage
     * aus den verknüpften Posten berechnet.
     */
    @Setter(AccessLevel.NONE)
    private BigDecimal betrag;

    /**
     * Liefert die vollständige Rechnungsnummer.
     * 
     * @return Rechnungsnummer inklusive Jahreszahl
     */
    public String getCompleteRechnungsNummer() {
        String jahreszahl = new SimpleDateFormat("y").format(datum);
        return jahreszahl + "/" + rechnungsNummer;
    }
}
src/nami/beitrag/db/BeitragPrenotification.java
@Data
public class BeitragPrenotification {
    private int prenotificationId;
    private int mandatId;
    private Date datum;
    private BigDecimal betrag;
    private Date faelligkeit;
    private boolean regelmaessig;
}
src/nami/beitrag/db/RechnungenMapper.java
public interface RechnungenMapper {
    /**
     * Möglichkeiten Buchungen nach dem Vorausberechnungs-Feld zu filtern.
     */
    static enum VorausberechnungFilter {
        /**
         * Keine Vorausberechnungen ausgeben.
         */
        KEINE,

        /**
         * Alle Buchungen ausgeben.
         */
        AUCH,

        /**
         * Nur Vorausberechnungen ausgeben.
         */
        NUR
    }

    /**
     * Filtert Mitglieder danach, ob ihnen ein gültiges, aktives
     * Lastschrift-Mandat zugewiesen ist.
     */
    static enum ZahlungsartFilter {
        /**
         * Mitglied hat ein gültiges, aktives SEPA-Mandat.
         */
        LASTSCHRIFT,

        /**
         * Mitglied hat <i>kein</i> gültiges, aktives SEPA-Mandat.
         */
        KEINE_LASTSCHRIFT,

        /**
         * Filtere Mitglieder nicht nach diesem Kriterium.
         */
        ALLE
    }

    /**
     * Beschreibt Filterkriterien für die Suche nach Personen und Buchungen.
     */
    @Data
    static class FilterSettings {
        /**
         * Frühestes Halbjahr, dessen Buchungen gewählt werden. Falls der Wert
         * <tt>null</tt> ist, wird nicht nach diesem Kriterium gefiltert.
         */
        private Halbjahr halbjahrVon = null;

        /**
         * Spätestes Halbjahr, dessen Buchungen gewählt werden. Falls der Wert
         * <tt>null</tt> ist, wird nicht nach diesem Kriterium gefiltert.
         */
        private Halbjahr halbjahrBis = null;

        /**
         * Gibt an, ob Buchungen selektiert werden sollen, die
         * Vorausberechnungen sind.
         */
        private VorausberechnungFilter vorausberechnung;

        /**
         * Hiermit können nur Mitglieder selektiert werden, für die ein aktives
         * Lastschrift-Mandat vorhanden ist.
         */
        private ZahlungsartFilter zahlungsart = null;

        /**
         * Gibt an, ob auch Buchungen selektiert werden, die bereits in einer
         * Rechnung enthalten sind.
         */
        private boolean bereitsBerechnet;
    }

    /**
     * Liefert alle Mitglieder, bei denen das Beitragskonto nicht ausgeglichen
     * sind. Dabei werden nur Buchungen berücksichtigt, die den übergebenen
     * Filterkriterien entsprechen.
     * 
     * @param filterSettings
     *            Kriterien, nach denen die Buchungen gefiltert werden
     * @return Mitglieder, deren Beitragskonto (bezogen auf die Buchungen, die
     *         <tt>filterSettings</tt> erfüllen) nicht ausgeglichen ist
     */
    Collection<DataMitgliederForderungen> mitgliederOffeneForderungen(
            @Param("filterSettings") FilterSettings filterSettings);

    /**
     * Liefert für ein bestimmtes Mitglied alle Buchungen, die vorgegebene
     * Kriterien erfüllen.
     * 
     * @param mitgliedId
     *            ID des Mitglieds
     * @param filterSettings
     *            Kriterien, nach denen die Buchungen gefiltert werden
     * @return Buchungen, die die Kriterien erfüllen
     */
    Collection<BeitragBuchung> getBuchungenFiltered(
            @Param("mitgliedId") int mitgliedId,
            @Param("filterSettings") FilterSettings filterSettings);

    /**
     * Liefert die höchste Rechnungsnummer, die im übergebenen Jahr bisher
     * verwendet wurde.
     * 
     * @param jahr
     *            angefragtes Jahr
     * @return höchste bisher verwendete Rechnungsnummer
     */
    int maxRechnungsnummer(int jahr);

    /**
     * Fügt eine Rechnung in die Datenbank ein. Die <tt>rechnungId</tt> der neu
     * eingefügten Rechnung ist anschließend im Objekt gespeichert, das als
     * Parameter übergeben wurde.
     * 
     * @param rechnung
     *            einzufügende Rechnung
     */
    void insertRechnung(BeitragRechnung rechnung);

    /**
     * Holt den vollen Datensatz einer Rechnung aus der Datenbank.
     * 
     * @param rechnungId
     *            ID der Rechnung
     * @return alle Daten der Rechnung
     */
    BeitragRechnung getRechnung(int rechnungId);

    /**
     * Aktualisiert eine Rechnung in der Datenbank. Dabei wird nur das
     * Status-Feld geändert (die anderen Felder einer Rechnung sollten nach dem
     * Anlegen nicht mehr verändert werden).
     * 
     * @param rechnung
     *            Rechnungsdaten
     */
    void updateRechnung(BeitragRechnung rechnung);

    /**
     * Ergebnis-Datentyp, der verwendet wird, wenn eine Rechnung mit allen
     * Informationen aus der Datenbank geholt wird. Dabei wird der entsprechende
     * Mitgliedsdatensatz (Name, Anschrift, usw.) mit ausgelesen und außerdem
     * eine Liste der Posten, die in der Rechnung enthalten sind.
     */
    @Getter
    public static class DataRechnungMitBuchungen {
        private BeitragRechnung rechnung;
        private BeitragMitglied mitglied;
        private List<BeitragBuchung> buchungen;
    }

    /**
     * Liefert eine Rechnung mit allen Informationen aus der Datenbank. Dabei
     * wird neben den Daten der Rechnung noch der entsprechende
     * Mitgliedsdatensatz und die Liste der enthaltenen Posten aus der Datenbank
     * ausgelesen.
     * 
     * @param rechnungId
     *            ID der angefragten Rechnung
     * @return Rechnung mit verknüpften Informationen
     */
    DataRechnungMitBuchungen getRechnungMitBuchungen(int rechnungId);

    /**
     * Fügt einen Posten zu einer Rechnung hinzu.
     * 
     * @param rechnungId
     *            Rechnung, zu der der Posten gehört
     * @param buchungId
     *            Buchung, die damit beglichen werden soll
     * @param buchungstext
     *            Text, der auf der Rechnung angezeigt wird
     */
    void insertPosten(@Param("rechnungId") int rechnungId,
            @Param("buchungId") int buchungId,
            @Param("buchungstext") String buchungstext);

    /**
     * Beschreibt die zurückgegebenen Objekte bei der Rechnungsabfrage mit
     * Filterkriterien.
     */
    @Getter
    public class DataFindRechnungen {
        /**
         * Datensatz der Rechnung.
         */
        private BeitragRechnung rechnung;

        /**
         * Anzahl erstellter Mahnungen.
         */
        private int mahnungen;

        /**
         * Frist der letzten Mahnung. Wird auf <tt>null</tt> gesetzt, falls noch
         * keine Mahnungen erstellt wurden.
         */
        private Date letzteFrist;

        /**
         * Vorname des Mitglieds.
         */
        private String vorname;

        /**
         * Nachname des Mitglieds.
         */
        private String nachname;
    }

    /**
     * Fragt alle Rechnungen aus der Datenbank ab, die den übergebenen Kriterien
     * entsprechen.
     * 
     * @param erstellungsjahr
     *            Legt fest, aus welchem Jahr die Rechnungen stammen sollen.
     *            Falls der Wert <tt>-1</tt> ist, wird nicht nach dem
     *            Erstellungsjahr der Rechnung gefiltert.
     * @param status
     *            Legt fest, welchen Status die Rechnung haben muss. Falls der
     *            Wert <tt>null</tt> ist, wird nicht nach dem Status gefiltert.
     * @param ueberfaellig
     *            Falls dieser Parameter gesetzt ist, werden nur überfällige
     *            Rechnungen geliefert. Dabei bedeutet überfällig, dass die
     *            Frist der Rechnung selbst (und ggf. die der letzten erstellte
     *            Mahnung) bereits verstrichen ist. Dieser Parameter macht nur
     *            dann Sinn, wenn der Status auf <tt>OFFEN</tt> gesetzt wird
     * @param mitgliedId
     *            Es werden nur Rechnungen für dieses Mitglied gefunden. Falls
     *            der Wert <tt>-1</tt> ist, wird nicht nach dem Mitglied
     *            gefiltert.
     * @return Rechnungen, die den Kriterien entsprechen
     */
    ArrayList<DataFindRechnungen> findRechnungen(
            @Param("erstellungsjahr") int erstellungsjahr,
            @Param("status") Rechnungsstatus status,
            @Param("ueberfaellig") boolean ueberfaellig,
            @Param("mitgliedId") int mitgliedId);

    /**
     * Fragt alle offenen Rechnungen an das Mitglied ab, die Buchungen aus dem
     * angefragten Halbjahr enthalten. Dabei wird als Rechnungsbetrag nur der
     * Betrag des betreffenden Halbjahres zurückgegeben.
     * 
     * @param halbjahr
     *            Halbjahr, dessen Buchungen betrachtet werden
     * @param mitgliedId
     *            Mitglied
     * @return Rechnungen, die den Kriterien entsprechen
     */
    ArrayList<BeitragRechnung> getOffeneRechnungenByHalbjahr(
            @Param("halbjahr") Halbjahr halbjahr,
            @Param("mitgliedId") int mitgliedId);

    /**
     * Beschreibt die zurückgegebenen Objekte bei der Abfrage der Posten einer
     * Rechnung.
     */
    @Getter
    public class DataListPosten {
        /**
         * Buchung, auf die sich der Posten bezieht.
         */
        private BeitragBuchung buchung;

        /**
         * Buchungstext auf der Rechnung.
         */
        private String buchungstext;
    }

    /**
     * Liefert die Posten aus der Datenbank, die zu einer Rechnung gehören.
     * 
     * @param rechnungId
     *            ID der Rechnung, deren Posten gesucht werden
     * @return Posten der Rechnung
     */
    ArrayList<DataListPosten> getPosten(int rechnungId);

    /**
     * Liefert alle Mahnungen, die zu einer Rechnung erstellt wurden.
     * 
     * @param rechnungId
     *            ID der Rechnung
     * @return Mahnungen, die sich auf die Rechnung beziehen
     */
    ArrayList<BeitragMahnung> getMahnungen(int rechnungId);

    /**
     * Beschreibt die zurückgegebenen Objekte bei der Abfrage der Betragssummen
     * für die Halbjahre.
     */
    @Getter
    public class DataHalbjahrBetraege {
        /**
         * Halbjahr.
         */
        private Halbjahr halbjahr;

        /**
         * Summe der Beträge für das Halbjahr.
         */
        private BigDecimal betrag;
    }

    /**
     * Liefert die Beträge der Posten einer Rechnung gruppiert nach dem
     * Halbjahr, dem sie zugeordnet sind.
     * 
     * @param rechnungId
     *            ID der Rechnung
     * @return Paare von Halbjahren und deren Betragssummen
     */
    ArrayList<DataHalbjahrBetraege> getHalbjahrBetraege(int rechnungId);

    /**
     * Fügt eine Mahnung in die Datenbank ein. Die generierte <tt>mahnungId</tt>
     * der neu eingefügten Rechnung ist anschließend im Objekt gespeichert, das
     * als Parameter übergeben wurde.
     * 
     * @param mahnung
     *            einzufügende Mahnung
     */
    void insertMahnung(BeitragMahnung mahnung);

    /**
     * Ergebnis-Datentyp, der verwendet wird, wenn eine Mahnung mit allen
     * Informationen aus der Datenbank geholt wird. Dabei wird die entsprechende
     * Rechnung und der Mitgliedsdatensatz (Name, Anschrift, usw.) mit
     * ausgelesen und außerdem eine Liste der vorherigen Mahnungen.
     */
    @Getter
    public class DataMahnungKomplett {
        private BeitragMahnung mahnung;
        private BeitragRechnung rechnung;
        private BeitragMitglied mitglied;
        private BeitragMahnung vorherigeMahnung;
    }

    /**
     * Holt eine Mahnung mit allen Informationen aus der Datenbank. Diese
     * enthalten die entsprechende Rechnung und den Mitgliedsdatensatz. Außerdem
     * werden alle vorherigen Mahnungen geliefert, d.h. diejenigen, bei denen
     * die mahnungArt geringer ist.
     * 
     * @param mahnungId
     *            ID der Mahnung
     * @return aller Informationen aus der Datenbank, die zur Mahnung gehören
     */
    DataMahnungKomplett getMahnungKomplett(int mahnungId);
}
src/nami/beitrag/letters/LetterGenerator.java
public class LetterGenerator {
    // Namen und Pfad zu den Template-Dateien
    private static final String TEMPLATE_RECHNUNGEN = "rechnung.vm";
    private static final String TEMPLATE_MAHNUNGEN = "mahnung.vm";
    private static final String TEMPLATE_PRENOTIFICATIONS = "prenotification.vm";
    private static final String PATH_TEMPLATES = LetterGenerator.class
            .getPackage().getName().replace(".", "/")
            + "/";

    private SqlSessionFactory sqlSessionFactory;
    private LetterDirectory dir;

    private String mRefPrefix;
    private String credId;

    private static Logger logger = Logger.getLogger(LetterGenerator.class
            .getName());

    // Globale Einstellungen für Velocity
    static {
        Velocity.setProperty("resource.loader", "class");
        Velocity.setProperty("class.resource.loader.class",
                "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
        Velocity.init();

    }

    /**
     * Erzeugt einen neuen Brief-Generator.
     * 
     * @param sqlSessionFactory
     *            Verbindung zur Datenbank, aus der die Daten geholt werden
     * @param dir
     *            Verzeichnis, in dem die erstellten Briefe (als
     *            LaTeX-Quelltexte) abgelegt werden
     * @param conf
     *            Konfiguration des Nami-Beitrags-Tools
     */
    public LetterGenerator(SqlSessionFactory sqlSessionFactory,
            LetterDirectory dir, NamiBeitragConfiguration conf) {
        this.sqlSessionFactory = sqlSessionFactory;
        this.dir = dir;
        mRefPrefix = conf.getSepaMRefPrefix();
        credId = conf.getSepaCreditorId();
    }

    private static Template getTemplate(String templateName) {
        return Velocity.getTemplate(PATH_TEMPLATES + templateName);
    }

    /**
     * Erzeugt einen einzelnen Brief. Die übergebenen Parameter werden teilweise
     * zur Erstellung des Dateinamens benötigt.
     * 
     * @param type
     *            Typ des Briefs (bestimmt u. a. die verwendete Vorlage und die
     *            Datenbank-Tabelle aus der die Daten geholt werden)
     * @param id
     *            ID in der jeweiligen Datenbank-Tabelle (z. B. rechnungId,
     *            mahnungId)
     * @param datum
     *            Datum, an dem der Brief versandt wird (nur für den Dateinamen)
     * @param nachname
     *            Nachname des Empfängers (nur für den Dateinamen)
     * @param vorname
     *            Vorname des Empfängers (nur für den Dateinamen
     * @return Brief-Objekt, das erstellt wurde (enthält briefId und Dateiname)
     */
    public BeitragBrief generateLetter(LetterType type, int id, Date datum,
            String nachname, String vorname) {
        LinkedList<Integer> ids = new LinkedList<Integer>();
        ids.add(id);
        File f = dir.createFilenameSingle(type, datum, nachname, vorname);
        return generateLetters(type, ids, datum, f);
    }

    /**
     * Erzeugt eine Sammlung von Briefen. Die übergebenen Parameter werden
     * teilweise zur Erstellung des Dateinamens benötigt.
     * 
     * @param type
     *            Typ der Briefe (bestimmt u. a. die verwendete Vorlage und die
     *            Datenbank-Tabelle aus der die Daten geholt werden)
     * @param ids
     *            IDs in der jeweiligen Datenbank-Tabelle (z. B. rechnungId,
     *            mahnungId)
     * @param datum
     *            Datum, an dem die Briefe versandt werden (nur für den
     *            Dateinamen)
     * @return erstelltes Brief-Objekt (enthält briefId und Dateiname)
     */
    public BeitragBrief generateLetters(LetterType type,
            Collection<Integer> ids, Date datum) {
        File f = dir.createFilenameMultiple(type, datum);
        return generateLetters(type, ids, datum, f);
    }

    /**
     * Erstellt den/die übergebenen Brief(e) in der angegebenen Datei.
     * 
     * @param type
     *            Typ der Briefe
     * @param ids
     *            IDs in der Datenbank
     * @param file
     *            Dateiname, unter dem die Briefe geschrieben werden
     * @return erstelltes Brief-Objekt (enthält briefId und Dateiname)
     */
    private BeitragBrief generateLetters(LetterType type,
            Collection<Integer> ids, Date datum, File file) {
        if (ids.size() < 1) {
            throw new IllegalArgumentException(
                    "Did not get any ids to generate letters");
        }

        FileWriter fileWriter;
        SqlSession session = sqlSessionFactory.openSession();
        try {
            fileWriter = new FileWriter(file);
            Writer w = new BufferedWriter(fileWriter);

            switch (type) {
            case RECHNUNG:
                generateRechnungen(ids, w);
                break;
            case MAHNUNG:
                generateMahnungen(ids, w);
                break;
            case PRENOTIFICATION:
                generatePrenotifications(ids, w);
                break;
            default:
                throw new IllegalArgumentException(
                        "Letter type not implemented: " + type);
            }
            w.close();

            if (file.exists() && file.length() > 0) {
                BeitragBrief brief = new BeitragBrief();
                brief.setDateiname(file.getName());
                brief.setDatum(datum);
                brief.setTyp(type);
                brief.setKompiliert(null);

                BriefeMapper mapper = session.getMapper(BriefeMapper.class);
                mapper.insertBrief(brief);
                session.commit();

                return brief;
            } else {
                logger.log(Level.SEVERE, "Did not write letter file");
                return null;
            }

        } catch (IOException e) {
            logger.log(Level.SEVERE, "Could not write letter file", e);
            return null;
        } finally {
            session.close();
        }
    }

    private void generateRechnungen(Collection<Integer> rechnungIds, Writer w) {
        SqlSession session = sqlSessionFactory.openSession();
        try {
            RechnungenMapper mapper = session.getMapper(RechnungenMapper.class);

            // Lade Rechnungen und zugehörige Buchungen aus Datenbank
            LinkedList<DataRechnungMitBuchungen> rechnungen = new LinkedList<>();
            for (int rechnungId : rechnungIds) {
                rechnungen.add(mapper.getRechnungMitBuchungen(rechnungId));
            }

            // Übergebe Daten an Velocity
            VelocityContext context = new VelocityContext();
            context.put("date", new DateTool());
            context.put("df", getCurrencyFormatter());
            context.put("rechnungen", rechnungen);

            // Template füllen
            Template template = getTemplate(TEMPLATE_RECHNUNGEN);
            template.merge(context, w);
        } finally {
            session.close();
        }
    }

    private void generateMahnungen(Collection<Integer> mahnungIds, Writer w) {
        SqlSession session = sqlSessionFactory.openSession();
        try {
            RechnungenMapper mapper = session.getMapper(RechnungenMapper.class);

            // Lade Rechnungen und zugehörige Buchungen aus Datenbank
            LinkedList<DataMahnungKomplett> mahnungen = new LinkedList<>();
            for (int mahnungId : mahnungIds) {
                mahnungen.add(mapper.getMahnungKomplett(mahnungId));
            }

            // Übergebe Daten an Velocity
            VelocityContext context = new VelocityContext();
            context.put("date", new DateTool());
            context.put("df", getCurrencyFormatter());
            context.put("mahnungen", mahnungen);

            // Template füllen
            Template template = getTemplate(TEMPLATE_MAHNUNGEN);
            template.merge(context, w);
        } finally {
            session.close();
        }
    }

    private void generatePrenotifications(
            Collection<Integer> prenotificationIds, Writer w) {
        SqlSession session = sqlSessionFactory.openSession();
        try {
            LastschriftenMapper mapper = session
                    .getMapper(LastschriftenMapper.class);

            // Lade Rechnungen und zugehörige Buchungen aus Datenbank
            LinkedList<DataPrenotificationMandat> prenots = new LinkedList<>();
            for (int prenotId : prenotificationIds) {
                prenots.add(mapper.getPrenotificationMitMandat(prenotId));
            }

            // Übergebe Daten an Velocity
            VelocityContext context = new VelocityContext();
            context.put("date", new DateTool());
            context.put("df", getCurrencyFormatter());
            context.put("prenots", prenots);
            context.put("creditorId", credId);
            context.put("mrefPrefix", mRefPrefix);

            // Template füllen
            Template template = getTemplate(TEMPLATE_PRENOTIFICATIONS);
            template.merge(context, w);
        } finally {
            session.close();
        }
    }

    private DecimalFormat getCurrencyFormatter() {
        DecimalFormatSymbols sym = new DecimalFormatSymbols(Locale.GERMAN);
        return new DecimalFormat("#,##0.00", sym);
    }
}
src/nami/beitrag/db/BeitragSammelLastschrift.java
@Data
public class BeitragSammelLastschrift {
    private int sammelLastschriftId;
    private Date faelligkeit;
    private boolean ausgefuehrt;
    private String bezeichnung;

    // Die folgenden Felder sind nicht direkt in der Datenbank gespeichert
    @Setter(AccessLevel.NONE)
    private int anzahlLastschriften;
    @Setter(AccessLevel.NONE)
    private BigDecimal betrag;
    @Setter(AccessLevel.NONE)
    private boolean alleGueltig;
}
src/nami/beitrag/Rechnungsstatus.java
public enum Rechnungsstatus {
    /**
     * Die Rechnung wurde erstellt, aber noch nicht bezahlt.
     */
    OFFEN,
    /**
     * Die Rechnung wurde bezahlt.
     */
    BEGLICHEN,
    /**
     * Die Rechnung wurde noch nicht bezahlt und man kann nicht davon ausgehen,
     * dass sie noch bezahlt wird.
     */
    ABGESCHRIEBEN
}
src/nami/beitrag/db/BeitragLastschrift.java
@Data
public class BeitragLastschrift {
    private int lastschriftId;
    private int sammelLastschriftId;
    private int mandatId;
    private String verwendungszweck;

    // Die folgenden Felder sind nicht direkt in der Datenbank gespeichert,
    // sondern werden bei der Abfrage berechnet.
    @Setter(AccessLevel.NONE)
    private BigDecimal betrag;
}
src/nami/beitrag/db/DataLastschriftMandat.java
@Getter
public class DataLastschriftMandat {
    private BeitragLastschrift lastschrift;
    private BeitragSepaMandat mandat;
}
src/nami/beitrag/gui/utils/DisabledCellRenderer.java
public class DisabledCellRenderer extends DefaultTableCellRenderer {
    private static final long serialVersionUID = -4317607684491411756L;

    @Override
    public Component getTableCellRendererComponent(JTable table,
            Object value, boolean isSelected, boolean hasFocus, int row,
            int column) {

        TableCellRenderer renderer = table.getDefaultRenderer(table
                .getColumnClass(column));
        Component c = renderer.getTableCellRendererComponent(table, value,
                isSelected, hasFocus, row, column);

        // Deaktiviert die Komponente, falls das Feld nicht bearbeitbar ist
        if (!table.isCellEditable(row, column)) {
            c.setEnabled(false);
        }

        return c;
    }
}
src/nami/beitrag/db/RechnungenMapper.java
@Getter
public class DataHalbjahrBetraege {
    /**
     * Halbjahr.
     */
    private Halbjahr halbjahr;

    /**
     * Summe der Beträge für das Halbjahr.
     */
    private BigDecimal betrag;
}
src/nami/beitrag/db/LastschriftenMapper.java
public interface LastschriftenMapper {

    /**
     * Beschreibt Filterkriterien für die Suche nach Mandaten und Buchungen.
     */
    @Data
    public static class FilterSettings {
        /**
         * Dieser Parameter filtert die Rechnungen nach dem Erstellungsdatum.
         * Wenn dieser Parameter <tt>null</tt> ist, wird nicht nach dem
         * Rechnungsdatum gefiltert.
         */
        private Date rechnungsdatum = null;

        /**
         * Gibt an, ob auch Rechnungen selektiert werden, für die bereits eine
         * Lastschrift erstellt wurde.
         */
        private boolean bereitsErstellt;
    }

    /**
     * Ergebnis-Datentyp bei der Suche nach Mandaten und Rechnungen, die vom
     * jeweiligen Mandat eingezogen werden können.
     */
    @Getter
    public static class DataMandateRechnungen {
        private BeitragSepaMandat mandat;
        private List<DataRechnungMitglied> rechnungen;
    }

    /**
     * Fasst ein Mitglied und eine Rechnung zusammen.
     */
    @Getter
    public static class DataRechnungMitglied {
        private BeitragMitglied mitglied;
        private BeitragRechnung rechnung;
    }

    /**
     * Liefert alle offenen Rechnungen und die zugehörigen aktiven, gültigen
     * Mandate, die die übergebenen Filterkriterien erfüllen.
     * 
     * @param filterSettings
     *            Kriterien nach denen gefiltert wird
     * @return Mandate und jeweils offene Rechnungen
     */
    Collection<DataMandateRechnungen> mandateOffeneRechnungen(
            @Param("filterSettings") FilterSettings filterSettings);

    /**
     * Fügt eine Lastschrift in die Datenbank ein. Die <tt>lastschriftId</tt>
     * der neu eingefügten Lastschrift ist anschließend im Objekt gespeichert,
     * das als Parameter übergeben wurde.
     * 
     * @param lastschrift
     *            Daten der einzufügenden Lastschrift
     */
    void insertLastschrift(BeitragLastschrift lastschrift);

    /**
     * Löscht eine Lastschrift aus der Datenbank. Die enthaltenen Rechnungen
     * sollten vorher schon gelöscht worden seien (siehe
     * {@link #deleteAllRechnungenFromLastschrift(int)}).
     * 
     * @param lastschriftId
     *            ID der Lastschrift, die gelöscht werden soll
     */
    void deleteLastschrift(int lastschriftId);

    /**
     * Fügt eine Rechnung zu einer Lastschrift hinzu, d. h. diese Rechnung wird
     * mit der jeweiligen Lastschrift eingezogen.
     * 
     * @param lastschriftId
     *            ID der Lastschrift
     * @param rechnungId
     *            ID der Rechnung
     */
    void addRechnungToLastschrift(@Param("lastschriftId") int lastschriftId,
            @Param("rechnungId") int rechnungId);

    /**
     * Löscht alle Rechnungen aus einer Lastschrift. Die Rechnungen werden dabei
     * in der Datenbank belassen, nur ihre Verbindungen zur Lastschrift werden
     * entfernt.
     * 
     * @param lastschriftId
     *            ID der Lastschrift
     */
    void deleteAllRechnungenFromLastschrift(int lastschriftId);

    /**
     * Fügt eine Sammellastschrift in die Datenbank ein. Die
     * <tt>sammelLastschriftId</tt> der neu eingefügten Lastschrift ist
     * anschließend im Objekt gespeichert, das als Parameter übergeben wurde.
     * 
     * @param sammelLastschrift
     *            Daten der einzufügenden Sammellastschrift
     */
    void insertSammelLastschrift(BeitragSammelLastschrift sammelLastschrift);

    /**
     * Aktualisiert den Datensatz einer Sammellastschrift.
     * 
     * @param sammelLastschrift
     *            Objekt, dessen geänderte Felder in die Datenbank gespeichert
     *            werden sollen
     */
    void updateSammelLastschrift(BeitragSammelLastschrift sammelLastschrift);

    /**
     * Löscht eine Sammellastschrift aus der Datenbank. Die enthaltenen
     * Lastschriften sollten vorher schon gelöscht worden seien.
     * 
     * @param sammelLastschriftId
     *            ID der Sammellastschrift
     */
    void deleteSammelLastschrift(int sammelLastschriftId);

    /**
     * Fragt alle Sammellastschriften (inkl. der Anzahl der enthaltenen
     * Einzellastschriften und des Gesamtbetrages) aus der Datenbank ab, die dem
     * übergebenen Filterkriterium entsprechen.
     * 
     * @param ausgefuehrt
     *            Gibt an, ob ausgeführte Sammellastschriften angezeigt werden
     *            sollen.
     *            <ul>
     *            <li><tt>True</tt>: nur ausgeführte werden angezeigt</li>
     *            <li><tt>False</tt>: nur <em>nicht</em> ausgeführte werden
     *            angezeigt</li>
     *            <li><tt>null</tt>: Filterkriterium wird ignoriert</li>
     *            </ul>
     * @return Sammellastschriften, die dem angegebenen Filterkriterium
     *         entsprechen
     */
    ArrayList<BeitragSammelLastschrift> findSammelLastschriften(
            @Param("ausgefuehrt") Boolean ausgefuehrt);

    /**
     * Liefert alle Lastschriften (inkl. der zugehörigen Mandate), die in einer
     * Sammellastschrift enthalten sind.
     * 
     * @param sammelLastschriftId
     *            ID der Sammellastschrift
     * @return enthaltenen (Einzel-)Lastschriften
     */
    ArrayList<DataLastschriftMandat> getLastschriften(int sammelLastschriftId);

    /**
     * Liefert alle Rechnungen, die in einer Sammellastschrift enthalten sind.
     * Das heißt es werden die zugeordneten Rechnungen aller enthaltenen
     * Einzellastschriften vereinigt.
     * 
     * @param sammelLastschriftId
     *            ID der Sammellastschrift
     * @return zugeordnete Rechnungen
     */
    List<BeitragRechnung> getRechnungenInSammelLastschrift(
            int sammelLastschriftId);

    /**
     * Fügt eine Prenotification in die Datenbank ein. Die
     * <tt>prenotificationId</tt> der neu eingefügten Prenotification ist
     * anschließend im Objekt gespeichert, das als Parameter übergeben wurde.
     * 
     * @param pre
     *            Daten der einzufügenden Prenotification
     */
    void insertPrenotification(BeitragPrenotification pre);

    /**
     * Überprüft, ob die aktuellste (nach Ausstellungsdatum), als regelmäßig
     * gekennzeichnete Prenotification im Betrag mit den Parametern
     * übereinstimmt. In diesem Fall muss also keine neue erstellt werden.
     * 
     * @param mandatId
     *            ID des Mandats
     * @param betrag
     *            benötigter Lastschriftbetrag
     * @return <tt>true</tt>, falls die aktuellste Prenotification den passenden
     *         Betrag enthält
     */
    boolean existsValidPrenotification(@Param("mandatId") int mandatId,
            @Param("betrag") BigDecimal betrag);

    /**
     * Fasst eine Prenotification und das dazugehörige Mandat zusammen.
     */
    @Getter
    public class DataPrenotificationMandat {
        private BeitragPrenotification prenotification;
        private BeitragSepaMandat mandat;
    }

    /**
     * Liefert eine Prenotification und das dazugehörige Mandat.
     * 
     * @param prenotificationId
     *            ID der Prenotification
     * @return Prenotification mit Mandat
     */
    DataPrenotificationMandat getPrenotificationMitMandat(int prenotificationId);
}
src/nami/beitrag/hibiscus/HibiscusExporter.java
public class HibiscusExporter {
    // URL zur Kontaktaufnahme zu Hibiscus
    private String url;
    // ID (Hibiscus-Intern) des Kontos, für das die Lastschriften eingefügt
    // werden
    private String kontoId;
    // Gläubiger-ID des Zahlungsempfängers
    private String creditorId;
    // Verwendeter Lastschrifttyp (CORE oder COR1)
    private String sepatype;
    // Präfix, das in jeder Mandatsreferenz vor der Mandats-ID eingefügt wird
    private String mrefPrefix;

    private SqlSessionFactory sqlSessionFactory;

    private static Logger logger = Logger.getLogger(HibiscusExporter.class
            .getName());

    // Werden von den statischen Methoden verwendet, um Daten und Geldbeträge zu
    // formatieren
    // Sollten nur synchronized verwendet werden
    private static DateFormat formatter = DateFormat
            .getDateInstance(DateFormat.MEDIUM);
    private static DecimalFormat germanDecimalFormat;

    static {
        NumberFormat nf = NumberFormat.getNumberInstance(Locale.GERMAN);
        nf.setGroupingUsed(false);
        germanDecimalFormat = (DecimalFormat) nf;
    }

    /**
     * Erzeugt einen neuen Exporter.
     * 
     * @param conf
     *            Konfiguration der Beitrags-Tools
     * @param sqlSessionFactory
     *            Verbindung zur SQL-Datenbank.
     */
    public HibiscusExporter(NamiBeitragConfiguration conf,
            SqlSessionFactory sqlSessionFactory) {
        creditorId = conf.getSepaCreditorId();
        sepatype = conf.getSepaType();
        mrefPrefix = conf.getSepaMRefPrefix();
        kontoId = conf.getHibiscusKontoId();
        url = conf.getHibiscusUrl();

        this.sqlSessionFactory = sqlSessionFactory;
    }

    /**
     * Übergibt eine einzelne SEPA-Lastschrift an Hibiscus.
     * 
     * @param lastschriftMandat
     *            Daten der Lastschrift (inkl. Betrag) und des Mandats
     * @param faelligkeit
     *            Fälligkeitstermin, zu dem die Lastschrift belastet wird
     * @return <tt>true</tt>, falls die Lastschrift erfolgreich an Hibiscus
     *         übergeben wurde. Andernfalls werden Informationen zum Fehler auf
     *         dem Logger ausgegeben.
     */
    public boolean exportLastschrift(DataLastschriftMandat lastschriftMandat,
            Date faelligkeit) {
        BeitragLastschrift lastschrift = lastschriftMandat.getLastschrift();
        BeitragSepaMandat mandat = lastschriftMandat.getMandat();

        SqlSession session = sqlSessionFactory.openSession();
        try {

            // Client-Config erzeugen
            XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
            // config.setBasicPassword(<Master-Passwort>);
            // config.setBasicUserName("admin");
            config.setServerURL(new URL(url));
            config.setEnabledForExtensions(true);
            config.setEncoding("ISO-8859-1");

            XmlRpcClient client = new XmlRpcClient();
            client.setConfig(config);

            // Sequenztyp bestimmen (dazu wird überprüft, ob bereits eine
            // Lastschrift von diesem Mandat gezogen wurde)
            MandateMapper mapper = session.getMapper(MandateMapper.class);
            String sequenceType;
            if (mapper.isMandatUsed(mandat.getMandatId())) {
                sequenceType = "RCUR";
            } else {
                sequenceType = "FRST";
            }

            // Objekt zur Übergabe an Hibiscus vorbereiten
            Map<String, String> params = new HashMap<>();
            params.put("konto", kontoId);
            params.put("termin", formatDate(faelligkeit));
            params.put("blz", mandat.getBic());
            params.put("kontonummer", mandat.getIban());
            params.put("name",
                    MyStringUtils.replaceUmlauts(mandat.getKontoinhaber()));
            params.put("betrag", formatBetrag(lastschrift.getBetrag().negate()));
            params.put("verwendungszweck", MyStringUtils
                    .replaceUmlauts(lastschrift.getVerwendungszweck()));
            params.put("mandateid",
                    mrefPrefix + Integer.toString(mandat.getMandatId()));
            params.put("creditorid", creditorId);
            params.put("sigdate", formatter.format(mandat.getDatum()));
            params.put("sequencetype", sequenceType);
            params.put("sepatype", sepatype);
            params.put("targetdate", formatDate(faelligkeit));

            // Aufruf der RPC-Funktion
            Object result = client.execute(
                    "hibiscus.xmlrpc.sepalastschrift.create",
                    new Object[] { params });

            // Rückgabe überprüfen
            if (result != null) {
                logger.log(
                        Level.WARNING,
                        "Fehler beim Senden an Hibiscus (Mandat-ID "
                                + mandat.getMandatId() + ", Kontoinhaber "
                                + mandat.getKontoinhaber() + "): " + result);
                return false;
            }

            return true;
        } catch (MalformedURLException e) {
            logger.log(Level.SEVERE, "Invalid URL for Hibiscus export", e);
        } catch (XmlRpcException e) {
            logger.log(Level.SEVERE,
                    "Error in XML-RPC call for Hibiscus export", e);
        } finally {
            session.close();
        }

        return false;
    }

    /**
     * Übergibt eine Reihe von Lastschriften als Sammellastschrift an Hibiscus.
     * Möglicherweise entstehen dabei zwei Sammellastschriften, da FRST- und
     * RCUR-Buchungen getrennt werden müssen (in jeder Sammellastschrift kann
     * nur einer der Sequenztypen vorkommen).
     * 
     * @param lastschriften
     *            zu exportierende Lastschriften
     * @param sl
     *            Sammellastschrift (aus dieser werden Fälligkeitsdatum und
     *            Bezeichnung entnommen)
     * @return <tt>true</tt>, falls alle Lastschriften erfolgreich an Hibiscus
     *         übergeben wurden. Andernfalls werden Informationen zum Fehler auf
     *         dem Logger ausgegeben.
     */
    public boolean exportSammellastschrift(
            List<DataLastschriftMandat> lastschriften,
            BeitragSammelLastschrift sl) {

        // Gibt an, ob bisher alle Sammellastschriften erfolgreich an Hibiscus
        // übergeben wurden
        boolean allSuccessful = true;

        SqlSession session = sqlSessionFactory.openSession();
        try {
            // Client-Config erzeugen
            XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
            // config.setBasicPassword(<Master-Passwort>);
            // config.setBasicUserName("admin");
            config.setServerURL(new URL(url));
            config.setEnabledForExtensions(true);
            config.setEncoding("ISO-8859-1");

            XmlRpcClient client = new XmlRpcClient();
            client.setConfig(config);

            List<Map<String, Object>> buchungenRcur = new LinkedList<>();
            List<Map<String, Object>> buchungenFrst = new LinkedList<>();

            MandateMapper mapper = session.getMapper(MandateMapper.class);
            for (DataLastschriftMandat ls : lastschriften) {
                BeitragLastschrift lastschrift = ls.getLastschrift();
                BeitragSepaMandat mandat = ls.getMandat();
                Map<String, Object> params = new HashMap<>();
                params.put("blz", mandat.getBic());
                params.put("kontonummer", mandat.getIban());
                params.put("name",
                        MyStringUtils.replaceUmlauts(mandat.getKontoinhaber()));
                params.put("betrag", formatBetrag(lastschrift.getBetrag()
                        .negate()));
                params.put("verwendungszweck", MyStringUtils
                        .replaceUmlauts(lastschrift.getVerwendungszweck()));
                params.put("mandateid",
                        mrefPrefix + Integer.toString(mandat.getMandatId()));
                params.put("creditorid", creditorId);
                params.put("sigdate", formatDate(mandat.getDatum()));

                // Sequenztyp bestimmen (dazu wird überprüft, ob bereits eine
                // Lastschrift von diesem Mandat gezogen wurde)
                if (mapper.isMandatUsed(ls.getMandat().getMandatId())) {
                    buchungenRcur.add(params);
                } else {
                    buchungenFrst.add(params);
                }
            }

            // Objekt zur Übergabe an Hibiscus vorbereiten
            Map<String, Object> params = new HashMap<>();
            params.put("konto", kontoId);
            params.put("termin", formatDate(sl.getFaelligkeit()));
            params.put("sepatype", sepatype);
            params.put("targetdate", formatDate(sl.getFaelligkeit()));

            if (!buchungenFrst.isEmpty()) {
                params.put("name", "FRST - " + sl.getBezeichnung());
                params.put("sequencetype", "FRST");
                params.put("buchungen", buchungenFrst);

                // Aufruf der RPC-Funktion
                Object result = client.execute(
                        "hibiscus.xmlrpc.sepasammellastschrift.create",
                        new Object[] { params });

                // Rückgabe überprüfen
                if (result != null) {
                    logger.log(Level.WARNING,
                            "Fehler beim Senden an Hibiscus (FRST): " + result);
                    allSuccessful = false;
                }
            }

            if (!buchungenRcur.isEmpty()) {
                params.put("name", "RCUR - " + sl.getBezeichnung());
                params.put("sequencetype", "RCUR");
                params.put("buchungen", buchungenRcur);

                // Aufruf der RPC-Funktion
                Object result = client.execute(
                        "hibiscus.xmlrpc.sepasammellastschrift.create",
                        new Object[] { params });

                // Rückgabe überprüfen
                if (result != null) {
                    logger.log(Level.WARNING,
                            "Fehler beim Senden an Hibiscus (RCUR): " + result);
                    allSuccessful = false;
                }
            }

            return allSuccessful;
        } catch (MalformedURLException e) {
            logger.log(Level.SEVERE, "Invalid URL for Hibiscus export", e);
        } catch (XmlRpcException e) {
            logger.log(Level.SEVERE,
                    "Error in XML-RPC call for Hibiscus export", e);
        } finally {
            session.close();
        }
        return false;
    }

    /**
     * Formatiert das übergebene Datum so, wie es Hibiscus erwartet.
     * 
     * @param date
     *            zu formatierendes Datum
     * @return formatiertes Datum
     */
    private static synchronized String formatDate(Date date) {
        return formatter.format(date);
    }

    /**
     * Formatiert den übergebenen Betrag so, wie ihn Hibiscus erwartet. Das
     * heißt mit einem Komma als Dezimaltrennzeichen und ohne
     * Zifferngruppierung.
     * 
     * @param betrag
     *            zu formatierender Betrag
     * @return formatierter Betrag
     */
    private static synchronized String formatBetrag(BigDecimal betrag) {
        return germanDecimalFormat.format(betrag);
    }
}
src/nami/beitrag/letters/LetterType.java
public enum LetterType {
    /**
     * Rechnung.
     */
    RECHNUNG("rechnung", "rechnungen"),

    /**
     * Mahnung.
     */
    MAHNUNG("mahnung", "mahnungen"),

    /**
     * SEPA-Prenotification.
     */
    PRENOTIFICATION("prenotification", "prenotifications");

    private String filenamePart;
    private String filenamePartPlural;

    private LetterType(String filenamePart, String filenamePartPlural) {
        this.filenamePart = filenamePart;
        this.filenamePartPlural = filenamePartPlural;
    }

    /**
     * Liefert den String, der für diesen Brieftyp im Dateinamen verwendet wird.
     * 
     * @return Bestandteil für Dateinamen im Singular
     */
    public String getFilenamePart() {
        return filenamePart;
    }

    /**
     * Liefert den String, der für diesen Brieftyp im Dateinamen verwendet wird,
     * wenn mehrere Briefe in der Datei enthalten sind.
     * 
     * @return Bestandteil für Dateinamen im Plural
     */
    public String getFilenamePartPlural() {
        return filenamePartPlural;
    }
}
src/nami/beitrag/NamiBeitragConfiguration.java
@Getter
public class NamiBeitragConfiguration {
    private String gruppierungsnummer;
    private Properties databaseConfig;
    private Map<Beitragsart, BigDecimal> beitragssaetze;

    private String sepaCreditorId;
    private String sepaType;
    private String sepaMRefPrefix;
    private String hibiscusUrl;
    private String hibiscusKontoId;

    private String pdfViewer;
    private String letterOutputPath;

    private static Logger log = Logger.getLogger(NamiBeitragConfiguration.class
            .getName());
    private static final URL XSDFILE = NamiBeitragConfiguration.class
            .getResource("namibeitrag.xsd");

    /**
     * Lädt die Konfiguration aus der übergebenen Konfigurationsdatei.
     * 
     * @param configFile
     *            Konfigurationsdatei im XML-Format
     * @throws ConfigFormatException
     *             wenn ein Fehler beim Lesen oder Parsen der
     *             Konfigurationsdatei auftritt
     */
    public NamiBeitragConfiguration(File configFile)
            throws ConfigFormatException {
        // Lese Konfigurationsdatei ein (inkl. Validierung)
        Document doc;
        try {
            XMLReaderJDOMFactory schemafac = new XMLReaderXSDFactory(XSDFILE);
            SAXBuilder builder = new SAXBuilder(schemafac);

            log.info("Using Beitrag config file: "
                    + configFile.getAbsolutePath());
            if (!configFile.exists() || !configFile.canRead()) {
                throw new ConfigFormatException("Cannot read config file");
            }
            doc = builder.build(configFile);
        } catch (JDOMException e) {
            throw new ConfigFormatException("Could not parse config file", e);
        } catch (IOException e) {
            throw new ConfigFormatException("Could not read config file", e);
        }

        // Parse Konfiguration aus XML
        Element namibeitragEl = doc.getRootElement();
        if (namibeitragEl.getName() != "namibeitrag") {
            throw new ConfigFormatException("Wrong root element in config file");
        }

        gruppierungsnummer = namibeitragEl
                .getAttributeValue("gruppierungsnummer");

        // Datenbankverbindung aus XML lesen
        Element databaseEl = namibeitragEl.getChild("database");
        databaseConfig = new Properties();
        databaseConfig.setProperty("driver", databaseEl.getChildText("driver"));
        databaseConfig.setProperty("url", databaseEl.getChildText("url"));
        databaseConfig.setProperty("username",
                databaseEl.getChildText("username"));
        databaseConfig.setProperty("password",
                databaseEl.getChildText("password"));

        // Beitragssätze aus XML einlesen
        Element beitragssaetzeEl = namibeitragEl.getChild("beitragssaetze");
        beitragssaetze = new HashMap<>();
        for (Element satzEl : beitragssaetzeEl.getChildren("beitragssatz")) {
            String typStr = satzEl.getAttributeValue("typ");
            Beitragsart typ = Beitragsart.fromString(typStr);
            String betragStr = satzEl.getAttributeValue("betrag");
            BigDecimal betrag = new BigDecimal(betragStr);

            beitragssaetze.put(typ, betrag);
        }

        // SEPA-Parameter einlesen
        Element sepaEl = namibeitragEl.getChild("sepa");
        sepaCreditorId = sepaEl.getChildText("creditorId");
        sepaType = sepaEl.getChildText("lastschriftType");
        if (sepaType == null || sepaType.isEmpty()) {
            sepaType = "CORE";
        }
        sepaMRefPrefix = sepaEl.getChildText("mrefPrefix");
        if (sepaMRefPrefix == null) {
            sepaMRefPrefix = "";
        }
        hibiscusUrl = sepaEl.getChildText("hibiscusUrl");
        hibiscusKontoId = sepaEl.getChildText("hibiscusKontoId");

        pdfViewer = namibeitragEl.getChildText("pdfViewer");
        letterOutputPath = namibeitragEl.getChildText("letterOutputPath");
    }
}
src/nami/beitrag/Buchungstyp.java
public enum Buchungstyp {
    /**
     * Beitrag, der von der Bundesebene für ein Mitglied berechnet wird.
     */
    RECHNUNG_BUNDESEBENE,

    /**
     * Gutschrift die von Bundesebene für ein Mitglied erstellt wird.
     */
    GUTSCHRIFT_BUNDESEBENE,

    /**
     * Überweisung (eingehend oder ausgehend), die von einem oder an ein
     * Mitglied erfolgt.
     */
    UEBERWEISUNG,

    /**
     * Lastschrift, die von einem Mitglied gezogen wird.
     */
    LASTSCHRIFT,

    /**
     * Rücklastschrift, die durch ein Mitglied (bzw. dessen Bank) veranlasst
     * wird.
     */
    RUECKLASTSCHRIFT,

    /**
     * Barzahlung, die von einem Mitglied entgegengenommen wird.
     */
    BAR,

    /**
     * Gutschrift, die ohne Gegenleistung des Mitglieds erfolgt, also Erlass
     * eines Mitgliedsbeitrages.
     */
    ERLASS,

    /**
     * Belastung eines Mitglieds-Kontos (z. B. mit Auslagen für Mahnungen,
     * Gebühren für Rücklastschrift).
     */
    BELASTUNG;
}
src/nami/beitrag/db/BeitragMapper.java
public interface BeitragMapper {
    /**
     * Liefert den Datensatz eines Mitglieds.
     * 
     * @param mitgliedId
     *            ID des Mitglieds
     * @return kompletter Datensatz des Mitglieds
     */
    BeitragMitglied getMitglied(int mitgliedId);

    /**
     * Liefert den Datensatz eines Mitglieds.
     * 
     * @param mitgliedsnummer
     *            Mitgliedsnummer
     * @return kompletter Datensatz des Mitglieds
     */
    BeitragMitglied getMitgliedByNummer(int mitgliedsnummer);

    /**
     * Liefert die Mitglieds-IDs, die in der Datenbank vorhanden sind.
     * 
     * @return vorhandene Mitglieds-IDs
     */
    Set<Integer> getMitgliedIds();

    /**
     * Fügt ein Mitglied in die Datenbank ein. Die Mitglieds-ID muss gesetzt
     * sein.
     * 
     * @param mgl
     *            Mitglieds-Datensatz, der in die Datenbank geschrieben werden
     *            soll
     */
    void insertMitglied(BeitragMitglied mgl);

    /**
     * Aktualisiert ein Mitglied in der Datenbank. Der Datensatz wird anhand der
     * Mitglieds-ID identifiziert.
     * 
     * @param mgl
     *            Mitglieds-Datensatz, der in die Datenbank geschrieben werden
     *            soll
     */
    void updateMitglied(BeitragMitglied mgl);

    /**
     * Fragt ab, ob ein Mitglied in der Datenbank als 'deleted' markiert ist.
     * 
     * @param mitgliedsId
     *            ID des Mitglieds
     * @return <tt>true</tt>, falls das Mitglied als gelöscht markiert ist
     */
    boolean isDeleted(int mitgliedsId);

    /**
     * Markiert ein Mitglied in der Datenbank als 'deleted'.
     * 
     * @param mitgliedsId
     *            ID des Mitglieds
     */
    void setDeleted(int mitgliedsId);

    /**
     * Findet alle Mitglieder in der lokalen Datenbank, die den Suchkriterien
     * entsprechen.
     * 
     * @param mitgliedsnummer
     *            gesuchte Mitgliedsnummer; <tt>null</tt> bzw. der leere String
     *            werden ignoriert; ansonsten wird exakt verglichen
     *            (SQL-Operator =)
     * @param vorname
     *            gesuchter Vorname; <tt>null</tt> bzw. der leere String werden
     *            ignoriert; ansonsten wird mittels LIKE verglichen
     * @param nachname
     *            gesuchter Nachname; <tt>null</tt> bzw. der leere String werden
     *            ignoriert; ansonsten wird mittels LIKE verglichen
     * @return Mitglieder, die den Kriterien entsprechen
     */
    Collection<BeitragMitglied> findMitglieder(
            @Param("mitgliedsnummer") String mitgliedsnummer,
            @Param("vorname") String vorname, @Param("nachname") String nachname);

    /**
     * Liefert einen Buchungs-Datensatz aus der Datenbank.
     * 
     * @param buchungId
     *            ID der Buchung in der lokalen Datenbank
     * @return Datensatz der Buchung; <tt>null</tt>, falls keine Buchung mit der
     *         ID existiert
     */
    BeitragBuchung getBuchungById(int buchungId);

    /**
     * Liefert einen Buchungs-Datensatz aus der Datenbank.
     * 
     * @param namiBuchungId
     *            ID der Buchung in NaMi
     * @return Datensatz der Buchung; <tt>null</tt>, falls keine Buchung mit der
     *         ID existiert
     */
    BeitragBuchung getBuchungByNamiId(int namiBuchungId);

    /**
     * Gibt die Anzahl von Buchungen für das angegebene Mitglied und Halbjahr
     * an, die als RECHNUNG_BUNDESEBENE markiert sind.
     * 
     * @param halbjahr
     *            Halbjahr
     * @param mitgliedId
     *            ID des Mitglieds
     * @return Anzahl der gefundenen Buchungen
     */
    int checkForRechnungBundesebene(@Param("halbjahr") Halbjahr halbjahr,
            @Param("mitgliedId") int mitgliedId);

    /**
     * Löscht alle Buchungen für das angegebene Mitglied und Halbjahr, die als
     * Vorausberechnung markiert sind.
     * 
     * @param halbjahr
     *            Halbjahr
     * @param mitgliedId
     *            ID des Mitglieds
     * @deprecated Sollte nicht verwendet werden, da eine Buchung ggf. auch auf
     *             einer Rechnung enthalten sein kann. Verwende stattdessen
     *             {@link #storniereVorausberechnung(Halbjahr, int)}.
     */
    void deleteVorausberechnung(@Param("halbjahr") Halbjahr halbjahr,
            @Param("mitgliedId") int mitgliedId);

    /**
     * Storniert alle Buchungen für das angegebene Mitglied und Halbjahr, die
     * als Vorausberechnung markiert sind.
     * 
     * @param halbjahr
     *            Halbjahr
     * @param mitgliedId
     *            ID des Mitglieds
     */
    void storniereVorausberechnung(@Param("halbjahr") Halbjahr halbjahr,
            @Param("mitgliedId") int mitgliedId);

    /**
     * Storniert alle Buchungen im angegebenen Halbjahr, die als
     * Vorausberechnung markiert sind.
     * 
     * @param halbjahr
     *            Halbjahr
     */
    void storniereVorausberechnungen(@Param("halbjahr") Halbjahr halbjahr);

    /**
     * Fügt einen Buchungs-Datensatz in die Datenbank ein.
     * 
     * @param buchung
     *            die einzufügende Buchung
     */
    void insertBuchung(BeitragBuchung buchung);

    /**
     * Liefert für jedes Halbjahr die Summe aller Buchungen für ein bestimmtes
     * Mitglied.
     * 
     * @param mitgliedId
     *            Mitglied, für das die Buchungen abgefragt werden
     * @return für jedes Halbjahr die Summe der Buchungsbeträge und Anzahl der
     *         Buchungen
     */
    Collection<ZeitraumSaldo> getSaldoPerHalbjahr(int mitgliedId);

    /**
     * Liefert alle Buchungen, die den Kriterien entsprechen.
     * 
     * @param halbjahr
     *            Halbjahr, in dem die Buchung liegt
     * @param mitgliedId
     *            Mitglied, dem die Buchung zugeordnet ist
     * @return Buchungen des Mitglieds im Halbjahr
     */
    Collection<BeitragBuchung> getBuchungenByHalbjahr(
            @Param("halbjahr") Halbjahr halbjahr,
            @Param("mitgliedId") int mitgliedId);

    /**
     * Prüft, ob für das angegebene Halbjahr eine Vorausberechnung für die
     * Bundesebenen-Rechnung existiert.
     * 
     * @param halbjahr
     *            Halbjahr
     * @param mitgliedId
     *            ID des Mitglieds
     * @return <tt>true</tt>, falls eine nicht stornierte Vorausberechnung mit
     *         Typ RECHNUNG_BUNDESEBENE für das angegebene Mitglied und Halbjahr
     *         existiert
     */
    boolean hasVorausberechnungBundesebene(
            @Param("halbjahr") Halbjahr halbjahr,
            @Param("mitgliedId") int mitgliedId);

    /**
     * Holt einen Zeitraum aus der Datenbank.
     * 
     * @param halbjahr
     *            Das Halbjahr, zu dem der entsprechende Zeitraum aus der
     *            Datenbank geholt werden soll
     * @return vollständiger Zeitraum-Datensatz
     */
    BeitragZeitraum getZeitraum(Halbjahr halbjahr);

    /**
     * Fügt einen Zeitraum in die Datenbank ein.
     * 
     * @param zeitraum
     *            einzufügender Zeitraum
     */
    void insertZeitraum(BeitragZeitraum zeitraum);

}


Question: import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.border.EmptyBorder;
import javax.swing.border.TitledBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.AbstractTableModel;
import nami.beitrag.Buchungstyp;
import nami.beitrag.NamiBeitragConfiguration;
import nami.beitrag.Rechnungsstatus;
import nami.beitrag.db.BeitragBuchung;
import nami.beitrag.db.BeitragLastschrift;
import nami.beitrag.db.BeitragMapper;
import nami.beitrag.db.BeitragPrenotification;
import nami.beitrag.db.BeitragRechnung;
import nami.beitrag.db.BeitragSammelLastschrift;
import nami.beitrag.db.BeitragSepaMandat;
import nami.beitrag.db.DataLastschriftMandat;
import nami.beitrag.db.LastschriftenMapper;
import nami.beitrag.db.RechnungenMapper;
import nami.beitrag.db.RechnungenMapper.DataHalbjahrBetraege;
import nami.beitrag.gui.utils.DisabledCellRenderer;
import nami.beitrag.hibiscus.HibiscusExporter;
import nami.beitrag.letters.LetterGenerator;
import nami.beitrag.letters.LetterType;
import net.miginfocom.swing.MigLayout;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import com.toedter.calendar.JDateChooser;

                    for (DataLastschriftMandat row : rows) {
                        pre = createPrenotification(sl, row);
                        pre.setRegelmaessig(false);
                        mapper.insertPrenotification(pre);

                        prenotIds.add(pre.getPrenotificationId());
                        lastMandat = row.getMandat();
                    }
                    session.commit();
                } else if (type == PrenotificationType.EINZELN_EINMALIG
                        || type == PrenotificationType.EINZELN_DAUERHAFT) {
                    DataLastschriftMandat selected = getSelectedEinzellast();

                    if (selected != null) {
                        pre = createPrenotification(sl, selected);
                        if (type == PrenotificationType.EINZELN_DAUERHAFT) {
                            pre.setRegelmaessig(true);
                        } else {
                            pre.setRegelmaessig(false);
                        }
                        mapper.insertPrenotification(pre);
                        session.commit();

                        prenotIds.add(pre.getPrenotificationId());
                        lastMandat = selected.getMandat();
                    } else {
                        logger.severe("Keine Einzellastschrift für "
                                + "Prenotification ausgewählt.");
                    }
                }
            } finally {
                session.close();
            }

            if (prenotIds.isEmpty()) {
                logger.log(Level.INFO, "Keine Prenotifications erzeugt");
            } else if (prenotIds.size() == 1) {
                letterGenerator.generateLetter(LetterType.PRENOTIFICATION,
                        prenotIds.getFirst(), notificationdatum.getDate(),
                        lastMandat.getKontoinhaber(), null);
            } else {
                letterGenerator.generateLetters(LetterType.PRENOTIFICATION,
                        prenotIds, notificationdatum.getDate());
            }
        }
    }

    private JPanel createExportPanel() {
        JPanel panel = new JPanel();
        panel.setLayout(new MigLayout("", "[][grow]", "[][][][][]"));

        JLabel lblExportErklaerung = new JLabel(
                "<html>Es wird immer die komplette Sammellastschrift exportiert.<br />"
                        + "Damit der Export funktioniert, muss Hibiscus im Hintergrund "
                        + "laufen und entsprechend konfiguriert sein.");
        panel.add(lblExportErklaerung, "flowx,cell 0 0");

        JButton btnSammellastschriftExport = new JButton(
                "Als Sammellastschrift an Hibiscus senden");
        btnSammellastschriftExport.addActionListener(new ExportAction(
                HibiscusExportType.SAMMEL));
        panel.add(btnSammellastschriftExport, "cell 0 1,span");

        JButton btnEinzellastschriftExport = new JButton(
                "Alle als Einzellastschriften an Hibiscus senden");
        btnEinzellastschriftExport.addActionListener(new ExportAction(
                HibiscusExportType.ALLE_EINZEL));
        panel.add(btnEinzellastschriftExport, "cell 0 2,span");

        JButton btnEinzellastschriftSingleExport = new JButton(
                "Markierte als Einzellastschrift an Hibiscus senden");
        btnEinzellastschriftSingleExport.addActionListener(new ExportAction(
                HibiscusExportType.MARKIERT_EINZEL));
        panel.add(btnEinzellastschriftSingleExport, "cell 0 3,span");

        lblExportUngueltigWarning = new JLabel(
                "In der Sammellastschrift sind ungültige Mandate enthalten.");
        lblExportUngueltigWarning.setForeground(Color.RED);
        panel.add(lblExportUngueltigWarning, "cell 0 4,span");

        return panel;
    }

    /**
     * Beschreibt die verschiedenen Möglichkeiten eine Sammellastschrift an
     * Hibiscus zu senden.
     */
    private enum HibiscusExportType {
        /**
         * Sendet eine Sammellastschrift gesammelt an Hibiscus.
         */
        SAMMEL,

        /**
         * Sendet alle enthaltenen Lastschriften als Einzellastschriften an
         * Hibiscus.
         */
        ALLE_EINZEL,

        /**
         * Sendet nur die markierte Einzellastschrift einzeln an Hibiscus.
         */
        MARKIERT_EINZEL
    }

    /**
     * Sendet die Sammellastschrift (ggf. als einzelne Lastschriften) an
     * Hibiscus.
     */
    private final class ExportAction implements ActionListener {
        private HibiscusExportType type;

        private ExportAction(HibiscusExportType type) {
            this.type = type;
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            BeitragSammelLastschrift sl = getSelectedSammellast();
Answer:             HibiscusExporter exporter = new HibiscusExporter(conf,