ts-api/dist/core/abschluss/AbschlussManager.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.cast_de_nrw_schule_svws_core_abschluss_AbschlussManager = exports.AbschlussManager = void 0;
const JavaObject_1 = require("../../java/lang/JavaObject");
const GEAbschlussFach_1 = require("../../core/data/abschluss/GEAbschlussFach");
const AbschlussErgebnis_1 = require("../../core/data/abschluss/AbschlussErgebnis");
const StringBuilder_1 = require("../../java/lang/StringBuilder");
const Abschluss_1 = require("../../core/types/Abschluss");
const GELeistungsdifferenzierteKursart_1 = require("../../core/types/ge/GELeistungsdifferenzierteKursart");
const Vector_1 = require("../../java/util/Vector");
const HashSet_1 = require("../../java/util/HashSet");
class AbschlussManager extends JavaObject_1.JavaObject {
    constructor() {
        super();
    }
    /**
     * Erzeugt ein Ergebnis der Abschlussberechnung unter Angabe, ob dieser erworben
     * wurde. Die Liste der Nachprüfungsfächer ist leer und ein Log ist nicht zugeordnet.
     * Sollten Nachprüfungsmöglichkeiten bestehen so ist die Methode
     * {@link AbschlussManager#getErgebnisNachpruefung} zu nutzen.
     * und ob dieser erworben wurde.
     *
     * @param abschluss   der Abschluss für den das Ergebnis erzeugt wird
     * @param erworben    true, falls der Abschluss erworben wurde, sonst false
     *
     * @return das Ergebnis der Abschlussberechnung
     */
    static getErgebnis(abschluss, erworben) {
        let ergebnis = new AbschlussErgebnis_1.AbschlussErgebnis();
        ergebnis.abschluss = abschluss === null ? null : abschluss.toString();
        ergebnis.erworben = erworben;
        ergebnis.npFaecher = null;
        ergebnis.log = null;
        return ergebnis;
    }
    /**
     * Erzeugt ein Ergebnis der Abschlussberechnung, wo der Abschluss nicht erreicht wurde, aber ggf.
     * noch durch Nachprüfungen erreicht werden kann. Ein log wird nicht zugeordnet.
     *
     * @param abschluss    der Abschluss für den das Ergebnis erzeugt wird
     * @param np_faecher   eine Liste von Nachprüfungsfächern, falls eine Nachprüfung möglich ist,
     *                     ansonsten null oder eine leere Liste
     *
     * @return das Ergebnis der Abschlussberechnung
     */
    static getErgebnisNachpruefung(abschluss, np_faecher) {
        let ergebnis = new AbschlussErgebnis_1.AbschlussErgebnis();
        ergebnis.abschluss = abschluss === null ? null : abschluss.toString();
        ergebnis.erworben = false;
        if ((np_faecher === null) || (np_faecher.size() === 0))
            ergebnis.npFaecher = null;
        else
            ergebnis.npFaecher = np_faecher;
        ergebnis.log = null;
        return ergebnis;
    }
    /**
     * Gibt an, ob für einen Abschluss eine Nachprüfungsmöglichkeit besteht.
     *
     * @param ergebnis   das Abschluss-Ergebnis bei dem auf eine Nachprüfungsmöglichkeit
     *                   geprüft werden soll.
     *
     * @return true, falls eine Nachprüfungsmöglichkeit besteht, sonst false
     */
    static hatNachpruefungsmoeglichkeit(ergebnis) {
        return (ergebnis.npFaecher !== null) && ergebnis.npFaecher.size() > 0;
    }
    /**
     * Gibt die Nachprüfungsfächer als Komma-separierten String zurück.
     *
     * @param ergebnis   das Abschluss-Ergebnis bei dem die Nachprüfungsmöglichkeiten
     *                   ausgegeben werden sollen
     *
     * @return die Nachprüfungsfächer als Komma-separierten String
     */
    static getNPFaecherString(ergebnis) {
        if (ergebnis.npFaecher === null)
            return "";
        let sb = new StringBuilder_1.StringBuilder();
        for (let fach of ergebnis.npFaecher) {
            if (sb.length() > 0)
                sb.append(", ");
            sb.append(fach);
        }
        return sb.toString();
    }
    /**
     * Vergleicht die beiden Abschlüsse, ob sie identisch sind. Ein
     * Übergabewert null wird als {@link Abschluss#OHNE_ABSCHLUSS}
     * interpretiert.
     *
     * @param a   der eine Abschluss
     * @param b   der andere Abschluss
     *
     * @return true, falls sie identisch sind und ansonsten false
     */
    static equalsAbschluesse(a, b) {
        if ((a === null) || (Abschluss_1.Abschluss.OHNE_ABSCHLUSS.is(a)))
            return (b === null) || (Abschluss_1.Abschluss.OHNE_ABSCHLUSS.is(b));
        return JavaObject_1.JavaObject.equalsTranspiler(a, (b));
    }
    /**
     * Gibt den Abschluss zurück. Im Falle das kein Abschluss angegeben ist
     * wird Abschluss.OHNE_ABSCHLUSS zurückgegeben.
     *
     * @param ergebnis   das Ergebnis
     *
     * @return der Abschluss
     */
    static getAbschluss(ergebnis) {
        return ergebnis.abschluss === null ? Abschluss_1.Abschluss.OHNE_ABSCHLUSS.toString() : ergebnis.abschluss;
    }
    /**
     * Die Methode dient dem Erzeugen eines Faches für die Abschlussberechnung.
     *
     * @param kuerzel           das Kürzel des Faches
     * @param bezeichnung       die Bezeichnung des Faches
     * @param note              die Note, die in dem Fach erteilt wurde
     * @param kursart           gibt die Kursart Faches an: leistungsdifferenzierter (E-Kurs, G-Kurs) oder sonstiger Kurs
     * @param istFremdsprache   gibt an, ob es sich bei dem Fach um eine Fremdsprache handelt oder nicht
     *
     * @return das Abschlussfach
     */
    static erstelleAbschlussFach(kuerzel, bezeichnung, note, kursart, istFremdsprache) {
        let fach = new GEAbschlussFach_1.GEAbschlussFach();
        fach.kuerzel = kuerzel;
        fach.bezeichnung = (bezeichnung === null || JavaObject_1.JavaObject.equalsTranspiler("", (bezeichnung))) ? "---" : bezeichnung;
        fach.note = note;
        fach.kursart = kursart.kuerzel;
        fach.istFremdsprache = istFremdsprache === null ? false : istFremdsprache;
        return fach;
    }
    /**
     * Liefert eine List mit den Fachkürzeln aus der übergebenen Liste mit Abschlussfächern.
     *
     * @param faecher   die Liste mit Abschlussfächern
     *
     * @return die Liste mit den Fachkürzeln
     */
    static getKuerzel(faecher) {
        let result = new Vector_1.Vector();
        for (let i = 0; i < faecher.size(); i++) {
            let fach = faecher.get(i);
            if ((fach === null) || fach.kuerzel === null)
                continue;
            if (result.contains(fach.kuerzel))
                continue;
            result.add(fach.kuerzel);
        }
        return result;
    }
    /**
     * Prüft, ob vier leistungsdifferenzierte Fächer belegt wurden. Dabei wird nicht geprüft, ob
     * es sich um G oder E-Kurse handelt.
     *
     * @param abschluss_faecher   die Abschlussfächer
     *
     * @return true, falls vier leistungsdifferenzierte Fächer belegt wurden, sonst false
     */
    static pruefeHat4LeistungsdifferenzierteFaecher(abschluss_faecher) {
        if (abschluss_faecher.faecher === null)
            return false;
        let count = 0;
        let faecher = abschluss_faecher.faecher;
        for (let fach of faecher) {
            if (fach === null)
                continue;
            let kursart = GELeistungsdifferenzierteKursart_1.GELeistungsdifferenzierteKursart.from(fach.kursart);
            if ((kursart === GELeistungsdifferenzierteKursart_1.GELeistungsdifferenzierteKursart.E) || (kursart === GELeistungsdifferenzierteKursart_1.GELeistungsdifferenzierteKursart.G))
                count++;
        }
        return (count === 4);
    }
    /**
     * Prüft, ob Duplikate bei den Kürzeln der Fächer vorkommen. Dies darf zur korrekten
     * Ausführung des Abschlussalgorithmus nicht vorkommen.
     *
     * @param abschluss_faecher   die Abschlussfächer
     *
     * @return true, falls keine Duplikate vorkommen, sonst false
     */
    static pruefeKuerzelDuplikate(abschluss_faecher) {
        if (abschluss_faecher.faecher === null)
            return true;
        let kuerzel = new HashSet_1.HashSet();
        let faecher = abschluss_faecher.faecher;
        for (let fach of faecher) {
            if ((fach === null) || (fach.kuerzel === null))
                continue;
            if (!kuerzel.add(fach.kuerzel))
                return false;
        }
        return true;
    }
    isTranspiledInstanceOf(name) {
        return ['de.nrw.schule.svws.core.abschluss.AbschlussManager'].includes(name);
    }
}
exports.AbschlussManager = AbschlussManager;
function cast_de_nrw_schule_svws_core_abschluss_AbschlussManager(obj) {
    return obj;
}
exports.cast_de_nrw_schule_svws_core_abschluss_AbschlussManager = cast_de_nrw_schule_svws_core_abschluss_AbschlussManager;
//# sourceMappingURL=AbschlussManager.js.map