/// <summary>
/// Methode exportiert alle Noten in eine csv-Datei
/// Format: ID;Name;Fachkürzel;Lehrerkürzel;Zeugnisnote
/// </summary>
/// <param name="fileName">Der Dateiname.</param>
public static void ExportiereNoten(string fileName)
{
using (FileStream stream = new FileStream(fileName, FileMode.Create, FileAccess.Write))
using (StreamWriter writer = new StreamWriter(stream))
{
var schuelerAdapter = new SchuelerTableAdapter();
foreach (var dbSchueler in schuelerAdapter.GetData())
{
Schueler schueler = new Schueler(dbSchueler);
foreach (var fachNote in schueler.getNoten.alleFaecher)
{
var fachKuerzel = fachNote.getFach.Kuerzel;
if (IsExportNecessary(fachKuerzel, schueler))
{
var lehrer = Zugriff.Instance.KursRep.Find(fachNote.kursId).getLehrer;
string lehrerKuerzel = lehrer == null ? "" : lehrer.Kuerzel;
var noteImFach = schueler.getNoten.getFach(fachNote.kursId);
var note = noteImFach.getRelevanteNote(Zeitpunkt.Jahresende);
writer.WriteLine(schueler.Id +""+ Separator + schueler.Name + Separator + noteImFach.getFach.Kuerzel + Separator + lehrerKuerzel + Separator + note);
}
}
if (schueler.getKlasse.Jahrgangsstufe == Jahrgangsstufe.Elf && schueler.getKlasse.Schulart == Schulart.FOS)
{
var fpa = schueler.FPANoten;
if (!fpa.IsErfolgNull())
{
writer.WriteLine(schueler.Id + Separator + schueler.Name + Separator + fpa.Erfolg);
}
}
}
}
}
/// <summary>
/// Die Methode zum Einlesen der Daten.
/// </summary>
/// <param name="fileName">Der Dateiname.</param>
public static void ReadSchueler(string fileName)
{
using (StreamReader reader = new StreamReader(fileName, Encoding.GetEncoding("iso-8859-1")))
using (SchuelerTableAdapter tableAdapter = new SchuelerTableAdapter())
using (KlasseTableAdapter klasseTableAdapter = new KlasseTableAdapter())
{
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
if (string.IsNullOrEmpty(line))
{
log.Debug("Ignoriere Leerzeile");
continue;
}
string[] array = line.Split(new string[] { "\t" }, StringSplitOptions.None);
string[] cleanArray = array.Select(aString => aString.Trim(new char[] { '\"', ' ', '\n' })).ToArray();
//TODO: Schueler nicht in Teilklassen stecken (bei Mischklassen, vor allem FOS/BOS-Mischung problematisch)
var klasse = GetKlasseId(klasseTableAdapter, cleanArray[klasseSpalte].Trim());
if (klasse == null)
{
log.Debug("Ignoriere einen Schüler ohne richtige Klasse. Übergebene Klasse war " + cleanArray[klasseSpalte]);
continue;
}
// wenn der Schüler noch nicht vorhanden ist
var table = tableAdapter.GetDataById(int.Parse(cleanArray[schuelerIdSpalte]));
diNoDataSet.SchuelerRow row = (table.Count == 0) ? table.NewSchuelerRow() : table[0];
FillRow(cleanArray, klasse, row);
if (table.Count == 0)
{
table.AddSchuelerRow(row);
}
row.AcceptChanges();
tableAdapter.Update(row);
// Diese Zeile meldet den Schüler bei allen notwendigen Kursen seiner Klasse an
new Schueler(row).WechsleKlasse(new Klasse(klasse));
}
}
}
private void diNoDataSetBindingSource_CurrentChanged(object sender, EventArgs e)
{
var alteListe = this.fKSchuelerToKlasseBindingSource.DataSource as diNo.diNoDataSet.SchuelerDataTable;
if (aenderungenVorhanden)
{
var result = MessageBox.Show("Sie hatten in der Klasse " + aktuelleKlasse + " Änderungen. Wollen Sie speichern?", "Frage", MessageBoxButtons.YesNo);
if (result == System.Windows.Forms.DialogResult.Yes)
{
new SchuelerTableAdapter().Update(alteListe);
}
}
var neueKlasse = ((this.klasseBindingSource.Current as DataRowView).Row as diNoDataSet.KlasseRow);
var schuelerDerKlasse = new SchuelerTableAdapter().GetDataByKlasse(neueKlasse.Id);
this.fKSchuelerToKlasseBindingSource.DataSource = schuelerDerKlasse;
schuelerDerKlasse.RowChanged += schuelerDerKlasse_RowChanged;
aktuelleKlasse = neueKlasse.Bezeichnung;
aenderungenVorhanden = false;
}
public override void Init()
{
SchuelerTableAdapter BerichtTableAdapter;
rpt.BerichtBindingSource.DataMember = "Schueler";
BerichtTableAdapter = new SchuelerTableAdapter();
BerichtTableAdapter.ClearBeforeFill = true;
BerichtTableAdapter.FillByKlasse(rpt.diNoDataSet.Schueler, 89); // 12Wf
rpt.reportViewer.LocalReport.ReportEmbeddedResource = "diNo.rptSchuelerliste.rdlc";
}
public void LoadSchueler(bool nurAktive=true)
{
diNoDataSet.SchuelerDataTable sListe;
int NotStatus = nurAktive?1:255; // Status=1 bedeutet abgemeldet,
var ta = new SchuelerTableAdapter();
if (SiehtAlles)
sListe = ta.GetDataByStatus(NotStatus); // alle Schüler reinladen
else if (IstNurNormalerLehrer)
sListe = ta.GetDataByLehrerId(NotStatus,lehrer.Id); // nur eigene Schüler
else
sListe = ta.GetDataByLehrerIdFPASem(NotStatus,lehrer.Id); // Lehrer mit erweiterten Rollen
AnzahlSchueler = sListe.Count;
foreach (var sRow in sListe)
{
Klasse k;
Schueler s = new Schueler(sRow);
SchuelerRep.Add(s); // Schüler ins Repository aufnehmen
if (KlassenRep.Contains(sRow.KlasseId))
{
k = KlassenRep.Find(sRow.KlasseId);
}
else
{
k = new Klasse(sRow.KlasseId);
Klassen.Add(k);
KlassenRep.Add(k);
}
s.getKlasse = k; // dem Schüler die Klasseninstanz zuweisen, damit die nicht jedesmal neu erzeugt werden muss!
k.eigeneSchueler.Add(s); // und umgekehrt dieser Klasse den Schüler hinzufügen
}
// alles sortieren
Klassen.Sort((x, y) => x.Bezeichnung.CompareTo(y.Bezeichnung));
foreach (var klasse in Klassen)
{
klasse.eigeneSchueler.Sort((x, y) => x.NameVorname.CompareTo(y.NameVorname));
if (klasse.KlassenleiterId == lehrer.Id) eigeneKlasse = klasse;
}
}
private IList<int> GetAlleGueltigenSchuelerIds()
{
var result = new List<int>();
command.CommandText = "SELECT _SCHUELER_ID FROM DSchueler";
using (var cmdResult = command.ExecuteReader())
{
var schuelerTable = new SchuelerTableAdapter();
while (cmdResult.Read())
{
int schuelerId = cmdResult.GetInt32(0);
if (schuelerTable.GetDataById(schuelerId).Count > 0) // Entferne die Schülerdatensätze aus dem Vorjahr oder sonstige Wartelisten- und Spaßdatensätze
{
result.Add(schuelerId);
}
}
}
return result;
}
/// <summary>
/// Die Methode zum Einlesen der Daten.
/// </summary>
/// <param name="fileName">Der Dateiname.</param>
public static void ReadSchueler(string fileName)
{
using (StreamReader reader = new StreamReader(fileName, Encoding.GetEncoding("iso-8859-1")))
using (SchuelerTableAdapter tableAdapter = new SchuelerTableAdapter())
using (KlasseTableAdapter klasseTableAdapter = new KlasseTableAdapter())
{
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
if (string.IsNullOrEmpty(line))
{
log.Debug("Ignoriere Leerzeile");
continue;
}
string[] array = line.Split(new string[] { "\t" }, StringSplitOptions.None);
string[] cleanArray = array.Select(aString => aString.Trim(new char[] { '\"', ' ', '\n' })).ToArray();
int klasseId = GetKlasseId(klasseTableAdapter, cleanArray[klasseSpalte].Trim());
if (klasseId == -1)
{
log.Debug("Ignoriere einen Schüler ohne richtige Klasse. Übergebene Klasse war " + cleanArray[klasseSpalte]);
continue;
}
// wenn der Schüler noch nicht vorhanden ist
if (tableAdapter.GetDataById(int.Parse(cleanArray[schuelerIdSpalte])).Count == 0)
{
tableAdapter.Insert(
int.Parse(cleanArray[schuelerIdSpalte]),
cleanArray[nachnameSpalte],
cleanArray[vornameSpalte],
klasseId,
cleanArray[rufnameSpalte],
cleanArray[geschlechtSpalte],
ParseDate(cleanArray[geburtsdatumSpalte]),
cleanArray[geburtsortSpalte],
cleanArray[bekenntnisSpalte],
cleanArray[anschr1PlzSpalte],
cleanArray[anschr1OrtSpalte],
cleanArray[anschr1StrasseSpalte],
cleanArray[anschr1TelefonSpalte],
ChangeAusbildungsrichtung(cleanArray[ausbildungsrichtungSpalte]),
cleanArray[fremdsprache2Spalte],
cleanArray[reliOderEthikSpalte],
cleanArray[wahlpflichtfachSpalte],
cleanArray[wahlfach1Spalte],
cleanArray[wahlfach2Spalte],
cleanArray[wahlfach3Spalte],
cleanArray[wahlfach4Spalte],
cleanArray[wdh1JahrgangsstufeSpalte],
cleanArray[wdh2JahrgangsstufeSpalte],
cleanArray[wdh1GrundSpalte],
cleanArray[wdh2GrundSpalte],
ParseDate(cleanArray[probezeitBisSpalte]),
ParseDate(cleanArray[austrittsdatumSpalte]),
cleanArray[schulischeVorbildungSpalte],
cleanArray[beruflicheVorbildungSpalte],
cleanArray[lrsStoerungSpalte] == "1",
cleanArray[lrsSchwaecheSpalte] == "1",
ParseDate(cleanArray[lrsBisDatumSpalte]),
cleanArray[verwandtschaftsbezeichnungEltern1Spalte],
cleanArray[nachnameEltern1Spalte],
cleanArray[vornameEltern1Spalte],
cleanArray[anredeEltern1Spalte],
cleanArray[nachnameEltern2Spalte],
cleanArray[vornameEltern2Spalte],
cleanArray[anredeEltern2Spalte],
cleanArray[verwandtschaftsbezeichnungEltern2Spalte]
);
}
}
}
}
/// <summary>
/// Methode importiert die Zeugnisnoten des Vorjahres.
/// </summary>
/// <param name="fileName">Der Dateiname.</param>
public static void ImportiereNoten(string fileName)
{
using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
using (StreamReader reader = new StreamReader(stream))
{
var schuelerAdapter = new SchuelerTableAdapter();
var fpaAdapter = new FpANotenTableAdapter();
Dictionary<string, Kurs> kurse = GetKursverzeichnis();
kurse.Add("G", GetGeschichteKurs());
while (!reader.EndOfStream)
{
string[] line = reader.ReadLine().Split(SeparatorChar);
int schuelerId = int.Parse(line[0]);
var schuelerGefunden = schuelerAdapter.GetDataById(schuelerId);
if (schuelerGefunden == null || schuelerGefunden.Count == 0)
{
continue;
}
var schueler = new Schueler(schuelerGefunden[0]);
if (schueler.getKlasse.Jahrgangsstufe == Jahrgangsstufe.Zwoelf)
{
// nur bei Schülern in der zwölften Klasse wird irgendetwas importiert
if (line.Length == 5)
{
//notenzeile
string nachname = line[1];
string fachKuerzel = line[2];
string lehrerKuerzel = line[3];
if (string.IsNullOrEmpty(line[4])) // was das heißt ist aber auch fraglich. keine Note?
{
continue;
}
byte zeugnisnote = byte.Parse(line[4]);
if (schueler.getKlasse.Jahrgangsstufe == Jahrgangsstufe.Zwoelf)
{
schueler.MeldeAn(kurse[fachKuerzel.ToUpper()]);
BerechneteNote bnote = new BerechneteNote(kurse[fachKuerzel.ToUpper()].Id, schueler.Id);
bnote.ErstesHalbjahr = false;
bnote.JahresfortgangGanzzahlig = zeugnisnote;
bnote.Abschlusszeugnis = zeugnisnote;
bnote.writeToDB();
}
}
else if (line.Length == 3)
{
//FpA-Zeile
string nachname = line[1];
int gesamterfolg = int.Parse(line[2]);
fpaAdapter.Insert(schuelerId, "", null, null, null, null, gesamterfolg, null, null);
}
else
throw new InvalidOperationException("Diese Zeile hat " + line.Length + " Spalten. Das ist mir unbekannt");
}
}
}
TrageFehlendeSchülerInDummykurseEin();
}
/// <summary>
/// Methode importiert die Zeugnisnoten des Vorjahres.
/// </summary>
/// <param name="fileName">Der Dateiname.</param>
public static void ImportiereNotenAusWinSD(string fileName)
{
using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
using (StreamReader reader = new StreamReader(stream))
{
var schuelerAdapter = new SchuelerTableAdapter();
var fpaAdapter = new FpANotenTableAdapter();
Kurs geschichte = GetGeschichteKurs();
Dictionary<string, Kurs> kurse = new Dictionary<string, Kurs>();
kurse.Add("W11", FindOrCreateDummyKurs("Rechtslehre aus elfter Jahrgangsstufe", "Rl"));
kurse.Add("S11", FindOrCreateDummyKurs("Chemie aus elfter Jahrgangsstufe", "C"));
kurse.Add("T11", FindOrCreateDummyKurs("TZ aus elfter Jahrgangsstufe", "TZ"));
kurse.Add("A11", null); // laut Stundentafel legt der Agrarzweig außer Geschichte nichts ab.
while (!reader.EndOfStream)
{
string[] line = reader.ReadLine().Split(SeparatorChar);
if (line.Length == 5)
{
//notenzeile
int schuelerId = int.Parse(line[0]);
string faecherspiegel = line[1];
fpaNote fpaNote = OmnisDB.Konstanten.GetFpaNoteFromString(line[2]);
byte? geschichteNote = string.IsNullOrEmpty(line[3]) ? (byte?)null : byte.Parse(line[3]);
byte? zweitesAbgelegtesFachNote = string.IsNullOrEmpty(line[4]) ? (byte?)null : byte.Parse(line[4]);
var schuelerGefunden = schuelerAdapter.GetDataById(schuelerId);
if (schuelerGefunden == null || schuelerGefunden.Count == 0)
{
continue;
}
var schueler = new Schueler(schuelerGefunden[0]);
if (geschichteNote != null)
{
TrageNoteEin(geschichte, (byte)geschichteNote, schueler);
}
Kurs zweitesFach = kurse[faecherspiegel];
if (zweitesFach != null && zweitesAbgelegtesFachNote != null)
{
TrageNoteEin(zweitesFach, (byte)zweitesAbgelegtesFachNote, schueler);
}
fpaAdapter.Insert(schuelerId, "", null, null, null, null, (int)fpaNote,null,null);
}
else
throw new InvalidOperationException("Diese Zeile hat " + line.Length + " Spalten. Das ist mir unbekannt");
}
}
TrageFehlendeSchülerInDummykurseEin();
}
/// <summary>
/// Konstruktor.
/// </summary>
/// <param name="sourceFileName">Der Dateiname des Exportfiles der leeren DZeugnis-Tabelle.</param>
/// <param name="targetFileName">Der Dateiname des zu erstellenden ImportFiles der DZeugnis-Tabelle.</param>
public DZeugnisFileController(string sourceFileName, string targetFileName, Zeitpunkt zeitpunkt)
{
Faecherspiegel faecher = new Faecherspiegel();
SchuelerTableAdapter ada = new SchuelerTableAdapter();
using (FileStream inStream = new FileStream(sourceFileName, FileMode.Open, FileAccess.Read))
using (StreamReader reader = new StreamReader(inStream, Encoding.GetEncoding("iso-8859-1")))
using (FileStream outStream = new FileStream(targetFileName, FileMode.Create, FileAccess.Write))
using (StreamWriter writer = new StreamWriter(outStream, Encoding.GetEncoding("iso-8859-1")))
{
while (!reader.EndOfStream)
{
var zeile = new VerwalteZeile(reader.ReadLine());
int schuelerId = int.Parse(zeile[Konstanten.schuelerIdCol]);
// Prüfe vorher, ob der Schüler existiert (hier kommen tausend Schüler aus den Vorjahren)
if (ada.GetDataById(schuelerId).Count == 0)
{
continue;
}
Schueler schueler = Zugriff.Instance.SchuelerRep.Find(schuelerId);
if (BrauchtZeugnis(schueler, zeitpunkt))
{
zeile[Konstanten.fpaCol] = Konstanten.GetFpaString(GetFpaNote(zeitpunkt, schueler));
KlassenzielOderGefaehrdung zielerreichung = GetZielerreichung(zeitpunkt, schueler);
zeile[Konstanten.klassenzielOderGefaehrdungCol] = Konstanten.GetKlassenzielOderGefaehrdungString(zielerreichung);
if (zeitpunkt == Zeitpunkt.ErstePA || zeitpunkt == Zeitpunkt.ZweitePA || zeitpunkt == Zeitpunkt.DrittePA)
{
zeile[Konstanten.zeugnisartCol] = zielerreichung == KlassenzielOderGefaehrdung.AbschlusspruefungOhneErfolg ? "J" : "A";
zeile[Konstanten.APBestandenCol] = Konstanten.GetBestandenString(GetBestanden(zeitpunkt, schueler));
}
zeile[Konstanten.abweisungCol] = Konstanten.GetAbweisungString(schueler.GefahrDerAbweisung);
var seminarfachNote = new SeminarfachnoteTableAdapter().GetDataBySchuelerId(schuelerId);
if (seminarfachNote != null && seminarfachNote.Count == 1 && !seminarfachNote[0].IsGesamtnoteNull())
{
zeile[Konstanten.seminarfachGesamtnote] = string.Format(CultureInfo.CurrentCulture, "{0:00}", seminarfachNote[0].Gesamtnote);
zeile[Konstanten.seminarfachThema] = !string.IsNullOrEmpty(seminarfachNote[0].ThemaKurz) ? seminarfachNote[0].ThemaKurz : seminarfachNote[0].ThemaLang.Substring(0, 128);
}
string faecherspiegel = zeile[Konstanten.faecherspiegelCol];
if (string.IsNullOrEmpty(faecherspiegel))
{
log.Warn("Für den Schüler " + schueler.NameVorname + " gibt es keinen passenden Fächerspiegel!");
continue;
}
for (int i = 0; i < 30; i++)
{
zeile[Konstanten.notePflichtfach1Col + i] = faecher.GetFachNoteString(faecherspiegel, i, schueler.getKlasse.Schulart, schueler, zeitpunkt);
}
if (Konstanten.ZeugnisartFromString(zeile[Konstanten.zeugnisartCol]) != Zeugnisart.Zwischenzeugnis)
{
for (int i = 0; i < 20; i++)
{
zeile[Konstanten.jahresfortgangPflichtfach1Col + i] = faecher.FindeJahresfortgangsNoten(faecherspiegel, i, schueler.getKlasse.Schulart, schueler, zeitpunkt);
zeile[Konstanten.APschriftlichPflichtfach1Col + i] = faecher.FindeAPSchriftlichNoten(faecherspiegel, i, schueler.getKlasse.Schulart, schueler, zeitpunkt);
zeile[Konstanten.APmuendlichPflichtfach1Col + i] = faecher.FindeAPMuendlichNoten(faecherspiegel, i, schueler.getKlasse.Schulart, schueler, zeitpunkt);
zeile[Konstanten.gesamtNoteMitAPGanzzahlig1Col + i] = faecher.GetFachNoteString(faecherspiegel, i, schueler.getKlasse.Schulart, schueler, zeitpunkt);
}
}
SucheWahlpflichtfach(zeitpunkt, faecher, zeile, schueler, Konstanten.weiteresFach1BezeichnungCol, Konstanten.weiteresFach1NoteCol);
SucheWahlpflichtfach(zeitpunkt, faecher, zeile, schueler, Konstanten.weiteresFach2BezeichnungCol, Konstanten.weiteresFach2NoteCol);
SucheWahlpflichtfach(zeitpunkt, faecher, zeile, schueler, Konstanten.weiteresFach3BezeichnungCol, Konstanten.weiteresFach3NoteCol);
}
// rausgeschrieben werden immer alle Zeugnisse, da im Import "ersetzen" angehakt werden muss
writer.WriteLine(zeile.ToString());
}
}
}
/// <summary>
/// Trägt einen Schüler in einen Kurs in der Datenbank ein.
/// </summary>
/// <param name="kurs">Der Kurs.</param>
/// <param name="dbKlasse">Die Klasse.</param>
/// <param name="kursSelector">Ein Selektor zur Prüfung, welche Schüler in welchen Kurs auch wirklich müssen.</param>
public static void AddSchuelerToKurs(diNoDataSet.KursRow kurs, diNoDataSet.KlasseRow dbKlasse, ISchuelerKursSelector kursSelector)
{
using (SchuelerTableAdapter sAdapter = new SchuelerTableAdapter())
{
sAdapter.ClearBeforeFill = true;
var schuelerDerKlasse = sAdapter.GetDataByKlasse(dbKlasse.Id);
if (schuelerDerKlasse.Count == 0)
{
if (dbKlasse.Bezeichnung.StartsWith("FB") && dbKlasse.Bezeichnung.EndsWith("F"))
{
// z.B. FB13T_F meint die FOSler der Mischklasse FB13T. Evtl. sind die als eigene Klasse F13T in der DB
string modifizierteKlasse = dbKlasse.Bezeichnung.Replace("FB", "F");
modifizierteKlasse = modifizierteKlasse.Replace("_F", string.Empty);
dbKlasse = FindOrCreateKlasse(modifizierteKlasse, false);
if (dbKlasse != null)
{
schuelerDerKlasse = sAdapter.GetDataByKlasse(dbKlasse.Id);
}
}
if (dbKlasse.Bezeichnung.StartsWith("FB") && dbKlasse.Bezeichnung.EndsWith("B"))
{
// z.B. FB13T_B meint die BOSler der Mischklasse FB13T. Evtl. sind die als eigene Klasse B13T in der DB
string modifizierteKlasse = dbKlasse.Bezeichnung.Replace("FB", "B");
modifizierteKlasse = modifizierteKlasse.Replace("_B", string.Empty);
dbKlasse = FindOrCreateKlasse(modifizierteKlasse, false);
if (dbKlasse != null)
{
schuelerDerKlasse = sAdapter.GetDataByKlasse(dbKlasse.Id);
}
}
if (dbKlasse.Bezeichnung.EndsWith("_W") && dbKlasse.Bezeichnung.Contains("SW"))
{
// z.B. B13SW_W meint die Wirtschaftler der Mischklasse B13SW. Evtl. sind die nur als Mischklasse in der DB
string modifizierteKlasse = dbKlasse.Bezeichnung.Replace("_W", string.Empty);
dbKlasse = FindOrCreateKlasse(modifizierteKlasse, false);
if (dbKlasse != null)
{
schuelerDerKlasse = sAdapter.GetDataByKlasseAndZweig(dbKlasse.Id, "W");
if (schuelerDerKlasse.Count == 0)
{
schuelerDerKlasse = sAdapter.GetDataByKlasseAndZweig(dbKlasse.Id, "WVR");
}
}
}
if (dbKlasse.Bezeichnung.EndsWith("_S") && dbKlasse.Bezeichnung.Contains("SW"))
{
// z.B. B13SW_S meint die Wirtschaftler der Mischklasse B13SW. Evtl. sind die nur als Mischklasse in der DB
string modifizierteKlasse = dbKlasse.Bezeichnung.Replace("_S", string.Empty);
dbKlasse = FindOrCreateKlasse(modifizierteKlasse, false);
if (dbKlasse != null)
{
schuelerDerKlasse = sAdapter.GetDataByKlasseAndZweig(dbKlasse.Id, "S");
}
}
if (dbKlasse.Bezeichnung.EndsWith("_T") && dbKlasse.Bezeichnung.Contains("TW"))
{
// Techniker aus der Mischklasse
string modifizierteKlasse = dbKlasse.Bezeichnung.Replace("_T", string.Empty);
dbKlasse = FindOrCreateKlasse(modifizierteKlasse, false);
if (dbKlasse != null)
{
schuelerDerKlasse = sAdapter.GetDataByKlasseAndZweig(dbKlasse.Id, "T");
}
}
if (dbKlasse.Bezeichnung.EndsWith("_W") && dbKlasse.Bezeichnung.Contains("TW"))
{
// Wirtschaftler aus der Mischklasse
string modifizierteKlasse = dbKlasse.Bezeichnung.Replace("_W", string.Empty);
dbKlasse = FindOrCreateKlasse(modifizierteKlasse, false);
if (dbKlasse != null)
{
schuelerDerKlasse = sAdapter.GetDataByKlasseAndZweig(dbKlasse.Id, "W");
}
}
if (dbKlasse.Bezeichnung.EndsWith("_T") && dbKlasse.Bezeichnung.Contains("ST"))
{
// Techniker aus der Mischklasse
string modifizierteKlasse = dbKlasse.Bezeichnung.Replace("_T", string.Empty);
dbKlasse = FindOrCreateKlasse(modifizierteKlasse, false);
if (dbKlasse != null)
{
schuelerDerKlasse = sAdapter.GetDataByKlasseAndZweig(dbKlasse.Id, "T");
}
}
if (dbKlasse.Bezeichnung.EndsWith("_S") && dbKlasse.Bezeichnung.Contains("ST"))
{
// Soziale aus der Mischklasse
string modifizierteKlasse = dbKlasse.Bezeichnung.Replace("_S", string.Empty);
dbKlasse = FindOrCreateKlasse(modifizierteKlasse, false);
if (dbKlasse != null)
{
schuelerDerKlasse = sAdapter.GetDataByKlasseAndZweig(dbKlasse.Id, "S");
}
}
}
if (schuelerDerKlasse.Count == 0)
{
//throw new InvalidOperationException("Klasse " + dbKlasse.Bezeichnung + " ist leer");
log.Error("Klasse " + dbKlasse.Bezeichnung + " ist leer");
}
foreach (var schueler in schuelerDerKlasse)
{
AddSchuelerToKurs(kurs, kursSelector, schueler);
}
}
}
/// <summary>
/// Prüft, ob die Legasthenievermerke der Datenbank mit der Excel-Datei übereinstimmen.
/// </summary>
/// <param name="sheet">Das Excel-Sheet.</param>
/// <param name="kursAdapter">Der Kurs-Adapter.</param>
/// <param name="kurs">Die Zeile des aktuellen Kurses in der Datenbank.</param>
/// <param name="alleSchueler">Liste aller Schüler aus der Datenbank.</param>
private static void CheckLegastheniker(ExcelSheet sheet, KursTableAdapter kursAdapter, diNoDataSet.KursRow kurs, diNoDataSet.SchuelerKursDataTable alleSchueler)
{
//TODO: Methode ungetestet
using (FachTableAdapter fachAdapter = new FachTableAdapter())
{
var deutsch = fachAdapter.GetDataByKuerzel("D")[0];
var englisch = fachAdapter.GetDataByKuerzel("E")[0];
if (kurs.FachId == deutsch.Id || kurs.FachId == englisch.Id)
{
foreach (var schueler in alleSchueler)
{
var excelSchueler = sheet.Schueler.FirstOrDefault(
x => x.Id == schueler.SchuelerId
);
//falls der Schüler noch in der Excel-Datei drinsteht. Könnte ja sein, dass er schon ausgetreten o. ä. ist
if (excelSchueler != null)
{
var dbSchueler = new SchuelerTableAdapter().GetDataById(schueler.SchuelerId)[0];
if (excelSchueler.IsLegastheniker != (dbSchueler.LRSSchwaeche || dbSchueler.LRSStoerung))
{
excelSchueler.IsLegastheniker = (dbSchueler.LRSSchwaeche || dbSchueler.LRSStoerung);
sheet.SetLegasthenieVermerk(excelSchueler);
}
}
}
}
}
}
/// <summary>
/// Holt sich die aktuelle Schülerliste aus der Datenbank. Falls ein Schüler fehlt, wird dieser in Excel unten angehängt.
/// Todo: Abgemeldete Schüler rauslöschen (zumindest den Namen).
/// </summary>
/// <param name="sheet">Das ExcelSheet.</param>
/// <param name="kursId">Die Id des Kurses.</param>
/// <returns>Die Datentabelle mit allen Schüler-Kurs-Zuordnungen.</returns>
private static diNoDataSet.SchuelerKursDataTable CheckSchueler(ExcelSheet sheet, int kursId)
{
var alleSchueler = new SchuelerKursTableAdapter().GetDataByKursId(kursId);
foreach (var schueler in alleSchueler)
{
if (!sheet.Schueler.Any(x => x.Id == schueler.SchuelerId))
{
// Dieser Schüler fehlt offenbar bisher
var dbSchueler = new SchuelerTableAdapter().GetDataById(schueler.SchuelerId)[0];
// TODO: Testen, ob da wirklich null drinsteht oder eher DateTime.MinValue oder sowas
if (dbSchueler.Austrittsdatum == null)
{
sheet.AppendSchueler(new Schueler(dbSchueler.Id, dbSchueler.Vorname, dbSchueler.Name, dbSchueler.LRSSchwaeche || dbSchueler.LRSStoerung, ""));
}
}
}
return alleSchueler;
}
/// <summary>
/// Hole alle Daten von Neuem aus der Datenbank.
/// </summary>
public void Refresh()
{
var rst = new SchuelerTableAdapter().GetDataById(this.Id);
if (rst.Count == 1)
{
this.data = rst[0];
}
else
{
throw new InvalidOperationException("Konstruktor Schueler: Ungültige ID.");
}
this.klasse = null;
this.kurse = null;
this.noten = null;
this.vorkommnisse = null;
}
