42.3 Die Komponentenverwaltung

Eine Komponente, die nur Daten ausgeben kann, macht natürlich keinen Spaß und meistens auch keinen Sinn. Wir brauchen also einen Administrationsbereich, mit dem wir neue Datensätze anlegen und bestehende verändern können.

Es müssen mindestens zwei Ansichten erstellt werden: zum einen eine Liste, die alle Datensätze anzeigt und verwalten lässt, zum anderen eine Einzelansicht, in der die Daten bearbeitet werden. Der Übersicht halber wollen wir die Klassen, die für die Liste verantwortlich sind, mit Pairranks bezeichnen, die für die Einzelansicht mit Pairrank.

Auch im Backend wird mit einer MVC-Architektur gearbeitet. Daraus ergeben sich die folgenden Dateien, die zusätzlich eingespielt werden müssen:

Basis und Controller

• admin.pairrank.php
  Das Einstiegsskript für das Backend.

• controller.php
  Verwaltet die Aktionen wie Bearbeiten, Speichern und Löschen.

Model

• models/pairrank.php
  Das Datenmodel für die Bearbeitungsansicht.

• models/pairranks.php
  Das Datenmodel für die Listenansicht.

• tables/pairrank.php
  Eine vereinfachte Zugriffsvariante auf Datenbanktabellen.

Views

• views/pairrank/view.html.php
  Bereitet die Daten für die Bearbeitungsansicht vor.

• views/pairrank/tmpl/form.php
  Das HTML-Template für die Bearbeitungsansicht.

• views/pairranks/view.html.php
  Bereitet die Daten für die Listenansicht vor.

• views/pairranks/tmpl/default.php
  Das HTML-Template für die Listenansicht.

Diese Dateien müssen nun im Installationsverzeichnis pairrank_inst erstellt werden. Legen Sie dazu innerhalb des Ordners admin die folgende Struktur an. Wir werden den Administrationsbereich in zwei Schritten erstellen. Für die Installation ist es aber ratsam, zunächst alle Dateien zu erstellen und die nicht benötigten leer zu lassen:

admin
    admin.pairrank.php
    install.sql
    uninstall.sql
    controller.php
    models
       pairrank.php
       pairranks.php
    tables
       pairrank.php
    views
       pairrank
          view.html.php
          tmpl
             form.php
       pairranks
          view.html.php
          tmpl
             default.php

Nachdem die Dateien alle vorhanden sind, muss die Beschreibungsdatei der Komponente noch so angepasst werden, dass auch die neuen Dateien bei einer Installation mit kopiert werden.

28      <files folder="admin"> 
29        <filename>admin.pairrank.php</filename> 
30        <filename>install.sql</filename> 
31        <filename>uninstall.sql</filename> 
32        <filename>controller.php</filename> 
33        <filename>models/pairrank.php</filename> 
34        <filename>models/pairranks.php</filename> 
35        <filename>tables/pairrank.php</filename> 
36        <filename>views/pairrank/view.html.php</filename> 
37        <filename>views/pairrank/tmpl/form.php</filename> 
38        <filename>views/pairranks/view.html.php</filename> 
39        <filename>views/pairranks/tmpl/default.php</filename> 
40      </files>

Listing 42.11 Auszug aus pairrank.xml

Mit der Installation der Komponente sollten Sie noch bis zum Ende des nächsten Abschnitts warten.

Machen wir uns als Nächstes an die Ausgabe der Listenansicht.

42.3.1 Das Grundgerüst

Das Grundgerüst der Administrationsoberfläche ähnelt sehr stark dem des Frontends. Die Basis-Datei ist identisch bis auf den Namen der Klasse, den wir aus Gründen der besseren Trennung von Front- und Backend-Darstellung mit PairranksController bezeichnet haben.

1   <?php 
2   defined('_JEXEC') or die('Restricted access'); 
3   require_once (JPATH_COMPONENT.DS.'controller.php'); 
4   $classname = 'PairranksController'; 
5   $controller = new $classname( ); 
6   $controller->execute( JRequest::getVar('task') ); 
7   $controller->redirect(); 
8   ?>

Listing 42.12 admin.pairrank.php

Nachdem der Basis-Controller eingebunden worden ist (Zeile 3), wird in den folgenden Zeilen eine eigene Programmlogik instanziiert und dann ausgeführt (Zeile 6).

Der Controller ist zunächst ebenfalls dem Frontend-Controller sehr ähnlich. Aber täuschen Sie sich nicht: Den werden wir in den folgenden Seiten gehörig ausbauen. Momentan muss er allerdings nur eine Aktion verwalten, nämlich das Darstellen der Daten.

1   <?php 
2   defined( '_JEXEC' ) or die( 'Restricted access' ); 
3   jimport('joomla.application.component.controller'); 
4   class PairranksController extends JController { 
5      function display() { 
6         parent::display(); 
7      } 
8   } 
9   ?>

Listing 42.13 controller.php

Beachten Sie auch hier, dass wir einen PairranksController (mit s) erstellen.

Um die Liste aus der Datenbank zu holen, verwenden wir eine eigene Schnittstelle, das Model pairranks.php. In der Listenansicht muss wie im Frontend nichts weiter getan werden, als eine Darstellung der gespeicherten Datensätze zu erzeugen. Also reicht eine Funktion aus: getData. Diese wird von der Joomla!-API weiterverwendet. Daher ist es ratsam, diesen Namen beizubehalten.

1   <?php 
2   defined('_JEXEC') or die( 'Restricted Access' ); 
3   jimport( 'joomla.application.component.model' ); 
4   class PairranksModelPairranks extends JModel { 
5      var $_data; 
6      function getData() { 
7         if (empty( $this->_data )) { 
8             $query = ' SELECT * FROM #__pairrank '; 
9             $this->_data = $this->_getList( $query ); 
10        } 
11        return $this->_data; 
12     } 
13  }

Listing 42.14 Das Listen-Model: »pairranks.php«

Die Zugriffsklasse wird in Zeile 4 definiert. Achten Sie auf die beiden »Pairranks« bei der Namensgebung. Der erste Teil bezieht sich auf den Controller, der zweite auf das Model. Später werden wir noch ein Model »Pairrank« erstellen. In Zeile 5 wird die Variable $_data als Eigenschaft des Models festgeschrieben. Dort wird das Ergebnis der Abfrage der Liste gespeichert. So ist es bei mehrfachen Abfragen nicht mehr nötig, jedes Mal die Datenbank zu konsultieren. In Zeile 7 sehen Sie diesen Mechanismus. Es wird zuerst überprüft, ob die Daten schon gesetzt wurden, und wenn das nicht der Fall ist, wird die Abfrage in den Zeilen 8 und 9 ausgeführt. Die Funktion _getlist wird von JModel geerbt.

42.3.2 Die Listenansicht

Als Nächstes müssen die Ergebnisse für die Ausgabe aufbereitet werden. Dazu schreiben wir uns eine View-Klasse:

1   <?php 
2   defined('_JEXEC') or die( 'Restricted Access' ); 
3   jimport( 'joomla.application.component.view' ); 
4   class PairranksViewPairranks extends JView { 
5      function display($tpl = null) { 
 
6         JToolBarHelper::title( 'Paar-Rang-Verwaltung', 
7                                'generic.png' ); 
8         JToolBarHelper::deleteList(); 
9         JToolBarHelper::editListX(); 
10        JToolBarHelper::addNewX(); 
11        $items =& $this->get( 'Data'); 
12        $this->assignRef( 'items', $items ); 
13        parent::display($tpl); 
14     } 
15  } 
16  ?>

Listing 42.15 View.html.php

Neu sind hier die Befehle für die Titelleiste und die Aktionssymbole. Diese finden Sie in den Zeilen 6 bis 10. Der Titel selbst nimmt zwei Parameter entgegen (Zeile 6): Zum einen den Wortlaut des Titels und dann noch ein Icon, das davor angezeigt wird. Wir verwenden hier einen allgemeinen Platzhalter, generic.png. Dann werden die Symbole zum Löschen (deleteList), Bearbeiten (editListX) und Anlegen eines neuen Elements (addNewX) dargestellt. Eine Liste mit weiteren Symbolen finden Sie in Tabelle 42.2 (siehe auch Anhang B).

Mit den Symbolen wird jeweils auch ein Standardbefehl erstellt, der vom Controller in einer Funktion abgerufen werden kann. Aber dazu später mehr.

Was uns zur Anzeige einer Liste noch fehlt, ist das Template:

1   <?php defined('_JEXEC') or die('Restricted access'); ?> 
2   <form action="index.php" method="post" name="adminForm"> 
3   <div id="editcell"> 
4    <table class="adminlist"> 
5     <thead> 
6      <tr> 
7       <th width="20"> 
8        <input type="checkbox" name="toggle" value="" 
9               onclick="checkAll( 
10                 <?php echo count( $this->items ); ?> 
11              );" /> 
12    </th> 
13     <th width="5">ID</th> 
14     <th>Paar</th> 
15     <th>Punkte</th> 
16    </tr> 
17   </thead> 
18  <?php 
19  $k = 0; 
20  for ($i=0, $n=count( $this->items ); $i < $n; $i++) { 
21     $row =& $this->items[$i]; 
22     $checked = JHTML::_( 'grid.id', $i, $row->id ); 
23     $link = JRoute::_( 
24        'index.php?option=com_pairrank' 
25        .'&controller=pairrank' 
26        .'&task=edit&cid[]='. $row->id ); 
27  ?> 
28    <tr class="<?php echo "row$k"; ?>"> 
29     <td><?php echo $checked; ?></td> 
30     <td><?php echo $row->id; ?></td> 
31     <td><a href="<?php echo $link; ?>"> 
32         <?php echo $row->pair; ?></a></td> 
33     <td><?php echo $row->points; ?></td> 
34    </tr> 
35  <?php 
36     $k = 1 – $k; 
37  } 
38  ?> 
39   </table> 
40  </div> 
41  <input type="hidden" name="option" value="com_pairrank" /> 
42  <input type="hidden" name="task" value="" /> 
43  <input type="hidden" name="boxchecked" value="0" /> 
44  <input type="hidden" name="controller" value="pairrank" /> 
45 </form>

Listing 42.16 Default.php

In diesem Skript finden sich drei verschiedene Programmier- bzw. Beschreibungssprachen. Die gesamte Datei ist eine PHP-Datei und enthält zur Steuerung der Ausgabe auch einige PHP-Befehle. Diese sind zur besseren Übersichtlichkeit fett gedruckt. Der größte Teil der Ausgabe ist HTML-Code, der eine Tabelle beschreibt. In Zeile 9 wird zudem noch ein JavaScript eingebunden, das bei einem Klick auf die Checkbox in der Kopfzeile der Tabelle alle darunterliegenden Checkboxen markiert.

Die gesamte HTML-Ausgabe ist in einem Formular eingeschlossen, das abgesendet wird, wenn auf eines der Aktionssymbole geklickt wird. Die Ausgabe erfolgt mithilfe einer Tabelle. Der Tabellenkopf wird in den Zeilen 5 –17 definiert. Dort werden die Beschriftungen festgelegt und wird auch die oben genannte Checkbox mit Funktionalität bestückt.

Ab Zeile 19 beginnt die Ausgabe der einzelnen Datensätze. Dazu wird zunächst ein Durchlaufzähler $k auf 0 gesetzt, den wir brauchen, um die ungeraden Zeilen zu identifizieren. Die Schleife wird über foreach realisiert, die alle Elemente durchläuft. Diese sind in der Variable items gespeichert. In Zeile 21 wird die aktuelle Zeile aus der Datenbanktabelle zum einfacheren Zugriff in die Variable $row gepackt. Die folgende Zeile erzeugt eine Checkbox mithilfe der JHTML-Klasse, die alle nötigen Parameter hat, damit sie von den JavaScripts, die das Formular steuern, angesprochen werden kann. Die Zeilen 23 bis 26 legen eine URL fest. Diese benötigen wir später, wenn wir den Namen des Paares mit einem Link hinterlegen wollen, der direkt zur Bearbeitungsansicht führt.

Ab Zeile 28 folgt die Ausgabe der Tabellenzeilen. Da kommt zunächst die Checkbox, mit der das Element ausgewählt werden kann (Zeile 29). Diese wurde zuvor in der Variablen $checked vorbereitet. Die nächste Zelle enthält den Namen des Tanzpaares. Dieser wird über die eben festgelegte URL mit der Edit-Funktion verbunden (Zeile 31). In der dritten Spalte wird ganz unspektakulär der Punktestand ausgegeben.

Den Abschluss bilden vier versteckte Variablen, die vom Joomla!-Framework benötigt werden, um die Eingaben zu bearbeiten (Zeilen 41–44).

Sie können die Ausgabe bereits testen. Vergessen Sie nicht, die Dateien im Verzeichnis joomla/administrator/components/com_pair_rank abzulegen und nicht in joomla/components/com_pair_rank. Wenn alles geklappt hat, sehen Sie eine Liste wie in Abbildung 42.2.

Abbildung 42.2 Die »Paar-Verwaltung«

42.3.3 Ändern der Daten

Änderungen an den Daten werden weitestgehend von Joomla! automatisiert. Man muss keine komplexen SQL-Statements schreiben, das übernimmt alles die Joomla!-Datenbankklasse JTable. Um den Datenbankzugriff zu erleichtern, schreiben wir eine Klasse, die von JTable abgeleitet ist:

1  <?php 
2  defined('_JEXEC') or die('Restricted access'); 
3  class TablePairrank extends JTable { 
4     var $id = null; 
5     var $pair = null; 
6     var $points = null; 
7     var $published = null; 
8     function TablePairrank( &$db ) { 
9         parent::__construct('#__pairrank', 'id', $db); 
10    } 
11 } 
12 ?>

Listing 42.17 Table-Klasse: »pairrank.php«

Die Klasse wird in den Zeilen 3 bis 11 definiert. Zunächst wird für jede Tabellenspalte eine passende Variable erstellt und mit einem Standardwert (null bedeutet so viel wie »leer«) belegt. Die Funktion TablePairrank (Zeilen 8–10) hat den gleichen Namen wie die Klasse. Das führt dazu, dass sie automatisch ausgeführt wird, wenn ein Objekt der Klasse mit new erstellt wird. Hier wird eine weitere Funktion der Oberklasse aufgerufen, die unser Objekt initialisiert. Dabei werden als Parameter der Name der Datenbanktabelle und der Name der Spalte übergeben, die eine eindeutige ID des Datensatzes enthält. Jetzt haben wir sehr einfache Funktionen zum Speichern und Löschen der Datensätze zur Verfügung.

Die Tabellenklasse hilft uns, das Model relativ übersichtlich zu halten. Dort werden die eigentlichen Aktionen zur Datenmanipulation definiert. Sehen wir uns die Datei einmal an:

1   <?php 
2   defined('_JEXEC') or die('Restriced Access'); 
3   jimport('joomla.application.component.model'); 
4   class PairranksModelPairrank extends JModel { 
5      function __construct() { 
6         parent::__construct(); 
7         $array = JRequest::getVar('cid',  0, '', 'array'); 
8         $this->setId($array[0]); 
9      } 
10     function setId($id) { 
11        $this->_id = $id; 
12        $this->_data = null; 
13     }

Listing 42.18 Auszug aus dem Model »pairrank.php«

Der Konstruktor, der aufgerufen wird, wenn das Model-Objekt instanziiert wird, fragt zunächst den URL-Parameter cid ab (Zeile 7). Dieser hat diejenigen IDs der Datensätze gespeichert, die in der Listenansicht per Checkbox ausgewählt wurden. Da es in der Liste möglich ist, mehrere Paare auszuwählen, in der Bearbeitungsansicht jedoch nur ein einziger Datensatz bearbeitet werden kann, wird in Zeile 8 die erste ID aus der Liste ausgewählt und als aktiver Datensatz an die Funktion setId übergeben. Diese Funktion (Zeile 10 –13) legt nun die ID intern ab und löscht eventuell bestehende alte Daten aus der Variable $_data.

Als Nächstes benötigen wir eine Funktion zum Auslesen des aktuell gewählten Datensatzes:

14     function getData() { 
15        if (empty( $this->_data )) { 
16           $query = ' SELECT * FROM #__pairrank '. 
17                    '  WHERE id = '.$this->_id; 
18           $this->_db->setQuery( $query ); 
19           $this->_data = $this->_db->loadObject(); 
20        } 
21        if (!$this->_data) { 
22           $this->_data = new stdClass(); 
23           $this->_data->id = 0; 
24           $this->_data->pair = null; 
25           $this->_data->points = null; 
26           $this->_data->published = null; 
27        } 
28        return $this->_data; 
29     }

Listing 42.19 Auszug aus dem Model »pairrank.php«

Die Funktion getData prüft zunächst, ob der Datensatz bereits abgeholt wurde (Zeile 14). Ist dies nicht der Fall, wird die Abfrage in den Zeilen 16 und 17 zusammengestellt und in Zeile 18 an das Datenbank-Objekt übergeben. Dieses Objekt ist bereits in der Variablen $this->_db vorhanden. Dafür sorgt die Basisklasse JModel. In Zeile 19 wird das Ergebnis geladen. Sollte die Abfrage kein Ergebnis liefern (das ist der Fall, wenn ein neuer Eintrag erstellt wird), werden die Daten jeweils mit Standardwerten belegt (Zeile 21 bis 27). In Zeile 28 wird das Ergebnis als Wert der Methode zurückgegeben.

Eine weitere Aufgabe des Models ist das Speichern von Daten, das im Folgenden programmiert wird:

30     function store() { 
31        $row =& $this->getTable(); 
32        $data = JRequest::get( 'post' ); 
33        if (!$row->bind($data)) { 
34           $this->setError($this->_db->getErrorMsg()); 
35           return false; 
36        } 
37        if (!$row->check()) { 
38           $this->setError($this->_db->getErrorMsg()); 
39           return false; 
40        } 
41        if (!$row->store()) { 
42           $this->setError( $row->getErrorMsg() ); 
43           return false; 
44        } 
45        return true; 
46     }

Listing 42.20 Auszug aus dem Model »pairrank.php«

In Zeile 31 wird unser Tabellenobjekt aus Listing 42.17 erstellt. Danach werden in Zeile 32 die zu speichernden Daten aus dem Formular abgeholt. Wie Sie sehen, werden alle Variablen aus der POST-Übergabe verwendet. In Zeile 33 werden diese Variablen an die Tabelle übergeben. Das macht die Methode bind, die aus dem JTable-Objekt kommt. Das passiert in einer Abfrage, die überprüft, ob die Übergabe funktioniert. Ist dies nicht der Fall, wird eine Fehlermeldung erzeugt (Zeile 34) und die Funktion beendet (Zeile 35). Danach werden die Daten mit der Methode check auf ihre Gültigkeit getestet (Zeile 37), und im Fehlerfall wird wiederum abgebrochen. Zuetzt werden die Daten über store gespeichert (Zeile 41). Hat alles geklappt, wird true als Rückgabewert übergeben.

Zu guter Letzt ist noch die Löschfunktionalität zu implementieren.

47     function delete() { 
48        $cids = JRequest::getVar( 'cid', array(0), 
49                                  'post', 'array' ); 
50        $row =& $this->getTable(); 
51        if (count( $cids )) { 
52           foreach($cids as $cid) { 
53              if (!$row->delete( $cid )) { 
54                 $this->setError( $row->getErrorMsg() ); 
55                 return false; 
56              } 
57           } 
58        } 
59        return true; 
60     } 
61  } 
62  ?>

Listing 42.21 Auszug aus dem Model »pairrank.php«

Zunächst werden die IDs aus der URL-Anfrage extrahiert und als Liste gespeichert (Zeilen 48 und 49). Dann wird die Verbindung zum Table-Objekt aufgenommen. In Zeile 51 wird überprüft, ob überhaupt Elemente zum Löschen ausgewählt wurden. Ist dem so, wird nach bewährtem Muster in Zeile 53 der Löschbefehl delete an das Table-Objekt gesendet.

Damit ist die volle Funktionalität zur Manipulation der Daten in der Datenbank hergestellt. Jetzt gilt es, die Benutzeraktionen zu erfassen und sie entsprechend weiterzuleiten. Das ist die Aufgabe des Controllers.

1  <?php 
2  defined( '_JEXEC' ) or die( 'Restricted access' ); 
3  jimport('joomla.application.component.controller'); 
4  class PairranksController extends JController { 
5     function display() { 
6          parent::display(); 
7     } 
8     function __construct() { 
9        parent::__construct(); 
10       $this->registerTask( 'add', 'edit' ); 
11    }

Listing 42.22 Auszug aus »controller.php«

Bis Zeile 7 sollte Ihnen der Controller schon bekannt vorkommen. In den Zeilen 8–11 wird ein Konstruktor erstellt, der die Aufgabe hat, auch das Kommando für das Hinzufügen von Datensätzen mit der Funktion edit zu verbinden. Normalerweise gibt es dafür einen eigenen Handler, der in unserem Fall jedoch nicht notwendig ist. Hinzufügen ruft nun die gleiche Maske auf wie Bearbeiten.

12    function edit() { 
13       JRequest::setVar( 'view', 'pairrank' ); 
14       JRequest::setVar( 'layout', 'form'  ); 
15       JRequest::setVar( 'hidemainmenu', 1 ); 
16       parent::display(); 
17    }

Listing 42.23 Auszug aus »controller.php«

Für die Bearbeitung eines Datensatzes müssen ein paar interne Variablen gesetzt werden. In Zeile 13 wird das Ausgabeziel auf pairrank (ohne s) gesetzt. Darauf folgt die Bestimmung des HTML-Templates. In Zeile 15 wird noch festgesetzt, dass das Menü in der Bearbeitungsansicht nicht verfügbar ist.

18    function save() { 
19       $model = $this->getModel('pairrank'); 
20       if ($model->store()) { 
21         $msg = 'Speichern war erfolgreich'; 
22       } else { 
23         $msg = 'Fehler beim Speichern'; 
24       } 
25       $this->setRedirect( 'index.php?option=com_pairrank', 
26                           $msg); 
27    } 
28    function remove() { 
29       $model = $this->getModel('pairrank'); 
30       if($model->delete()) { 
31          $msg = 'Löschen war erfolgreich'; 
32       } else { 
33          $msg = 'Fehler beim Löschen'; 
34       } 
 
 
35       $this->setRedirect( 'index.php?option=com_pairrank', 
36                           $msg ); 
37    }

Listing 42.24 Auszug aus »controller.php«

Die Aktionen Speichern und Löschen werden nach dem gleichen Muster erstellt. Zunächst wird das Model festgelegt (Zeilen 19 und 29). Dann wird die Aktion mit store bzw. delete ausgeführt (Zeilen 20 und 30). Das geschieht wieder innerhalb einer Bedingung, um gleich auf das Ergebnis reagieren zu können. Daraufhin wird eine entsprechende Meldung generiert und in eine Variable gespeichert. Zum Schluss wird dem Controller gesagt, welche Zielseite nach erfolgter Aktion angesprungen werden soll (Zeile 25 und 26 bzw. 35 und 36).

Zuletzt muss noch auf den Abbruch einer Aktion in der Bearbeitungsansicht reagiert werden. Denken Sie daran, dass es für beide Ansichten (Liste und Bearbeitung) nur einen Controller gibt.

38    function cancel() { 
39       $msg = 'Aktion abgebrochen'; 
40       $this->setRedirect( 'index.php?option=com_pairrank', 
41                           $msg ); 
42    } 
43 } 
44 ?>

Listing 42.25 Auszug aus »controller.php«

Hier wird nur eine entsprechende Meldung generiert und wieder zurück auf die Startseite der Komponente verwiesen.

Damit ist die Funktionalität zur Datenmanipulation abgeschlossen.

42.3.4 Bearbeitungsmodus

Fast haben wir es geschafft. Uns fehlt nur noch die zweite View für den Bearbeitungsmodus. Diese wollen wir nun erstellen.

1  <?php 
2  defined('_JEXEC') or die( 'Restricted access' ); 
3  jimport( 'joomla.application.component.view' ); 
4  class PairranksViewPairrank extends JView { 
5     function display($tpl = null) { 
6        $pairrank =& $this->get('Data'); 
7        $isNew = ($pairrank->id < 1); 
8        $text = $isNew ? JText::_( 'New' ) : JText::_( 'Edit' ); 
9        JToolBarHelper::title( 'Paar-Rang: <small> [ ' 
10                               .$text.' ]</small>' ); 
11       JToolBarHelper::save(); 
12       if ($isNew) { 
13          JToolBarHelper::cancel(); 
14       } else { 
15          JToolBarHelper::cancel( 'cancel', 'Close' ); 
16       } 
17       $this->assignRef('pairrank', $pairrank); 
18       parent::display($tpl); 
19    } 
20 } 
21 ?>

Listing 42.26 Die View der Bearbeitungsansicht: »view.html.php«

In den Zeilen 6 und 7 wird über eine Abfrage der Daten überprüft, ob ein neuer Datensatz angelegt werden soll oder ob ein bestehender bearbeitet werden soll. Ist die ID gleich 0, so wird die Variable $isNew auf true gesetzt und in Zeile 8 der Titel der Bearbeitungsansicht entsprechend geändert. Der Titel wird in den Zeilen 9 und 10 vom Objekt ToolbarHelper ausgegeben. In Zeile 11 wird das Symbol für das Speichern des Datensatzes geschrieben. Die Zeilen 12 bis 16 setzen die Beschriftung für das Abbrechen-Symbol. Handelt es sich um einen neuen Datensatz, wird hier Abbrechen verwendet, ansonsten Schliessen.

Erstellen wir nun noch das HTML-Template:

1  <?php defined('_JEXEC') or die('Restricted access'); ?> 
2  <form action="index.php" method="post" 
3        name="adminForm" id="adminForm"> 
4  <div class="col100"> 
5   <fieldset class="adminform"> 
6    <legend><?php echo JText::_( 'Details' ); ?></legend> 
7    <table class="admintable"> 
8     <tr> 
9      <td width="100" align="right" class="key"> 
10      <label for="pair">Paar</label> 
11     </td> 
12     <td> 
13      <input class="text_area" type="text" name="pair" 
14             id="pair" size="32" maxlength="250" 
15             value="<?php echo $this->pairrank->pair;?>" /> 
16     </td> 
17    </tr> 
18    <tr> 
19     <td width="100" align="right" class="key"> 
20      <label for="points">Punkte</label> 
21     </td> 
22     <td> 
23      <input class="text_area" type="text" name="points" 
24             id="points" size="32" maxlength="250" 
25             value="<?php echo $this->pairrank->points;?>" /> 
26      </td> 
27     </tr> 
28    </table> 
29   </fieldset> 
30  </div> 
31  <div class="clr"></div> 
32  <input type="hidden" name="option" value="com_pairrank" /> 
33  <input type="hidden" name="id" 
34         value="<?php echo $this->pairrank->id; ?>" /> 
35  <input type="hidden" name="task" value="" /> 
36  <input type="hidden" name="controller" value="pairrank" /> 
37 </form>

Listing 42.27 form.php

Das Formular wird in Form einer Tabelle ausgegeben. Die erste Spalte enthält jeweils die Beschriftungen (im Tag label, Zeile 10 und 20), die zweite ein Eingabefeld, das die Werte ausgibt und einliest (Zeilen 13–15 und 23–25). Am Ende werden die üblichen Steuervariablen für die Weiterverarbeitung gesetzt.

Somit ist unsere Komponente komplett. Wenn Sie diese jetzt installieren, können Sie alle Funktionen testen.

Abbildung 42.3 Die Bearbeitungsansicht eines Paares

Ihr Kommentar