projmi/src/main/java/de/uniluebeck/mi/projmi6/db/DBHandler.java

package de.uniluebeck.mi.projmi6.db;

import de.uniluebeck.mi.projmi6.model.*;

import java.sql.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

/**
 * Handler fuer alle DB Interaktionen.
 */
public class DBHandler {

    private static final String SELECT_ALL_PATIENTS = "SELECT * FROM `patient`";
    private static final String SELECT_PATIENT_BY_ID = "SELECT * FROM `patient` WHERE `id` = ?";
    private static final String UPDATE_PATIENT = "UPDATE `patient`" +
            "SET `CAVE`=?," +
            "`Vorname`=?," +
            "`Geburtsname`=?," +
            "`Nachname`=?," +
            "`Geburtsdatum`=?," +
            "`Geschlecht`=?," +
            "`Familienstand`=?," +
            "`Strasse`=?," +
            "`Hausnummer`=?," +
            "`PLZ`=?," +
            "`Ort`=?," +
            "`Telefon`=?," +
            "`KassenID`=?," +
            "`Versichertennummer`=?," +
            "`LetzterBearbeiter`=? " +
            "WHERE `ID`=?";
    private static final String INSERT_PATIENT = "INSERT INTO `patient`" +
            "(`CAVE`," +
            "`Vorname`," +
            "`Geburtsname`," +
            "`Nachname`," +
            "`Geburtsdatum`," +
            "`Geschlecht`," +
            "`Familienstand`," +
            "`Strasse`," +
            "`Hausnummer`," +
            "`PLZ`," +
            "`Ort`," +
            "`Telefon`," +
            "`KassenID`," +
            "`Versichertennummer`," +
            "`LetzterBearbeiter`," +
            "`Ersteller`)" +
            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
    private static final String SELECT_ALL_STATIONEN = "SELECT *,`r`.`abteilung` AS abteilung " +
            "FROM `stammstation` s " +
            "INNER JOIN `relfachrichtungstation` r ON s.station = r.station";
    private static final String SELECT_FAELLE_BY_PATID = "SELECT * FROM `fall` WHERE `patientid` = ?";
    private static final String INSERT_FALL = "INSERT INTO `fall`" +
            "(`Aufnahmedatum`," +
            "`Entlassungsdatum`," +
            "`Vorstelldatum`," +
            "`EinweisenderArzt`," +
            "`Fallart`," +
            "`Selbsteinweisung`," +
            "`Hauptdiagnose`," +
            "`Versichertennummer`," +
            "`KassenID`," +
            "`storniert`," +
            "`LetzterBearbeiter`," +
            "`PatientID`," +
            "`Ersteller`)" +
            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
    private static final String UPDATE_FALL = "UPDATE `fall`" +
            "SET `Aufnahmedatum`=?," +
            "`Entlassungsdatum`=?," +
            "`Vorstelldatum`=?," +
            "`EinweisenderArzt`=?," +
            "Fallart=?," +
            "`Selbsteinweisung`=?," +
            "Hauptdiagnose=?," +
            "`Versichertennummer`=?," +
            "KassenID=?," +
            "`storniert`=?," +
            "LetzterBearbeiter=? " +
            "WHERE `FallID`=?";
    private static final String SELECT_DIAGNOSE_BY_ID = "SELECT * FROM `diagnose` WHERE `diagid` = ?";
    private static final String SELECT_ALL_ICD10CODES = "SELECT * FROM `stammicd10`";
    private static final String SELECT_ALL_OPSCODES = "SELECT * FROM `stammops`";
    private static final String SELECT_ICD10CODE_BY_ID = "SELECT * FROM `stammicd10` WHERE `icd10code` = ? AND `version` = ?";
    private static final String SELECT_OPSCODE_BY_ID = "SELECT * FROM `stammops` WHERE `opscode` = ? AND `version` = ?";
    private static final String SELECT_ALL_MITARBEITER = "SELECT * FROM `mitarbeiter`";
    private static final String SELECT_UNTERS_BY_FALLID = "SELECT * FROM `untersuchung` WHERE `fallid` = ?";
    private static final String INSERT_UNTERSUCHUNG = "INSERT INTO `untersuchung`" +
            "(`DurchfuehrenderArzt`," +
            "`FallID`," +
            "`OPSCode`," +
            "`OPSVersion`," +
            "`storniert`," +
            "`Untersuchungsdatum`," +
            "`LetzterBearbeiter`," +
            "`Ersteller`)" +
            "VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
    private static final String UPDATE_UNTERSUCHUNG = "UPDATE `untersuchung` " +
            "SET `DurchfuehrenderArzt`=?," +
            "`FallID`=?," +
            "`OPSCode`=?," +
            "`OPSVersion`=?," +
            "`storniert`=?," +
            "`Untersuchungsdatum`=?," +
            "`LetzterBearbeiter`=? " +
            "WHERE `UntersID`=?";
    private static final String SELECT_MITARBEITER_BY_ID = "SELECT * FROM `mitarbeiter` WHERE `mitarbid` = ?";
    private static final String SELECT_DIAGNOSE_BY_FALLID = "SELECT * FROM `diagnose` WHERE `fallid` = ?";
    private static final String SELECT_ALL_KASSEN = "SELECT * FROM `kasse`";
    private static final String SELECT_KASSE_BY_KASSENID = "SELECT * FROM `kasse` WHERE `kasse`.`KassenID` = ?";
    private static final String SELECT_STATHIST_BY_FALLID = "SELECT * FROM `stationshistorie` WHERE `stationshistorie`.`fallid` = ?";
    private static final String SELECT_STATUBERITEMS_BY_STATION = "SELECT p.id AS patid," +
            "concat(p.nachname, ', ', p.vorname) AS patname," +
            "p.geburtsdatum AS dob," +
            "timestampdiff(YEAR, p.geburtsdatum, curdate()) AS patage," +
            "f.aufnahmedatum AS aufnahme," +
            "f.entlassungsdatum AS entlassung," +
            "f.fallid AS fallid " +
            "FROM stationshistorie s " +
            "INNER JOIN fall f ON s.fallid = f.fallid " +
            "INNER JOIN patient p ON f.patientid = p.id " +
            "WHERE s.station = ?";
    private static final String INSERT_STATHISTENTRY = "INSERT INTO `stationshistorie`" +
            "(`Aufnahmedatum`," +
            "`Entlassungsdatum`," +
            "`FallID`," +
            "`LetzterBearbeiter`," +
            "`Station`," +
            "`Ersteller`)" +
            "VALUES (?, ?, ?, ?, ?, ?)";
    private static final String UPDATE_STATHISTENTRY = "UPDATE `stationshistorie` " +
            "SET `Aufnahmedatum`=?," +
            "`Entlassungsdatum`=?," +
            "`FallID`=?," +
            "`LetzterBearbeiter`=?," +
            "`Station`=? " +
            "WHERE `StatHistID`=?";
    private static final String SELECT_LAST_HL7ENTRIES = "SELECT * FROM `hl7_nachrichten` limit ?";
    private static final String INSERT_HL7NACHRICHT = "INSERT INTO `hl7_nachrichten` " +
            "(`hl7msg`," +
            "`timestamp`," +
            "`source`) " +
            "VALUES (?, ?, ?)";
    private static final String INSERT_DIAGNOSE = "INSERT INTO `diagnose` " +
            "(`Arzt`," +
            "`DiagArt`," +
            "`Ersteller`," +
            "`Freitext`," +
            "`ICD10Code`," +
            "`ICD10Version`," +
            "`LetzterBearbeiter`," +
            "`FallID`) " +
            "VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
    private static final String DELETE_STATHIST = "DELETE FROM `stationshistorie` WHERE `StatHistID` =?";
    private static final String SELECT_FALLIDS_BY_PATID = "SELECT `fallid` FROM `fall` WHERE `patientid` =?";
    private static final String INSERT_HL7NACHRICHT_ = "INSERT INTO `hl7_nachrichten` " +
            "(`hl7msg`," +
            "`timestamp`," +
            "`source`," +
            "`direction`) " +
            "VALUES (?, ?, ?, ?)";

    private DBHandler() {

    }

    /**
     * Gibt alle {@link Patient} aus der DB zurueck.
     *
     * @return Liste aller {@link Patient}.
     * @throws SQLException wenn Fehler bei der SQL Verarbeitung auftreten.
     */
    public static List<Patient> getAllPatients() throws SQLException {
        Statement statement = MySqlConnectionFactory.getConnection().createStatement();
        ResultSet rs = statement.executeQuery(SELECT_ALL_PATIENTS);

        List<Patient> patients = new ArrayList<>();
        while (rs.next()) {
            patients.add(getPatient(rs));
        }

        return patients;
    }

    /**
     * Extrahiert ein Objekt {@link Patient} aus einem gegebenen {@link ResultSet}.
     *
     * @param rs ResultSet from Database Query.
     * @return {@link Patient}
     * @throws SQLException
     */
    private static Patient getPatient(ResultSet rs) throws SQLException {
        Patient patient = new Patient();
        patient.setPatID(rs.getInt("id"));
        patient.setGeburtsname(rs.getString("geburtsname"));
        patient.setVorname(rs.getString("vorname"));
        patient.setNachname(rs.getString("nachname"));
        if (rs.getDate("geburtsdatum") != null) {
            patient.setGeburtsdatum(rs.getDate("geburtsdatum").toLocalDate());
        }

        patient.setCave(rs.getString("cave"));

        patient.setStrasse(rs.getString("strasse"));
        patient.setHausnummer(rs.getString("hausnummer"));
        patient.setPlz(rs.getString("plz"));
        patient.setOrt(rs.getString("ort"));
        patient.setTelefon(rs.getString("telefon"));
        if (rs.getString("familienstand") != null) {
            patient.setFamilienstand(Patient.Familienstand.parseChar(rs.getString("familienstand").charAt(0)));
        }
        if (rs.getString("geschlecht") != null) {
            patient.setGeschlecht(Patient.Geschlecht.parseChar(rs.getString("geschlecht").charAt(0)));
        }
        patient.setVersichertennummer(rs.getString("versichertennummer"));
        patient.setKassenID(rs.getInt("kassenid"));
        setVersionInformation(patient, rs);
        return patient;
    }

    // TODO: Never used.
    public static Patient getPatient(int id) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(SELECT_PATIENT_BY_ID);
        ResultSet rs;
        statement.setInt(1, id);
        rs = statement.executeQuery();

        return getPatient(rs);
    }

    /**
     * Fuehrt {@code INSERT} bei einem neuen Datensatz und {@code UPDATE} bei einem existierenden Datensatz aus.
     *
     * @param patient  zu verarbeitender Datensatz.
     * @param mitarbid {@link Mitarbeiter#mitarbID} des aktuellen Benutzers/Mitarbeiters.
     * @param isUpdate {@code true} wenn der Datensatz bereits existiert, sonst {@code false}.
     * @throws SQLException wenn Fehler bei der SQL Verarbeitung auftreten.
     */
    public static void setPatient(Patient patient, int mitarbid, boolean isUpdate) throws SQLException {
        PreparedStatement statement;
        if (isUpdate) {
            statement = MySqlConnectionFactory.getConnection().prepareStatement(UPDATE_PATIENT);
        } else {
            statement = MySqlConnectionFactory.getConnection().prepareStatement(INSERT_PATIENT);
        }

        statement.setString(1, patient.getCave());                                  // CAVE
        statement.setString(2, patient.getVorname());                               // Vorname
        statement.setString(3, patient.getGeburtsname());                           // Geburtsname
        statement.setString(4, patient.getNachname());                              // Nachname

        statement.setDate(5, Date.valueOf(patient.getGeburtsdatum()));              // Geburtsdatum
        if (patient.getGeschlecht() != null) {
            statement.setString(6, String.valueOf(patient.getGeschlecht().id()));   // Geschlecht
        } else {
            statement.setString(6, String.valueOf(Patient.Geschlecht.OTHER.id()));
        }
        if (patient.getFamilienstand() != null) {
            statement.setString(7, String.valueOf(patient.getFamilienstand().id()));// Familienstand
        } else {
            statement.setString(7, String.valueOf(Patient.Familienstand.LEDIG.id()));
        }
        statement.setString(8, patient.getStrasse());                               // Strasse
        statement.setString(9, patient.getHausnummer());                            // Hausnummer
        statement.setString(10, patient.getPlz());                                  // PLZ
        statement.setString(11, patient.getOrt());                                  // Ort
        statement.setString(12, patient.getTelefon());                              // Telefon
        statement.setInt(13, patient.getKassenID());                                // KassenID
        statement.setString(14, patient.getVersichertennummer());                   // Versichertennummer
        statement.setInt(15, mitarbid);                                             // LetzterBearbeiter
        if (!isUpdate) {
            statement.setInt(16, mitarbid);                                         // Ersteller
        } else {
            statement.setInt(16, patient.getPatID());                               // PatID (WHERE)
        }


        statement.execute();
    }

    /**
     * Gibt Liste aller Stationen aus der DB zurueck.
     *
     * @return Liste der Stationen
     * @throws SQLException
     */
    public static List<Station> getAllStationen() throws SQLException {
        Statement statement = MySqlConnectionFactory.getConnection().createStatement();
        ResultSet rs = statement.executeQuery(SELECT_ALL_STATIONEN);

        List<Station> stationen = new ArrayList<>();
        while (rs.next()) {
            stationen.add(getStation(rs));
        }

        return stationen;
    }

    /**
     * Extrahiert ein Objekt {@link Station} aus einem gegebenen {@link ResultSet}.
     *
     * @param rs ResultSet from Database Query.
     * @return {@link Station}
     * @throws SQLException wenn Fehler bei der SQL Verarbeitung auftreten.
     */
    private static Station getStation(ResultSet rs) throws SQLException {
        Station station = new Station();
        station.setStation(rs.getString("station"));
        station.setBezeichnung(rs.getString("bezeichnung"));
        station.setBezeichnungLang(rs.getString("bezeichnunglang"));
        station.setStationstyp(rs.getInt("stationstyp"));
        station.setAbteilung(rs.getString("abteilung"));

        return station;
    }

    /**
     * Gibt besondere Eintraege fuer die Stationsubersicht nach Station zurueck.
     *
     * @param station Station
     * @return Liste der Eintraege auf der Station.
     * @throws SQLException
     */
    public static List<StationsUebersichtsItem> getStationsUebersichtsItems(String station) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(SELECT_STATUBERITEMS_BY_STATION);
        statement.setString(1, station);
        ResultSet rs = statement.executeQuery();

        List<StationsUebersichtsItem> statUeberItems = new ArrayList<>();
        while (rs.next()) {
            statUeberItems.add(getStatUeberItem(rs));
        }
        return statUeberItems;
    }

    private static StationsUebersichtsItem getStatUeberItem(ResultSet rs) throws SQLException {
        StationsUebersichtsItem item = new StationsUebersichtsItem();
        item.setFallId(rs.getInt("fallid"));
        item.setPatId(rs.getInt("patid"));
        item.setPatName(rs.getString("patname"));
        item.setPatAge(rs.getInt("patage"));
        item.setPatBirthdate(rs.getDate("dob").toLocalDate());
        if (rs.getDate("aufnahme") != null) {
            item.setStationAufnahme(rs.getDate("aufnahme").toLocalDate());
        }
        if (rs.getDate("entlassung") != null) {
            item.setStationEntlassung(rs.getDate("entlassung").toLocalDate());
        }
        return item;
    }

    /**
     * Gibt die Stationshistorie zu einem Fall aus.
     *
     * @param fall Fall
     * @return Liste der StationsHistorie Eintraege.
     * @throws SQLException
     */
    public static List<StationsHistorie> getStationsHistorieByFall(Fall fall) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(SELECT_STATHIST_BY_FALLID);
        statement.setInt(1, fall.getFallID());
        ResultSet rs = statement.executeQuery();

        List<StationsHistorie> historie = new ArrayList<>();
        while (rs.next()) {
            historie.add(getStationsHistorie(rs));
        }

        return historie;
    }

    /**
     * Erstellt bzw. aktuallisiert einen Eintrag in die Stationshistorie.
     *
     * @param hist     StationsHistorie Objekt
     * @param isUpdate true wenn Update.
     * @throws SQLException
     */
    public static void setStationsHistorie(StationsHistorie hist, boolean isUpdate) throws SQLException {
        PreparedStatement statement;
        if (isUpdate) {
            statement = MySqlConnectionFactory.getConnection().prepareStatement(UPDATE_STATHISTENTRY);
        } else {
            statement = MySqlConnectionFactory.getConnection().prepareStatement(INSERT_STATHISTENTRY);
        }

        if (hist.getAufnahmeDatum() != null) {
            statement.setTimestamp(1, Timestamp.valueOf(hist.getAufnahmeDatum()));      // `Aufnahmedatum`
        } else {
            statement.setTimestamp(1, null);
        }
        if (hist.getEntlassungsDatum() != null) {
            statement.setTimestamp(2, Timestamp.valueOf(hist.getEntlassungsDatum()));   // `Entlassungsdatum`
        } else {
            statement.setTimestamp(2, null);
        }
        statement.setInt(3, hist.getFallID());                                          // `FallID`
        statement.setInt(4, hist.getBearbeiter());                                      // `LetzterBearbeiter`
        statement.setString(5, hist.getStationKey());                                   // `Station`

        if (isUpdate) {
            statement.setInt(6, hist.getStatHistID());                                  // `StatHistID`
            statement.executeUpdate();
        } else {
            statement.setInt(6, hist.getErsteller());                                   // `Ersteller`
            statement.execute();
        }
    }

    /**
     * Entfernt einen StationsHistorie Eintrag aus der Datenbank.
     *
     * @param hist Zu entfernendes StationsHistorie Objekt
     * @throws SQLException
     */
    public static void delStationsHistorie(StationsHistorie hist) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(DELETE_STATHIST);
        statement.setInt(1, hist.getStatHistID());
        statement.execute();
    }

    /**
     * Gibt einzelnes StationsHistorie Objekt aus einem ResultSet zurueck.
     *
     * @param rs DB Query Result
     * @return StationsHistorie
     * @throws SQLException
     */
    private static StationsHistorie getStationsHistorie(ResultSet rs) throws SQLException {
        StationsHistorie hist = new StationsHistorie();

        hist.setStatHistID(rs.getInt("stathistid"));
        if (rs.getTimestamp("aufnahmedatum") != null) {
            hist.setAufnahmeDatum(rs.getTimestamp("aufnahmedatum").toLocalDateTime());
        }
        if (rs.getTimestamp("entlassungsdatum") != null) {
            hist.setEntlassungsDatum(rs.getTimestamp("entlassungsdatum").toLocalDateTime());
        }
        hist.setStationKey(rs.getString("station"));

        return hist;
    }

    /**
     * Gibt alle Faelle eines Patienten zuruck.
     *
     * @param id Patienten ID
     * @return Liste aller Faelle.
     * @throws SQLException
     */
    public static List<Fall> getFaelleByPatID(int id) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(SELECT_FAELLE_BY_PATID);
        statement.setInt(1, id);
        ResultSet rs = statement.executeQuery();

        List<Fall> faelle = new ArrayList<>();
        while (rs.next()) {
            faelle.add(getFall(rs));
        }

        return faelle;
    }

    /**
     * Extrahiert ein Objekt {@link Fall} aus einem gegebenen {@link ResultSet}.
     *
     * @param rs ResultSet from Database Query.
     * @return {@link Fall}
     * @throws SQLException wenn Fehler bei der SQL Verarbeitung auftreten.
     */
    private static Fall getFall(ResultSet rs) throws SQLException {
        Fall fall = new Fall();

        fall.setFallID(rs.getInt("fallid"));
        if (rs.getTimestamp("aufnahmedatum") != null) {
            fall.setAufnahmeDatum(rs.getTimestamp("aufnahmedatum").toLocalDateTime());
        }
        if (rs.getTimestamp("entlassungsdatum") != null) {
            fall.setEntlassungsDatum(rs.getTimestamp("entlassungsdatum").toLocalDateTime());
        }
        if (rs.getInt("hauptdiagnose") != 0) {
            fall.setHauptDiagnose(getDiagnose(rs.getInt("hauptdiagnose"), fall));
            fall.setHauptdiagnoseId(rs.getInt("hauptdiagnose"));
        }
        if (rs.getString("versichertennummer") != null) {
            fall.setVersichertenNummer(rs.getString("versichertennummer"));
        }
        if (rs.getInt("kassenid") != 0) {
            fall.setKasse(getKasse(rs.getInt("kassenid")));
        }
        fall.setFallArt(FallArt.parseString(rs.getString("fallart")));
        fall.setEinweisenderArzt(rs.getString("einweisenderarzt"));
        fall.setStorniert(rs.getBoolean("storniert"));

        return fall;
    }

    /**
     * Fuehrt {@code INSERT} bei einem neuen Datensatz und {@code UPDATE} bei einem existierenden Datensatz aus.
     *
     * @param fall     zu verarbeitender Datensatz.
     * @param mitarbid {@link Mitarbeiter#mitarbID} des aktuellen Benutzers/Mitarbeiters.
     * @param isUpdate {@code true} wenn der Datensatz bereits existiert, sonst {@code false}.
     * @throws SQLException wenn Fehler bei der SQL Verarbeitung auftreten.
     */
    public static int setFall(Fall fall, int mitarbid, boolean isUpdate) throws SQLException {
        PreparedStatement statement;
        if (isUpdate) {
            statement = MySqlConnectionFactory.getConnection().prepareStatement(UPDATE_FALL);
        } else {
            statement = MySqlConnectionFactory.getConnection().prepareStatement(INSERT_FALL, Statement.RETURN_GENERATED_KEYS);
        }

        if (fall.getAufnahmeDatum() != null) {
            statement.setTimestamp(1, Timestamp.valueOf(fall.getAufnahmeDatum()));      // Aufnahmedatum
        } else {
            statement.setTimestamp(1, null);
        }
        if (fall.getEntlassungsDatum() != null) {
            statement.setTimestamp(2, Timestamp.valueOf(fall.getEntlassungsDatum()));   // Entlassungsdatum
        } else {
            statement.setTimestamp(2, null);
        }
        if (fall.getVorstellDatum() != null) {
            statement.setTimestamp(3, Timestamp.valueOf(fall.getVorstellDatum()));      // Vorstelldatum
        } else {
            statement.setTimestamp(3, null);
        }
        if (fall.getEinweisenderArzt() != null) {
            statement.setString(4, fall.getEinweisenderArzt());                         // EinweisenderArzt
        } else {
            statement.setTimestamp(4, null);
        }
        if (fall.getFallArt() != null) {
            statement.setString(5, fall.getFallArt().id());                             // Fallart
        } else {
            statement.setString(5, null);
        }
        statement.setBoolean(6, fall.getSelbsteinweisung());                            // Selbsteinweisung
        if (fall.getHauptdiagnoseId() != 0) {
            statement.setInt(7, fall.getHauptdiagnoseId());                             // Hauptdiagnose
        } else {
            statement.setTimestamp(7, null);
        }
        statement.setString(8, fall.getVersichertenNummer());                           // Versichertennummer
        if (fall.getKasse() != null) {
            statement.setInt(9, fall.getKasse().getKassenID());                         // KassenID
        } else {
            statement.setTimestamp(9, null);
        }
        statement.setBoolean(10, fall.getStorniert());                                  // storniert
        statement.setInt(11, mitarbid);                                                 // Letzter Bearbeiter
        if (!isUpdate) {
            statement.setInt(12, fall.getPatient().getPatID());                         // PatientID
            statement.setInt(13, mitarbid);                                             // Ersteller
        }
        if (isUpdate) {
            statement.setInt(12, fall.getFallID());
        }

        statement.execute();

        if (!isUpdate) {
            ResultSet genkeys = statement.getGeneratedKeys();
            while (genkeys.next()) {
                return genkeys.getInt(1);
            }
            return -1; // Sollte nie vorkommen.
        } else {
            return fall.getFallID();
        }
    }

    /**
     * Fuehrt {@code INSERT} eines neuen Datensatz durch.
     *
     * @param fall     zu verarbeitender Datensatz.
     * @param mitarbid {@link Mitarbeiter#mitarbID} des aktuellen Benutzers/Mitarbeiters.
     * @throws SQLException wenn Fehler bei der SQL Verarbeitung auftreten.
     */
    public static int setFall(Fall fall, int mitarbid) throws SQLException {
        return setFall(fall, mitarbid, false);
    }

    private static Diagnose getDiagnose(int diagid, Fall fall) throws SQLException {
        Diagnose diagnose = getDiagnose(diagid);
        diagnose.setFall(fall);

        return diagnose;
    }

    private static Diagnose getDiagnose(int id) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(SELECT_DIAGNOSE_BY_ID);
        statement.setInt(1, id);
        ResultSet rs = statement.executeQuery();

        rs.next(); // TODO
        return getDiagnose(rs);
    }

    /**
     * Extrahiert ein Objekt {@link Diagnose} aus einem gegebenen {@link ResultSet}.
     *
     * @param rs ResultSet from Database Query.
     * @return {@link Diagnose}
     * @throws SQLException wenn Fehler bei der SQL Verarbeitung auftreten.
     */
    private static Diagnose getDiagnose(ResultSet rs) throws SQLException {
        Diagnose diagnose = new Diagnose();

        diagnose.setDiagID(rs.getInt("diagid"));
        diagnose.setFreiText(rs.getString("freitext"));
        diagnose.setArzt(new Mitarbeiter(rs.getInt("arzt")));
        diagnose.setDiagArt(DiagArt.parseInt(rs.getInt("diagart")));
        setVersionInformation(diagnose, rs);
        diagnose.setIcd10code(getIcd10Code(rs.getString("icd10code"), rs.getInt("icd10version")));
        return diagnose;
    }

    private static void setVersionInformation(Version version, ResultSet rs) throws SQLException {
        version.setErsteller(rs.getInt("ersteller"));
        if (rs.getTimestamp("erstelldatum") != null) {
            version.setErstellDatumZeit(rs.getTimestamp("erstelldatum").toLocalDateTime());
        }
        version.setBearbeiter(rs.getInt("letzterbearbeiter"));
        if (rs.getTimestamp("letztesbearbeitungsdatum") != null) {
            version.setBearbeitetDatumZeit(rs.getTimestamp("letztesbearbeitungsdatum").toLocalDateTime());
        }
    }

    /**
     * Gibt alle in der DB hinterlegten ICD10 Codes zurueck.
     *
     * @return Liste aller ICD10 Codes.
     * @throws SQLException
     */
    public static List<Icd10Code> getAllIcd10Codes() throws SQLException {
        Statement statement = MySqlConnectionFactory.getConnection().createStatement();
        ResultSet rs = statement.executeQuery(SELECT_ALL_ICD10CODES);

        List<Icd10Code> icd10codes = new ArrayList<>();
        while (rs.next()) {
            icd10codes.add(getIcd10Code(rs));
        }

        return icd10codes;
    }

    private static Icd10Code getIcd10Code(String code, int version) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(SELECT_ICD10CODE_BY_ID);
        ResultSet rs;
        statement.setString(1, code);
        statement.setInt(2, version);
        rs = statement.executeQuery();

        rs.next(); // TODO
        return getIcd10Code(rs);
    }

    /**
     * Extrahiert ein Objekt {@link Icd10Code} aus einem gegebenen {@link ResultSet}.
     *
     * @param rs ResultSet from Database Query.
     * @return {@link Icd10Code}
     * @throws SQLException wenn Fehler bei der SQL Verarbeitung auftreten.
     */
    private static Icd10Code getIcd10Code(ResultSet rs) throws SQLException {
        String code = rs.getString("icd10code");
        String text = rs.getString("text");
        int version = rs.getInt("version");

        return new Icd10Code(code, text, version);
    }

    /**
     * Gibt alle in der Datanbank hinterlegten OPS Codes zurueck.
     *
     * @return Liste der OPS Codes.
     * @throws SQLException
     */
    public static List<OpsCode> getAllOpsCodes() throws SQLException {
        Statement statement = MySqlConnectionFactory.getConnection().createStatement();
        ResultSet rs = statement.executeQuery(SELECT_ALL_OPSCODES);

        List<OpsCode> opscodes = new ArrayList<>();
        while (rs.next()) {
            opscodes.add(getOpsCode(rs));
        }

        return opscodes;
    }

    private static OpsCode getOpsCode(String code, int version) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(SELECT_OPSCODE_BY_ID);
        ResultSet rs;
        statement.setString(1, code);
        statement.setInt(2, version);
        rs = statement.executeQuery();

        rs.next(); // TODO
        return getOpsCode(rs);
    }

    /**
     * Extrahiert ein Objekt {@link OpsCode} aus einem gegebenen {@link ResultSet}.
     *
     * @param rs ResultSet from Database Query.
     * @return {@link OpsCode}
     * @throws SQLException wenn Fehler bei der SQL Verarbeitung auftreten.
     */
    private static OpsCode getOpsCode(ResultSet rs) throws SQLException {
        String code = rs.getString("opscode");
        String text = rs.getString("text");
        int version = rs.getInt("version");

        return new OpsCode(code, text, version);
    }

    /**
     * Gibt Liste der Mitarbeiter aus der DB zurueck.
     *
     * @return Liste der Mitarbeiter.
     * @throws SQLException
     */
    public static List<Mitarbeiter> getAllMitarbeiter() throws SQLException {
        Statement statement = MySqlConnectionFactory.getConnection().createStatement();
        ResultSet rs = statement.executeQuery(SELECT_ALL_MITARBEITER);

        List<Mitarbeiter> mitarbeiters = new ArrayList<>();
        while (rs.next()) {
            mitarbeiters.add(getMitarbeiter(rs));
        }

        return mitarbeiters;
    }

    private static Mitarbeiter getMitarbeiter(int id) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(SELECT_MITARBEITER_BY_ID);
        ResultSet rs;
        statement.setInt(1, id);
        rs = statement.executeQuery();

        rs.next(); // TODO
        return getMitarbeiter(rs);
    }

    /**
     * Extrahiert ein Objekt {@link Mitarbeiter} aus einem gegebenen {@link ResultSet}.
     *
     * @param rs ResultSet from Database Query.
     * @return {@link Mitarbeiter}
     * @throws SQLException wenn Fehler bei der SQL Verarbeitung auftreten.
     */
    private static Mitarbeiter getMitarbeiter(ResultSet rs) throws SQLException {
        Mitarbeiter mitarbeiter = new Mitarbeiter(rs.getInt("mitarbid"));
        mitarbeiter.setTitel(rs.getString("titel"));
        mitarbeiter.setVorname(rs.getString("vorname"));
        mitarbeiter.setNachname(rs.getString("nachname"));
        mitarbeiter.setEinweisenderArzt(rs.getString("einweisenderarzt"));
        return mitarbeiter;
    }

    /**
     * Gibt gibt alle {@link Untersuchung} zu einem {@link Fall} aus.
     *
     * @param fall Parent {@link Fall}
     * @return Liste aller {@link Untersuchung} zu einem {@link Fall}.
     * @throws SQLException wenn Fehler bei der SQL Verarbeitung auftreten.
     */
    public static List<Untersuchung> getUntersuchungByFall(Fall fall) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(SELECT_UNTERS_BY_FALLID);
        statement.setInt(1, fall.getFallID());
        ResultSet rs = statement.executeQuery();

        List<Untersuchung> untersuchungen = new ArrayList<>();
        while (rs.next()) {
            untersuchungen.add(getUntersuchung(rs, fall));
        }

        return untersuchungen;
    }

    private static Untersuchung getUntersuchung(ResultSet rs, Fall fall) throws SQLException {
        Untersuchung untersuchung = new Untersuchung();
        untersuchung.setUntersID(rs.getInt("untersid"));
        untersuchung.setFall(fall);
        untersuchung.setDurchfuehrenderArzt(getMitarbeiter(rs.getInt("durchfuehrenderarzt")));
        untersuchung.setUntersuchungsdatum(rs.getTimestamp("untersuchungsdatum").toLocalDateTime());
        untersuchung.setOpscode(getOpsCode(rs.getString("opscode"), rs.getInt("opsversion")));
        untersuchung.setStorniert(rs.getBoolean("storniert"));
        setVersionInformation(untersuchung, rs);
        return untersuchung;
    }


    /**
     * Fuehrt {@code INSERT} bei einem neuen Datensatz und {@code UPDATE} bei einem existierenden Datensatz aus.
     *
     * @param untersuchung zu verarbeitender Datensatz.
     * @param mitarbid     {@link Mitarbeiter#mitarbID} des aktuellen Benutzers/Mitarbeiters.
     * @param isUpdate     {@code true} wenn der Datensatz bereits existiert, sonst {@code false}.
     * @throws SQLException wenn Fehler bei der SQL Verarbeitung auftreten.
     */
    public static void setUntersuchung(Untersuchung untersuchung, int mitarbid, boolean isUpdate) throws SQLException {
        PreparedStatement statement;
        if (isUpdate) {
            statement = MySqlConnectionFactory.getConnection().prepareStatement(UPDATE_UNTERSUCHUNG);
        } else {
            statement = MySqlConnectionFactory.getConnection().prepareStatement(INSERT_UNTERSUCHUNG);
        }

        statement.setInt(1, untersuchung.getDurchfuehrenderArzt().getMitarbID());           // DurchfuehrenderArzt
        statement.setInt(2, untersuchung.getFall().getFallID());                            // FallID
        statement.setString(3, untersuchung.getOpscode().getOpsCode());                     // OPSCode
        statement.setInt(4, untersuchung.getOpscode().getVersion());                        // OPSVersion
        statement.setBoolean(5, untersuchung.getStorniert());                               // storniert
        statement.setTimestamp(6, Timestamp.valueOf(untersuchung.getUntersuchungsdatum())); // Untersuchungsdatum
        statement.setInt(7, mitarbid);                                                      // Letzter Bearbeiter
        if (isUpdate) {
            statement.setInt(8, untersuchung.getUntersID());                                // `UntersID`
        } else {
            statement.setInt(8, mitarbid);                                                  // Ersteller
        }

        statement.execute();
    }

    /**
     * Gibt alle Diagnosen zu einem Fall zurueck.
     *
     * @param fall Fall
     * @return Liste der Diagnosen.
     * @throws SQLException
     */
    public static List<Diagnose> getDiagnosenByFall(Fall fall) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(SELECT_DIAGNOSE_BY_FALLID);
        statement.setInt(1, fall.getFallID());
        ResultSet rs = statement.executeQuery();

        List<Diagnose> diagnosen = new ArrayList<>();
        Diagnose diagnose;
        while (rs.next()) {
            diagnose = getDiagnose(rs.getInt("diagid"), fall);
            if( diagnose != null) {
                diagnosen.add ( diagnose );
            }
        }

        return diagnosen;
    }

    /**
     * Gibt Liste der hinterlegten Kassen zurueck.
     *
     * @return Liste der hinterlegten Kassen
     * @throws SQLException
     */
    public static List<Kasse> getAllKassen() throws SQLException {
        Statement statement = MySqlConnectionFactory.getConnection().createStatement();
        ResultSet rs = statement.executeQuery(SELECT_ALL_KASSEN);

        List<Kasse> kassen = new ArrayList<>();
        while (rs.next()) {
            kassen.add(getKasse(rs));
        }

        return kassen;
    }

    private static Kasse getKasse(int kassenid) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(SELECT_KASSE_BY_KASSENID);
        statement.setInt(1, kassenid);
        ResultSet rs = statement.executeQuery();

        rs.next(); // TODO
        return getKasse(rs);
    }

    /**
     * Extrahiert ein Objekt {@link Kasse} aus einem gegebenen {@link ResultSet}.
     *
     * @param rs ResultSet from Database Query.
     * @return {@link Kasse}
     * @throws SQLException wenn Fehler bei der SQL Verarbeitung auftreten.
     */
    private static Kasse getKasse(ResultSet rs) throws SQLException {
        Kasse kasse = new Kasse();
        kasse.setKassenID(rs.getInt("kassenid"));
        kasse.setName(rs.getString("name"));
        kasse.setAdresse(rs.getString("adresse"));
        kasse.setPrivat(rs.getBoolean("privat"));
        setVersionInformation(kasse, rs);
        return kasse;
    }

    /**
     * Speichert Diagnose in die Datenbank.
     *
     * @param diagnose Diagnose
     * @throws SQLException
     */
    public static void setDiagnose(Diagnose diagnose) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(INSERT_DIAGNOSE);
        statement.setInt(1, diagnose.getArzt().getMitarbID());      // `Arzt`
        statement.setInt(2, diagnose.getDiagArt().id());            // `DiagArt`
        statement.setInt(3, diagnose.getErsteller());               // `Ersteller`
        statement.setString(4, diagnose.getFreiText());             // `Freitext`
        statement.setString(5, diagnose.getIcd10code().getCode());  // `ICD10Code`
        statement.setInt(6, diagnose.getIcd10code().getVersion());  // `ICD10Version`
        statement.setInt(7, diagnose.getBearbeiter());              // `LetzterBearbeiter`
        statement.setInt(8, diagnose.getFall().getFallID());        // `FallID`
        statement.execute();
    }

    /**
     * Speichert eine raw HL7 Nachricht in die DB.
     *
     * @param hl7msg    raw HL7 Nachricht
     * @param timestamp LocalDateTime
     * @param source    Source bzw. Destination
     * @throws SQLException
     */
    public static void setHL7Nachricht(String hl7msg, LocalDateTime timestamp, String source) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(INSERT_HL7NACHRICHT);
        statement.setString(1, hl7msg);
        statement.setTimestamp(2, Timestamp.valueOf(timestamp));
        statement.setString(3, source);
        statement.execute();
    }

    /**
     * Gibt die letzten 30 HL7 Logeintraege aus der DB zurueck.
     *
     * @return
     * @throws SQLException
     */
    public static List<HL7LogEntry> getLastHL7LogEntries() throws SQLException {
        return getLastHL7LogEntries(30);
    }

    /**
     * Gibt die angegebene Anzahl HL7 Logeintraege aus der DB zurueck.
     *
     * @param last Anzahl Eintraege
     * @return Liste mit HL7LogEntries zurueck.
     * @throws SQLException
     */
    public static List<HL7LogEntry> getLastHL7LogEntries(int last) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(SELECT_LAST_HL7ENTRIES);
        statement.setInt(1, last);
        ResultSet rs = statement.executeQuery();

        List<HL7LogEntry> hl7entries = new ArrayList<>();
        while (rs.next()) {
            hl7entries.add(getHL7LogEntry(rs));
        }
        return hl7entries;
    }

    /**
     * Speichert eine HL7 Nachricht in der hl7 Log Tabelle.
     *
     * @param entry HL7 Nachricht
     * @throws SQLException
     */
    public static void setHL7LogEntry(HL7LogEntry entry) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(INSERT_HL7NACHRICHT_);
        statement.setString(1, entry.getMessage());
        statement.setTimestamp(2, Timestamp.valueOf(entry.getTimestamp()));
        statement.setString(3, entry.getSource());
        statement.setString(4, entry.getDirection().toString());
        statement.execute();
    }

    private static HL7LogEntry getHL7LogEntry(ResultSet rs) throws SQLException {
        HL7LogEntry entry = new HL7LogEntry(rs.getInt("msgid"));
        entry.setMessage(rs.getString("hl7msg"));
        entry.setTimestamp(rs.getTimestamp("timestamp").toLocalDateTime());
        entry.setSource(rs.getString("source"));
        entry.setDirection(HL7LogEntry.Direction.parseDirection(rs.getString("direction")));
        return entry;
    }

    /**
     * Gibt alle FallIDs eines Patienten zurueck.
     *
     * @param patid Patienten ID
     * @return Liste aller FallIDs
     * @throws SQLException
     */
    public static List<Integer> getAlleFallIdsByPatID(int patid) throws SQLException {
        PreparedStatement statement = MySqlConnectionFactory.getConnection().prepareStatement(SELECT_FALLIDS_BY_PATID);
        statement.setInt(1, patid);
        ResultSet rs = statement.executeQuery();

        List<Integer> fallids = new ArrayList<>();
        while (rs.next()) {
            fallids.add(rs.getInt("fallid"));
        }
        return fallids;
    }
}