Ist Django für mein Projekt geeignet?

[Pitwheazle]

Ok! Ich habe aber keine Idee, wie man die verschiednenen Aufgabentypen innerhalb eines Models abbilden kann. Alleine im Modul "Geometrie" (eines von 35) gibt es 13 verschiedene Untertypen, die ziemlich unterschiedliche Aufgaben erzeugen, einige mit Grafiken von geometrischen Figuren bzw. Körpern, einige mit Koordinatensystem, einige nur mit Text. Diese Typen sind dann u.U. nochmal in verschiedene Untertypen unterteilt (Ich frage mich, ob das überhaupt als Webapplikation zu realisieren ist?). Je nach Jahrgang, Lernfortschritt und Kurszugehörigkeit, werden die Aufgaben angepasst.

Hier ist der Code nur für dieses eine Modul: https://www.dropbox.com/s/2g2pgn4ewlie0 ... e.txt?dl=1 , dass natürlich auf andere Funktionen zugreift - vielleicht will ja jemand reinschauen - wenn gewünscht, kann ich auch den ganzen Code offenlegen.

Git habe ich installiert, in Github einen Account, es gelingt mir aber noch nicht, den Code hochzuladen.

[sparrow]

Umsetzten als Webapplikation ist kein Problem.

Die grundlegende Frage ist, wie viel sich die Aufgaben tatsächlich von einander unterscheiden. Also erst einmal in der Grundstruktur.

Ich sehe bei den Geometrieaufgaben gerade nicht, dass das Ergebnis dynmisch ist, oder?
Da wird zum Beispiel ein Text angezeigt (der die Frage enthält), dann wird ggf. noch eine Grafik angezeigt und das Ergebnis ist dann immer eindeutig und vorbestimmt, oder? Es wird ggf. noch eine Frage von mehreren möglichen ausgewählt, aber die Frage an sich ist statisch und hat immer die selbe Antwort?

[Pitwheazle]

Ja. die Fragen beinhalten Zufallszahlen und u.U. Begriffe die zufällig aus Listen ausgewählt werden und die Ergebnisse ergeben sich fest daraus. (Hast du dich wirklich durch meinen wirren Text gearbeitet?). Ich habe an Whities Beispiel schon erkannt, dass ich das anders als in meinem bestehenden Rechentrainer aufbauen muss und die Texte strukturierter in einer Datenbank ablegen muss.

[sparrow]

Dann stell dir mal vor, man würde die ganzen Aufgaben gar nicht im Code niederschreiben sondern wie folgt vorgehen:

Code: Alles auswählen

class Exercise(models.Model):
    category = models.ForeignKey(ExerciceCategory, on_delete=models.CASCADE)  # für die Einordnung in eine Kategorie
    topic = models.CharField(max_length=200)
    text = models.TextField()


class ExerciseQuestion(models.Model):
    exercise = models.ForeignKey(Exercise, related_name="questions", on_delete=models.CASCADE)
    question = models.TextField()
    answer = models.TextField()

Das könnte eine Grundsruktur sein.

Man könnte dann in der Datenbank eine Exercise mit dem topic "Dreieck" anlegen. In text würde man etwas Erklärung packen. Oder alternativ Exercise noch Bilder zuweisen, die angezeigt werden können.
Es wäre auch denkbar, dass Exercise ein Feld bekommt, in dem man angibt, wie Dinge gezeichnet werden sollen (und der View zeichnet nur, wenn dort etwas drin steht). Und alternativ das ganze auch für einen Graph.

Ein Exercise kann mehrere ExerciseQuestion haben (1:n). Die könnte man dann zum Beispiel per Zufall ziehen.
Hier die einfachste Annahme, dass eine solche Qestion einfach nur eine question und eine answer hat. Da müsste man danns schaeun, dass man die Funktionalität der Auwahl von Wörtern aus Listen, etc. hinterlegt. Oder dass Zufallszahlen generiert werden.

Dann würden die Aufgaben aber nicht mehr im Code stehen. Sie sind einfach Dinge in der Datenbank die man einfach Bearbeiten/Erweitern/Neue anlegen kann.

Bei dieser einfachsten Version würde man nur die "starre" Antwort im View prüfen. Und damit ist deren Größe plötzlich sehr gering.

[Pitwheazle]

Nicht dass ich das jetzt schon umsetzen könnte, das klingt aber sinnvoll. Da komme ich nochmal auf dich zurück.

... Jetzt versuche ich aber schon wieder seit einer Stunde, meinen Code in GitHub hochzuladen. Irgendwie habe ich da einen Fehler:
Im Ordner "RechentrainerWeb" liegt der Ordner "rechentrainer" mit meinem Djangoprojekt und da habe ich auch den .git Ordner reingepackt. In Github habe ich auch ein repository "rechentrainer" angelegt. Den Befehl "git remote https://github.com/pitweazle/rechentrainer.git", bekomme ich die Meldung "remote origin already exists" und "git push -u origin master" bringt "failed to push some refs to 'https://github.com/pitweazle/rechentrainerWeb.git":

... irgendwas mache ich mit dem Ordner falsch. Wo gehört denn die .git Datei hin?

[sparrow]

Das .git Verzeichnis solltest du nie verschieben.
Ich würde den Weg umgekehrt gehen.

Erstell dir ein leeres Verzeichnis.
Wechsel hinein und Klone dein Repository von Github: git clone https://github.com/pitweazle/rechentrainerWeb.git
Dann kopiere dein Projekt (ohne das .git Verzeichnis!) hinein.
Füge mit "git add ." alle Dateien hinzu
Mach mit mit "git commit" alle deine bisherigen Dateien hinzu.

Dann sollte git push funktioneren.
Und dann kannst du mit diesem Verzeichnis dein bisheriges Arbeitsverzeichnis ersetzen.

[__deets__]

Ich weiß nicht woher du den .git-Ordner hast, aber den bewegt man eigentlich nirgends hin. Stattdessen ruft man im Verzeichnis, in dem das Projekt liegt, git init auf. Dann hat man erstmal lokal commits erstellen, und fügt das remote von github hinzu. Und pusht das lokale Repository dahin. Weil du da wahrscheinlich schon was drin liegen hat, muss der erste Push mit —force erfolgen.

[Pitwheazle]

Ich weiß nicht woher du den .git-Ordner hast, aber den bewegt man eigentlich nirgends hin. Stattdessen ruft man im Verzeichnis, in dem das Projekt liegt, git init auf. Dann hat man erstmal lokal commits erstellen, und fügt das remote von github hinzu. Und pusht das lokale Repository dahin. Weil du da wahrscheinlich schon was drin liegen hat, muss der erste Push mit —force erfolgen.

Genauso habe ich den .git Ordner erstellt: Im Ordner "rechentrainer", in dem auch die anderen Dateien des Projekts liegen, habe ich "git init" aufgerufen. Den habe ich dann nicht verschoben. Ich habe das ganze dann später aber auch nochmal im übergeordneten Ordenr "rechentrainerWeb" gemacht, da dies in der Fehlermeldung aufgetaucht ist. Wo kommt den das "rechentrainerWeb" in der Fehlermeldung her? Den .git Ordner dort habe ich dann aber wieder gelöscht, nachdem das auch nicht funktioniert hat.
Aber denkt doch bitte dran: Ich habe nicht wirklich Ahnung, was ich da mache:
Was bedeutet: "und fügt das remote von github hinzu"? und "pusht das lokale Repository dahin"?
Soll ich nicht besser den ganzen git-Bettel löschen und einfach nochmal neu erstellen? Da ist ja noch nichts Wichtiges drin?

[Pitwheazle]

OK - das hat funktioniert. Ich habe alles gelöscht und neu erstellt.

[Pitwheazle]

(Zwischenzeitlich funktioniert es nicht mehr - das sollte ich aber allein hinbekommen.)

Ihr könnt mir aber bei einer anderen Frage helfen:
Noch bastele ich an meiner Datenbank und die will noch nicht so wie ich. Ich bin nicht sicher, ob ich die Daten, die ich ansonsten in einem Array abspeichern würde auch anders abspeichern kann. Ich erkläre wofür: Eine starke Motivation meiner Rechentrainer-Nutzer war, dass alle Felder grün werden wenn sie ordentlich arbeiten. Zu diesem behufe werden die Fehlerstände in dem jeweiligen Modul gelöscht, wenn eine bestimmte Anzahl von Aufgaben an einem Stück richtig beantwortet wurden, ohne einen Fehler zu machen, die Lösung anzuzeigen oder die Hilfe anzeigen zu lassen. Dafür hätte ich gerne einen Zähler mit 35 Einträgen, auf die ich mit einem Index zugreifen kann. Nehme ich ein Array oder eine Liste, und wenn Letzteres, wie muss ich die definieren? (Dieses Problem habe ich auch noch an anderen Stellen.)

Und noch was: Wie kann ich es organisieren, dass in den Feldern mit den Fragen (Aufgabentexten) auch weitere Daten gespeichert sind, insbesondere der Bereich für die Zufallszahlen? Ich erkläre dies auch an einem Beispiel: Fünftklässer müssen die Aufgaben mit ganzen Zahlen rechnen, irgendwann ab der sechsten Klasse (oder der entsprechenden Stufe) müssen die entsprechenden Aufgaben mit Kommazahlen gerechnet werden und E-Kurs Schüler bekommen u.U. auch noch schwierigere Aufgaben. Da wäre es sehr hilfreich, wenn ich dafür nicht verschiedene Fragen (Instanzen?) aufrufen müsste. Geht das?

[__deets__]

Zur ersten Frage: jede der gestellten Aufgaben hat ja eine Lösung. Das lässt sich in der Datenbank zb mit einer 1:1-Beziehung modellieren. Dieses Lösung beinhaltet die eigentliche Eingabe, oder wenigstens einen Wahrheitswert, ob die Eingabe richtig war. Weitere boooleans halten fest, ob Hilfe genutzt wurde. Und sie hat einen Zeitstempel, wann sie durchgeführt wurde. Und damit hast du alle Informationen zusammen: eine Abfrage der Lösungen, sortiert absteigend nach der Zeit, limitiert (oder einfach nur genutzt) bis zu deinem Schnittpunkt von zb 10 fragen. Wenn die alle richtig, und ohne Hilfestellung beantwortet wurden, dann ist alles “im grünen Bereich”.

Was die Speicherung der Daten angeht: meiner persönlichen Meinung nach bietet sich durch die Vielzahl an Aufgabentypen, multipliziert mit einer solchen Varianz pro Typ, eine flexible Moedellirung mit JSON-Spalten an. Dadurch hast du aus Sicht der Datenbank eine zwar relativ intransparente Darstellung, weil Abfragen darauf schwer werden. Aber die sehe ich auch als unkritisch - sowas wäre nur relevant für aggregation zb für einen Report.

Und mit diesem Ansatz kannst du auch viel freier entscheiden, was für einen Aufgabentypen alles notwendig ist. Und es einfach als Datenstruktur “Wörterbuch” ablegen.

[Pitwheazle]

Zur ersten Frage: Warscheinlich tue ich mich immer noch schwer, mich von meiner Tabellenstruktur zu lösen und darauf zu vertrauen, dass aus riesigen datenmengen in kurzer Zeit beliebeige Abfragen erstellt werden. Ich stelle mir, am Ende, wie in meinem bereits existierenden Rechentrainer eine Übersichtsseite vor, die etwa so aussieht:


Hier kann man auf einen Blick erkennen, was gemacht wurde, was noch erledigt werden muss und wie hoch z.B. jeweils die Fehlerquote ist. Und da fällt es mir schwer, mir vorzustellen, dass all diese Werte on the fly aus der Datenbank "zusammengesucht" werden. Aber wenn du meinst, das ginge, dann lasse ich mich mal darauf ein.

Ich hatte ja aber oben geschrieben, dass es noch andere Beispiele für die "Array oder Liste" Überlegung da sind. Ich habe bestimmte Voreinstellungen für die Schüler, die ich möglicherweise doch mit einer Liste abspeichern muss. Auch hier ein Beispiel: Wenn die Kids zum ersten Mal eine Aufgabe zu Wurzeln oder zu Kreisen aufrufen, blende ich einen Hinweis ein, wie sie mit dem Wurzelzeichen bzw. mit Pi umgehen sollen. Da ist dann unten in der Ecke der Hinweis "Diese Meldung in Zukunft nicht mehr anzeigen". Jetzt bin ich mal gespannt, ob du mir aufzeigen kannst, dass ich das auch aus den gespeicherten Daten herauslesen kann .

Und was den zweiten Teil deines Postings angeht: Dann muss ich halt zu Python, Django, HTML, CSS auch noch JSON lernen - man wächst ja angeblich an seinen Aufgaben (Ich bin mir da nicht mehr so sicher bei mir).

[__deets__]

Sowas modelliert man als n:m-Beziehung, als Tabelle mit Fremdschluessel zum Schueler, und einem zweiten Fremdschluessel zum Aufgabentyp. Und wenn da ein Eintrag vorhanden ist, wurde diese Option angewaehlt. Wenn nicht, dann nicht.

[Pitwheazle]

Ist das dann eine eigene Klasse/model/Tabelle (leider weiß ich immer noch nicht die richtige Bezeichnung für das was ich in "models" als "class" anlege - darf ich das Tabelle nennen?)

[__deets__]

Nein, das ist in diesem Fall keine Klasse. Sondern nur ein Eigenschaft. Wenn wir mal https://docs.djangoproject.com/en/4.0/t ... y_to_many/ zugrunde legen, und sagen, dass Publication dein Aufgabentyp ist, und Article dein Schueler. Dann legt

Code: Alles auswählen

publications = models.ManyToManyField(Publication)

eine Menge von Publikationen an, zu denen der Article im Verhaeltnis steht. In deinem Fall waere dann also sowas wie

Code: Alles auswählen

aufgabebentyp_bekannt = models.ManyToManyField(Aufgabentyp)

auf dem Schueler.

Dadurch kannst du dann pruefen, ob der Aufgabentyp, der gerade in Bearbeitung ist, in dieser Menge ist. Wenn nicht, dann muss dein Hilfetext angezeigt werden.

Unter der Haube wird daraus aber tatsaechlich eine Tabelle, mit zwei Spalten: der jeweiligen ID von Schueler und Aufgabentyp.

[Pitwheazle]

OK, das ist hilfreich (wenn ich es auch noch nicht ganz verstehe, dazu muss ich es wahrscheinlich mal anwenden). Es ist aber nicht ganz das Gewünschte, denn der Hilfetext taucht, nach deiner Beschreibung, nicht mehr auf, wenn der Aufgabentyp einmal bearbeitet wurde. Mein Schülerinnen und Schüler benötigen den Text aber oft mehrmals, daher ein Eintrag irgendwo, wenn "Den Text zukünftig nicht mehr anzeigen" angeklickt wurde, wäre m.E. sinnvoller. (Irgendwann bekomme ich sicher mal eine Liste/Array unter )

[__deets__]

Das habe ich schon verstanden, und auch beruecksichtigt. Das ist eine Relation, die lediglich mit dem Zweck, diese Information vorzuhalten, angelegt wird. Und auch nur auf expliziten Wunsch traegst du da deinen Aufgabentypen ein. aufgabentyp_bekannt haette also auch "aufgabentyp_bekannt_und_keine_hilfe_mehr_noetig" heissen koenen. Aus naheligenden Gruenden habe ich das nicht genommen.

[Pitwheazle]

Ich habe jetzt das Konzept meiner Datenbank erstellt und es wäre prima, wenn da mal jemand drüberschauen könnte, ob das so Sinn macht:

Code: Alles auswählen

from django.contrib.auth.models import User
from django.db import models

from django import forms
from django.db.models import IntegerField

class Kategorien(models.Model):
    gruppe = models.CharField(max_length=1, blank=True)             #Untergruppe A, B, C, D, E um die Ansicht übersichtlicher gestalten zu können
    zeile = models.PositiveSmallIntegerField(default=0)             # entspricht der Aufgabengruppe (1 bis 35)
    name = models.CharField(max_length=20)

    start_Jg = models.PositiveSmallIntegerField(default=5, verbose_name="Start in Jahrgang")
    start_SW = models.PositiveSmallIntegerField(default=1, verbose_name="Start in Schulwoche")

    eof = models.PositiveSmallIntegerField(default=25, verbose_name="Eingaben ohne Fehler")  # Aufgaben die an einem Stück richtig beantwortet werden müssen damit der Fehlerzähler zurückgesetzt wird

    def __str__(self):
        return f"({self.name})"

    class Meta:
        verbose_name = 'Kategorie'
        verbose_name_plural = 'Kategorien'

class Fragen(models.Model):
    kategorie = models.ForeignKey(Kategorien, on_delete=models.CASCADE, related_name="Fragen")
    typA = models.PositiveSmallIntegerField(default=0)
    typB = models.PositiveSmallIntegerField(default=0)
    anz = models.PositiveSmallIntegerField(default=10, verbose_name="Anzahl Aufgaben")      #Aufgaben die am Stück gerechnet werden müssen

    text = models.CharField(max_length=40)
    aufgabe = models.CharField(max_length=20)
    protokolltext = models.CharField(max_length=20)

    anmerkung = models.CharField(max_length=20)
    grafik = models.IntegerField(default=0)  # gehört eine Grafik zur Aufgabe?

    hilfe1 = models.CharField(max_length=25)
    hilfe2 = models.CharField(max_length=25)

    ergebnis = models.DecimalField(max_digits=15, decimal_places=5, default=0)
    loesung = models.CharField(max_length=100)

    def __str__(self):
        return f"({self.text})"

    class Meta:
        verbose_name = 'Frage'
        verbose_name_plural = 'Fragen'

class Schulen(models.Model):
    name = models.CharField(max_length=30)
    schulform = models.CharField(max_length=20)  # , NULL=True)

    nummer = models.IntegerField(default=0, verbose_name='Schulnummer')

    ort = models.CharField(max_length=30,  verbose_name="Schulort")
    plz = models.CharField(max_length=5,  verbose_name="PLZ des Schulortes")

    Land = models.CharField(max_length=20, default="Hessen", verbose_name='Bundesland')
    Staat = models.CharField(max_length=2, default="DE", verbose_name='Land', editable=False)

    def __str__(self):
        return f"({self.name}, {self.plz} {self.ort})"

    class Meta:
        verbose_name = 'Schule'
        verbose_name_plural = 'Schulen'

class Lehrer(models.Model):
    anrede = models.CharField(max_length=5)
    nachname = models.CharField(max_length=20)
    vorname = models.CharField(max_length=20)
    schule = models.ForeignKey(Schulen, null=True, on_delete=models.SET_NULL ,related_name="Lehrer")
    sprache = models.CharField(max_length=2, default="de", editable=False)

    def __str__(self):
        return f"({self.anrede} {self.nachname})"

    class Meta:
        verbose_name = 'Lehrer'
        verbose_name_plural = 'Lehrer'

class Gruppen(models.Model):
    name = models.CharField(max_length=10)
    lehrer = models.ForeignKey(Lehrer, on_delete=models.CASCADE ,related_name="Gruppe")
    schule = models.ForeignKey(Schulen, on_delete=models.CASCADE ,related_name="Gruppe")

    def __str__(self):
        return f"({self.name}, {self.lehrer}, {self.schule})"

    class Meta:
        verbose_name = 'Gruppe'
        verbose_name_plural = 'Gruppen'

class Schueler(models.Model):
    nachname = models.CharField(max_length=20)
    vorname = models.CharField(max_length=20)
    klasse = models.CharField(max_length=10)
    jahrgang = models.PositiveSmallIntegerField(default=0)
    kurs = models.CharField(max_length=1, default="E")
    kurs_i = models.BooleanField(default=False, verbose_name="Förderkind", editable=False)
    kurs_E = models.BooleanField(default=True, verbose_name="E-Kurs", editable=False)

    schule = models.ForeignKey(Schulen, null=True, on_delete=models.SET_NULL , related_name="Schüler")
    lehrer = models.ForeignKey(Lehrer,  null=True, on_delete=models.SET_NULL , related_name="Schüler")
    gruppe = models.ForeignKey(Gruppen, null=True, on_delete=models.SET_NULL , related_name="Schüler")
    sprache = models.CharField(max_length=20, default="de", editable=False)

    # werden beim Erstellen eingestellt
    datum_start = models.DateField(auto_now_add=True, verbose_name="Startdatum", editable=False, )
    stufe = models.PositiveSmallIntegerField(default=0, editable=False)
    halbjahr = models.PositiveSmallIntegerField(default=0, editable=False)
    voreinst = models.IntegerField(default=1)                               #hier könnte, mithilf von Primzahlen, Voreinstellungen gesetzt und abgefragt werden

    zaehler_EoF = models.PositiveSmallIntegerField(default=0,  editable=False)  # je nach Einstellung LoeOF in Aufgaben wird der Fehlerzähler gelöscht
    zaehler_Fehler = models.PositiveSmallIntegerField(default=0,  editable=False)  # und hier wird dann, für jede Kategorie, der Zähler auf Null gesetzt

    def __str__(self):
        return f"({self.vorname} {self.nachname}, {self.klasse})"

    class Meta:
        verbose_name = 'Schüler'
        verbose_name_plural = 'Schüler'

class Daten(models.Model):
    schueler = models.ForeignKey(Schueler, on_delete=models.CASCADE, related_name="Daten")
    kategorie = models.ForeignKey(Kategorien, on_delete=models.CASCADE, verbose_name="Kategorie", related_name="Daten")
    typ = models.CharField(max_length=5, blank=True )
    halbjahr = models.PositiveSmallIntegerField(default=0)

    text = models.CharField(max_length=30, blank=True, verbose_name="Aufgabentext")
    aufgabe = models.CharField(max_length=20, blank=True, verbose_name="Aufgaben")
    eingabe = models.CharField(max_length=20, blank=True, verbose_name="Eingabe")
    loesung = models.CharField(max_length=20, blank=True, verbose_name="Lösung")

    start = models.DateTimeField('Start', auto_now_add=True)
    ende = models.DateTimeField('Ende', blank=True, null=True, default=None)
    bearbeitungszeit=models.DateTimeField(blank=True, null=True, default=None)

    richtig = models.PositiveSmallIntegerField(default=0)
    zusatz = models.DecimalField(max_digits=5, decimal_places=2, default=0)
    falsch = models.PositiveSmallIntegerField(default=0)

    zaehler_falsch = models.PositiveSmallIntegerField(default=0)

    abbrechen = models.PositiveSmallIntegerField(default=0)
    hilfe = models.PositiveSmallIntegerField(default=0)

    class Meta:
        verbose_name = 'Daten'
        verbose_name_plural = 'Daten'

    def __str__(self):
        return f"({self.aufgabe}={self.eingabe}?)"

Und dann wäre es ganz toll, wenn ihr mir noch bei ein paar Anfängerfragen helfen könntet:

1. Model "Kategorien":
für jede Kategorie will ich festlegen ab welchem Jahrgang und welcher Schulwoche diese Aufgaben jeweils bearbeitet werden müsste. Das habe ich nach dem Lehrplan unserer Schule festgelegt (start_Jg, start_SW) - die würde ich als default setzen. In einem Gymnasium geht das schneller. Wenn ich jetzt eine Möglichkeit schaffen möchte, dass von einer anderen Schule andere Werte eingetragen werden können - wie ginge das? Ist das eine Many to Many Relation (Ich muss mich noch in diese Strukturen eindenken)?

2. Model "Fragen":
Da ist mir immer noch nicht klar, wie ich hier für verscheidene Leistungsstufen (z.B. mit Komma oder ohne Komma), Vorgaben speichern könnte.
Und dann gibt es Aufgaben mit mehreren Lösungsmöglichkeiten. Die würde ich im Feld "loesungen" eintragen. Kann ich da auch eine Liste anlegen? (Ich traue mich gar nicht nach einem Array zu fragen)

3. Model "Schulen":
Hier hätte ich gedacht, dass Schülerinnen und Schüler bzw. Lehrerinnen und Lehrer bei der Anmeldung ihre Schule eintragen. Da kann ich nur wahrscheinlich nicht verhindern, dass eine Schule mit zwei Schreibweisen auftaucht. Ich geh davon aus, dass man (Lehrerinnen bzw. Lehrer) das händisch anpassen müssen.

4. Model "Lehrer":
Wie kann ich hier dafür sorgen, dass man/frau bei Anrede unter Hr. und Fr. wählen kann? Einigen Lehrerinnen und Lehrern ist es nicht recht, wenn ihre Schülerinnen und Schüler bei der Auswahl der Lehrerinnen und Lehrer (das ist ja zu blöd hier immer beide Geschlechter angeben zu müssen - aber das ist eine andere Diskussion).

5. Model "Gruppen":
Hier hatte ich angedacht, dass irgendwann Lehrerinen und Lehrer eine Gruppe anlegen können und "ihre" Schülerinnen und Schüler zusammensuchen, und deren Daten dann einsehen können.

6. Model "Schüler"
Ich hatte schon geschrieben, dass es für die Schülerinnen und Schüler schön ist, dass ihr Fehlerstand gelöscht wird, wenn eine bestimmte Anzahl von Aufgaben am Stück richtig gelöst wurde. Dass man die Anzahl der richtigen und falschen Aufgaben aus den Daten auslesen kann, habe ich jetzt ja gelernt. Nur die Anzahl der falschen Eingaben anzuzeigen, die seit dem letzten Löschen angefallen sind, ist etwas aufwendiger, wäre es hier nicht doch einfacher eine Many to Many (?) zu erstellen - anstelle des Feldes "zaehler_Fehler"? Oder speichere ich einfach diesen Zähler extra nach jeder Aufgabenstellung in den Daten ("zaehler_falsch")?

Wenn sich hier jemand die Mühe macht, sich da durchzuarbeiten, gebe ich einen aus!

[sparrow]

Die Namen von Modellen sind immer Einzahl.
Du definierst da die Representation einer Kategorie - nicht von Kategorien.

Bitte verwende keine Abkürzungen.
Das erschwert jedem das Lesen deines Codes. Insbesondere auch dir, wenn du deinen Code länger als 3 Wochen nicht angeschaut hast.
Halte dich auch an die Konventionen, dass Namen (außer die namen von Klassen) klein_mit_unterstrich geschrieben werden.

Also kein zaehler_EoF sondenr irgend etwas, das jedem (auch dir) sofort sagt, was das für ein Wert ist.
Und bei kurs_i und kurs_E sieht es ebenso aus.

1.: Hier wird kein Default gesetzt. Die Werte gehören nicht in das Model, wenn sie für jede Schule unterschiedliche Werte geben kann, dann muss das aus dem Model heraus gezogen werden. Es muss dann ein weiteres Model mit zwei Foreign-Keys - einen auf die Schule und eines auf die Kategorie.

2.: Die Dragen werden das Komplexeste. Das wirdst du nicht alleine durch die das bauen der Modelle abhandeln können. Dafür musst du einmal alle Arten von Aufgaben darlegen, damit man da eine Möglichkeit finden kann.

3.: Warum möchtest du diese Daten überhaupt erheben? Wer pflegt die? Welchen Vorteil hat das? Warum müssen da die Schüler etwas eingeben? Irgendwer muss ja auch die Vorgaben in Punkt 1 pflegen.

4.: Wie Punkt 3.

5.: Wie Punkt 3.

6.: Niemals redundante Daten speichern. Wie bereits gesagt. Weg mit den Zaehlern.

[__deets__]

Ich haette auch noch eine allgemeine Anmerkung: du wirst scheitern mit dem Versuch, alles, was du jetzt schon hast, von vorneherein einzubauen. Du solltest da langsamer vorgehen. Eine Fragenkategorie, ein Schuelerobjekt, ein Satz Aufgaben fuer den Schueler. Denn beim Versuch, alles auf einmal zu machen, wirst du dich verhaspeln. Dann eine zweite Kategorie, um sich zu erarbeiten, wie man die modelliert. Wie die Unterschiede in den Parametern dargestellt werden. Ob das so passt, oder ob man da mit anderen Ansaetzen wie zB Parameter-Modell-Objekten arbeiten sollte. Auch dein Rechentrainer ist so nicht an einem Tag entstanden. Es ist gut, dass du schon weisst, wo du hin musst. Das ist der Wert eines Prototypen sozusagen. Aber auch damit kann man nicht alles auf einmal stemmen.