SideBarMenu

Anmeldesets und -regeln

Auf dieser Seite... (ausblenden)

  1.   1.  Konzept
  2.   2.  Aufbau einer Anmelderegel
    1.   2.1  Speichern und Laden der Daten
    2.   2.2  Regeldefinition
    3.   2.3  Zusammenfassung
  3.   3.  Verteilungsalgorithmus

§

1.  Konzept

Ein Anmeldeset stellt einen Rahmen für Veranstaltungen dar, die gemeinsame Regeln zur Anmeldung besitzen. Mit Stud.IP 3.0 werden initial schon einige verschiedene Regeln mitgeliefert, hier soll jedoch unter anderem beschrieben werden, wie man selbst eine solche Regel implementieren kann.

↑ Inhaltsverzeichnis

§

2.  Aufbau einer Anmelderegel

Alle Anmelderegeln liegen im Ordner lib/admissionrules. Pro Regeltyp gibt es dort einen Ordner, in dem typischerweise die Klassendefinition der Regel liegt (Regeltyp.class.php, SQL-Anweisungen, die bei (De-)Installation der Regel ausgeführt werden müssen und templates zur Konfiguration und zur Kurzanzeige der Regel.

Im Folgenden soll das Beispiel NightAdmission entwickelt werden, eine Regel, die eine Anmeldung nur zwischen 22 und 6 Uhr zulässt.

2.1  Speichern und Laden der Daten

Die Regel vom Typ NightAdmission sollen alle in einer eigenen Tabelle nightadmissions in der Datenbank gespeichert werden. Da dieser Regeltyp neben dem standardmäßig vorhandenen Infotext keine weiteren Attribute besitzt, sieht diese Tabelle so aus:

  1. CREATE TABLE `nightadmissions` (
  2.     `rule_id` VARCHAR(32) NOT NULL,
  3.     `message` TEXT NOT NULL,
  4.     `mkdate` INT NOT NULL,
  5.     `chdate` INT NOT NULL,
  6.     PRIMARY KEY (`rule_id`);

Wird dieser Regeltyp komplett aus dem System entfernt, so reicht folgende SQL-Anweisung zum Aufräumen:

  1. DROP TABLE `nightadmissions`;
  2. DELETE FROM `courseset_rule` WHERE `type`='NightAdmission';

2.2  Regeldefinition

Wir legen eine Datei NightAdmission.class.php an, die von der bereits vorhandenen Klasse AdmissionRule erbt. Da wir nur die aktuelle Uhrzeit berücksichtigen müssen, braucht diese Klasse keine eigenen, weiteren Attribute. Wir definieren nur, mit welchen anderen Anmelderegeltypen diese Regel kombinierbar ist (nämlich alle Standardregeln außer zeitgesteuerter und komplett gesperrter Anmeldung).

Einige Standardmethoden müssen wir ebenfalls implementieren, um das Laden und Speichern in eigene Tabellen zu realisieren.

  1. <?php
  2. class NightAdmission extends AdmissionRule {
  3.  
  4.     // Mit welchen anderen Regeltypen ist diese Regel kombinierbar?
  5.     public $allowed_combinations = array(
  6.         'ParticipantRestrictedAdmission',
  7.         'LimitedAdmission',
  8.         'ConditionalAdmission',
  9.         'PasswordAdmission'
  10.     );
  11.  
  12.     /**
  13.      * Standardkonstruktor
  14.      */
  15.     public function __construct($ruleId='', $courseSetId = '')
  16.     {
  17.         parent::__construct($ruleId, $courseSetId);
  18.         $this->default_message = _("Sie können sich nur nachts zwischen 22 und 6 Uhr anmelden.");
  19.         if ($ruleId) {
  20.             // Regel bereits vorhanden, lade Daten.
  21.             $this->load();
  22.         } else {
  23.             // Erzeuge neue ID.
  24.             $this->id = $this->generateId('nightadmissions');
  25.         }
  26.         return $this;
  27.     }
  28.  
  29.     /**
  30.      * Lösche aktuelle Regel aus der Datenbank.
  31.      */
  32.     public function delete() {
  33.         parent::delete();
  34.         $stmt = DBManager::get()->prepare("DELETE FROM `nightadmissions` WHERE `rule_id`=?");
  35.         $stmt->execute(array($this->id));
  36.     }
  37.  
  38.     /**
  39.      * Beschreibungstext für diesen Regeltyp, wird angezeigt, wenn eine neue
  40.      * Regel zu einem Anmeldeset hinzugefügt werden soll.
  41.      */
  42.     public static function getDescription() {
  43.         return _("Diese Regel erlaubt die Anmeldung nur nachts zwischen 22 und 6 Uhr.");
  44.     }
  45.  
  46.     /**
  47.      * Name für diesen Regeltyp, wird angezeigt, wenn eine neue Regel zu einem
  48.      * Anmeldeset hinzugefügt werden soll.
  49.      */
  50.     public static function getName() {
  51.         return _("Nächtliche Anmeldung");
  52.     }
  53.  
  54.     /**
  55.      * Holt das Template zur Anzeige der Konfiuration dieser Regel
  56.      * (configuration.php, hinterlegt im Unterordner templates). Für unser
  57.      * Beispiel brauchen wir nur das Standardtemplate, da es nichts eigenes*
  58.      * für diesen Regeltyp zu konfigurieren gibt.
  59.      */
  60.     public function getTemplate() {
  61.         $tpl = $GLOBALS['template_factory']->open('admission/rules/configure');
  62.         $tpl->set_attribute('rule', $this);
  63.         return $tpl->render();
  64.     }
  65.  
  66.     /**
  67.      * Lädt die Regel aus der Datenbank.
  68.      */
  69.     public function load() {
  70.         $rule = DBManager::get()->fetch("SELECT * FROM `nightadmissions` WHERE `rule_id`=? LIMIT 1", array($this->id));
  71.         $this->message = $rule['message'];
  72.         return $this;
  73.     }
  74.  
  75.     /**
  76.      * Diese Funktion überprüft, ob sich der gegebene Benutzer zur gegebenen
  77.      * Veranstaltung anmelden darf, ob die Regel also greift.
  78.      * Zurückgegeben wird eine Fehlermeldung, falls die Anmeldung nicht
  79.      * möglich ist.
  80.      */
  81.     public function ruleApplies($userId, $courseId) {
  82.         $failed = array();
  83.         $now = mktime();
  84.         // Zeit zwischen 6 und 22 Uhr => keine Anmeldung erlaubt.
  85.         if (date('H', $now) < 22 && date('H', $now) >= 6) {
  86.             $failed[] = $this->default_message;
  87.         }
  88.         return $failed;
  89.     }
  90.  
  91.     /**
  92.      * Speichert die aktuelle Regel in der Datenbank.
  93.      */
  94.     public function store() {
  95.         $stmt = DBManager::get()->prepare("INSERT INTO `nightadmissions`
  96.             (`rule_id`, `message`, `mkdate`, `chdate`)
  97.             VALUES
  98.             (:id, :message, UNIX_TIMESTAMP(), UNIX_TIMESTAMP())
  99.             ON DUPLICATE KEY
  100.             UPDATE `message`=VALUES(`message`), `chdate`=VALUES(`chdate`)");
  101.         $stmt->execute(array('id' => $this->id, 'message' => $this->message));
  102.         return $this;
  103.     }
  104.  
  105. }

Am wichtigsten sind die beiden Methoden ruleApplies und getTemplate.

Erstere Methode spezifiert das Verhalten der Regel, also wann und unter welchen Voraussetzungen überhaupt eine Anmeldung erfolgreich sein kann. Hier können im Prinzip beliebige Datenbankabfragen oder sonstige anderen Funktionen aufgerufen werden.

Das Template definiert die GUI zur Konfiguration der jeweiligen Regel. Standardmäßig wird nur ein Textfeld angeboten, das einen Text aufnehmen kann, der vor der Anmeldung auf der Veranstaltungsseite erscheint. Will man hier weitere Werte, Checkboxen oder anderes einstellbar machen, muss man selbst ein Flexi-Template dafür schreiben.

Daneben kann es noch ein Info-Template geben, das nur zur Anzeige der Regel in normalem Prosatext dient.

2.3  Zusammenfassung

Um diese Beispielregel in Stud.IP zu installieren, reicht es, in lib/admissionrules einen Ordner nightadmissions zu erstellen, dort die obige Klasse Nightadmission.class.php hineinzukopieren und die nötigen SQL-Anweisungen auszuführen. Da kein eigenes Template benötigt wird, ist hier auch kein Unterordner templates von Nöten. In der globalen Konfiguration unter Anmelderegeln kann die Regel dann aktiviert werden.

↑ Inhaltsverzeichnis

3.  Verteilungsalgorithmus

Der Algorithmus, der die Plätze der Veranstaltungen eines Anmeldesets verteilt, kann ebenfalls frei selbst implementiert werden. Standardmäßig wird bereits ein Algorithmus mitgeliefert.

Zum Anlegen eines neuen Algorithmus reicht es, das vorhandene Interface AdmissionAlgorithm zu implementieren, dabei handelt es sich im Prinzip nur um eine Methode run(), die den Algorithmus ausführt.

Letzte Änderung am 17.02.2014 14:57 Uhr von hackl.