Das .info-File

Das .info-File kann mit jedem Editor geschrieben werden. Ich benutze die Freeware-Version von PHP-Designer von MK-Soft. Damit erstelle ich auch alle anderen Scripte (wenn nicht weise ich darauf hin). Das .info-File folgt der .ini-Syntax. Genaueres kann man unter php.net erfahren. Die genaue Definition ist unter Drupal-Info-File-Beschreibung nachzulesen. Hier das wichtigste: Das File beginnt mit der Beschreibung ; $Id$ Das ungewöhnliche daran ist das die Komentare mit ein ; eingeleitet werden. Nach dem ; folgt die erste Erklärung, diese beginnt und endet mit einem $. Hier ein Beispiel:

; $ Id: ersterinhalt.info, UwBach, 2008/04/14 $
name = ersterinhalt
description = Erzeugt einen Eintrag im Admin-Menue
package = "AA"
version = "$Name$"
project = "Uwe_Test"
datestamp = "1207381502"

Nun noch einige Erklärungen zu den einzelenen Punkten:

name

Der Name des Modules - Pflichtangabe. Hier muss eine "computerfreundliche" Schreibweise gewählt werden. Die Bezeichnung wird sich durch alle weiteren Code-Bestandteile ziehen, wählt daher eine eindeutige und einfache Bezeichnung. Es dürfen keine Leerschritte, Zahlen oder Sonderzeichen drin vorkommen, Ausnahme der Unterstrich. Nur der erste Buchstabe darf groß geschrieben werden.

description

Die Beschreibung in einer Zeile (max. 255 Zeichen) - Pflichtangabe. Vermeide bitte Anführungsstriche, egal ob einfache oder doppelte

dependencies

Abhängigkeiten - optional. Hier können Abhängigkeiten zu anderen Modulen beschrieben werden. Wichtig ist das um die Funktionen eigener Module zu gewährleisten, falls man diese im eigenen Code aufruft. Das Modul läßt sich dann erst aktivieren, wenn die beschriebenen Module im Administrationsbereich zur Verfügung stehen und aktiviert sind.

package

Zuweisen des eigenen Moduls zu einem bestimmten Package - optional. Im Beispeil ist das Package "AA" gewählt worden um es in der Administrationsobfläche ganz oben zu positionieren.

version

Versionsangabe des Moduls. Die richtige Versionsnummer wird von "Drupal.org" vergeben, wenn das Modul hochgeladen wird. Dann sollte der Name $Name$ sein. Wird das Modul nicht hochgeladen kannst du machen was du willst.

project

nur für "Drupal.org". Das bitte nicht verwenden. Bei bedarf wird Drupal.org diese Bezeichnung für den Update bestimmter Packages verwenden.

datestamp

Der Zeitpunkt der Erstellung (Unix-Timestamp)

Jetzt ist alles bereit und wir können ein Verzeichnis anlegen - sites/all/modules/ersterinhalt. Darin wird unsere Datei unter dem Namen ersterinhalt.info abgespeichert. Das war der erste Schritt ...

Das .module-File

Der nächste Schritt ist das .module-File zu erstellen. In diesem File sind alle Funktionen abgelegt. Um einen Eintrag im Administration-Menü zu erstzeugen brauchen wir nicht viel: <?php // $ID$
/**
* @file
* Irgendeine Beschreibung
*/   Den Snipsel speichern unter ersterinhalt.module und fertig. Das Script muss natürlich wieder im Verzeichnis sites/all/modules/ abgespeichert werden.

Ruft man jetzt den "Administer -> Site building -> Modules" (h t t p://.../admin/build/modules) auf, sieht man schon das neue Modul.

Natürlich haben wir noch keine Funktionalitäten zur Verfügung und guter Stiel ist das auch nicht.
Es gibt hier aber schon einige Besonderheiten zu sehen. So wird die Datei, wie bei PHP-Scripten üblich mit <?php eröffnet, allerdings fehlt das schließende Tag ?>. Der erste Dokumentationsblock /** muss eine Leerzeile zur //$Id$ haben.
Des weiteren soll genau ein Leerschritt in den folgenden Zeilen zwischen dem Zeilenbeginn dem * und ein Leerschritt zur Beschreibung eingehalten werden.
Das ist wieder nur dann erforderlich, wen ggf. mal ein Script an "Drupal.org" gegeben werden soll. Hierfür ist auch das Tag @file gedacht. Es sollte schon darauf geachtet werden, es kann sonst zu Problemen mit bestimmten Includes führen (siehe Drupal.org).

Aber nun soll es darum gehen Inhalte in das .module-File zu bringen. Dafür muss ich etwas weiter ausholen ...

Zum Nachmachen ist das Beschriebene im Anhang ..

Das Menü-System

Den Hook hook_menu() als reines Menü-System zu bezeichnen trifft es nicht genau. Das hook_menu() ist einiges mehr. Jedes Script braucht einen Punkt über den es aufgerufen werden kann. Dies wird über das hook_menu() erreicht. Zudem wird hier auch festgelegt welche Funktion, im eigenen Script, die Antwort auf einen Request der Seite zurückgibt. Weiter können die Berechtigungen festgelegt werden, die es erlauben bestimmte Funktionen bzw. Menüpunkte aufzurufen. Dabei ist jeder Menüpunkt ein eigenes Array. Das Array besteht aus folgenden Komonenten:

path

Der Pfad über den der Punkt zu erreichen ist. Pflichtangabe

title

Der übersetzte Titel im Menü. Pflichtangabe

callback

Die Funktion die aufgerufen wird, wenn der User den Menüpunkt aufruft.

callback arguments

An array of arguments to pass to the callback function.

access

Ein Boolean-Wert der angibt ob der Menüpunkt angezeigt werden soll. Gibt eine Entscheidung an user_access(). If omitted and "callback" is also absent, the access rights of the parent menu item will be used instead.

weight

Ist ein Integerwert der bestimmt an welcher Stelle im Menü der Punkt erscheint (Wertebereich -10 bis 10; Default 0. Wenn hier keine Angabe gemacht wurde, wird alphabetisch sortiert.

type

Gibt an in welchem Menü der Punkt erscheinen soll. A bitmask of flags describing properties of the menu item. Many shortcut bitmasks are provided as constants in menu.inc:

MENU_NORMAL_ITEM

Anzeige im normalen Menü-Baum. Die Position kann vom Administrator verändert werden.

MENU_ITEM_GROUPING

Item groupings are used for pages like "node/add" that simply list subpages to visit.

MENU_CALLBACK

Callbacks simply register a path so that the correct function is fired when the URL is accessed.

MENU_DYNAMIC_ITEM

Dynamic menu items change frequently, and so should not be stored in the database for administrative customization.

MENU_SUGGESTED_ITEM

Modules may "suggest" menu items that the administrator may enable.

MENU_LOCAL_TASK

Erzeugt einen lokalen Tab.

MENU_DEFAULT_LOCAL_TASK

Alle Seiten mit Tab's benötigen einen "default" Tab. Dieser wird immer zu Anfang aufgrufen.

Fehlt der "type", wird MENU_NORMAL_ITEM angenommen.

Jetzt aber ein wenig Code:

/**
* Einhängen in das Menue
*/
function ersterinhalt_menu($may_chache)
{
$items = array();  
if(!$may_chache)
{
$items[] =
array(
'path' => 'ersterinhalt',
'title' => t('Erster Inhalt'),
'callback' => 'ersterinhalt_seiteninhalt',
'callback arguments' => array(''),
'access' => TRUE,
// user_access('anonymous user'),
'type' => MENU_NORMAL_ITEM );
}  
return $items;
}  
 
/**
* Die Callback-Funktion
*/
function ersterinhalt_seiteninhalt()
{
return t('Hallo   Mein erster Seiteninhalt.   '.date('d.m.Y H:i:s', mktime()));
}
Jetzt sollte im User-Menü der Menüpunkt erscheinen und die Callback-Funktion ersterinhalt_seiteninhalt() sollte einen Inhalt rausgeben.

Über das Administrationsmenü kann der Punkt dann gesondert verschoben werden, so das er an der richtigen Stelle erscheint:

Dabei werden die Informationen in der Datenbank gespeichert und beim nächsten Aufruf wieder ausgelesen. Es ist gut zu wissen wie die internen Abläufe zum Menü-Aufbau sind, daher eine kleine Übersicht:
Damit ist auch klar das MENU_DYNAMIC_ITEM nicht in der Datenbank gespeichert werden können. Diese Funktion ist wichtig, wenn Menüs aus eigenen Datenbeständen erstellt werden sollen - z. B. Produktkatalogen. Ferner ist es möglich für Menüpunkte Unterpunkte zu definieren. Dazu wird in der Funktion hook_menu(), in unserem Beispiel function erster_inhalt() ein weiterer Menüpunkt definiert. function ersterinhalt_menu($may_chache)
{
$items = array();
 
if(!$may_chache)
{
$items[] = array
(
'path' => 'ersterinhalt',
'title' => t('Erster Inhalt'),
'callback' => 'ersterinhalt_seiteninhalt',
'callback arguments' => array(''),
'access' => TRUE,
'type' => MENU_NORMAL_ITEM,
);
// Hier wird der erste Unterpunkt definiert
$items[] = array
(
'path' => 'ersterinhalt/upunkt',
'title' => t('Erster Unterpunkt'),
'callback' => 'ersterinhalt_ersterupunktinhalt',
'callback arguments' => array(''),
'access' => TRUE,
'type' => MENU_NORMAL_ITEM
);  
}  
 
return $items;
}  
 
/**
* Die Callback-Funktion des ersten Seiteninhaltes
*/
function ersterinhalt_seiteninhalt()
{ return t('Hallo
Mein erster Seiteninhalt.
'.date('d.m.Y H:i:s', mktime()));
}  
 
/**
* Die Callback-Funktion für den ersten Unterpunkt
*/
function ersterinhalt_ersterupunktinhalt()
{
return t('Hallo
Mein erster Seiteninhalt im Unterpunkt.
'.date('d.m.Y H:i:s', mktime()));
}

Sollte das Menü über die Administrationsoberfläche geändert worden sein, werden die neuen Werte in der Datenbank (Tabelle menu) gespeichert. Werden dann Änderungen im Code gemacht, die die Sichtbarkeit oder Bezeichnung beeinflussen, kann es passieren das diese nicht korrekt umgesetzt werden. Hier einfach ein Update der Struktur durchführen (Verwalten -> Strukturieren -> Modul => Link update.php oder ./update.php). Drupal überprüft dann alle Module auf Änderungen und trägt diese neu in die Datenbank ein.

Seiten mit Tab's

Eine besondere Form des Menüs sind Seiten mit Tabs. Tabs können in zwei Varianten erstellt werden; einmal als Reiter und einmal als Link-Unterpunkte.

(Zur besseren Sichtbarkeit wurde das Themes gewechselt) Hier erst einmal der Code:

/**
* Einhängen in das Menue
*/
function ersterinhalt_menu()
{
$items = array();
 
if(!$may_chache)
{
// Der Hauptmenüpunkt
$items[] = array
(
'path' => 'ersterinhalt',
'title' => t('Erster Inhalt'),
'callback' => 'ersterinhalt_seiteninhalt',
'callback arguments' => array(''),
'access' => TRUE,
'type' => MENU_CALLBACK,
);
 
// Der erste Reiter
$items[] = array
(
'path' => 'ersterinhalt/task',
'title' => t('Erster Unterpunkt'),
'access' => TRUE,
'type' => MENU_DEFAULT_LOCAL_TASK,
'weight' => -1,
);
 
// Der zweite Reiter
$items[] = array
(
'path' => 'ersterinhalt/nr1',
'title' => t('Erster Tab'),
'callback' => 'ersterinhalt_upunkt_nr1',
'access' => TRUE,
'type' => MENU_LOCAL_TASK,
);
 
// Der dritte Reiter
$items[] = array
(
'path' => 'ersterinhalt/nr2',
'title' => t('Zweiter Tab'),
'callback' => 'ersterinhalt_upunkt_nr2',
'access' => TRUE,
'type' => MENU_LOCAL_TASK,
);
 
// Der erste Unterunterpunkt als Link
$items[] = array
(
'path' => 'ersterinhalt/task/upunkt1',
'title' => t('Erster Unterunterpunkt'),
'access' => TRUE,
'type' => MENU_LOCAL_TASK,
'callback' => 'upunkt1',
);
 
// Der zweite Unterunterpunkt als Link
$items[] = array
(
'path' => 'ersterinhalt/task/upunkt2',
'title' => t('Zweiter Unterunterpunkt'),
'access' => TRUE,
'type' => MENU_LOCAL_TASK,
'callback' => 'upunkt2',
);
}
 
return $items;
}  
 
function ersterinhalt_seiteninhalt()
{
return t('Hallo
Mein erster Seiteninhalt.
'.date('d.m.Y H:i:s', mktime()));
}  
 
function ersterinhalt_ersterupunktinhalt()
{
return t('Hallo
Mein erster Seiteninhalt im Unterpunkt (TAB).
'.date('d.m.Y H:i:s', mktime()));
}  
 
function ersterinhalt_upunkt_nr1()
{
return t('Hallo
Mein erster Tab-Inhalt.
'.date('d.m.Y H:i:s', mktime()));
}

 
function ersterinhalt_upunkt_nr2()
{
return t('Hallo
Mein zweiter Tab-Inhalt.
'.date('d.m.Y H:i:s', mktime()));
}  
 
function upunkt1()
{
return 'Erster Unter-Unterpunkt';
}  
 
function upunkt2()
{
return 'Zweiter Unter-Unterpunkt';
}

In den ersten beiden Arrays, wird zum einen der Menüpunkt definiert und zum anderen der Default-Tab festgelegt.
// Der Hauptmenüpunkt
$items[] = array
(
'path' => 'ersterinhalt',
'title' => t('Erster Inhalt'),
'callback' => 'ersterinhalt_seiteninhalt',
'callback arguments' => array(''),
'access' => TRUE,
'type' => MENU_CALLBACK
);
// Der erste Reiter
$items[] = array
(
'path' => 'ersterinhalt/task',
'title' => t('Erster Unterpunkt'),
'access' => TRUE,
'type' => MENU_DEFAULT_LOCAL_TASK,
'weight' => -1,
);

Die Werte des Hauptmenüpunktes unterscheiden sich nur in der Definition des "type", der hier auf MENU_CALLBACK gesetzt. Das zweite Array hat einen erweiterten path, kein definiertes callback und der type ist auf MENU_DEFAULT_LOCAL_TASK gesetzt. Damit wird die Tab als Default-Tab definiert. Die nächsten beiden Tabs sind wie bisher üblich definiert. Der path ist als Unterpfad des Menüpunktes definiert - der type ist auf MENU_LOCAL_TASK gesetzt. Beide Tabs haben jeweils eigene Callback-Funktionen. Die beiden Link-Tabs ("Erster Unterunterpunkt", "Zweiter Unterunterpunkt") unterscheiden sich nur durch die path-Angabe von den echten Tabs. Wie auch sonst im Menü kann die Reihenfolge der Einträge durch weight beeinflußt werden (siehe "Erster Unterpunkt"). Fehlt der Wert wird alphabetisch sortiert.

Block mit ungelesenen Nodes erstellen

Ich habe versucht mit Views einen Block mit ungelesenen Nodes eines Users zu erstellen. Das scheiterte an zwei Dingen:

1. die Tabelle {history} ist nicht in Views integriert und
2. die Berechtigungen einen Node zu lesen können mit Views nicht korrekt abgefragt werden.

Daher habe ich mich entschlossen ein eigenes Modul zu schreiben, dass einen Block erzeugt der die ungelesenen Nodes anzeigen kann. Die Vorgaben sind:

• Konfiguration der einzubeziehenden Node-Types
• Angabe von zurückliegenden Zeiten der Node-Erstellung
• Berücksichtigung von Berechtigungen (View) aus dem Modul "node_privacy_byrole"
• Rollenbasierte Berechtigung den Block anzuzeigen

Herausgekommen ist ein eigenes Modul "unreaded_nodes":

<?php //; $ Id: unreaded_nodes.info, UwBach, 2008/08/04 $  
 
/**
* @file Erstellen eines Blockes mit nocht gelesenen Nodes
* Version 0.1
*
* Erstellen von Rechten
* Block-Zuweisung
* Block-Konfiguration
*/
  
/**
* Funktion zum erstellen eines Blockes zu anzeigen noch nicht gelesener Nodes
*/
function unreaded_nodes_block($op = 'list', $delta = 0, $edit = array())
{
switch ($op)
{
case 'list':
$blocks[0]['info'] = t('ungelesen');
return $blocks;
break;  
 
case 'configure':
// Holen der möglichen Node Types
$node_types = node_get_types($op = 'types');
// DEFAULT-Variable
$node_type_option_list = array();
// Auslesen der Node Types
foreach($node_types as $node_typ)
$node_type_option_list[$node_typ -> type] = $node_typ -> name;
$node_desc_option_list = array
(
'1' => t('aufsteigend'),
'0' => t('absteigend')
);  
 
$form['notreaded_nodes_count'] = array
(
'#type' => 'textfield',
'#title' => 'Anzahl der unglesenen Nachrichten',
'#default_value' => variable_get('notreaded_nodes_count', 10),
'#description' => t('Anzahl der anzuzeigenden Mitteilungen')
);  
 
$form['notreaded_nodes_nodetypes'] = array
(
'#type' => 'checkboxes',
'#title' => t('Welche Node-Types sollen berücksichtigt werden?'),
'#default_value' => variable_get('notreaded_nodes_nodetypes', ''),
'#options' => $node_type_option_list,
'#description' => t('Wenn keine Node Types ausgewählt werden, werden alle Node Types abgefragt.')
);  
 
$form['notreaded_nodes_time'] = array
(
'#type' => 'textfield',
'#title' => t('Zeitbeschränkung'),
'#default_value' => variable_get('notreaded_nodes_time', 0),
'#description' => t('In Sekunden die zurückliegende Zeit angeben')
);  
 
$form['notreaded_nodes_desc'] = array
(
'#type' => 'select', '#title' => t('Reihenfolge '),
'#default_value' => variable_get('notreaded_nodes_desc', ''),
'#options' => $node_desc_option_list,
'#description' => t('Wenn keine Node Types ausgewählt werden, werden alle Node Types abgefragt.')
);  
 
return $form;
break;  
 
case 'save':  
$node_types = array();
 
if(!count($edit['notreaded_nodes_nodetypes'])) ;
else
foreach($edit['notreaded_nodes_nodetypes'] as $key => $node_typ)
if($node_typ)
$node_types[$key] = $node_typ;  
 
variable_set('notreaded_nodes_count', (int)$edit['notreaded_nodes_count']); variable_set('notreaded_nodes_nodetypes', $node_types); variable_set('notreaded_nodes_time', (int)$edit['notreaded_nodes_time']); variable_set('notreaded_nodes_desc', $edit['notreaded_nodes_desc']);
 
break;  
 
case 'view':
if(user_access(t('notreaded_zugriff')))
{
global $user;  
 
// falls ein User nicht angemeldet ist
if($user -> uid == 0) return ;  
 
$subquery_nodetype = '';  
// Holen der Anzahl der anzuzeigenden Node Types
$notreaded_nodes_count = (int)variable_get('notreaded_nodes_count', 10);
// Holen der Zeiten
$notreaded_nodes_time = (int)variable_get('notreaded_nodes_time', 0);  
// Holen der betroffenen Node-Types
$betroffene_nodetypes = variable_get('notreaded_nodes_nodetypes', array());
// Wenn keine Node-Types gespeichert sind alle Node-Types zu holen
// sonst hole nur betroffene Node-Types
if(count($betroffene_nodetypes))
{
$mehr_types = '';
 
foreach($betroffene_nodetypes as $node_typ => $wert)
{
$subquery_nodetype .= $mehr_types.' node.type = "'.$node_typ.'"';
$mehr_types = ' OR';
}
 
}
else
$subquery_nodetype .= '1';  
 
$query = 'SELECT node.nid, node.title, node.created FROM {node} AS node WHERE node.status = 1 AND node.nid NOT IN (SELECT history.nid FROM {history} AS history WHERE history.uid = %d GROUP BY history.nid)';
 
if($notreaded_nodes_time)
$query = $query.' AND node.created BETWEEN (UNIX_TIMESTAMP() - '.$notreaded_nodes_time.') AND UNIX_TIMESTAMP()'; if($subquery_nodetype)
 
$query = $query.' AND ('.$subquery_nodetype.')';  
$query = $query.' ORDER BY node.created '.((variable_get('notreaded_nodes_desc', 0)?'DESC ':'ASC '));
 
if($notreaded_nodes_count)
$query = $query.' LIMIT '.$notreaded_nodes_count.'';  
 
$result = db_query($query, $user -> uid);  
 
$url = drupal_get_destination();  
 
$module = module_list();
$node_privacy_byrole = false;
$node_privacy_byrole_list = array();  
 
// Prüfen ob Modul node_privacy_byrole genutzt wird if($module['node_privacy_byrole'])
{
$node_privacy_byrole = true;
$roles = $user -> roles;
$more_roles = '';
$roles_query = '';  
// Zusammenstellen der User-bezogenen Rollen
foreach($roles as $role => $bezeichnung)
{
$roles_query .= $more_roles.' gid = '.$role;
$more_roles = ' OR ';
}
 
// Holen der Rollen
$node_access_query = 'SELECT nid FROM {node_access} WHERE grant_view = 1 AND ('.$roles_query.') GROUP BY nid';  
 
$ergDB_node_access = db_query($node_access_query);  
 
while($erg_node_access = db_fetch_array($ergDB_node_access))
$node_privacy_byrole_list[$erg_node_access['nid']] = 1;
 
} // END if
 
while($punkt = db_fetch_object($result))
{
// wenn kein node_privacy_byrole genutzt wird
if(!$node_privacy_byrole)
$liste[] = format_date($punkt -> created).'
'.l($punkt -> title, 'node/'.$punkt -> nid, array(), NULL, '');
// ansonsten checken ob der user berechtigt ist die Meldung zu sehen elseif($node_privacy_byrole_list[$punkt -> nid])
$liste[] = format_date($punkt -> created).'
'.l($punkt -> title, 'node/'.$punkt -> nid, array(), NULL, '');
}
 
if(count($liste) == 0) return ;  
$block['subject'] = t('Neue Mitteilungen');
$block['content'] = theme('item_list', $liste);  
return $block;
} // END  case 'view': if
 
} // END switch  
} // END manipulation_block
 
/**
* Funktion zum setzen der Berechtigungen für das BLOCK-Modul
*/
function unreaded_nodes_perm()
{
return array(t('notreaded_zugriff'));
}


Nach der Aktivierung sollten als erstes die Rechte gesetzt werden. Dabei sollte der "Gast" bzw. "anonymous user" ausgenommen werden. Das Modul bricht allerdings bei der UID = 0 ohnehin ab. Im nächsten Schritt wird das Modul einer Area zugewiesen (Block "ungelesen"). In der Konfiguration können folgende Einstellungen gemacht werden:

• Anzahl der anzuzeigenden Nodes. Dabei macht es an dieser Stelle keinen Sinn einen "mehr"-Link zu setzen (die übliche Einstellung in Views), da eine gelesene Nachricht durch die nächste ersetzt wird.
• Welche Node-Typen berücksichtigt werden sollen.
• Wie weit zurückliegende Nodes noch angezeigt werden sollen, z. B. 15552000 für die letzten 180 Tage. Hier werden nur positive Integerwerte eingetragen.
• Und die Reihenfolge in der die Nodes angezeigt werden sollen, die ältesten zuerst oder die neusten zuerst.

Das Style kann in der common.css angepasst werden. Der Block wird mit .block .block-unreaded_nodes { } angesprochen. Alle Strings die angezeigt werden, können in dem "Lokalisierungs"-Modul (Zeichenketten verwalten" bearbeitet werden. Das war es auch schon ..

Auslesen des User-Objektes

Was steht nun in dem User-Objekt? Dazu lesen wir das Userobjekt erst einmal aus. Dazu verwenden wir erst einmal eine eigene Funktion, besser ist das Debugger-Modul zu verwenden, dazu aber später.

/**
* Startseite des AWS
*/
function aws_start()
{
// Holen des User-Objektes
global $user;  
$uebergabe = 'Start AWS';
$uebergabe .= '';  
$uebergabe .= array_auslesen($user);
 
return $uebergabe;
} // END aws_start  
 
/**
* Einfache Funktion zum Auslesen von Arrays
*/
function array_auslesen($array)
{
// Das Array auslesen
foreach($array as $key => $wert)
{
if(!is_array($wert))
$uebergabe .= $key.' - '.$wert.'
';
else
{
$uebergabe .= $key.' (
';  
$uebergabe .= array_auslesen($wert);  
$uebergabe .= ')
';
}
}  
 
return $uebergabe;
} // END array_auslesen


Ausgabe:
uid - 3
name - Mitarbeiter1
pass - cfe09803c312143de6ef0fe9dc436bc9
mail - mitarbeiter1@xxx.de
mode - 0
sort - 0
threshold - 0
theme -
signature -
created - 1208330988
access - 1208340810
login - 1208339914
status - 1
timezone -
language -
picture -
init -
mitarbeiter1@xxx.de
data - a:0:{}
sid - 8797c3216b5f0032fa1a38bda510e5f6
hostname - 127.0.0.1
timestamp - 1208340810
cache - 0
session -
roles (
2 - authenticated user
3 - Mitarbeiter
)

Hier die Definition der wichtigsten Punkte:

uid

Die User-ID des Users. Das ist der Primary-Key aus der Datenbank

name

Name des Users. Standardmäßig erfasst Drupal nur einen Namen und unterscheidet nicht Vor- bzw. Nachname.

pass

Das Passwort als MD5-Hash.

mail

Die Standard-Email-Adresse des Users.

status

Sollte eine 1 beinhalten, nur wenn der User gesperrt ist steht hier eine 0

data

Enthält ein serialisiertes Array in dem über die Funktion user_save() Daten hinterlegt werden können.

roles

Enthält ein Array mit den zugewiesenen Rollen. Es gibt zwei DEFAULT-Rollen

1. anonymous user
2. authenticated user

sid

Session ID

hostname

Die IP-Adresse

Über die Rolle wird im folgenden das weitere Menü gesteuert.

Benutzerabhängiges Menü

Als erstes soll unter dem Startmenü ein Menüpunkt erscheinen, der nur aktiv ist wenn ein User eingeloggt ist. Dafür gibt es zwei Möglichkeiten:

1. Ein Admin-Menü erstellen in dem die Rechte der Sichtabrkeit über die Administrationsoberfläche in Drupal definiert werden können. Die Berechtigungen werden dann in der Drupal-eigenen Datenbank gespeichert.
2. Die Berechtigungen in dem eigenen Modul setzen. (Das wird im Folgendem favorisiert)

Um einen ersten Menüpunkt zu erzeugen der nur für eingeloggte Mitarbeiter sichtbar ist, wird folgender Code verwendet:
/**
* Das Menüsystem des AWS
*/
function aws_menu()
{
// Holen des User-Objektes
global $user;
$items = array();
 
if(!$may_chache && ($user -> uid > 0))
{
$items[] = array
(
'path' => 'aws',
'title' =>t( 'Arbeitszeiten'),
'callback' => 'aws_helper',
'access' => true,
'type' => MENU_NORMAL_ITEM,
);
 
$items[] = array
(
'path' => 'aws/start',
'title' =>t( 'Arbeitszeit Start'),
'callback' => 'aws_start',
'access' => true,
'type' => MENU_NORMAL_ITEM,
);
}
 
return $items;
}


Anschließend wird der Menüpunkt in den Startpunkt verschoben (admin/build/menu). Solange der User nicht angemeldt ist, ist der Menüpunkt nicht sichtbar.

Erst nach der Anmeldung wird der neue Menüpunkt sichtbar. Hierzu sind zwei Dinge notwendig

1. Einbinden des User-Objektes (global $user;).
2. Abfragen ob ein User eingeloggt ist(if(!$may_chache && ($user -> uid > 0))).

User Login Bypass

Es kommt häufig vor das Daten schon in einer anderen Anwendung oder in einer anderen Datenbank liegen. Hier ist es nicht gewünscht alle Daten in Dupal zu integrieren, zumeist soll die externe Anwendung oder Datenbank genutzt werden. Drupal bietet dafür mehrere Möglichkeiten:

Externers Login via XML-RPC

Dazu verbindet sich Drupal mit einem externen Server und übergibt den Nutzernamen und das Passwort. Die Anwort ist ein TRUE oder FALSE. Bei Misserfolg können auch die Fehlermeldungen des kontaktierten Servers ausgegeben werden. Genaueres ist in der Dokumentation zu drupal_xmlrpc() nachzulesen. Bei Erfolg wird der User in die Tabelle {authmap} eingetragen.

Eigenes Script ohne User-Generierung

Hierbei wird die Authentifizierungsabfrage in Drupal um ein eigenes Script erweitert. Drupal wird dann nur mitgeteilt ob die Authentifizierung erfolgreich ist oder nicht. Drupal legt zwar einen eigenen User dafür an, aktiviert diesen aber nicht.

Eigenes Script mit User-Generierung

Hierbei wird die Authentifizierungsabfrage in Drupal um ein eigenes Script erweitert. Drupal wird dann nicht nur mitgeteilt ob die Authentifizierung erfolgreich ist oder nicht, sondern es wird gleichzeitig ein eigener User angelegt und aktiviert.

Es gibt noch eine Reihe fertiger Module mit denen die Authentifizierrung erledigt werden kann, z. B. das LDAP Integration um direkt auf eine Datenbank zuzugreifen. Generell schaut Drupal nur in der eigenen Datenbanktabelle {users} nach ob dort der User existiert, der sich grade versucht einzuloggen. Wenn dieser existiert wird das Passwort geprüft und geprüft ob der User aktiviert ist. Sind diese Prüfungen erfolgreich, werden die Userdaten geladen und im User-Objekt gespeichert. Damit sind dann auch die Berechtigungen global verfügbar. Es besteht jedoch auch die Möglichkeit einen eigenen Authentifizierungs-Mechanismus einzuhängen - (hook_auth()). Der Ablauf verändert sich dann ein wenig:

1. Drupal schaut in die Tabelle {users}, findet er hier den aktivierten User - alles klar, dann wird abgebrochen und der User geladen.
2. Drupal schaut in die Tabelle {authmap}, findet er hier den aktivierten User - alles klar, dann wird abgebrochen und der User geladen.
3. Drupal schaut ob irgendwelche Module den hook_auth implementiert haben. Wenn nicht ist hier Schluss und der User wird abgewiesen.
4. Drupal fragt den hook_auth nach seinem Ergebnis. Kommt hier ein FALSE ist Schluss und der User wird abgewiesen.
5. Drupal legt den User an (falls er noch nicht existiert). An diesem Punkt kann auch in das User-Objekt eingegriffen werden.

Das Ergebnis ist dass der User jetzt im System angemeldet ist. Solange er kein aktiviertes Konto hat, stehen Ihm aber nicht alle Möglichkeiten offen.
/**
* Implementation des Hook_auth
*/
function aws_auth($username, $password, $server = FALSE)
{
drupal_set_message('Authentifikation - user:'.$username.' - pw:'.$password.' ist zugelassen');  
// Hier die Prüfung einbauen  
$return = true;  
 
return $return;
} // END aws_auth
 

Hier also ein "universeller" Bypass, der so natürlich nur lokal und nur zum Test verwendet werden sollte. Zumeist werden die Daten aus einer Datenbank geholt und Drupal mitgeteilt das der User Zugriff hat oder nicht. Wenn der User einen dauerhaften Zugriff auf das Drupal-System haben soll, besteht die Möglichkeit direkt einen Drupal-User anzulegen.
/**
* Implementation des Hook_auth
*/
function aws_auth($username, $password, $server = FALSE)
{
drupal_set_message('Authentifikation - user:'.$username.' - pw:'.$password.' ist zugelassen');  
 
// Hier die Prüfung einbauen und die Daten holen  
user_save('',
array
(
'name' => $username,
'pass' => $password,
'mail' => 'user@email.org',
'roles' => array
(2 => 'authenticated user', 3 => 'beliebige rolle'),
'status' => 1,
'init' => 'user@email.org',
)
);
 
$return = true;  
return $return;
} // END aws_auth
 

Mit der Methode user_save können die Daten direkt an Drupal gegeben und der User dort angelegt werden. Wird der erste Parameter mit der $user -> uid angegeben, wird kein neuer Account angelegt sondern geprüft ob ein Account vorhanden ist und dieser bei Bedarf upgedatet. Der zweite Parameter sind die Daten aus dem User-Objekt die als Array zurückgegeben werden. Man sollte sich allerdings immer die Frage stellen ob das sinnvoll ist, denn für diesen User existieren ja dann zwei Datensätze an unterschiedlichen Orten die auch gepflegt werden müssen.

User-Profilseite verändern

Die normale Profilseite eines Users in Drupal gibt nicht viel her. Man kann die Profile mit Drupal-Mitteln recht einfach erweitern und diese zusätzlichen Angaben auch ausgeben lassen. Dazu muss das Modul Profile (Dupal-Standardumfang) aktiviert werden und unter Verwalten -> Benutzerverwaltung können die Profile dann angepasst werden. Die Augabensteuerung und die Sichtbarkeiten für andere User sind alldings beschränkt. Daten aus externen Datenbanken oder Informationen die nicht im Profil sind können aber kaum ausgegeben werden.

Hierfür kann aber über den hook_user($op, &$edit, &$account, $category = NULL) direkt die Inhalte zugegriffen werden. Der Zugriff erfolgt wieder in einem eigenen Modul. Es soll in diesem Beispiel erst einmal eine Adresse eingeblendet werden, die nicht im Drupal-System gespeichert ist. Es soll weiterhin eine Prüfung erfolgen ob der User auch die Berechtigung hat die Daten zu sehen.
<?php //; $ Id: manipulation.module, UwBach, 2008/05/14 $
 
/**
* @file Menümanipulation der Anwendung
* Erster Versuch
*/
 
/**
* Funktion um Usereinstellungen zu maipulieren
* Hier wird der gespeicherte Benutzername durch den richtigen Namen ersetzt, soweit er erfasst ist
*/
function manipulation_user($op, &$edit, &$user, $category = NULL)
{
// Wenn der User ein Profil aufruft
if($op == 'view')
{
// Der nachgefragte User
$requested_user = $user;
 
// Falls der User keine Berechtigung hat
if(!$user -> uid)
// Prüfung für Zugangsberechtigung einfügen oder weglassen
return ;
else
{
// hole irgendwelche Fremddaten
$externe_daten = array
(
'strasse' => 'Musterstrasse',
'hausnummer' => '12a',
'plz' => '12345',
'ort' => 'Testhausen'
);
}
 
// Der angemeldete User
global $user;  
 
// DEFAULT-Werte für die Sichtbarkeit der Angaben
$sichtbarkeit_adresse = FALSE;
 
// Falls der User seine eigenen Daten nachfragt - alles freigeben if($requested_user -> uid == $user -> uid)
{
$sichtbarkeit_adresse = TRUE;
} // Falls ein fremder Account nachgefragt wird - prüfen was freigegeben werden kann
else
{
// eigene Prüfung einfügen
} // Prüfen Ob die Adresse ausgeben werden soll
 
if($sichtbarkeit_adresse)
{
$items[] = array
(
'title' => t('Strasse'),
'value' => $externe_daten['strasse'],
'class' => 'adresse',
);  
 
$items[] = array
(
'title' => t('Hausnummer'),
'value' => $externe_daten['hausnummer'],
'class' => 'adresse',
);
 
$items[] = array
(
'title' => t('Postleitzahl'),
'value' => $externe_daten['plz'],
'class' => 'adresse',
);
 
$items[] = array
(
'title' => t('Ort'),
'value' => $externe_daten['ort'],
'class' => 'adresse',
);
 
return array
(
t('Adresse') => $items);
} // END  if($sichtbarkeit_adresse)
} // END if($op == 'view')  
} // END manipulation_user()
Die Ausgabe hat sich jetzt verändert:

Im Modul User Funktion user_user($type, &$edit, &$user, $category = NULL) wird die Default-Ausgabe generiert und kann ggf. überschrieben werden. Die Umsetzung des Arrays erfolgt in der Funktion function theme_user_profile($account, $fields) ebenfalls in dem Modul User. Interessant ist noch die Angabe 'class' mit der CSS-Klassen erzeugt werden. Der Quelltext sieht dann so aus:
<div class="profile">
<h2 class="title">Verlauf</h2>
<dl>
<dt class="user-member">Mitglied seit</dt>
<dd class="user-member">1 Woche 35 Minuten</dd>
</dl>
 
<h2 class="title">Adresse</h2>
<dl>
<dt class="manipulation-adresse">Strasse</dt>
<dd class="manipulation-adresse">Musterstrasse</dd>
<dt class="manipulation-adresse">Hausnummer</dt>
<dd class="manipulation-adresse">12a</dd>
<dt class="manipulation-adresse">Postleitzahl</dt>
<dd class="manipulation-adresse">12345</dd>
<dt class="manipulation-adresse">Ort</dt>
<dd class="manipulation-adresse">Testhausen</dd>
</dl>
</div>
Damit kann durch die Einbindung einer einfachen CSS-Datei das eigene Design schnell umgesetzt werden (siehe Kapitel "CSS einbinden").

Formularelemente 1 von 2

Formularelemente sind immer als Array aufgebaut, z. B.
$form['textfield_bsp'] = array
(
'#type' => 'textfield',
'#title' => t('Der Titel'),
'#description' => t('Machen Sie mal eine Eingabe.'),
'#required' => false,
'#default_value' => 'hier eingeben',
);
Dabei sind nur die Bezeichnung (['textfield_bsp']) und der '#type' für die meisten Elemente zwingend erforderlich. Zur Verfügung stehen folgende Elemente:

• Textfield
• Password
• Textarea
• Select
• Radio
• Checkboxes
• Value
• Hidden
• Date
• Weight
• File Upload
• Fieldset
• Submit
• Button
• Markup
• Item

Die wichtigsten sollen genauer betrachtet werden. Dafür benötigen wir erst einmal ein Testformular das dann immer erweitert werden kann. Das .info-File /site/all/testform/testform.info ; $Id$ name = testform description = Test eines Formulars version = "$Name$" und das .module-File /site/all/testform/testform.module
<?php // $Id$  
 
/**
* @file
* Testen von Formularelementen
*/  
 
/**
* Ein eigenes Menü muss her
*/
function testform_menu()
{
$items = array();  
 
$items[] = array
(
'path' => 'testform',
'title' => t('Beispielsformular'),
'callback' => 'testform_page',
'access' => TRUE,
'type' => MENU_NORMAL_ITEM
);
 
return $items;
} // END testform_menu()
 
/**
* Rückgabe der Seite
*/
function testform_page()
{
$uebergabe = t('Das ist ein Beispielsformular');  
$uebergabe .= drupal_get_form('testform_bspform');
 
return $uebergabe;
} // END testform_page()
 
/**
* Hier wird das Formular angelegt
*/
function testform_bspform()
{
$form = array();
 
return $form;
} // END testform_bspform()  
 
/**
* Validierung der Formulareingaben
*/
function testform_bspform_validate($form_id, $form_values)
{
 
} // END testform_bspform_validate()
 
/**
* Das kommt jetzt nach erfolgreicher Validierung
*/
function testform_bspform_submit($form_id, $form_values)
{
return 'ersterinhalt';
} // testform_bspform_submit()
Damit hat man eine Grundform die es erlaubt mit eigenen Formularen zu arbeiten. In der Funktion testform_bspform_submit($form_id, $form_values) wird erst einmal auf eine x-beliebige Seite verwiesen. Später wird hier noch eine Meldung für den User in einer eigenen Seite ausgegeben.

Formularelemente 2 von2

Textfield
Fieldset
Submit
Das Textfield
Das am Häufigsten benötigte Elemen ist wohl das "textfield". Die Definition ist einfach:
$form['dein_vorname'] = array
(
'#title' => t('Dein Vorname'),
'#type' => 'textfield',
'#description' => t('Hier gib bitte deinen Vornamen ein')
);
Mit $form['dein_vorname'] wird dem $form-Array ein neues Element hinzugefügt. Die Mindestangabe im Array ist der '#type' der einen definierten Wert enthält. Mit '#title' wird über dem Formularelement ein Titel und mit '#description' unter dem Formularelement eine Beschreibung ausgegeben. Die Elemente werden durch die Drupal-Funktion form_builder($form_id, $form) in HTML erstellt und die Formatierung der ausgegebenen Elemente wird durch das verwendete Theme bestimmt. Für Textfields stehen noch einige weitere Möglichkeiten offen:

'#default_value'

STRING - Setzen eines Default-Values. Kann durch eine neue Eingabe überschrieben werden.

'#value'

STRING - Setzen eines festen Wertes.

'#size'

INTEGER - Größe des dargestellten Elementes (Default-Wert 60)

'#maxlength'

INTEGER - Angabe der Zeichen die aufgenommen werden können (Default-Wert 128)

'#weight'

INTEGER - Die Position im Formular (Default-Wert 0)

'#autocomplete_path'

STRING - Erstellen von AJAX-baierten Funktionen zur Autosuche nach passenden Werten.

'#reqired'

BOOLEAN - Gibt an ob ein Wert zwingend erforderlich ist. Drupal übernimmt die Überprüfung ob ein Wert übergeben wurde, der eigentliche Wert muss dann allerdings noch überprüft werden.

'#field_prefix'

STRING - Ausgabe direkt vor dem Formularfeld.

'#field_suffix'

STRING - Ausgabe direkt hinter dem Formularfeld.

'#prefix'

STRING - Ausgabe vor dem Formularelement, z. B. '#prefix' => '<div class="dein_nachname">', um eine eigene CSS-Klasse hinzuzufügen.

'#suffix'

STRING - Ausgabe nach dem Formularelement, z. B. '#suffix' => '</div>',

um den DIV-Block von '#prefix' abzuschließen.

'#access'

BOOLEAN - Gibt an ob ein Formularelement angezeigt werden soll oder nicht.

Alle hier aufgeführten Werte sind für alle weiteren Formularelemente zu verwenden.

Das Fieldset
Formularelemente können auch sehr einfach in Gruppen organisiert werden. Dazu wird ein Fieldset erzeugt und die zugeordneten Formularelemente diesem in einem mehrdimensionalen Array zugeordnet.
/**
* Hier wird das Formular angelegt
*/
function testform_bspform($form_values)
{
global $user;
 
$form['name_fieldset'] = array
( '#title' => t('Dein Name'),
'#type' => 'fieldset',
'#description' => t('Wie heißt du?')
);
 
$form['name_fieldset']['vorname'] = array
(
'#title' => t('Dein Vorname'),
'#type' => 'textfield',
'#description' => t('Hier gib bitte deinen Vornamen ein'),
'#field_suffix' => 'Grossbuchstaben',
'#default_value' => 'Vorname',
);
 
$form['name_fieldset']['name'] = array
(
'#title' => t('Dein Nachname'),
'#type' => 'textfield',
'#description' => t('Hier gib bitte deinen Nachnamen ein'),
'#size' => 30,
'#maxlength' => 30,
'#value' => (isset($form_values['name']))? $form_values['name'] : '',
'#weight' => -1,
'#prefix' => '<div class="dein_nachname">',
'#suffix' => '</div>',
'#required' => true
);
 
$form['optionalesFeld'] = array
(
'#title' => t('Zusaetzliche Angaben'),
'#type' => 'fieldset',
'#description' => t('Ausfuellen wenn du magst?'),
'#collapsible' => TRUE,
'#collapsed' => True,
'#access' => ($user -> uid) ? true : false,
);
 
$form['optionalesFeld']['textfeld'] = array
(
'#title' => 'Irgendwas',
'#type' => 'textfield',
'#description' => t('hier können Sie irgendwas eingeben'),
);
 
$form['submit'] = array
(
'#type' => 'submit',
'#value' => t('Senden')
);
 
return $form;
} // END testform_bspform()

Die Fieldsets können auch mit verschieden Attributen versehen werden. Die wichtigsten sind hier:

'#collapsible'

BOOLEAN - gibt an ob ein Fieldset verkleinerbar sein soll. Bei keine Angabe wird der DEFAULT-Wert FALSE angenommen.

'#collapsed'

BOOLEAN - gibt an ob ein Fieldset verkleinert ausgeliefert werden soll oder nicht.

Über das Attribut '#access' im Fieldset lassen sich schnell angepasste Formulare entwickeln. In diesem Fall wird das zweite Fieldset nur angemeldeten Usern angezeigt ('#access' => ($user -> uid) ? true : false,).

Submit
Der Submit-Button kann noch zusätzlich mit dem Attribut '#button_typ' belegt werden. Hierfür wird noch eine Pfadangabe zur verwendeten Grafik benötigt.

Grundsätzliche Arbeitsweise bei der Formularerstellung

Drupal erzeugt Formulare indem es zunächst die Informationen die ein Formular enthält sammelt und in einem Array speichert. Dabei werden die einzelnen Module abgefragt ob Sie etwas zu dieser Funktion beitragen möchten, daher ist es wichtig sich bei eigenen Modulen an die Konventionen zu halten.

Sind alle Informationen gesammelt wird überprüft ob es eine entsprechende Validierungsfunktion gibt. Es kann eine einzige Funktion zur Validierung des gesammten Formulars genutzt werden oder es können einzelnen Elementen gesonderte Validierungsfunktionen zugewiesen werden. Das erspart einem Programmierer in so fern Arbeit das vorhandene Validierungsfunktionen, z. B. die Validierung eines Passwortes oder einer Email-Adresse, genutzt werden können. Ein weiterer Vorteil ist das eine Validierungsfunktion nur an einer Stelle upgedatet muss und nicht jedes Formular einzeln angepasst wird. Nach der Prüfung der Validierung wird geprüft ob eine Submit-Funktion zur Verarbeitung der Rückgaben vorhanden ist. Erst wenn auch diese gefunden wurde wird das Formular erzeugt und übermittelt (selbst hier kann das Formular nochmals abgefangen werden - empfiehlt sich allerdings nicht da die Prüfungen umgangen werden). Kommen die Formularwerte wieder zurück werden die Ergebnisse an die entsprechende Valierungsfunktion(en) übergeben. Fehler die während der Validerung auftreten werden mit der Funktion form_set_error() an das Drupal-System gemeldet und dort gesammelt. Sind Fehler aufgetreten wird das Formular erneut aufgerufen und die entsprechenden Fehlermeldungen eingeblendet. Sind keine Fehler während der Validierung aufgetreten, werden die Formularwerte and die _submit()-Funktion übergeben und dort verarbeitet.

Hinzufügen einer Einverständniserklärung bei der Standardregistrierung

Anhand des Beispiels soll beispielhaft erkärt werden wie über hook_user($op, &$edit, &$account, $category = NULL) Veränderungen an einem Formular vorgenommen werden können. Hierfür wird ein eigenes Modul erzeugt: Die Datei /site/all/einverstaendniserklaerung/einverstaendniserklaerung.info

; $Id$ name = Einverstaendniserklaerung
description = Zeigt eine Einverstaendniserklaerung bei der Registrierung
version = "$Name$"
Die Datei /site/all/einverstaendniserklaerung/einverstaendniserklaerung.module
<?php // $id$
 
/**
* @file
* Enthält eine Einverständniserklärung während des Registrierungsprozesses
*/
 
/**
* Implementation des hook_users()
*/
function erklaerung_user($op, &$edit, &$user, $category = NULL)
{
switch ($op)
{
// Wenn der User registriert ist
case 'register' :
// Hinzufügen eines Radio-Button im Registrierungsformular $fields['einverstaendniserklaerung'] = array
(
'#type' => 'fieldset',
'#title' => t('Einverständniserklärung'),
);
 
$fields['einverstaendniserklaerung']['decision'] = array
(
'#type' => 'radios',
'#description' => 'Ich bin einverstanden',
'#default_value' => 0,
'#options' => array(t('nicht OK'), t('OK'))
);
 
return $fields;  
 
case 'validate' :  
if(isset($edit['decision']) && $edit['decision'] != 1)
{
form_set_error('decision', t('Die Registrierung kann ohne Ihr Einverstaendnis nicht abgeschlossen werden.'));
}
return;
 
case 'insert' :  
watchdog('user', t('User %user hat zugestimmt', array('%user' => $user -> name)));
return;
 
}
}

Erweiterung für das Modul Webform - eigene Token /dynamische Listen erstellen

Für ein internes Projekt war es gefordert das User eigene Formulare erstellen können. Damit fiel die Wahl schnell auf das Modul webform. Das Modul ist einfacher zu händeln als z. B. CCK. Allerdings waren einige Anpassungen notwendig um die Anforderungen zu erfüllen. Anforderungen waren:

• Einbindung von bestehenden Web-Services
• Automatisierte Weiterverarbeitung von Formularen
• Zugriff auf die Auswertungen durch User

Insbesondere bei Listen-Elementen wurden hier schnell Einschränkungen im Gebrauch deutlich. Webform kann zwar Schlüssel und Werte abspeichern,
Syntax:
Schlüssel1|Wert1
Schlüssel2|Wert2
gibt aber bei der Ausgabe nur den gespeicherten Wert zurück - also den Schlüssel. Das ist zwar für die Weiterverarbeitung praktisch, eignet sich allerdings nur bedingt für einen Enduser. Für die Weiterverarbeitung von Formularen, wurde zunächst das Modul Workflow getestet, aber schnell als ungeeignet, da nicht flexibel genug, abgetan. Webform hat allerdings die Möglichkeit nach erfolgreicher Formulareingabe den User auf eine definierte Seite weiterzuleiten und diese wird genutzt um in einem eigenen Modul den Workflow abzuwickeln. Dazu wird ein einfaches MENU_CALLBACK definiert das auf eine bestimmte Funktion zugreift.
/**
* Implementierung des Hook Menü
*/
function dev_form_menu()
{
$items = array();
 
// erstellen einer Callbackfunktion für die Weiterverarbeitung von eigenen Formularen
// Dieser Pfad kann in Webform Feld: Bestätigungsnachricht oder Weiterleitungs-URL - gesetzt werden
$items['formular_intern/_step_1'] = array
(
'title' => 'Step 1',
'type' => MENU_CALLBACK,
'description' => 'erster Schritt zur Weiterverarbeitung von eigenen Formularen',
'access arguments' => array('Step 1'),
'access callback' => 'user_access',
'page callback' => '_step_1',
'page arguments' => array(1),
'load arguments' => array(1),
);
 
return $items;
} // END dev_form_menu
Diese Funktionalität erforderte keinen Eingriff in das Webform-Modul. Bei den anderen Punkten ließen sich aber Anpassungen direkt im Modul nicht umgehen. Im Detail mußte im Script webform.module und webform_report.inc je zwei Anpassungen gemacht werden. In webform.module wurde die Help-Funktion angepasst um eigen definierte Token mit aufführen zu können.
function theme_webform_token_help()
{
$tokens = array
(
'%username',
'%useremail',
....
 
if (module_exists('profile'))
{
$output .= ' '. t('If you are using the profiles module, you can also access all profile data using the syntax %profile[form_name]. If you for example have a profile value named profile_city, add the variable %profile[profile_city].');
}
 
// Anpassung START
if(module_exists('dev_form'))
$output .= ' '.dev_form_token_help();
// Anpassung ENDE
 
$fieldset = array
(
'#title' => t('Token values'),
'#type' => 'fieldset',
'#collapsible' => TRUE,
'#collapsed' => TRUE,
'#children' => '<div>'. $output .'</div>',
);
 
return theme('fieldset', $fieldset);
}

In der Funktion dev_form_token_help() werden die Anzeigetexte für die User geschrieben.

Um auf diese selbst definierten Token zugreifen zu können wurden in der Funktion webform_load($node) eine Anpassung gemacht:
/**
* Implementation of hook_load().
*/
function webform_load($node)
{
module_load_include('inc', 'webform', 'webform_components');
 
...
// Ab hier werden die Token geladen
$additions->webform['components'] = array();
$additions->webform['additional_emails'] = array();
$result = db_query('SELECT * FROM {webform_component} WHERE nid = %d ORDER BY weight, name', $node->nid);
while ($c = db_fetch_array($result))
{
$component => $additions->webform['components'][$c['cid']]; $component['nid'] = $node->nid;
$component['cid'] = $c['cid'];
$component['form_key'] = $c['form_key'] ? $c['form_key'] : $c['cid'];
$component['name'] = t($c['name']);
$component['type'] = $c['type'];
$component['value'] = $c['value'];
$component['extra'] = unserialize($c['extra']);
$component['mandatory'] = $c['mandatory'];
$component['email'] = $c['email'];
$component['pid'] = $c['pid'];
$component['weight'] = $c['weight'];
 
if (isset($component['extra']['email']) && $component['extra']['email'])
{
$additions->webform['additional_emails'][$c['cid']] = $c['cid'];
} // Modifikation START
 
if(module_exists('dev_form'))
{
$get = explode('/', $_GET['q']);
 
// um das Ersetzen von Token während des Editiernes zu vermeiden
if($get[2] != 'edit')
{
// Prüfen ob Defaultwerte gebraucht werden
if($dev_token = strstr($component['value'], '%dev'))
{
$fun = explode('[', $dev_token);
$fun2 = explode(']', $fun[1]);
 
if($daten = dev_form_token($fun2[0], $component['type'], true))
$component['value'] = $daten;
}
 
// Prüfen ob Listen abgefragt werden sollen
if($component['type'] == 'select')
if($dev_token = strstr($component['extra']['items'], %dev'))
{
$fun = explode('[', $dev_token);
$fun2 = explode(']', $fun[1]);
 
if($daten = dev_form_token($fun2[0], $component['type'], false))
$component['extra']['items'] = $daten;
}
}
} // Modifikation ENDE
 
webform_component_defaults($component);
}
....
return $additions;
}
Mit dem Funktionsaufruf dev_form_token($fun2[0], $component['type'], false) werden die Werte aus der eigenen Funktion abgerufen. Diese Funktion besteht im wesentlichen nur aus einem switch .. case. In dieser Funktion werden die Werte aus festen Werten oder wiederum durch Funktionsaufrufe übergeben.
/**
* Eigene Token definieren
*
* @param $token_name - Bezeichnung des Token
* @param $type - Art des Formularfeldes (normalerweise textfield, select)
* @param $default - Der Angefrate Wert ist ein Defaultwert für das Formularfeld
*/
function dev_form_token($token_name = '', $type = '', $default = false)
{
switch ($token_name):
 
case 'wert1':
return 'Token Test';
break;
 
// Gibt eine Liste aller registrierten User zurück
// Aufbau uid| Name
case 'userliste':
if(!$default)
return _get_token_userlist();
else
return '5';
break;
/*
// Weitere Funktionen
case '':
return 0;
break;
// Weitere Funktionen
case '':
return 0;
break;
*/
 
default :
return false;
endswitch;
} // END dev_form_token
Somit ist es jetzt möglich eigene Werte zu übergeben. Die Grenzen liegen hier nur noch in den Möglichkeiten des Programmierers. Insbesondere für SELECT-Typen kann noch die Option angegeben werden ob es sich um ein Default-Wert handelt. Somit kann mit dem gleichen Token sowohl die Liste als auch ein Default-Wert generiert werden. Dabei ist zu beachten das Default-Werte aus dem Schlüssel bestehen, nicht aus dem Wert, falls die Liste als Schlüssel/Wert-Paar übergeben werden. Unter case 'userliste': wird eine Funktion aufgerufen die die entsprechenden Werte generiert.
/**
* Liefert eine Liste mit allen registrierten Mitarbeitern
* Listenaufbau: uid | Benutzername
*/
function _get_token_userlist()
{
// Holt alle aktiven User
$query = 'SELECT uid, name FROM {users} WHERE status = 1';
$result = db_query($query);
 
if(!$result)
return false;
 
$uebergabe = '';
 
while($erg = db_fetch_array($result))
{
$uebergabe .= $erg['uid'].'|'.$erg['name'].' ';
}
return $uebergabe;
} // END _get_token_userlist()
Damit sind jetzt alle notwendigen Schritte erledigt und die Formulare können erstellt werden.

Wie man sieht ist hier jetzt eine User-Liste erstellt worden, die nicht zum normalen Funktionsumfang von Webform gehört. Allerdings werden bei der Ausgabe nur die Schlüssel angezeigt. Um diese wieder mit den Werten zu ersetzen mußten in webform_report.inc zwei Funktionen angepasst werden. Mit dem ersten Update werden die Werte in der Tabelle geparst und das zweite Update ersetzt die Werte in den Downloads. /**
* Create a table containing all submitted values for a webform node.
*/
function webform_results_table($node, $pager_count = 0)
{
// Load Components.
webform_load_components();
 
if (isset($_GET['results']) && is_numeric($_GET['results']))
{
$pager_count = $_GET['results'];
}
 
// Get all the submissions for the node.
$header = theme('webform_results_table_header', $node);
$submissions = webform_get_submissions($node->nid, $header, NULL, $pager_count);
$total_count = webform_get_submission_count($node->nid);
 
// Manipulation START
$submissions = dev_form_ersetze_listen_keys($node, $submissions);
// Manipulation ENDE
 
$output = theme('webform_results_table', $node, $node->webform['components'], $submissions, $total_count, $pager_count);
 
if ($pager_count)
{
$output .= theme('pager', NULL, $pager_count, 0);
}
 
return $output;
}

und
function webform_results_download($node, $format = 'delimiter', $options = array())
{
module_load_include('inc', 'webform', 'webform_export');
 
....
// Get all the submissions for the node.
$submissions = webform_get_submissions($node->nid);
// manipulation START
$submissions = dev_form_ersetze_listen_keys($node, $submissions);
// manipulation START
 
....
 
$export_name = _webform_safe_name($node->title);
$exporter->set_headers($export_name);
@readfile($file_name);
// The @ makes it silent.
@unlink($file_name);
// Clean up, the @ makes it silent.
 
exit();
}

Beidemal wird die Funktion dev_form_ersetze_listen_keys($node, $submissions); aufgerufen. In dieser werden die $submissions analysiert und ggf. ersetzt. /**
* Funktion zum ersetzen von Listenwerten
*/
function dev_form_ersetze_listen_keys($node, $submissions)
{
// prüfen ob ein Node übergeben wurde
if(!$node or !$submissions)
return $submissions;
 
$submissions_org = $submissions;
 
// Holen der Webform-Komponenten (Datenfelder, etc.)
$components_array = $node -> webform['components'];
// Prüfen ob Daten veändert wurden
$components_array_changed_global = FALSE;
$components_array_global = array();
 
// Für jedes Element überprüfen ob Daten ersetzt werden müssen
// Ersetzungen sind nur notwendig bei Datentyp SELECT
foreach($components_array as $component_key => $component_value)
{
// prüfen ob in diesem Typ geändert werden muss
$components_array_changed = FALSE;
 
// Prüfen ob es sich um ein Select-Feld handelt
if($component_value['type'] == 'select')
{
// Prüfen ob ein Array für die Listenelemente vorhanden ist
if(array_key_exists('items', $component_value['extra']))
{
// Trennen der einzelnen Listenelemente
$extra_items = explode('
', nl2br($component_value['extra']['items']));
 
// Vorbereiten des Arrays zur Aufnahme der einzelnen Werte
$extra_items_array = array();
// Jedes Array-Element bearbeiten
foreach($extra_items as $extra_item)
{
// Eine Trennung erfolgt nur für Listenelemente die aus Key und Value bestehen
$extra_item2 = explode('|', $extra_item);
 
// prüfen ob beide Werte übergeben werden
if(trim($extra_item2[0]) != '' and trim($extra_item2[1]) != '')
{
$extra_items_array[trim($extra_item2[0])] = trim($extra_item2[1]);
$components_array_changed_global = TRUE;
$components_array_changed = TRUE;
$components_array_global[$component_key] = $component_key;
}
}
 
// Wenn Änderungen gemacht wurden, diese zur späteren Verwendung speichern
if($components_array_changed)
$node -> webform['components'][$component_key]['extra'] = array('replace' =>$extra_items_array);
}
}
}
 
// Prüfen ob Änderungen vorgenommen wurden
if($components_array_changed_global)
// Jede Übermittlung überprüfen
foreach($submissions as $key => $submission)
// Jeden zu ändernden Wertebereich abgehen
foreach($components_array_global as $key_changed => $value)
// Ersetze die gefundene ID durch den Wert
$submissions[$key] -> data[$key_changed]['value'][0] = $node -> webform['components'][$key_changed]['extra']['replace'][$submissions[$key] -> data[$key_changed]['value'][0]];
 
// die geänderten Werte zurückgeben
if($components_array_changed_global)
return $submissions;
else
return $submissions_org;
} // END dev_form_ersetze_listen_keys($node, $submissions)

Im $node stehen alle Werte aus den Listen und müssen entsprechend nur noch ersetzt werden. Der Weg die Werte aus den Nodes herauszulesen ist etwas umständlicher als die dev_form-Funktion aufzurufen und hier die Werte gleich als Array zu bekommen, hat aber den Vorteil das auch Werte ersetzt werden können die nicht über die dev_form-Funktionen eingefügt wurden. Falls das jemand mal testet, wäre ich für ein Feedback dankbar.

Attachment erst nach Formular downloadbarbar

Das Modul "Attachment via Form" (Durpal 6.x) ermöglicht es Attachments eines Nodes erst nach dem passieren eines Formulars herunterladbar zu machen.
Der Hintergrund ist, das man so erfahren kann wer Interesse an weiterführenden Informationen bzw. wer welche Informationen erhalten hat. Das war bisher weder bei "Gästen" noch angemeldeten Besuchern für Attachments möglich.
Bei dieser Version ist das Formular statisch implementiert. Eine weiterführende Version soll eine Anbindung an das Modul Webform und CCK ermöglichen. Weiterhin ist kann den Formularfeldern automatisch eine Zuweisung zu Profil-Feldern hinzuprogrammiert werden.

Auf diese Weise kann nachgewiesen werden, wer wann welches Attachment gelesen hat (für den internen Gebrauch) und extern können Angaben von Interessenten gesammelt werden. Eine Anpassung des Formulars oder eine Erweiterung der Zugriffsrechte (z. B. nur 3 Downloads erlauben) ist jederzeit möglich => Sie können mich gerne kontaktieren.

Leistungen Die Konfiguration erlaubt bestimmte Formularfelder verpflichtend zu machen, eine Einverständniserklärung für weiterführende Kontakte (per Mail oder Telefon) zu bekommen und ggf. das Formular zu überspringen.
Dass Modul wird auf bestimmte Node-Types eingestellt und fügt dann das Formular ein. Einmal abgefragt werden bei weiteren Downloads die vorher eingetragenen Daten übernommen (das ist im Modul auch anpassbar).
Alle Daten sind in einer eigenen Tabelle einsehbar. Die Daten können als XML-Excel_Liste herunter geladen werden. _______________________________________________________________________________________________

The module "Attachment via Form" (Durpal 6.x) allows to make a node attachment downloadable until after pass a form.
The background is that you can learn so who are interested in further information or who has received the information.
This has been possible so far either for "guests" have registered visitors for the attachments. In this version the form is implemented statically.
An extended version is to allow a connection to the module Webform and CCK.
It is also intended to form fields automatically an assignment to profile fields to enable.
In this way it can be shown who has read an attachment (for internal use) and external addresses of prospects can be collected. An adaptation of the form or an extension of access rights (eg only allow three downloads) at any time => you are welcome to contact me.

Services
The specific configuration allows form fields to make mandatory a consent form for further contacts (by mail or telephone to get) and if necessary, the form skip.
That module is adjusted to specific node type and then inserts the form.
Once accepted to be interrogated for further downloads, the previously entered data (which is in the module also customizable).
All data are stored in a separate table. The data can be downloaded as XML Excel_Liste down.

Datenbankabfragen als Prepared Statements

Die Syntax ist eigentlich simpel; es wird eine normale Query formuliert und die Werte werden nur mit Platzhaltern versehen. Diese Platzhalter werden dann nach Prüfung durch die eigentliche Werte ersetzt. $user->uid = 12;
 
$result = db_query('SELECT r.rid, r.name FROM {role} r INNER JOIN {users_roles} ur ON ur.rid = r.rid WHERE ur.uid = %d', $user->uid);
Erstellt wird daraus die Query 'SELECT r.rid, r.name FROM {role} r INNER JOIN {users_roles} ur ON ur.rid = r.rid WHERE ur.uid = 12'. Werden mehrere Platzhalter verwendet, müssen diese in der richtigen Reihenfolge angegeben werden. Gleiche Werte sind dabei auch mehrfach nazugeben. Sieht einfach aus - aber warum der Aufwand? Ganz einfach: So können SQL-Injections verhindert werden und vorbereitete Statements können schneller reprudziert werden (werden schneller ausgeführt). Wichtig ist dabei die korrekte Syntax der Daten anzugeben, d. h. wie sollen sie Daten geprüft werden. Es gibt fünf Datentypen die entsprechend geprüft werden können:

%s

Prüft ob es sich um einen STRING handelt.

%d

Prüft ob es sich um einen INTERGER handelt.

%f

Prüft ob es sich um einen FLOAT handelt.

%b

Prüft ob es sich um einen BINARAY DATA handelt. Diese dürfen nicht in '' gekapselt werden.

%%

Prüft ob es sich um einen LITERAL handelt.

Insbesondere bei Strings sollte man allerdings sehr vorsichtig sein und ggf. noch mal eine gesonderte Prüfung einbauen bevor man die Daten mit der Query weitergibt. Als kleines Beispiel für eine schlechte Passwort-Abfrage:
$user = 'wackelpudding' OR uid = 1; --';
$pass = 'abc';
SELECT uid FROM users WHERE name = '.$username.' AND pass = MD5('.$password.')   // daraus wird:
// SELECT uid FROM users WHERE name = "wackelpudding" or uid = 1
// Das Ergebnis ist immer die UID des 1 Drupal-User (Administator)
Um solche Injections abzuwähren reicht ein einfaches Ersetzen bestimmter Strings, in diesem Fall '--' um die Auskommentierung eines Teils der Query zu verhindern. Auch sollten Strings immer escape-ed werden bevor sie an die Datenbank weitergegeben werden (Funktion db_escape_string($text). An dieser Stelle soll das reichen, es soll ja keine Anleitung zum Hacken werden, aber das macht deutlich wie gefährlich bestimmte Abfragen sein können. Für Litterale gilt eine gesonderte Regelung:
$suchbegriff = 'mann';
 
$query_suche1 = 'SELECT id_member AS id FROM member WHERE vorname like "%%%s%%" OR name LIKE "%%%s%%";';  
$ergDB_suche1 = db_query($query_suche1, $suchbegriff, $suchbegriff);
Die Query wird dann zu SELECT id_member AS id FROM member WHERE vorname like "%mann%" OR name LIKE "%mann%"; umgebaut.

Ergebnisse aus der Datenbank auslesen

Anhand eines Beispiels zur Einbindung einer externen Mitarbeiterdatenbank, soll das deutlich gemacht werden.

/**
* Prüft ob es einen Mitarbeiter mit der UID gibt
*
* @param User-ID des Drupal-System
* @return Array - 0 => 0 = user nicht registriert, 1 = User registriert
* 1 => Integer = Berechtigung des Users
*/
function check_ma($uid)
{
// Prüfen ob der User in der AWS-Datenbank registriert ist und holen der Berechtigung
$query = ' SELECT m.berechtigung, m.name FROM mitarbeiter AS m, abteilungzugehoerig AS a WHERE m.uid = %d AND m.eintrittsDatum < now() AND (m.austrittsDatum >= now() OR m.austrittsDatum = "0000-00-00") AND a.uid = %d AND a.active = 1';  
 
$ergDB = db_query($query, $uid, $uid);  
$anzahl_erg = db_num_rows($ergDB);
 
// Wenn kein Ergebniss gefunden wurde
if($anzahl_erg == 0)
return array(0 => 0, 1 => 0);
 
// Darf nicht passieren - dann ist etwas gewaltig schief gelaufen elseif($anzahl_erg > 1)
{
drupal_set_message('Suchen Sie den Programmierer und erschlagen Sie ihn.');
 
return array(0 => 0, 1 => 0);
}
 
// holen der Ergebnisse
$erg = db_fetch_array($ergDB);
 
// Rückgabe wenn nichts gefunden wurde
return array(0 => 1, 1 => $erg['berechtigung']);
} // END check_ma()
Weitere Beispiele folgen ..

Wechseln zu einer externen Datenbank

Um die Inhalte von Drupal und externen Anwendungen getrennt zu halten bietet es sich an verschiedene Datenbanken zu nutzen. Der Zugriff auf die externe Datentank kann auch über das Drupal-eigene Datenbankscript erfolgen. Hierfür ist es es erforderlich Drupal die Zugangsdaten mitzuteilen und die Datenbank dann jeweils umzuschalten. Die Einbindung der externen Datenbank ist auch im Script ./sites/default/settings.php niedergelegt.
// Orginaldatenbank
$db_url['default'] = 'mysql://user:password@localhost/drupal_db';
// externe Datenbank
//$db_url['externe_db'] = 'mysql://user:password@localhost/externe_db';

Jetzt hat Drupal die notwendigen Daten und Drupal kann mitgeteilt werden, wann Drupal eine andere Datenbank nutzen soll.
// Drupal db auf die extere Datenbank umstellen
function meinModul_xyz()
{
db_set_active('externe_db');
 
/**
*
* Diverse Datenbankoperationen *
*/
 
// Die Datenbank wieder auf Default-Wert setzen
db_set_active('default');
} // END meinModul_xyz()
Beim arbeiten mit externen Datenbank muss man allerrdings sehr vorsichtig sein, sobald eine Fehlermeldung aus einer Datenbankoperation generiert wird, versucht Drupal diese auszugeben - hierfür sind allerdings Datenbankoperationen auf der Drupaleigenen Datenbank notwendig und diese kann zu diesem Zeitpunkt nicht erreicht werden, da Drupal ja momentan auf der externen Datenbank steht. Die Folge ist eine Fehlermeldung die in einer BLANK-Seite ausgegeben wird, da Drupal auch für den Seitenaufbau seine eigene Datenbank benötigt. Es sollten alle Operationen daher doppelt abgesichert werden, z. B. eine Passwortabfrage auf eine externe Datenbank:
// Drupal db auf die externe Datenbank umstellen
db_set_active('externe_db');  
// Query mit den notwendigsten Daten holen
$query = 'SELECT externerUser, uid FROM externe_db AS mm WHERE mm.benutzername = LOWER("%s") AND mm.password = LOWER("%s") AND mm.status_id > 1;';
 
// Query ausführen
$result = db_query($query, $username, $password);
 
// Ermittel der Anzahl der Datensätze
$anzahl_datensaetze = db_num_rows($result);
 
// kein treffender User gefunden
if($anzahl_datensaetze == 0)
{
drupal_set_message('Es ist keine User mit Ihren Daten registriert.');
 
// Zurücksetzen zur Drupal-Datenbank
db_set_active('default');  
 
return false;
} // hier gibt es mehrere Datensätze
elseif($anzahl_datensaetze > 1)
{
drupal_set_message('Es gibt Probleme mit Ihrem Account, bitte wenden Sie sich an den Administrator - Fehlernummer d556.');
 
// Zurücksetzen zur Drupal-Datenbank
db_set_active('default');
 
return false;
}
elseif(db_error() != '')
{
drupal_set_message('Es gibt Probleme mit Ihrem Account, bitte wenden Sie sich an den Administrator - Fehlernummer d556.');
// Zurücksetzen zur Drupal-Datenbank
db_set_active('default');
 
return false;
}  
 
// holen der Mitglieds-Daten
$mitglied = db_fetch_array($result);  
// Zurücksetzen zur Drupal-Datenbank
db_set_active('default');
Ansonsten ist das Arbeiten mit externen Datenbanken problemlos.

Wie arbeitet ein Node

Grundsätzlich läuft alles über das Modul node. Die Daten eines Nodes werden in der Datenbank abgelegt. Ein Node hat immer eine eindeutige ID (nid). Die Bestandteile eines Node:

nid

Eindeutige ID des Nodes

vid

Eindeutige Revisions-ID des Node. Damit ist es möglich einen Node zu einem beliebigen Zeitpunkt wieder herzustellen.

type

STRING - Bezeichnung des Node. Standardmäßig ist der Node-Type page und story aktiviert. Der Node book ist im Core enthalten muss aber aktiviert werden.

title

Der Titel des Nodes als 128 Zeichen String. Diese kann deaktiviert werden (benötigt einen Eingriff über Programierung - siehe "Eigenen Node programmieren")

uid

Die UID des Erstellers.

status

0

Unveröffentlicht

1

Veröffentlicht

Der Status kann durch andere Module beeinflußt werden, z. B. "Node Privacy By Role"

created

Das Erstellungsdatum als UNIX_TIMESTAMP

changed

DAS Bearbeitungsdatum als UNIX_TIMESTAMP

comment

Integerfeld das die Möglichkeiten für Comments beschreibt

0

Keine Kommentare erlaubt

1

Vorhanden Kommentare lesen aber keine neuen erstellen

2

Lesen und schreiben von Kommentaren erlaubt

Die Berechtigungen hierfür werden über das Comment-Modul gesetzt. Siehe auch "NoComment"-Modul zur Kommentar-Steuerung einzelner Seiten als Beispiel zur Einflussnahme auf Nodes.

promote

Gibt an ob ein Node auf der Startseite bzw. unter domain/nodes erscheinen soll. 1 auf Startseite - 0 nicht auf Startseite

moderate

Gibt an ob ein Node unter Moderation steht. Im Core von Drupal ist hierfür allerdings kein Modul enthalten. Steht standardmäßig auf 0

sticky

Gibt an ob ein Node immer oben auf der Liste stehen soll. Ansonsten werden mehrere Nodes nach Datum ausgegeben.

    Ein Node kann in verschieden Stadien abgefangen werden. Die Stadien können über die Variable $op abgefragt werden. Die Stadien sind:

delete

The node is being deleted.

delete revision

The revision of the node is deleted. You can delete data associated with that revision.

insert

The node is being created (inserted in the database).

load

The node is about to be loaded from the database. This hook can be used to load additional data at this time.

prepare

The node is about to be shown on the add/edit form.

search result

The node is displayed as a search result. If you want to display extra information with the result, return it.

print

Prepare a node view for printing. Used for printer-friendly view in book_module

update

The node is being updated.

submit

The node passed validation and will soon be saved. Modules may use this to make changes to the node before it is saved to the database.

update index

The node is being indexed. If you want additional information to be indexed which is not already visible through nodeapi "view", then you should return it here.

validate

The user has just finished editing the node and is trying to preview or submit it. This hook can be used to check the node data. Errors should be set with form_set_error().

view

The node content is being assembled before rendering. The module may add elements $node->content prior to rendering. This hook will be called after hook_view(). The format of $node->content is the same as used by Forms API.

alter

the $node->content array has been rendered, so the node body or teaser is filtered and now contains HTML. This op should only be used when text substitution, filtering, or other raw text operations are necessary.

rss item

An RSS feed is generated. The module can return properties to be added to the RSS item generated for this node. See comment_nodeapi() and upload_nodeapi() for examples. The $node passed can also be modified to add or remove contents to the feed item.

Wo kann man eingreifen?

Ein Node kann an verschiedenen Stellen abgefangen werden. Die häufigste wird dabei wohl der _nodeapi(&$node, $op, $a3 = NULL, $a4 = NULL) sein. Dazu wird in einem eigenen Modul die Funktion node_api() integriert. Und um deutlich zu machen was übermittelt wird, soll jeder Node einmal ausgelesen werden.

<?php //; $ Id: nodetest.module, UwBach, 2008/05/29 $  
 
/**
* @file Zugriff auf den hook_nodeapi
* Erster Versuch
*/
 
/**
* Erlaubt Inhalte bestimmten Seiten hinzuzufügen oder zu bearbeiten
*/
function nodetest_nodeapi(&$node, $op, $a3 = NULL, $a4 = NULL)
{
drupal_set_message('Status - '.$op.''.array_auslesen((array)$node));
} // node_test_nodeapi()
 
/**
* Einfache Funktion zum Auslesen von Arrays
*/
function array_auslesen($array)
{ $uebergabe = '
';
if(is_array($array) or is_object($array))
// Das Array auslesen
foreach($array as $key => $wert)
{
if(!is_array($wert))
$uebergabe .= $key.' - '.$wert.'
';
else
{
$uebergabe .= $key.' (
';
$uebergabe .= array_auslesen($wert);
$uebergabe .= ')
';
}
}
else
$uebergabe = $array;
return $uebergabe;
}// END array_auslesen

Die Funktion array_auslesen() kann entweder auskommentiert werden oder durch eine print_r() ersetzt werden. In der Funktion nodetest_nodeapi() wird die Variable &$node als Objekt übergeben, daher muss sie zu auslesen gecarstet werden. Schaut man sich die Ausgabe an, fällt auf das ein normaler Node dreimal aufgerufen wird. Im Status load, view und alter. Beim Erstellen oder Verändern werden die Stati validate, submit, prepare, und ggf. update durchlaufen. In jedem Statdium kann nochmals auf den Node zugegriffen werden. Modul nodetest als Download

Eigene Box im Contentbereich

Auf einer bestimmten Seite (Startseite) soll eine zusätzliche Box mit den neusten Meldungen im Content-Bereich eingeblendet werden. Hier sollen nur die Titel und das Erstellungs- bzw. Änderungsdatum angezeigt werden. Die Meldungen können vom Typ 'story' und von einen Node-Typen stammen. Mit einer Box auf der rechten Seite konnten die gewünschten Ergebnisse nicht erreicht werden. Daher wird bei dem Aufruf der Startseite die hook_nodeapi() "angezapft" und ein eigener Bereich definiert. Dafür wird ein eigenes Modul manipulation.module angelegt. Mit der Funktion manipulation_nodeapi(&$node, $op, $teaser, $page) können dann die Informationen des Node abgefragt werden. Für diese Erweiterung ist nur das Stadium 'alter' interessant. /**
* Erlaubt Inhalte bestimmten Seiten hinzuzufügen
*/
function manipulation_nodeapi(&$node, $op, $teaser, $page)
{
// Änderungen für die Startseite
// Hinzufügen einer BOX mit den neusten Meldungen
if($_GET['q'] == 'node/18' and $op == 'alter')
{
// Angabe welche Nodes gelistet werden sollen
$node_type = 'story';
 
// Die anderen Nodes entfernt
// Anzahl der gelisteten Elemente
$list_no = 10;
 
// Select aus Node
$sql = 'SELECT node.title, node.type, node.nid, node.changed FROM {node} AS node WHERE node.type = "'.$node_type.'" node.promote = 1 ORDER BY node.changed DESC LIMIT '.$list_no.'';
 
// Inhalte als Liste erstellen
// Weitere Formatierungen in manipulation.css
$inhalt .= '<ul>';
$result = db_query($sql);
 
while ($anode = db_fetch_object($result))
{
$inhalt .= '<li>'.l($anode->title, 'node/'.$anode->nid).'
'.format_date($anode -> changed, 'small').'</li>';
}
 
$inhalt .= '</ul>';

// Die Box als erstes einfügen
// Weitere Formatierungen in manipulation.css
$node -> body = '<div class="frontpage_box" ><b>Die letzten Meldungen:</b>'.$inhalt.'</div>'.$node -> body;
 
// Hinzufügen eines eigenen CSS-Designs
drupal_add_css('sites/all/modules/manipulation/manipulation.css', 'theme', 'screen', TRUE);
}
//
} // END manipulation_nodeapi()
Mit if($_GET['q'] == 'node/18' and $op == 'alter') wird ein bestimmter Node abgefangen. Das funktioniert auch mit aktiviertem Clean-URL. In der Query wird bei den Nodes der Status abgefragt und zusätzlich, mit node.promote = 1 , ob der Eintrag auf der Startseite angezeigt werden soll. Dann werden die Ergebnisse aus der Datenbanktabelle {node} geholt. Die Ergebnisse werden gleich als Objekt ausgelesen und in einen Link umgewandlt. Um das Datum mit den lokalen Einstellungen auszugeben wird die Drupal-Funktion format_date($timestamp, $type = 'medium', $format = '', $timezone = NULL) verwendet. Schließlich werden die gesammelten Inhalte vor den eigentlichen Seiteninhalt gestellt. Die eigenen Inhalte werden dabei in einem eigenen DIV-Container (<div class="frontpage_box"> ) verpackt und anschließend mit einer eigenen CSS-Datei formatiert. Die CSS-Datei ist recht einfach gehalten:   .frontpage_box
{
width:250px;
float:right;
padding-left:10px;
padding-bottom:10px;
}
 
.frontpage_box li
{
list-style-type:none;
list-style-position:outside;
margin-left: -2.5em;
}

Damit wird die DIV-Box an den rechten Bereich des Content-Bereichs geschoben, eine Breite und ein Abstand unten und links definiert. Der Text der Seite umfließt den erstellten Container.

Sichten auf Teaser einschränken

In diesem Modul sollen für bestimmte Node-Typen die Sichten auf Rollenbasis eingeschränkt werden. Alle User sollen den Teaser sehen, aber die Vollanzeige soll auf Rollenbasis beschränkt werden. Statt dessen wird ein Hinweistext angezeigt. Zu beachten ist das nicht alle Node-Types beschränkt werden sollten, da sonst auch Seiten wie das Impressum, AGB's, usw. nicht mehr vollständig angezeigt werden. Ggf. sollte man sich neu Node-Typen als Clone anlegen. Das Modul hat den Namen "eingeschaenktesicht".

Das .info-File
; $ Id: eingeschraenktesicht.info, UwBach, 2008/06/06 $
name = eingeschraenktesicht
description = Schränkt die Sichten auf Artikel und Seiten ein
package = "Node-Sicht"
Das .module-File
<?php // $ Id: eingeschraenktesicht.info, UwBach, 2008/06/06 $  
/**
* @file
* Dieses Modul gibt nur beistimmte Seiten zur Vollansicht frei
*/
 
/**
* Erlaubt Inhalte bestimmten Seiten hinzuzufügen oder zu bearbeiten
*/
function eingeschraenktesicht_nodeapi(&$node, $op, $a3 = NULL, $a4 = NULL)
{
global $user;
 
$ersatz_text = t('Sie haben zum weiterlesen keine Berechtigung, machen Sie drei Purzelbäume und hüpfen auf einem Bein um weiter zu lesen.');
 
if($op == 'alter' && !user_access('Teasersicht '.$node -> type))
{
$node -> body = t($ersatz_text);
//$node -> links = '';
$node -> comment = 0;
//$node -> readmore = 0;
}
} // eingeschraenktesicht_nodeapi()
 
/**
* Zum Administrationsmenü hinzufügen
*/
function eingeschraenktesicht_perm()
{
$result = db_query('SELECT type FROM {node_type} WHERE module = "node"');
 
while($erg = db_fetch_array($result))
$node_types[] = 'Teasersicht '.$erg['type'];
 
return $node_types;
} // END eingeschraenktesicht_perm
 
/**
* Hook user_access() imlementieren
*/
function eingeschraenktesicht_access($op, $node)
{
return user_access('Teasersicht '.$node -> type);
} // END eingeschraenktesicht_access($op, $node)
Der Ersatz-Text in den Funktion eingeschraenktesicht_nodeapi(&$node, $op, $a3 = NULL, $a4 = NULL) muss angepasst werden. Nach der Aktivierung des Moduls können die Zugriffsrechte über die Benutzerverwaltung gesetzt werden.

Eigenen Node-Type programmieren

Der Vorteil einer Eigenprogrammierung liegt in dem exakten Funktionsumfang der den zusätzlichen Aufwand oftmals lohnt. Ein eigener Node setzt immer auf dem Standard-Node in Drupal auf. Man kann über diverse Hook's seine eigenen Anforderungen umsetzen. Dabei programmiert man praktisch immer ein Add-On auf die Default-Funktionen. Zusätzlich zum .info und .module-File wird meist noch ein .install-File benötigt. Hierin wird eine Anpassung der Datenbank gemacht. Es gibt i. R. eine Funktion zur Installierung und eine Funktion zum Deinstallieren. Im .module-File sollten folgende Funktionen ausprogrammiert werden:

_node_info()

Gibt "Grundeinstellungen" des eigenen Nodes bekannt.

_menu($may_chache)

Einhängen des Nodes in das Menü.

_perm()

Einstellungen für die Erteilung von (Benutzer-)Rechten. Hier werden die unterschiedlichen Bearbeitungsformen definiert, z. B. 'edit own nodetype', 'view nodetype'.

_access($op, $node)

Rückgabe der Benutzerrechte. Man kann hier sehr genau steuern wer was machen kann und darf.

_form($node)

Definition der eigenen Formularfelder zu Nodeerfassung / -bearbeitung.

_validate($node)

Validierung der Daten aus den zusätzlichen Formularfeldern

_insert($node)

Speicherung der zusätzlichen Daten.

_update($node)

Speicherung nach der Bearbeitung.

_delete(&$node)

Löschfunktion des Node's.

_load($node)

Holt die zusätzlichen Daten des Node's, z. B. für Updates.

_view($node, $teaser = FALSE, $page = FALSE)

Hinzufügen der Daten zu dem Node für die Anzeige im Browser.

theme_xx()

Möglichkeit die Ausgabe mit eigenen Formatierungen zu versehen.

Es müssen nicht unbedingt alle Funktionen ausprogrammiert werden. Vor der Programmierung muss man sich also Gedanken machen:

• was soll dargestellt werden?
• wie soll etwas dargestellt werden
• welche Aktionen müssen durchgeführt werden?
• wer soll die Berechtigung für bestimmte Aktionen bekommen?

Aber jetzt der Reihe nach:

• Planung der Beispielsanwendung
• Das .install-File
• Das .module-File 1 Die Grundfunktionen
• Das .module-File 2 Views-Implemantierung
• Einstellungen und Download aller Files für Stellenangebote