"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