PHP im Modul Template

[juedler]

Hallo,

ich würde sehr gern in einem Modul-Template per PHP eine Entscheidung einbauen.

Also etwa so:

Code: Alles auswählen

<?php
if ("{ARG1}" == "0")
?>
Blabla
<?
else
?>
Blablabla

Somit könnte ich mit einem Platzhalter entscheiden, welcher Code ausgegeben werden sollte. Im konkreten, oberen Fall würde ich das anders lösen, allerdings beschreibt dies ungefähr was ich vorhabe. Vielleicht kennt ihr einen besseren und einfacheren Weg.

[php0815]

Ich weis nicht ob PHP im Modul Template funzt
Wurde 2 Modul Template anlegen und in der Modul Datei selbst die Entscheidung treffen.

[juedler]

Ja klar. Leider hätte ich dann viele Template Dateien. Das wollte ich eigentlich nicht.

Eine Variante ist mir noch eingefallen: Man könnte die Teile auskommentieren. Leider sieht das im Quelltext dann blöd aus. Viellecht könnte man das mit dem true beim generate zurückgeben lassen, und dann abermals parsen. Was meint ihr?

[idea-tec]

Unter /contenido/classes/class.ExtendedTemplate.php speichern

Code: Alles auswählen

<?
cInclude("classes", "class.template.php", false);


/**
 * class ExtendedTemplate
 * 
 * Erweiterte Version der Contenido-Templateklasse
 * 
 * Die Funktion der Superklasse ist uneingeschränkt verfügbar.
 * Der erweiterten Klasse können Instanzen von Parserklassen, die von AbstractTemplateParser erben müssen,
 * oder deren Klassennamen übergeben werden, die dann nacheinander das Template auswerten.
 * 
 * Fest Implementiert sind zur Zeit die Klassen:
 * - StrAPIFunctionsParser
 * - CounterFunctionParser
 * - IfFunctionParser
 *
 *
 * @author Stefan Welpot
 * @version 1.0
 */
class ExtendedTemplate
	extends Template
{
	var $array_registeredParsers;
	
	/**
	 * Konstruktor
	 *
	 * @param $tags Array Tags Anfang und Ende des dynamischen Blocks, sowie für statische Bereiche
	 * @param $parser Array Objektinstanzen von Kindklassen von AbstractTemplateParser oder deren Klassennamen
	 */
	function ExtendedTemplate($tags = false, $parser = false) {
		$this->Template($tags);
		
		
		$this->array_registeredParsers = array(
											new StrAPIFunctionsParser(),
											new CounterFunctionParser(),
											new IfFunctionParser()
										);
										
				
		if(is_array($parser)) {
			$this->array_registeredParsers = $parser;
		}
		
	}
	
    /**
     * Generiert das Template und gibt es aus/zurück.
	 *
     * @param $template string/file Template
     * @param $return bool Return or print template
     * @param $note bool Echo "Generated by ... " Comment
     *
     * @return string complete Template string
     */
    function generate($template, $return = 0, $note = 1) {
		$template = parent::generate($template, true, $note);

		foreach($this->array_registeredParsers as $class) {
			if(is_string($class)) {
				$classInstance = new $class;
			}
			else if(is_object($class)) {
				$classInstance = $class;
			}
			
			if(is_object($classInstance)) {
				if(is_subclass_of($classInstance, "AbstractTemplateParser")) {
					$template = $classInstance->parse($template);
				}
				else {
					$template = "TemplateParserKlasse " . get_class($classInstance) . " ist nicht von AbstractTemplateParser abgeleitet!";
					break;
				}
			}
		}


        if ($return) {
            return $template;
        }
        
        echo $template;
	}
}



/**
 * class AbstractTemplateParser
 * 
 * Abstrakte Superklasse für alle Templateparser
 *
 * @author Stefan Welpot
 * @version 1.0
 */
class AbstractTemplateParser {

	/**
	 * Konstruktor
	 */
	function AbstractTemplateParser() {}
	
	/**
	 * Parst das übergeben Template
	 *
	 * @param $template string das zu parsende Template
	 *
	 * @return string das geparste Template
	 */
	function parse($template) {
		return $template;
	}
}


/**
 * class IfFunctionParser
 * 
 * Implemenation des AbstractTemplateParser zum Auswerten von 
 * If-Konstrukten im Template
 * Als Tags im Template sind vorgesehen:
 *   - {if(Bedigung)}
 *   - {else if(Bedingung)}
 *   - {else}
 *   - {/if}
 *
 * Ein If-Konstrukt besteht dabei mindestens aus {if(Bedingung)} und einem abschließenden {/if}.
 * Das {else if(Bedingung)} kann beliebig oft hintereinander verwendet werden.
 * Die Konstrukte an sich können beliebig tief geschachtelt werden.
 * Die Bedinungen der {if()}- und {else if()}-Teile werden durch eval ausgewertet
 * und können somit auch PHP-Funktionen interpretieren.
 *
 *
 * @author Stefan Welpot
 * @version 1.0
 */
class IfFunctionParser
	extends AbstractTemplateParser
{

    /**
     * Regexp-Pattern für {if(Bedingung)}
     * @var pattern_if
     */
	var $pattern_if = 		"\{if\040*\((.*?)\)\}";

    /**
     * Regexp-Pattern für {else if(Bedingung)}
     * @var pattern_elseif
     */
	var $pattern_elseif = 	"\{else if\040*\((.*?)\)\}";

    /**
     * Regexp-Pattern für {else}
     * @var pattern_else
     */
	var $pattern_else = 	"\{else\}";

    /**
     * Regexp-Pattern für {/if}
     * @var pattern_endif
     */
	var $pattern_endif = 	"\{\/if\}";
	
    /**
     * Länge des {if(Bedinung)}-Tags ohne Bedingung
     * @var patternlength_if
     */
	var $patternlength_if =			6;

    /**
     * Länge des {else if(Bedinung)}-Tags ohne Bedingung
     * @var patternlength_elseif
     */
	var $patternlength_elseif = 	11;

    /**
     * Länge des {else}-Tags
     * @var patternlength_else
     */
	var $patternlength_else = 		6;

    /**
     * Länge des {/if}-Tags
     * @var patternlength_endif
     */
	var $patternlength_endif = 		5;



	/**
	 * Konstruktor
	 */
	function IfFunctionParser() {
		$this->AbstractTemplateParser();
	}

	
	/**
	 * @see AbstractTemplateParser#parse(string)
	 */
	function parse($template) {
		$array2_uncompletedConstructs = array(); //geöffnete, aber noch nicht geschlossene funktionen

		//hilfsvariablen
		$array_match_all = array();
		$array_match_part = array();
		$uncompletedConstructsIndex = 0;
		$elseifIndex = 0;
		$currentOffset = 0;
		$oldOffset = -1;
		
		$array_construct = array();
		
		$pattern_all = "/(?is)(" . $this->pattern_if . "|" . $this->pattern_elseif . "|" . $this->pattern_else . "|" . $this->pattern_endif . ")/";

        //das template solange nach konstruktteilen durchsuchen bis keine mehr gefunden werden
		while($currentOffset != $oldOffset) {
			$oldOffset = $currentOffset;
			
			//wenn irgendein teil einer if-konstruktion gefunden wird
			if(preg_match($pattern_all, $template, $array_match_all, PREG_OFFSET_CAPTURE, $currentOffset) > 0) {
				//herausfinden, welcher teil gefunden wurde
				//if-teil
				if(preg_match("/(?is)" . $this->pattern_if . "/", $array_match_all[0][0], $array_match_part) > 0) {
					$uncompletedConstructsIndex++; //inkrement openFunctionIndex

					$array2_uncompletedConstructs[$uncompletedConstructsIndex]['if']['condition'] = $array_match_part[1];
					$array2_uncompletedConstructs[$uncompletedConstructsIndex]['if']['pos_start'] = $array_match_all[0][1];
					$array2_uncompletedConstructs[$uncompletedConstructsIndex]['if']['pos_end'] = $array2_uncompletedConstructs[$uncompletedConstructsIndex]['if']['pos_start'] + $this->patternlength_if + strlen($array_match_part[1]);
					$currentOffset = $array2_uncompletedConstructs[$uncompletedConstructsIndex]['if']['pos_end'];	
				}
				//elseif-teil
				else if(preg_match("/(?is)" . $this->pattern_elseif . "/", $array_match_all[0][0], $array_match_part) > 0) {
					$elseifIndex = count($array2_uncompletedConstructs[$uncompletedConstructsIndex]['elseif']);

					$array2_uncompletedConstructs[$uncompletedConstructsIndex]['elseif'][$elseifIndex]['condition'] = $array_match_part[1];
					$array2_uncompletedConstructs[$uncompletedConstructsIndex]['elseif'][$elseifIndex]['pos_start'] = $array_match_all[0][1];
					$array2_uncompletedConstructs[$uncompletedConstructsIndex]['elseif'][$elseifIndex]['pos_end'] = $array2_uncompletedConstructs[$uncompletedConstructsIndex]['elseif'][$elseifIndex]['pos_start'] + $this->patternlength_elseif + strlen($array_match_part[1]);
					$currentOffset = $array2_uncompletedConstructs[$uncompletedConstructsIndex]['elseif'][$elseifIndex]['pos_end'];	
				}
				//else-teil
				else if(preg_match("/(?is)" . $this->pattern_else . "/", $array_match_all[0][0], $array_match_part) > 0) {
					$array2_uncompletedConstructs[$uncompletedConstructsIndex]['else']['pos_start'] = $array_match_all[0][1];
					$array2_uncompletedConstructs[$uncompletedConstructsIndex]['else']['pos_end'] = $array2_uncompletedConstructs[$uncompletedConstructsIndex]['else']['pos_start'] + $this->patternlength_else;
					$currentOffset = $array2_uncompletedConstructs[$uncompletedConstructsIndex]['else']['pos_end'];	
				}
				//endif
				else if(preg_match("/(?is)" . $this->pattern_endif . "/", $array_match_all[0][0], $array_match_part) > 0) {
					$array2_uncompletedConstructs[$uncompletedConstructsIndex]['endif']['pos_start'] = $array_match_all[0][1];
					$array2_uncompletedConstructs[$uncompletedConstructsIndex]['endif']['pos_end'] = $array2_uncompletedConstructs[$uncompletedConstructsIndex]['endif']['pos_start'] + $this->patternlength_endif;
					$currentOffset = $array2_uncompletedConstructs[$uncompletedConstructsIndex]['endif']['pos_end'];	
					
					
					//gefundene komplette funktion sofort ersetzen
					$array_construct = array_pop($array2_uncompletedConstructs);
					$uncompletedConstructsIndex--;
					$template = $this->replaceConstruct($array_construct, $template);
					//offset korrigieren = anfang der ersetzten funktion
					$currentOffset = $array_construct['if']['pos_start'];
				}				
			}
		} // end while
		
		if($uncompletedConstructsIndex > 0) { // wenn noch offene Funktionen vorhanden sind => Fehler im Template
			$template = "Fehler in IF-Konstruktionen. Folgende If-Statements sind nicht abgeschlossen:<br>\n";
			foreach($array2_uncompletedConstructs as $array_construct) {
				$template .= "- {if(" . $array_construct['if']['condition'] . ")}<br>\n";
			}
		}
		
		return $template;
	} // end function
	
	
	/**
	 * Ersetzt die als Array übergebene Funktion durch 
	 * den ersten Teil mit einer wahren Bedingung
	 *
	 * @param $array_construct Array das komplette If-Konstrukt das ausgewertet werden soll
	 * @param $template string das Template in dem das Konstrukt ersetzt werden soll
	 *
	 * @return string das Template mit dem ersetzten Konstrukt
	 */
	function replaceConstruct($array_construct, $template) {
		$array_elseif = array();		
		$key = 0;
		$replace_text = "";
		$boolConditionTrue = false;

		//prüfen ob der if-teil wahr ist und $replace_text finden
		if(eval("return " . $array_construct['if']['condition'] . ";")) {
			if(array_key_exists('elseif', $array_construct)) { //wenn ein elseif-teil existiert
				$replace_text = substr($template, $array_construct['if']['pos_end'], $array_construct['elseif'][0]['pos_start'] - $array_construct['if']['pos_end']);
			}
			else if(array_key_exists('else', $array_construct)) { //wenn nur ein else-teil existiert
				$replace_text = substr($template, $array_construct['if']['pos_end'], $array_construct['else']['pos_start'] - $array_construct['if']['pos_end']);
			}
			else {//wenn der nächste teil schon endif ist
				$replace_text = substr($template, $array_construct['if']['pos_end'], $array_construct['endif']['pos_start'] - $array_construct['if']['pos_end']);
			}
		}
		else {
			//alle elseif-teile prüfen
			if(is_array($array_construct['elseif'])) {
				foreach($array_construct['elseif'] as $key => $array_elseif) {
					if(eval("return " . $array_elseif['condition'] . ";")) {
						$boolConditionTrue = true;
						
						if(array_key_exists(($key + 1), $array_construct['elseif'])) { //wenn ein weiterer elseif-teil existiert
							$replace_text = substr($template, $array_elseif['pos_end'], $array_construct['elseif'][$key+1]['pos_start'] - $array_elseif['pos_end']);
						}
						else if(array_key_exists('else', $array_construct)) { //wenn nächster teil nur ein else-teil ist
							$replace_text = substr($template, $array_elseif['pos_end'], $array_construct['else']['pos_start'] - $array_elseif['pos_end']);
						}
						else {//wenn der nächste teil schon endif ist
							$replace_text = substr($template, $array_elseif['pos_end'], $array_construct['endif']['pos_start'] - $array_elseif['pos_end']);
						}
						
						break;
					}
				}
			}
			
			//wenn bisher noch keine wahre Bedingung gefunden wurde
			if(!$boolConditionTrue) {
				if(array_key_exists('else', $array_construct)) { // wenn ein else-teil existiert
					$replace_text = substr($template, $array_construct['else']['pos_end'], $array_construct['endif']['pos_start'] - $array_construct['else']['pos_end']);
				}
				else { // sonst wird das gesamte kontrukt durch einen leeren string ersetzt
					$replace_text = "";
				}
			}
		} // end else
					
		//if-konstruktion durch wahren teil ersetzen
		$template = substr_replace($template, $replace_text, $array_construct['if']['pos_start'], $array_construct['endif']['pos_end'] - $array_construct['if']['pos_start']);
		
		return $template;
	}
}


/**
 * class CounterFunctionParser
 * 
 * Implemenation des AbstractTemplateParser zur Verwendung von 
 * Zählern im Template
 * Als Tag im Template ist vorgesehen:
 *   - {counter PARAMETER}
 * Die PARAMETER sind:
 *   - name=ZÄHLERNAME
 *   - start=STARTWERT (default: 0)
 *   - step=SCHRITTWEITE (default: 1)
 *   - print=(true|false) (default: true)
 * Alle Parameter sind optional.
 *
 * Über die Name-Eigenschaft können mehrere unschiedliche Zähler verwendet werden.
 * Bei jedem Vorkommen des {counter}-Tags wird der gleichnamige Zähler um STEP erhöht.
 * Wird die Eigenschaft print auf true oder gar nicht gesetzt erfolgt eine Ausgabe des 
 * Zählerwerts an der Stelle des {counter}-Tags
 *
 *
 * @author Stefan Welpot
 * @version 1.0
 */
class CounterFunctionParser
	extends AbstractTemplateParser
{

    /**
     * Regexp-Pattern für {counter PARAMETER}
     * @var pattern_countertag
     */
	var $pattern_countertag =	"/(?si)\{counter(.*?\})/";

    /**
     * Regexp-Pattern für Parameter name=NAME
     * @var pattern_countername
     */
	var $pattern_countername =	"/(?i)name\040?\=(.+?)(\040|\})/";

    /**
     * Regexp-Pattern für Parameter start=STARTWERT
     * @var pattern_counterstart
     */
	var $pattern_counterstart =	"/(?i)start\040?\=(\d+?)(\040|\})/";

    /**
     * Regexp-Pattern für Parameter step=SCHRITTWEITE
     * @var pattern_counterstep
     */
	var $pattern_counterstep =	"/(?i)step\040?\=(\d+?)(\040|\})/";

    /**
     * Regexp-Pattern für Parameter print=(true|false)
     * @var pattern_counterprint
     */
	var $pattern_counterprint =	"/(?i)print\040?\=(true|false)(\040|\})/";
	
    /**
     * Defaultwert für Parameter name
     * @var default_countername
     */
	var $default_countername = "unnamed";

    /**
     * Defaultwert für Parameter start
     * @var default_counterstart
     */
	var $default_counterstart = 0;

    /**
     * Defaultwert für Parameter step
     * @var default_counterstep
     */
	var $default_counterstep = 1;

    /**
     * Defaultwert für Parameter print
     * @var default_counterprint
     */
	var $default_counterprint = true;
	
	
	/**
	 * Konstruktor
	 */
	function CounterFunctionParser() {
		$this->AbstractTemplateParser();
	}

	
	/**
	 * @see AbstractTemplateParser#parse(string)
	 */
	function parse($template) {
		$counterParameters = "";
		$counterKey = "";
		$array_matches = array();
		$array_countermatches = array();
		$array_initCounters = array();
		$boolPrint = $this->default_counterprint;
		$boolDoNotInkr = false;
		
		preg_match_all($this->pattern_countertag, $template, $array_countermatches, PREG_SET_ORDER);

		for($i = 0; $i < count($array_countermatches); $i++) {
			$counterKey = "";
			
			$counterParameters = $array_countermatches[$i][1];

			//Attribut Countername auslesen, falls vorhanden
			preg_match($this->pattern_countername, $counterParameters, $array_matches);
			if(count($array_matches) > 0) {
				$counterKey = $array_matches[1];
			}
			else { // sonst defaultname
				$counterKey = $this->default_countername;
			}

							
			if(!array_key_exists($counterKey, $array_initCounters)) { // neuen Counter initialisieren
				$array_initCounters[$counterKey]['value'] = $this->default_counterstart;
				$array_initCounters[$counterKey]['step'] = $this->default_counterstep;
				$boolDoNotInkr = true;
			}
			

			//Attribut step
			preg_match($this->pattern_counterstep, $counterParameters, $array_matches);
			if(count($array_matches) > 0) {
				$array_initCounters[$counterKey]['step'] = $array_matches[1];
			}
	

			//Attribut start
			preg_match($this->pattern_counterstart, $counterParameters, $array_matches);
			if(count($array_matches) > 0) {
				$array_initCounters[$counterKey]['value'] = $array_matches[1];
				$boolDoNotInkr = true;
			}
			
			
			// value regulär erhöhen
			if(!$boolDoNotInkr) {
				$array_initCounters[$counterKey]['value'] = $array_initCounters[$counterKey]['value'] + $array_initCounters[$counterKey]['step'];
			}
			else {
				$boolDoNotInkr = false;
			}
			
			
			//Attribut print
			preg_match($this->pattern_counterprint, $counterParameters, $array_matches);
			if(count($array_matches) > 0) {
				$boolPrint = (strcasecmp("true", $array_matches[1]) == 0) ? true : false;
			}
			else {
				$boolPrint = $this->default_counterprint;
			}


			if($boolPrint) {
				$template = preg_replace($this->pattern_countertag, $array_initCounters[$counterKey]['value'], $template, 1);
			}
			else {
				$template = preg_replace($this->pattern_countertag, '', $template, 1);
			}
		}
		
		return $template;
	}
}



/**
 * class StrAPIFunctionsParser
 * 
 * Implemenation des AbstractTemplateParser zum Auswerten von 
 * ContenidoStrAPIFunktionen.
 * Als erlaubte Funktionen sind vorgesehen:
 *   - {capiStrTrimHard(STRING, LÄNGE)}
 *   - {capiStrTrimAfterWord(STRING, LÄNGE)}
 *   - {capiStrTrimSentence(STRING, LÄNGE)}
 *
 * Die die Funktionen werden ertrahiert, ausgewertet und anschließend durch das Ergebnis ersetzt.
 *
 *
 * @author Stefan Welpot
 * @version 1.0
 */
class StrAPIFunctionsParser 
	extends AbstractTemplateParser
{

    /**
     * zu ersetzende Funktionen
     * @var array_strAPIFunctions
     */
	var $array_strAPIFunctions = array(
									"capiStrTrimHard",
									"capiStrTrimAfterWord",
									"capiStrTrimSentence"
								);
								

    /**
     * Konstruktor
     */
	function StrAPIFunctionParser() {
		$this->AbstractTemplateParser();
	}
	
    /**
     * @see AbstractTemplateParser#parse(string)
     */
	function parse($template) {
		$anzahlMatches = 0;
		$array2_matches = array();
		$evaledCode = "";
		
		foreach($this->array_strAPIFunctions as $functionname) {
			$anzahlMatches = preg_match_all("/(?si)\{" . preg_quote($functionname, "/") . "\(\"?(.*?)\"?,\040?(\d+?)\)\}/", $template, $array2_matches);

			for($i = ($anzahlMatches - 1); $i >= 0; $i--) {
				$evaledCode = eval("return " . $functionname . "(\"" . $array2_matches[1][$i] . "\", " . $array2_matches[2][$i] . ");");
				
				$template = preg_replace(
								"/(?si)\{" . preg_quote($functionname, "/") . "\(\"?" . preg_quote($array2_matches[1][$i], "/") . "\"?,\040?" . preg_quote($array2_matches[2][$i], "/") . "\)\}/",
								$evaledCode,
								$template
				);
				
			} //end for(i)
		} // end foreach

		return $template;
	}
}
?>

Beispiel für Modul-Template:

Code: Alles auswählen

{if("{THEMA1}"!="")}<img src="upload/themen/{themabild1}.png" alt="{THEMA1}" title="{THEMA1}" />{/if}
{if("{THEMA2}"!="")}<img src="upload/themen/{themabild2}.png" alt="{THEMA2}" title="{THEMA2}" />{/if}
{if("{THEMA3}"=="1")}<img src="upload/themen/{themabild3}.png" alt="{THEMA3}" title="{THEMA3}" />{/if}
{if("{THEMA4}"=="1")}<img src="upload/themen/{themabild4}.png" alt="{THEMA4}" title="{THEMA4}" />{/if}

Einbinden im Modul-Output:

Code: Alles auswählen

cInclude('classes', 'class.ExtendedTemplate.php');
$tpl = new ExtendedTemplate();

[OliverL]

Hi,

Hab den Beitrag durch deinen Wiki-User gefunden bzw das Changelog

@idea-tec: krass große Datei (hab den scrollbalken gesehen und dachte nur "ne das guckste dir nicht um 23:15 noch an" )

@juedler: ich hatte auch schon das Problem das ich Dinge nicht ohne weiteres mit Platzhaltern realisieren konnte und habe folgend Lösung für dich.
Machst du ganzeinfach:

Code: Alles auswählen

eval ("?>\n".$oTpl->generate( $cfgClient[$client]['tpl']['path'].'template_file_name.html', true )."\n<?php\n");

Wichtig ist der zweite Parameter $return=true der Template-Klasse siehe http://www.contenido-wiki.org/wiki/inde ... ate-Klasse.

mfg
oli

Update: sehe gerade "Do Apr 15, 2010 4:02 pm" war der Post. naja besser spät als nie

[idea-tec]

Krass große Datei, vermutlich, aber voll genial ... zudem ist die nicht von mir, ich nutze die nur.
Zugegebenermaßen habe ich jedoch auch schon darüber nachgedacht, ob man die nicht mal noch erweitern und auch optimieren könnte (gescheitert ist es an der Zeit). Allerdings ist das eine Arbeit vom feinsten, die der urheber da geleistet hat.

Dein Code ist auch gut, löst aber nicht das Problem des Anfragenden, der sich wünscht, dass er WENIGE und nicht n Anzahl an Modul-Templates hat.
DAS ist es was die krass große Datei tut, man braucht nur EIN Modul-Termplate und kann dann im Modul-Template mit if und sogar else arbeiten!!!

[OliverL]

*schmunzel

Dann werd ich mir die krass große Datei mal angucken.
Aber wie man es kennt hab ich krass wenig Zeit (Ich hoffe ich vergesse es nicht)
Dann verstehe ich sicher auch den unterschied zwischen der ... Datei und meinem eval().
Aber auch nicht mehr jetzt vielleicht heute noch (sind ja noch runde 23 Stunden über).

mfg Oli