Sprachrohr

Tomatensalat

rok — Sun, 26 Jun 2011 12:17:28 +0000

So, heute mal wieder etwas Gesundes, nachdem es die Woche schon einen 500g Burger gab.

Zutaten

5 Tomaten
2 rote Zwiebeln
Sonnenblumenöl
Balsamico Essig
Olivenöl
Ziegenkäse
Kräuterlinge
Pfeffer
frische Kräuter

Zubereitung

Tomatenhälften kurz in der Pfanne mit Sonnenblumenöl anbraten. Ab 72°C sind EHEC und andere Keime abgetötet. Dann aus der Pfanne nehmen und die Zwiebeln in Würfeln in die Pfanne tun, Herd ausschalten. Die Tomatenhälften klein schneiden und in die Schüssel. Wenn fertig, dann die Zwiebeln drüber und ein wenig herumrühren. Dann Ziegenkäse in kleinen Stücken drüber, Essig und Öl drüber. Kräuterlinge, Pfeffer und wenn vorhanden, frische Kräuter. Leicht umrühren und halb warm genießen.
Der Käse schmeckt lecker, wenn er durch die Wärme seine Konsistenz leicht verändert.

Windows-Nutzer im Webformular vorausfüllen

rok — Fri, 01 Apr 2011 09:00:00 +0000

Heute stand ich vor der Herausforderung einen formulargestützten Prozess zu programmieren. Dabei war die eigentliche Herausforderung den Benutzernamen des angemeldeten Nutzers unter Windows in einem Feld vorauszufüllen.

Nach kurzer Recherche fand ich die Lösung mittels Java Applet. Eine andere Lösung per ActiveX-Object hab ich gleich wieder verworfen, weil die Sicherheitsrichtlinien dabei verändert werden müssen. Das werden die Nutzer des Formulars nicht tun.

Nun also die Lösung per Java Applet.

/**
* The Username returns the system property user.name which is the session name
* of the current user logged in.
*/
import java.applet.*;
import java.awt.*;
 
/**
* @author Kummerr
*/
public class Username extends Applet
{
        protected String username = "";
 
        /**
         * initialize
         */
        public void init()
        {
                username = System.getProperty("user.name");
                super.init();
        }
 
        /**
         * returns username
         * @return String
         */
        public String get()
        {
                getAppletContext().showStatus("Username is " + username);
                return username;
        }
 
        /**
         * draws the username
         * @param Graphics g
         */
        public void paint(Graphics g)
        {
                super.paint(g);
                g.drawString(username,5,15);
        }
}

Der Nutzername steht in dem Property “user.name” und läßt sich somit ganz einfach auslesen. Die Methode paint() schreibt mir den gefundenen Namen auf die Applet-Zeichenfläche (Canvas). Dies ist für Kontrollzwecke sehr positiv.

Die Methode get() werde ich per Javascript von der Formularseite aus ansprechen und darüber den Nutzernamen laden. Zusätzlich wird der Fensterstatus diesen Namen anzeigen.

Hier nun das HTML-File:





Insert title here

So kann man die Daten übertragen. Ich hab das mit eclipse programmiert und eclipse legt automatisch eine policy-Datei an, die Rechte auf alles erlaubt. Dies ist im Live-Modus nicht zu empfehlen. Stattdessen hab ich meine Datei mit dem policytool angepasst.

Hier meine Policy-Datei:

/* AUTOMATICALLY GENERATED ON Tue Mar 29 10:23:43 CEST 2011*/
/* DO NOT EDIT */
 
keystore "file:/c:/Documents and Settings/XXXXXXXXX/.keystore", "jks";
 
grant signedBy "mykey" {
  permission java.util.PropertyPermission "user.name", "read";
};

Unter Angabe meines Keystores hab ich nur Lesezugriff auf das System-Property user.name gegeben. Mehr verwende ich auch nicht.

Da ohne Angabe der korrekten Policy immer eine Exception in Javascript kommt hier nochmal der Weg zu einem signierten JAR mit korrekter Policy.

Keystore mit keytool (aus dem JDK) erzeugen.
keytool -genkey
Self-Signed Zertifikat erstellen (self-signed Zertifikate sind nur 6 Monate gültig)
keytool -selfcert
JAR aus der Klasse erzeugen
jar cvf username.jar Username.class
Signiertes JAR erzeugen
jarsigner -signedjar username.signed.jar username.jar mykey

Im letzten Schritt wird bei der Signierung mein Alias aus dem Keystore angegeben. Dieser wird automatisch auf “mykey” gesetzt, wenn man bei “keytool -genkey” keine weiteren Optionen angibt. Die Policy nutzt ebenfalls diesen Alias bei “SignedBy”.

Im Browser muss man beim ersten Start des Applets noch die Ausführung bestätigen, dann läuft es.

Während der Entwicklung ändert man immer mal die Policy und den Quellcode. Hier empfiehlt es sich gerade bei Änderungen in der Policy den Cache zu löschen, da dieser nur beim ersten Laden gespeichert wird. Das hat mich ne halbe Stunde fluchen gekostet.

Der Quellcode zum Artikel kann heruntergeladen werden: Username-Applet

Suchen mit Zend_Search_Lucene

rok — Fri, 25 Feb 2011 09:00:30 +0000

Eine Suche in einer MySQL-Datenbank ist arg begrenzt. Es gibt nur 2 verschiedene Suchvarianten:

Pseudo-Suche mit LIKE
Suche mit MATCH AGAINST

Beide Möglichkeiten können mit dem richtigen Index auch zu ganz guten Ergebnissen führen. Allerdings wird es bei größeren Datenmengen nicht mehr so performant. Alternativ kann man Lucene einsetzen.

Das Zend Framework liefert eine eigene Adaption der Apache Lucene Engine in PHP: Zend_Search_Lucene.

Index aufbauen mit Zend_Search_Lucene

Der Index bei Lucene beinhaltet alle Indexinformationen in einem binären Format. Das Format ist mit dem von Apache Lucene identisch und kann von beiden Engines genutzt und erzeugt werden.
Zum Aufbau des Indexes werden Dokumente in dem Index angelegt. Jedes Dokument besteht aus Feldern. Es gibt 5 verschiedene Feldtypen:

Keyword (Stichwort) Felder werden gespeichert und indiziert, was bedeutet, dass sie sowohl durchsucht als auch in Suchergebnissen angezeigt werden können. Sie werden nicht in einzelne Worte (Tokens) zerteilt. Datenbankfelder für Aufzählungen lassen sich normalerweise leicht in Keyword Felder für Zend_Search_Lucene überführen.
UnIndexed (unindizierte) Felder sind nicht durchsuchbar, werden aber bei Suchtreffern zurückgegeben. Datenbank Zeitstempel, Primärschlüssel, Pfade des Dateisystems und andere externe Identifikatoren sind gute Kandidaten für UnIndexed Felder.
Binary (binäre) Felder werden nicht in Token aufgeteilt und indiziert, aber für die Rückgabe bei Suchtreffern gespeichert. Sie können für die Speicherung aller Daten, die als binäre Zeichenkette kodiert sind, verwendet werden, wie z.B. eine Grafiksymbol.
Text Felder werden gespeichert, indiziert und in Token aufgeteilt. Text Felder sind geeignet für die Speicherung von Informationen wie Themen und Überschriften, die sowohl durchsuchbar sein müssen, als auch in Suchergebnissen zurückgegeben werden müssen.
UnStored (nicht gespeicherte) Felder werden in Token aufgeteilt und indiziert, aber nicht im Index gespeichert. Umfangreiche Texte werden am besten durch diesen Feldtyp indiziert. Gespeicherte Daten benötigen einen größeren Index auf der Festplatte, wenn du also Daten nur durchsuchbar aber nicht wieder ausgegeben haben musst, verwende ein UnStored Feld. UnStored Felder sind geeignet, wenn ein Zend_Search_Lucene Index in Kombination mit einer relationalen Datenbank verwendet wird. Du kannst große Datenfelder mit UnStored Feldern für die Suche indizieren und sie aus der relationalen Datenbank durch die Verwendung eines separaten Feldes mithilfe eines Identifikators zurückholen.

(Quelle: framework.zend.com)

Zum Aufbau des Indexes erstelle ich mir ein PHP-Skript, welches periodisch den Index komplett aktualisiert.

Hier die /cronjobs/Bootstrap.php:


 
// define base path
define('BASE_PATH', realpath(dirname(__FILE__) . '/../'));
 
// define application path
define('APPLICATION_PATH', BASE_PATH . '/application');
 
// define application environment
define('APPLICATION_ENV', 'development');
 
// set include path for zend library and models
set_include_path(
	BASE_PATH . '/library' . PATH_SEPARATOR . APPLICATION_PATH . '/models'
);
 
// create application, bootstrap, and run
require_once 'Zend/Application.php';
 
$application = new Zend_Application(
	APPLICATION_ENV,
	APPLICATION_PATH . '/configs/application.ini'
);
 
$application -> bootstrap();

Hier die /cronjobs/renew-index.php:


/**
 * This script renews the lucene search index
 */
ini_set('memory_limit', '512M');
 
$fltStartTime = microtime(true);
 
require_once 'Bootstrap.php';
 
$strIndex = APPLICATION_PATH . '/data/index';
 
//	clear all files in index folder
foreach (glob($strIndex . DIRECTORY_SEPARATOR . '*') as $file)
{
	unlink($file);
}
 
try
{
	echo 'opening index...';
	$index = Zend_Search_Lucene::open($strIndex);
	echo 'done' . PHP_EOL;
}
catch (Zend_Search_Exception $e)
{
	echo 'failed, index does not exist' . PHP_EOL;
	echo 'try creating...';
	$index = Zend_Search_Lucene::create($strIndex);
	echo 'done' . PHP_EOL;
}
 
$objSystems = new Default_Model_Mapper_SystemsMapper();
$objSystemsRowset = $objSystems -> fetchAll();
 
foreach ($objSystemsRowset as $objSystem)
{
	set_time_limit(0);
 
	$strId = $objSystem -> id; // technical id of the pc
	$strComputerName = $objSystem -> name; // name of pc
	$strFolderStructure = $objSystem -> folder_structure; // dirtree of system
 
	echo 'indexing ' . $strId . '...';
 
	$doc = new Zend_Search_Lucene_Document();
	//	never use the field identifier id and score, they are reserved by lucene
	$doc -> addField(Zend_Search_Lucene_Field::keyword('pcid', $strId, 'utf-8'));
	$doc -> addField(Zend_Search_Lucene_Field::keyword('computername', $strComputerName, 'utf-8'));
	$doc -> addField(Zend_Search_Lucene_Field::unStored('contents', $strFolderStructure, 'utf-8'));
 
	echo 'added to index' . PHP_EOL;
	$index -> addDocument($doc);
}
 
echo 'optimizing index' . PHP_EOL;
$index -> optimize();
 
echo 'docs in index           : ' . $index -> count() . PHP_EOL;
echo ' undeleted docs in index: ' . $index -> numDocs() . PHP_EOL;
 
$fltTimeEnd = microtime(true);
echo 'it took ' . round(($fltTimeEnd - $fltStartTime), 2) . 's' . PHP_EOL;
 
echo '[DONE]';
exit(0);

Damit habe ich bei 25.000 PCs einen 36 MB großen Index in /application/data/index angelegt. Wichtig: beim Öffnen oder Anlegen eines Index muss man immer ein Verzeichnis angeben und keine Datei.

Suchen mit Lucene

Für die Nutzung der Suche habe ich folgende Such-Action in einem Controller angelegt:

/**
 * simple search form
 */
public function searchAction()
{
	$doSearch = false;
	$doPagination = false;
	$objSearchForm = new Machines_Form_MachineSearch();
	$pageRequestHash = null;
 
	//	session store
	$objSessionSearchResult = new Zend_Session_Namespace('search');
 
	//	check requesting method:
	//		POST is new search
	//		GET is fresh display or paging through the results
	if ($this -> getRequest() -> isPost())
	{
		$strQuery = $this -> getRequest() -> getParam('q');
		$objSearchForm -> populate(array(
			'q' => $strQuery
		));
 
		$pageRequestHash = base64_encode($strQuery);
		$this -> view -> requestHash = $pageRequestHash;
		$doSearch = true;
 
		//	clear session store
		$objSessionSearchResult -> unsetAll();
	}
	else
	{
		$pageRequestHash = $this -> getRequest() -> getParam('hash');
		if (null !== $pageRequestHash)
		{
			$doPagination = true;
			$objSearchForm -> populate(array(
				'q' => base64_decode($pageRequestHash)
			));
			$this -> view -> requestHash = $pageRequestHash;
		}
		else
		{
			//	clear session store
			$objSessionSearchResult -> unsetAll();
		}
	}
 
	if ($doSearch === true)
	{
		$strIndex = APPLICATION_PATH . '/data/index';
		$objIndex = Zend_Search_Lucene::open($strIndex);
 
		$objQuery = Zend_Search_Lucene_Search_QueryParser::parse($strQuery);
		try
		{
			Application_Utilities::log('lucene simple find: ' . $strQuery, Zend_Log::DEBUG);
 
			$arrQueryHits = $objIndex -> find($objQuery);
			Application_Utilities::log('lucene search finished: ' . $strQuery, Zend_Log::DEBUG);
 
			$fltMaxScore = null;
			$arrResultHits = array();
 
			foreach ($arrQueryHits as $objQueryHit)
			{
				if (null === $fltMaxScore)
				{
					$fltMaxScore = $objQueryHit -> score;
				}
 
				$arrResultHits[ $objQueryHit -> lanid . $objQueryHit -> machineid ] = array(
					'id' => $objQueryHit -> id,
					'score' => $objQueryHit -> score,
					'pcid' => $objQueryHit -> pcid,
					'computername' => $objQueryHit -> computername
				);
			}
 
			//	store the search query result in the session
			$objSessionSearchResult -> arrResultHits = $arrResultHits;
		}
		catch (Exception $e)
		{
			$this -> addErrorMessage($e -> getMessage(), true);
		}
	}
 
	if (($doSearch === true
		|| $doPagination === true)
		&& is_array($objSessionSearchResult -> arrResultHits))
	{
		//	create a paginator with adapter
		$paginator = new Zend_Paginator(
			new Zend_Paginator_Adapter_Array($objSessionSearchResult -> arrResultHits)
		);
		$paginator -> setCacheEnabled(true);
 
		//	loading application settings
		$bootstrap = $this -> getInvokeArg('bootstrap');
 
		//	configure paginator
		$paginator -> setItemCountPerPage( $this -> _getParam('items', $bootstrap -> getOption('app.pagination.items_per_page', 20)) )
			-> setPageRange( $bootstrap -> getOption('app.pagination.page_range', 5) )
			-> setCurrentPageNumber($this -> _getParam('page', 1));
 
		//	send the objects data to the view
		$this -> view -> paginator = $paginator;
		$this -> view -> entries = $paginator -> getCurrentItems();
	}
 
	$this -> view -> objForm = $objSearchForm;
}

Das verwendete Formular beinhaltet lediglich ein Textfeld mit Namen “q” und einen Submit-Button.

Grundsätzlich fungiert die Suche als Einmal-Suche bei Absetzen des Suchbegriffes und bei der Ergebnisnavigation wird auf die Resultate aus der Session zurückgegriffen. Dies steigert die Performance, da nicht bei jedem Aufruf der Ergebnislisten eine neue Suche ausgeführt werden muss.
Nachteil ist, dass ich durch “veraltete” Ergebnisse navigiere. In zeitkritischen Systemen wäre dieses Vorgehen nicht sinnvoll. In meinem Beispiel geht das aber ganz gut.
Die Suche selber benötigt weniger als eine halbe Sekunde, um Ergebnisse zu einer beliebigen Anfrage herauszufinden.

Die Anfrage kann durch meine Nutzung den kompletten Umfang der Abfrage-API von Lucene nutzen.

Die verwendete Konfiguration entspricht der aus meinen vorherigen Beiträgen.

Ich hoffe, ihr könnt mir mal über euren Einsatz von Lucene berichten.

RAD im Zend Framework mit dem zf-Tool

rok — Fri, 18 Feb 2011 09:00:38 +0000

Nachdem ich in den vorherigen Beiträgen gezeigt habe, wie man eine Webapplikation erstellt und sie dann konfiguriert, will ich nun das zf Kommandozeilen-Tool näher beleuchten. Die Dokumentation dazu ist bisher sehr dünn bis nicht existent.

Voraussetzungen für die Nutzung

Nachdem man das Zend Framework Paket heruntergeladen hat muss man es entpacken, inklusive des bin-Ordners. Diesen muss man dann in der Pfad-Variable PATH (unter Windows) bekannt machen, damit man überall Zugriff auf das Kommando zf hat. Dazu muss der library-Ordner in der Struktur wie im Paket zu finden sein.

Als Probe muss man in der Eingabeaufforderung folgendes Kommando eingeben:

$> zf show version

Wenn kein Fehler kommt, dann ist das zf-Tool korrekt verfügbar.

A. Anlegen eines Projektes

Damit wird eine komplette Projektstruktur erstellt vom Wurzelverzeichnis angefangen. Siehe meinem ersten Beitrag.
Grundlegende Aufrufstruktur:

$> zf create project {ProjectName}

Konkreter Beispielaufruf

$> zf create project zf-app

Dieser Befehl erzeugt eine leere Projektverzeichnisstruktur mit diversen Grunddaten. Für die weitere Bearbeitung der Struktur mit dem zf-cli-Tool sollte man in das Applikations-/Projektverzeichnis wechseln.

B. Anlegen eines Moduls

Für die sinnvolle Teilung von anwendungsfallbezogenen Bereichen gibt es Module im Zend Framework. Ein Modul ist verzeichnisbezogen ein separates Verzeichnis unterhalb von application und dessen Unterordner modules. Es beinhaltet wiederum Unterordner für Controller, Views, Models und Formularen. Es ist quasi eine Applikation in der Applikation etwas überspitzt gesagt.

Grundlegende Aufrufstruktur:

$> zf create module {ModuleName}

Konkreter Beispielaufruf:

$> zf create module Modulname

Als Antwort erhält man folgendes:

Creating the following module and artifacts:
C:\workspace\zf-app/application/modules/Modulename/controllers
C:\workspace\zf-app/application/modules/Modulename/models
C:\workspace\zf-app/application/modules/Modulename/views
C:\workspace\zf-app/application/modules/Modulename/views/scripts
C:\workspace\zf-app/application/modules/Modulename/views/helpers
C:\workspace\zf-app/application/modules/Modulename/views/filters
Updating project profile 'C:\workspace\zf-app/.zfproject.xml'

Dieser Aufruf erzeugt folgende Verzeichnisstruktur unterhalb von application:

modules
└───Modulename
	├───controllers
	├───models
	└───views
		├───filters
		├───helpers
		└───scripts

Um nun auch dieses neue Modul nutzen zu können muss die application.ini erweitert werden um folgenden Eintrag:

resources.frontController.moduleDirectory = APPLICATION_PATH "/modules"

Erst nachdem dieser Parameter gesetzt ist, wird auch das Verhalten des Zend Frameworks dahingehend geändert, dass die Applikation modulbasiert funktioniert.
D.h. ein Aufruf der URL zf-app.loc/Modulname ohne den Konfigurationsparameter führt zu folgender Fehlermeldung:

An error occurred
Page not found
Exception information:
 
Message: Invalid controller specified (Modulname)
Stack trace:
 
#0 C:\workspace\zf-app\library\Zend\Controller\Front.php(954): Zend_Controller_Dispatcher_Standard->dispatch(Object(Zend_Controller_Request_Http), Object(Zend_Controller_Response_Http))
#1 C:\workspace\zf-app\library\Zend\Application\Bootstrap\Bootstrap.php(97): Zend_Controller_Front->dispatch()
#2 C:\workspace\zf-app\library\Zend\Application.php(366): Zend_Application_Bootstrap_Bootstrap->run()
#3 C:\workspace\zf-app\public\index.php(26): Zend_Application->run()
#4 {main}  
 
Request Parameters:
 
array (
  'controller' => 'Modulname',
  'action' => 'index',
  'module' => 'default',
)

Sobald der Parameter gesetzt ist kommt folgende Fehlermeldung:

An error occurred
Page not found
Exception information:
 
Message: Invalid controller specified (index)
Stack trace:
 
#0 C:\workspace\zf-app\library\Zend\Controller\Front.php(954): Zend_Controller_Dispatcher_Standard->dispatch(Object(Zend_Controller_Request_Http), Object(Zend_Controller_Response_Http))
#1 C:\workspace\zf-app\library\Zend\Application\Bootstrap\Bootstrap.php(97): Zend_Controller_Front->dispatch()
#2 C:\workspace\zf-app\library\Zend\Application.php(366): Zend_Application_Bootstrap_Bootstrap->run()
#3 C:\workspace\zf-app\public\index.php(26): Zend_Application->run()
#4 {main}  
 
Request Parameters:
 
array (
  'module' => 'Modulname',
  'controller' => 'index',
  'action' => 'index',
)

Der Unterschied ist in den “Request Parameters” -> “module” und “controller” zu sehen.
WICHTIG: Unter Windows ist ein großer Anfangsbuchstabe ein Problem bei dem Pfad zum Modul. Also unbedingt nachträglich das Verzeichnis “Modulname” in “modulname” umbenennen, andernfalls kommt statt der korrekten Seite folgende Exception:

An error occurred
Page not found
Exception information:
 
Message: Invalid controller specified (index)
Stack trace:
 
#0 C:\DATA\workspace\zf-app\library\Zend\Controller\Front.php(954): Zend_Controller_Dispatcher_Standard->dispatch(Object(Zend_Controller_Request_Http), Object(Zend_Controller_Response_Http))
#1 C:\DATA\workspace\zf-app\library\Zend\Application\Bootstrap\Bootstrap.php(97): Zend_Controller_Front->dispatch()
#2 C:\DATA\workspace\zf-app\library\Zend\Application.php(366): Zend_Application_Bootstrap_Bootstrap->run()
#3 C:\DATA\workspace\zf-app\public\index.php(26): Zend_Application->run()
#4 {main}  
 
Request Parameters:
 
array (
  'module' => 'machines',
  'controller' => 'index',
  'action' => 'index',
)

Seit Version 1.11.0 fügt das zf-Tool folgende Einstellung eigenständig in die application.ini hinzu:

resources.frontController.moduleDirectory = APPLICATION_PATH "/modules"

C. Anlegen eines Controllers

Zum Anlegen eines Controllers sollte man sich zuvor bewußt sein, wo dieser Controller angelegt werden soll: im default-Module (direkt unter application/controllers) oder in einem zuvor erstellten Modul.
Grundlegende Aufrufstruktur:

$> zf create controller {ControllerName}[(-m |--module=){ModuleName}]

Der Aufruf zum Erstellen im default-Module / entspricht auch dem Aufruf, wenn man keine modulbasierte Applikation hat:

$> zf create controller Index

Dies legt einen IndexController in application/controllers/IndexController.php an.
Der Aufruf für einen Controller innerhalb eines Moduls (das verändert auch den Klassennamen des Controllers und stellt den Modulnamen voran als Pseudo-Namensraum):

$> zf create controller Index -m Modulname

oder

$> zf create controller Index --module=Modulname

Dies erstellt den Modulname_IndexController in application/modules/Modulname/controllers/IndexController.php.
Folgende Antwort kommt nach dem Aufruf:

Creating a controller at C:\workspace\zf-app/application/modules/Machines/controllers/IndexController.php
Creating an index action method in controller Index
Creating a view script for the index action method at C:\workspace\zf-app/application/modules/Machines/views/scripts/index/index.phtml
Creating a controller test file at C:\workspace\zf-app/tests/application/controllers/IndexControllerTest.php
Updating project profile 'C:\workspace\zf-app/.zfproject.xml'

WICHTIG: Dies erstellt die Klassenhülle und eine leere indexAction().
Diese Action braucht also nicht gesondert erstellt werden. Ebenfalls wird das View-Skript index.phtml für die indexAction erzeugt.

D. Anlegen einer Action

Um einem Controller eine Action zu geben führt folgendes Kommando zum Ziel:
Grundlegende Aufrufstruktur:

$> zf create action {actionName} [(-c |--controller-name=|){ControllerName}][ {ModuleName}]

Konkreter Beispielaufruf:

$> zf create action login Index

Folgende Ausgabe liefert das Kommando:

Creating an action named login inside controller at C:\workspace\zf-app/application/controllers/IndexController.php
Updating project profile 'C:\workspace\zf-app/.zfproject.xml'
Creating a view script for the login action method at C:\workspace\zf-app/application/views/scripts/index/login.phtml
Updating project profile 'C:\workspace\zf-app/.zfproject.xml'

Dadurch wird die Action im Controller erzeugt und das dazugehörige View-Skript.

E. Anlegen eines Views

Zum separaten Anlegen eines View-Skriptes wird folgendes Kommando notwendig:
Grundlegende Aufrufstruktur:

$> zf create view [-c ]{ControllerName} [-a ]{view-script-name}

Konkreter Beispielaufruf:

$> zf create view Index logout

Als Ergebnis erscheint folgendes:

Updating project profile 'C:\workspace\zf-app/.zfproject.xml'

Leider steht nicht, dass ein View-Skript angelegt wurde, aber das wurde es trotzdem.
WICHTIG: Es wird lediglich das View-Skript selbst angelegt. Die Verwendung durch eine Action muss selbst umgesetzt werden. Bspw. kann nachträglich nochmal eine Action dazu erstellt werden mittels “zf create action logout Index“. Dies überschreibt allerdings das vorhandene View-Skript mit dem vordefinierten View-Skript. Das ist unschön und sollte beachtet werden.

F. Anlegen eines Models

Für die Implementierung der Businesslogik ist nun alles weitestgehend vorbereit. Lediglich die Akteure und Datenlieferanten [I] fehlen noch. Beginnen wir mit den Akteuren, die Businesslogik/-informationen beinhalten und einen Zugriff per Methoden ermöglichen.
Ein Model sollte eine Objektinstanz widerspiegeln und deswegen mit der Einzahl benamt werden.
Grundlegende Aufrufstruktur:

$> zf create model {ModelName}[-m {ModuleName}]

Konkreter Beispielaufruf:

$> zf create model Option -m system

Dieser Aufruf liefert folgende Ausgabe:

1 2	Creating a model at C:\workspace\zf-app/application/modules/system/models/Option.php Updating project profile 'C:\workspace\zf-app/.zfproject.xml'

Als Ergebnis haben wir folgendes Klassenkonstrukt:


 
class system_Model_Option
{
 
}

Dieses Model kann nun mit Methoden der Businesslogik weiter komplettiert werden. Zum Laden/Speichern von Daten aus einer Datenquelle (meist Datenbank) benötigen wir noch ein DbTable-Objekt passend zum Model. Dies wird in [I] erklärt.

G. Anlegen eines Formulars

Für die Generierung eines Formulars gibt es folgenden Befehl:
Grundlegende Aufrufstruktur:

$> zf create form {FormName}[-m {ModuleName}]

Konkreter Beispielaufruf:

$> zf create form Auth

Daraufhin wird folgendes Ergebnis gezeigt:

1 2	Creating a form at C:\workspace\zf-app/application/forms/Auth.php Updating project profile 'C:\workspace\zf-app/.zfproject.xml'

Mit diesem Aufruf wird eine Formularklasse Application_Form_Auth unter application/forms/Auth.php erstellt.

H. Einrichten einer Datenbankverbindung

Das zf-cli-Tool bietet nur wenige Möglichkeiten, um komfortabel Konfigurationseinstellungen an der application.ini vorzunehmen. Eine davon ist das Aktivieren der Layoutnutzung [J], eine andere ist die Konfiguration einer Datenbankverbindung.
Grundlegende Aufrufstruktur:

$> zf configure dbadapter "adapter={Adapter}&username={Username}&password={Password}&dbname={DbName}"[ [-s ]{SectionName}]

Konkrete Beispielaufrufe:

$> zf configure dbadapter "adapter=Pdo_Mysql&username=root&password=&dbname=zfapp" -s development

Liefert folgende Ausschrift:

A db configuration for the development section has been written to the application config file.

$> zf configure dbadapter "adapter=Pdo_Mysql&username=root&password=&dbname=transfer"

Liefert dagegen folgende Ausschrift:

A db configuration for the production section has been written to the application config file.

I. Anlegen eines DbTable-Objektes als Verbindung zwischen Model und Datenbank

Zum Laden, Aktualisieren und Speichern von datenbankbezogenen Werten mittels Model wird die Strukturkomponente “DbTable” benötigt. Alternativ kann auch ein anderen Datenlieferant (Provider) genutzt werden – meist ist aber eine Datenbank im Hintergrund.
Grundlegende Aufrufstruktur:

$> zf create dbtable {DbTableName/ModelName}[-a] {TableNameInDatabase}[-m {ModulName}][-f|--force-overwrite]

Damit wird ein DbTable Objekt mit dem korrekten Tabellennamen erstellt. Für eine Aktualisierung dieser Daten kann dies mit dem “–force-overwrite” Parameter erzwungen werden.
Alternativ kann mit

$> zf [-p] create dbtable.from-database

geschaut werden, welche Tabellen gefunden und welche als DbTable erstellt werden. Der Parameter “-p” zeigt lediglich an, was getan werden würde, tut dies aber nicht.
Auf diesen Automatismus wird hier nicht weiter eingegangen.
Konkreter Beispielaufruf:

$> zf create dbtable Options options -m system

Dies liefert folgende Ausschrift:

1 2	Creating a DbTable at C:\workspace\zf-app/application/modules/system/models/DbTable/Options.php Updating project profile 'C:\workspace\zf-app/.zfproject.xml'

Erstellt wurde folgendes Klassenkonstrukt:

class system_Model_DbTable_Options extends Zend_Db_Table_Abstract
{
 
	protected $_name = 'options';
 
}

Diese Zend_Db_Table-Kindklasse kann mit weiteren Properties entsprechend der Tabellendefinition parametrisiert werden.
Für die Verbindung zwischen Model[F] und DbTable[I] benötigt man einen Mapper [K].

J. Nutzen eines Layouts

Für die einheitliche Darstellung in HTML durch einen gewissen Rahmen, der wiederverwendbare Teilbereiche beinhaltet gibt es das Layout im Zend Framework. Um dieses zu verwenden gibt es folgenden Befehl:

$> zf enable layout

Das Ergebnis sieht folgendermaßen aus:

1 2	Layouts have been enabled, and a default layout created at C:\workspace\zf-app/application/layouts/scripts/layout.phtml A layout entry has been added to the application config file.

Es wurde in application/layouts/scripts ein Layout namens layout.phtml angelegt. Zur Nutzung/Aktivierung des Layouts wurde folgender Konfigurationseintrag in der application.ini ergänzt:

resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts/"

Zur Deaktivierung gibt es übrigens:

$> zf disable layout

Dieser Befehl löscht allerdings keine Dateien/Konfigurationen, sondern entfernt lediglich den Hinweis in der .zfproject.xml Datei.
WICHTIG: Eine Reaktivierung des Layouts überschreibt ohne Rückfrage die layout.phtml. Dies ist unschön und sollte beachtet werden.

K. Erstellen eines Mappers zur Verbindung von Model und DbTable

Als Voraussetzung muss ein Model[F] und ein DbTable[I] vorhanden sein. Zur Verbindung dieser beiden völlig eigenständigen Objektklassen wird der Mapper erstellt, der fallbezogen mal mit dem einen, mal mit dem anderen, mal mit beiden Objekten und/oder anderen Objekten zusammen arbeitet.
Den Mapper legen wir ebenfalls in das Models-Verzeichnis. Sonst gibt es Probleme mit der Namens-zu-Klassenauflösung mit dem Auto-Loading-Prozess.
Ganz konkret sieht das bspw. so aus (aus dem Quickstart):

class Application_Model_GuestbookMapper
{
	protected $_dbTable;
 
	public function setDbTable($dbTable)
	{
		if (is_string($dbTable)) {
			$dbTable = new $dbTable();
		}
		if (!$dbTable instanceof Zend_Db_Table_Abstract) {
			throw new Exception('Invalid table data gateway provided');
		}
		$this->_dbTable = $dbTable;
		return $this;
	}
 
	public function getDbTable()
	{
		if (null === $this->_dbTable) {
			$this->setDbTable('Application_Model_DbTable_Guestbook');
		}
		return $this->_dbTable;
	}
 
	/**
	 * take the Model to retrieve data/information and use them
	 * to let the DbTable do the insert/update action
	 * @param Application_Model_Guestbook $guestbook
	 * @return void
	 */
	public function save(Application_Model_Guestbook $guestbook)
	{
		$data = array(
			'email'   => $guestbook->getEmail(),
			'comment' => $guestbook->getComment(),
			'created' => date('Y-m-d H:i:s'),
		);
 
		if (null === ($id = $guestbook->getId())) {
			unset($data['id']);
			$this->getDbTable()->insert($data);
		} else {
			$this->getDbTable()->update($data, array('id = ?' => $id));
		}
	}
 
	/**
	 * use the DbTable to load the data for given primary key and
	 * return a Model instance
	 * @param int $id
	 * @return Application_Model_Guestbook
	 */
	public function find($id)
	{
		$result = $this->getDbTable()->find($id);
		if (0 == count($result)) {
			return;
		}
		$row = $result->current();
		$guestbook = new Application_Model_Guestbook();
		$guestbook->setId($row->id)
				  ->setEmail($row->email)
				  ->setComment($row->comment)
				  ->setCreated($row->created);
		return $guestbook;
	}
 
	/**
	 * retrieve a list of models
	 * @return array of Application_Model_Guestbook
	 */
	public function fetchAll()
	{
		$resultSet = $this->getDbTable()->fetchAll();
		$entries   = array();
		foreach ($resultSet as $row) {
			$entry = new Application_Model_Guestbook();
			$entry->setId($row->id)
				  ->setEmail($row->email)
				  ->setComment($row->comment)
				  ->setCreated($row->created);
			$entries[] = $entry;
		}
		return $entries;
	}
}

Die direkte Nutzung kann dann bspw. in einem Controller [C] erfolgen. Dies wird hier ebenfalls gezeigt.

class GuestbookController extends Zend_Controller_Action
{
	/**
	 * show all guestbook entries
	 */
	public function indexAction()
	{
		// hier den Mapper rufen, anstatt das Model,
		// weil wir nicht eine Instanz wollen, sondern
		// eine Liste von Instanzen
		$guestbook = new Application_Model_GuestbookMapper();
		$this->view->entries = $guestbook->fetchAll();
	}
 
	/**
	 * insert (or update) an entry
	 */
	public function signAction()
	{
		$request = $this->getRequest();
		$form    = new Application_Form_Guestbook();
 
		if ($this->getRequest()->isPost()) {
			if ($form->isValid($request->getPost())) {
				//	the constructor has to set the values to internal properties
				$comment = new Application_Model_Guestbook($form->getValues());
				//	the mapper is the communication level to the data storage: database
				$mapper  = new Application_Model_GuestbookMapper();
				//	the mapper saves the model, we do not need any kind of DbTable
				//	object as direct instance
				$mapper->save($comment);
 
				return $this->_helper->redirector('index');
			}
		}
 
		$this->view->form = $form;
	}
}

Damit werden die Daten vom Formular in das Model übertragen und der Mapper speichert diese Daten, in dem er sie sich wieder aus dem Model holt.
Sparer würden jetzt eventuell gern abkürzen und dem Mapper gleich die Daten aus dem Formular – komplett ohne Model übergeben. In dem einfachen Beispiel mag das sogar gehen, aber der wichtige Punkt Businesslogik würde dann komplett umgangen werden.
In unserem Beispiel könnte im Guestbook-Model noch eine Blacklist auf die E-Mail-Adresse und eine Bewertung des Kommentars vollzogen werden, der weder im Formular selbst, noch etwas in der Datenbank zu suchen hat.
Außerdem könnte eine Logikimplementierung ebenfalls einen Versand von einer Benachrichtigung auslösen. Diese sollte im Model gestartet werden und nicht im Controller/Action, damit das Model nicht nur im MVC Umfeld korrekt funktioniert, sondern vielleicht auch per API/Shell oder anderen Aufrufmöglichkeiten. Wichtig für den Versand der Benachrichtigung ist dabei nicht die Umgebung, in der erfasst wird, sondern viel mehr, dass erfasst wird.

Eine Webapplikation mit Zend Framework konfigurieren

rok — Fri, 11 Feb 2011 09:00:14 +0000

Im letzten Teil habe ich gezeigt, wie man eine Webapplikation mit dem Zend Framework initial erstellt. Heute will ich ein paar nützliche Konfigurationseinstellungen hinzufügen, die in einer Webapplikation wichtig sind. Alle Einträge beziehen sich auf die application.ini.

Korrekte Zeitzone

Für die korrekte Zeitzone der Applikation sollte folgender Eintrag im [production]-Teil ergänzt werden:

phpSettings.date.timezone = "Europe/Berlin"

Mit dieser Einstellung wird intern die Funktion date_default_timezone_set gerufen. Ich hab jetzt meine Zeitzone gewählt. Da sollte grundsätzlich die Zeitzone aus php genutzt werden, in der die Applikation läuft.
PHP-Settings können übrigens immer über die Struktur phpSettings. gesetz werden.

Verlegen der Dateien im default-Module

Das Zend Framework speichert standardmäßig im application-Ordner die Struktur des default-Modules. Um dies zu ändern geht man wie folgt vor:

resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"

ändern zu

resources.frontController.controllerDirectory = APPLICATION_PATH "/modules/default/controllers"

bzw. diesen Konfigurationseintrag löschen.
Danach muss man die Ordner controllers, models, views unterhalb application nach application/modules/default kopieren.
Damit das Default-Module sich dann auch genauso wie jedes andere Modul verhält ist folgende Konfiguration sinnvoll:

resources.frontController.params.prefixDefaultModule = 1

Dadurch verlangt das Zend Framework nun überall den Prefix “Default_“, wie es in anderen Modulen zwingend erforderlich ist.

Aktivieren des Firebug-Loggers für das Logging im Entwicklungssystem/Firefox

Voraussetzung dafür ist ein Firefox mit installiertem Firebug AddOn und FirePHP AddOn.
Danach benötigt man folgende Konfiguration in der application.ini:

1
2
3

resources.log.firebug.writerName = "Firebug"
resources.log.firebug.filterName = "Priority"
resources.log.firebug.filterParams.priority = 7

Diese Zeilen bewirken das Aktivieren des Firebug als Writer für Zend_Log. Außerdem wird der Filter nach “Priority” aktiviert und alle Log-Meldungen mit dem maximalen Wert 7 (Zend_Log::DEBUG) werden dahin geschrieben. Also faktisch alle Meldungen landen in der Firebug-Konsole.
Je nach Applikationsstufe sollte man hier die Priorität vermindern.
Im Produktionssystem sollte gar nicht in den Firebug geschrieben werden, deshalb sollte die Definition im höchsten Modus in der application.ini definiert werden.

Nützliche Konfigurationsparameter bei Datenbankverbindungen

Verbindung als Standard-Adapter deklarieren:

resources.db.isDefaultTableAdapter = true

Zeichensatz der Verbindung:

resources.db.params.charset = utf8

Profiler nach Firebug schreiben lassen

1 2	resources.db.params.profiler.enabled = true resources.db.params.profiler.class = Zend_Db_Profiler_Firebug

Eine Webapplikation mit dem Zend Framework erstellen

rok — Fri, 04 Feb 2011 11:42:20 +0000

Da wir immer wieder neue ZF-Projekte für unsere Kunden erstellen, wollte ich mal meine Erfahrungen im Erstellen einer Webapplikation mit dem Zend Framework bekanntgeben.

Dieser Artikel liegt schon etwas und bezieht sich deshalb auf die Version 1.8.0 des Frameworks. Aber der Grundaufbau des Frameworks hat sich kaum geändert, so dass die hier geschriebenen Dinge eine gewisse Zeit ihre Richtigkeit haben werden.

Meine genutzten Referenzen:

Eingesetztes Framework:

Zend Framework 1.8.0

Umgebung:

Windows XP
XAMPPlite 1.7.3 mit PHP 5.3.1, Apache 2.2.14

Bei ipunkt arbeiten wir zwar ausschließlich auf Ubuntu-Systemen, aber der Anschaulichkeit wegen hier mal ein Tutorial auf Windows-Basis.

1. Kommandozeilentool zf verfügbar machen

Nach dem Download des Zend Framework Paketes des Paket entpacken.

zf/bin und zf/library/Zend irgendwo hin entpacken, danach zf/bin in PATH-Umgebungsvariable ergänzen. Danach auf die Eingabeaufforderung wechseln.

2. Neues Projekt anlegen

Mein Workspace-Verzeichnis für Eclipse ist C:\workspace.

ZF-Projekt anlegen mit dem ZF-CLI-Tool

C:\workspace> zf create project zf-app
Creating project at C:/workspace/zf-app
Note: This command created a web project, for more information setting up your
VHOST, please see docs/README

In der Datei docs/README.txt steht drin, wie ich den VHOST konfigurieren muss und das kann ich eigentlich 1:1 übernehmen.

Mit dem zf-create-project-Befehl wurde ein komplettes Projektverzeichnis angelegt mit folgendem Inhalt:

zf-app
│   .zfproject.xml
│
├───application
│   │   Bootstrap.php
│   │
│   ├───configs
│   │       application.ini
│   │
│   ├───controllers
│   │       ErrorController.php
│   │       IndexController.php
│   │
│   ├───models
│   └───views
│       ├───helpers
│       └───scripts
│           ├───error
│           │       error.phtml
│           │
│           └───index
│                   index.phtml
│
├───docs
│       README.txt
│
├───library
├───public
│       .htaccess
│       index.php
│
└───tests
	│   phpunit.xml
	│
	├───application
	│       bootstrap.php
	│
	└───library
		bootstrap.php

Kurze Erläuterung der einzelnen Verzeichnisse und Dateien:

.zfproject.xml beinhaltet alle Projekteinstellungen, die ich mit dem zf-cli-Tool mache
application beinhaltet die für meine Applikation notwendigen Klassen und Dateien.
Die application.ini im configs Verzeichnis regelt das Applikationsverhalten weitestgehend und kann vom Bootstrap.php ergänzt werden.
Die Bootstrap.php kann das Standardverhalten beeinflussen und sollte grundlegende Definitionen vornehmen für Datenbankverbindungen, Cache-Verhalten, Verwaltung von Session, Registry, Locale, Translation und einigen
weiteren.
Auf die Verzeichnisse controllers, models und views wird erst im späteren Verlauf eingegangen.
docs sollte man auch für die Dokumentation der eigenen Applikation nutzen. Datenbankmodelle und Serverkonfiguration oder Requirements passen hervorragend hier hin.
library beinhaltet alle Bibliotheksdateien, bspw das Zend Framework sollte hier unter library/Zend zu finden sein.
Für Nutzer eines Repositories sollte man hier des Zend Framework als External einbinden.
```
$> svn propadd svn:external Zend http://framework.zend.com/svn/framework/standard/tags/release-1.8.0/library/Zend/
```
public ist der DocumentRoot des Webservers. Dort liegt die Startdatei index.php und eine .htaccess, die das Routing für das Zend Framework übernimmt. Für eine performantere Abarbeitung des Routing empfiehlt sich das Routing komplett in die httpd.conf des Apache zu übertragen und gänzlich auf .htaccess Files zu verzichten. Diese werden – anders als die Konfiguration – ständig gelesen.
tests ist der Ordner für TestCases mit PHPUnit und Zend_Test.

Ein wichtiger Punkt für den Laufzeit-Modus der Applikation ist die Umgebungsvariable APPLICATION_ENV. Diese wird laut docs/README.txt auf “development” eingestellt. Das macht in einer Entwicklungsumgebung Sinn, da auf diesen Modus bezogen auch die Konfigurationsparameter der application.ini geladen werden.

In der index.php steht ebenfalls, dass beim Fehlen dieser Umgebungsvariable automatisch von einer Live- oder Production-Umgebung ausgegangen wird, da man davon ausgeht, dass in einer Entwicklungsumgebung gesonderte Parameter für den Apache eingestellt
werden können, in einer Live-Umgebung ist dies nicht notwendig.

3. Libraries kopieren

Bisher haben wir das Projekt zf-app nur initial erstellen lassen und es fehlt noch das Zend Framework in der Applikation selbst. Dies wird nicht automatisch erstellt, weil man – wie oben beschrieben – diese Bibiothek durchaus per External einbinden kann. Für unser Tutorial gehen wir nun aber mal davon aus, dass wir kein SVN-Repository haben. (Wer das mal eben schnell mit SVN Repository testen möchte, dem kann ich ein demobereich Projekt empfehlen.)

In der index.php verweist ein require_once-Statement auf die Datei Zend/Application.php. Diese fehlt uns derzeit, deshalb würde dort folgender Fehler von PHP kommen.

1
2

Warning: require_once(Zend/Application.php) [function.require-once]: failed to open stream: No such file or directory in C:\workspace\zf-app\public\index.php on line 18
Fatal error: require_once() [function.require]: Failed opening required 'Zend/Application.php' (include_path='C:\workspace\zf-app\library;.;\Programme\xampplite\php\PEAR') in C:\workspace\zf-app\public\index.php on line 18

Nachdem Kopieren der Zend-Library nach library/Zend ist dieser Fehler behoben und die index.php kann korrekt starten.

4. VHost einrichten

Wie unter docs/README.txt angegeben den VHost konfigurieren mit den korrekten Pfaden zur eigenen Applikation. Mit XAMPP sieht das bspw. so aus:

NameVirtualHost *:80
 
ServerName zf-app.loc
DocumentRoot "c:\workspace\zf-app\public"
SetEnv APPLICATION_ENV "development"
 
Options All
AllowOverride All
Order allow,deny
Allow from all
 
ErrorLog "c:\Programme\xampplite\apache\logs\zfapp-error.log"
CustomLog "c:\Programme\xampplite\apache\logs\zfapp-access.log" combined

Das ist die leicht angepasste Konfiguration in der Datei c:\Programme\xampplite\apache\conf\extra\httpd-vhosts.conf.

Nun können wir den Apache starten. Wenn der Apache nicht startet, dann liegt meist ein Konfigurationsfehler vor. Konfigurationsfehler lassen sich dabei am besten in der error.log des Apache nachlesen.

Für die Nutzung einer lokalen Domain zf-app.loc muss noch ein Eintrag in der hosts Datei des Betriebssystems gemacht werden. Unter Windows ist das c:\WINDOWS\system32\drivers\etc\hosts, unter Linux
ist das /etc/hosts.

127.0.0.1	zf-app.loc

Eine Konfiguration von anderen Webserver kann hier nachgelesen werden.

5. Webapplikation testen

Jetzt im Browser die URL zf-app.loc aufrufen und man müßte folgende Seite sehen:

So, das war der erste Teil des Tutorials. Hiermit kann jeder eine laufende Zend Framework Webapplikation erstellen – ohne Vorkenntnisse. Tiefergehende Anpassungen werden im nächsten Tutorial erklärt.

Falls Ihr Ideen, Fragen und Anregungen dazu habt, dann einfach kommentieren und ich versuche all Eure Kommentare entsprechend zu beantworten.

Logfile Viewer für Eclipse

rok — Tue, 12 Oct 2010 10:00:00 +0000

Nachdem ich immer mal wieder Logfiles anschauen muss, wollte ich nicht mehr dauerhaft tail unter Ubuntu und Wintail unter Windows einsetzen. Da gibt es doch bestimmt etwas von Ratiopharm…oder für eclipse, hoffte ich.

Gesucht, gefunden: der eclipse logviewer von Andre Bossert. Update-Site: site.xml

Dieser integriert sich als View in Eclipse und lagert nun bei mir am unteren Rand von Eclipse. Total cool sind 2 Features: automatisches Tail und Highlightung nach eigenen Vorgaben. Sehr geil.

Damit kann ich nun alles im Blick behalten…auf einem Monitor eclipse mit den Logs, auf dem anderen Monitor im Browser testen mit Firebug-Konsole. So läßt es sich arbeiten.

Mit welchen Tools erledigt Ihr solche Aufgaben?

Beschreibung in einem Formular mit dem ZendFramework

rok — Fri, 08 Oct 2010 08:49:47 +0000

Kennt Ihr das Problem, dass Ihr einen Text mitten in einem Formular platzieren wollt? Ich brauche so etwas meist bei AGB-Häkchen oder Newsletter-bestellen-Häkchen. Dort behelfe ich mir derzeit mit der Beschreibung zum Formularelement, bzw. verwende ich im Template zur Ausgabe jedes einzelne Element und schreibe den wichtigen Text einfach in HTML dazwischen. Das ist alles in allem eine nicht sehr befriedigende Lösung und gehört wohl in die Kategorie “Quick-and-dirty”.

“Richtiger” wäre eine Umsetzung als eigenständiges Formularelement. Ich hab es Note genannt:

/**
 * @category   App
 * @package    App_Form
 * @subpackage App_Form_Element
 * @author     Robert Kummer 
 * @see        http://www.ipunkt.biz
 * @copyright  Creative Commons Attribution 3.0 Unported License
 * @license    http://creativecommons.org/licenses/by/3.0/
 */
 
/**
 * load Zend_Form_Element_Xhtml
 */
require_once 'Zend/Form/Element/Xhtml.php';
 
/**
 * A note form element, which uses the shipped view helper Zend_View_Helper_FormNote
 *
 * @category   App
 * @package    App_Form
 * @subpackage App_Form_Element
 * @author     Robert Kummer 
 * @see        http://www.ipunkt.biz
 * @copyright  Creative Commons Attribution 3.0 Unported License
 * @license    http://creativecommons.org/licenses/by/3.0/
 */
class App_Form_Element_Note extends Zend_Form_Element_Xhtml
{
    /**
     * Default view helper to use
     * @var string
     * @see Zend_View_Helper_FormNote
     */
    public $helper = 'formNote';
 
    /**
     * A non-existing form element is always valid
     *
     * @param mixed $value
     * @param mixed $context
     *
     * @return bool
     *
     * @see Zend_Form_Element::isValid()
     */
    public function isValid($value, $context = null)
    {
        return true;
    }
}r>

Ich erzeuge also ein Element, welches von Zend_Form_Element_Xhtml abgeleitet ist. Dadurch bekomme ich gleich mehrere Vorteile im Vergleich zu meiner bisherigen QnD-Lösung: Styling geht über das herkömmliche Decorator-Pattern, Hinzufügen/Löschen über die Element-Methoden innerhalb des Formulars/Subformulars, Ausgabe von HTML-Code dank der Nutzung des FormNote-ViewHelpers, komplette Nutzung der ZF-Struktur und den damit verbundenen Möglichkeiten.

Ich verwende standardmäßig den Zend_View_Helper_FormNote, der praktischerweise mitgeliefert wird. Dieser läßt mich kompletten HTML-Code als Value im Element übergeben und ich brauche nicht händisch das Escaping ausschalten (wie in der bisherigen QnD-Lösung).

So verwende ich dieses Element:

[..]
$objNoteElement = new App_Form_Element_Note('note');
$objNote -> setValue('Hier kommt der Text mit Tag.');
$objForm -> addElement($objNote);
[..]

Das erzeugt mit den Standard-Dekorierern folgende HTML-Ausgabe:


    


        Hier kommt der Text mit Tags.

So, das war es erstmal zu diesem Thema von mir von hier. Wer das genauso macht oder anders, der kann es ja mal kommentieren.

Meine verwendete ZendFramework-Version ist die 1.10.8.

FirePHP mit dem ZendFramework nutzen

rok — Thu, 30 Sep 2010 15:24:33 +0000

Das Manual des Zend Framework zum Thema Wildfire und FirePHP ist recht dürftig bis nicht existent. Wer dennoch gern etwas in der Firebug-Konsole ausgeben lassen möchte, der kann das folgendermaßen machen.

Für die Ausgabe von Tabellenwerten:

$message = new Zend_Wildfire_Plugin_FirePhp_TableMessage('SESSION');
$message -> setHeader(array('key', 'value'));
foreach ($_SESSION as $key => $value)
{
 $message -> addRow(array($key, $value));
}
// message senden
Zend_Wildfire_Plugin_FirePhp::getInstance() -> send($message);

Der Konstruktor bekommt dabei das Label übergeben. Dieses ist dann in der Konsole klickbar und öffnet den Inhalt der Tabelle. Mit setHeader() wird ein Array mit den Spaltenköpfen angegeben. Hier muss die Anzahl zu den Elementen in addRow() übereinstimmen – damit werden zeilenweise die darzustellenden Werte übergeben.

Für die Ausgabe von einfachen Meldungen:

$message = new Zend_Wildfire_Plugin_FirePhp_Message('INFO', 'Hier kommt die Meldung');
$message -> setLabel('Optionales Label');
// message senden
Zend_Wildfire_Plugin_FirePhp::getInstance() -> send($message);

Statt dem “INFO” gibt es noch weitere Stiltypen, die bspw. ein Info-Icon, Ausrufezeichen usw. darstellen lassen. Mögliche Werte sind: LOG, INFO, WARN, ERROR, TRACE, EXCEPTION. Für weitere Details sei auf die Klasse Zend/Wildfire/Plugin/FirePhp.php verwiesen. Das optionale Label wird dem Meldungstext einfach vorangestellt, gefolgt von einem Doppelpunkt und Leerzeichen.

WICHTIG: Wenn der Wert für den Stil nicht in Großbuchstaben übergeben wird, wird keine Meldung ausgegeben.

XML Schema ohne XMLSpy erstellen

rok — Fri, 24 Sep 2010 12:28:05 +0000

Wer die Evaluierungsphase mit Altova XMLSpy beendet hat und dennoch ein XML Schema aus einer XML-Datei bauen muss, dem kann ich wärmstens Pagina empfehlen.

Dort wird im Themenkomplex 2 sehr ausführlich auf die Schemenerstellung eingegangen. Das hat mir auch wieder sehr geholfen…oder wißt ihr im Detail welche Parameter bei komplexen Typen alle notwendig sind?

Sprachrohr

Tomatensalat

Zutaten

Zubereitung

Das könnte Sie auch interessieren:

Windows-Nutzer im Webformular vorausfüllen

Das könnte Sie auch interessieren:

Suchen mit Zend_Search_Lucene

Index aufbauen mit Zend_Search_Lucene

Suchen mit Lucene

Das könnte Sie auch interessieren:

RAD im Zend Framework mit dem zf-Tool

Voraussetzungen für die Nutzung

A. Anlegen eines Projektes

B. Anlegen eines Moduls

C. Anlegen eines Controllers

D. Anlegen einer Action

E. Anlegen eines Views

F. Anlegen eines Models

G. Anlegen eines Formulars

H. Einrichten einer Datenbankverbindung

I. Anlegen eines DbTable-Objektes als Verbindung zwischen Model und Datenbank

J. Nutzen eines Layouts

K. Erstellen eines Mappers zur Verbindung von Model und DbTable

Das könnte Sie auch interessieren:

Eine Webapplikation mit Zend Framework konfigurieren

Korrekte Zeitzone

Verlegen der Dateien im default-Module

Aktivieren des Firebug-Loggers für das Logging im Entwicklungssystem/Firefox

Nützliche Konfigurationsparameter bei Datenbankverbindungen

Das könnte Sie auch interessieren:

Eine Webapplikation mit dem Zend Framework erstellen

1. Kommandozeilentool zf verfügbar machen

2. Neues Projekt anlegen

3. Libraries kopieren

4. VHost einrichten

5. Webapplikation testen

Das könnte Sie auch interessieren:

Logfile Viewer für Eclipse

Das könnte Sie auch interessieren:

Beschreibung in einem Formular mit dem ZendFramework

Das könnte Sie auch interessieren:

FirePHP mit dem ZendFramework nutzen

Das könnte Sie auch interessieren:

XML Schema ohne XMLSpy erstellen

Das könnte Sie auch interessieren: