eigen framework / beheersysteem

Hij is nog niet helemaal klaar :)

To view or not to view... that's the question!

Oke... stel je hebt een framework gebaseerd op het MVC model. Dan stop je je views dus in aparte view (phtml) bestanden. Maar nu vraag ik me het volgende af. Stel je hebt een CMS-systeem. Qua layout zijn de pagina's in een CMS-systeem veelal hetzelfde. Ik kan me bijvoorbeeld voorstellen dat je een pagina hebt waarop je een user aanmaakt en een pagina waarop je een product invoert. Deze pagina's hebben allebei dezelfde header en footer, maar ze hebben ook allebei een paginatitel en een formulier waar je de gegevens van een user of product kunt invoeren. Header en footer lijkt me vrij logisch dat je die standaard voor iedere pagina toont, maar de content daartussen hou je variabel.

De user aanmaken pagina en product invoeren pagina zoals hierboven genoemd zijn uitsluitend bedoeld als voorbeeld. Je kunt je voorstellen dat je nog veel meer pagina's hebt, die bestaan uit een titel en een formulier. Het gaat er in ieder geval om dat je een aantal pagina's hebt die er qua opmaak hetzelfde uitzien.

En nu komt mijn vraag. Volgens het MVC model maak je voor iedere pagina een eigen view maar wat nu als veel pagina's op elkaar lijken? Ga je nu voor iedere pagina een aparte view (lees phtml bestand) maken, of regel je dit met een soort overkoepelend script? In de 1e situatie krijg je in het geval van de user aanmaken en product invoeren pagina's dan 2 afzonderlijke bestanden. In die bestanden staat hardcoded een titel en een formulier. In het laatste geval zou je 1 bestand krijgen waarin je de titel als variabele echoot en waarin het formulier via een script wordt opgebouwd.

In situatie 1 zou je de view (ongeveer) als volgt maken waarbij alle gegevens hardcoded in de view worden geplaatst:

makeView('user.phtml');
makeView('product.phtml');

en in situatie 2 zou je een view genereren waarbij de gegevens via variabelen worden doorgegeven aan de 'formulier view'.

makeFormView('User aanmaken.', $array('naam', 'leeftijd'), 'verzenden');
makeFormView('Product invoeren.', $array('artikelnummer', 'naam'), 'voer in');

Wat is nu de juiste / handigste / meest gangbare manier? Manier 2 lijkt me de makkelijkste en snelste manier + het resultaat (de view) ziet er altijd hetzelfde uit. Echter, wellicht is deze manier niet de bedoeling van het MVC model. Manier 1 is wat lastiger omdat je voor iedere pagina een apart bestand moet maken. Je bent echter wel flexibeler dan in situatie 2.

Ben benieuwd naar jullie visie.

Wat jij wilt is een default template waarin alle content van andere views wordt ingeladen.

Kijk eens naar Zend_View zou ik zeggen, die hebben dat netjes oplost. En wanneer je de default layout niet nodig hebt kan je hem daar gewoon uitschakelen op switchen met een andere :)

Overigens hoeven je template bestanden niet per definitie de extensie .phtml te hebben. .tpl kan ook gewoon.

Niels... het gaat om een eigen framework, remember ;) Dus Zend even achterwege laten a.u.b.

Wat ik normaal (nu nog via Zend) doe is dat ik een layout.phtml bestand heb met daarin de html structuur van de pagina (html, head, body) en in de body toon ik dan het variabele view (content) gedeelte, wat in feite het includen van een phtml bestand is.

Is dat wat jij bedoelt? Maar de vraag blijft nog steeds, ga je voor vergelijkbare views een "view script" maken of gewoon voor iedere pagina een view bestand. Wat is praktisch?

"Overigens hoeven je template bestanden niet per definitie de extensie .phtml te hebben. .tpl kan ook gewoon."

Dat heb ik dan weer wel van Zend :|

bumpje :)

Ik kan me voorstellen dat een view script voor formulier pagina's heel handig is, maaaar... stel ik wil na een tijdje de lay-out van een specifieke formulier pagina aanpassen, dan gaat dit niet want dan pas ik alle formulieren aan. Dus dan moet ik alsnog een aparte view maken. Vandaar dus mijn vraag.. wat is wijsheid?

Formulier een standaardview geven, die hij mag overschrijven.

In de controllers/acties die ik bouw, zit ook een mogelijkheid om een andere layout op te geven, of zelfs geen layout (dat is wel fijn bij antwoorden op een XHR-verzoek, of bij een file-download); dat werkt ook zo. De ouderklasse zet (protected) $this->layout op 'default', de afgeleide klassen mogen 'm veranderen.

"Formulier een standaardview geven, die hij mag overschrijven."

Hoe bedoel je dit precies? Ik snap niet helemaal wat je bedoelt eigenlijk. Kun je een voorbeeld geven?

Je kan die uitbreidbaarheid ook in meerdere lagen doen. Dan kan je dus een semi-layout tussen de view en de layout doen. (of 8 lager ertussen)

Ik heb laatst dit gemaakt:
<?php
class View extends ContainerAware
{
protected $extend;
protected $extendVars;
protected $helpers;

/**
* @param string $_viewFile The file, .phtml is appended
* @param array $_data The data for the view
* @return string The result
*/
public function render($_viewFile, $_data = array())
{
$this->helpers = $this->container->getSubContainer('view_helper_');

$_path = __DIR__.'/App/views/'.$_viewFile.'.phtml';

if(!file_exists($_path))
throw new InvalidArgumentException(sprintf(
"Viewfile '%s' not found at '%s'",
$_viewFile, $_path
));

extract($_data);
ob_start();
require_once $_path;
$content = ob_get_clean();

if(isset($this->extend)) {
$this->extendVars['content'] = $content;
return $this->container->view->render($this->extend, $this->extendVars);
} else
return $content;
}

/**
* Use a parent view. The result of the child view is set
* as the content variable in the parent view.
* @param string $viewFile The parent file, .phtml is appended
* @param array $_data The data for the parent view
*/
protected function extend($viewFile, $data = array())
{
$this->extend = $viewFile;
$this->extendVars = $data;
}

/**
* Include the result of another view
* @param string $_viewFile The file, .phtml is appended
* @param array $_data The data for the view partial
* @return string The result
*/
protected function partial($viewFile, $data = array())
{
return $this->container->view->render($viewFile, $data);
}

/**
* Escape a string for use in HTML
* @param string $string The string
* @return string The escaped result
*/
protected function e($string)
{
return htmlspecialchars($string, ENT_QUOTES);
}
}
?>
Dat kan je dan als volgt gebruiken:
hello.phtml

<?php
$this->extend('layout', array('title'=>'Hi '.$name));
?>
Hello <?php echo $this->e($name); ?>!

layout.phtml

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Site - <?php echo $title ?></title>
    </head>
    <body>
        <?php
            echo $content;
        ?>
    </body>
</html>

Dit geeft met naam 'Pim'
[code]
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Site - Hi Pim</title>
</head>
<body>
Hello Pim!
</body>
</html>

Ah oke, nice...

Stel dat ik nu een formulier script maak dan is het enige waarvoor ik bang ben dat ik straks pagina''s niet meer kan terugvinden omdat die geen eigen view hebben maar worden opgebouw via een view script. Ik zie mezelf al een half uur lang naar een bestand zoeken wat uiteindelijk helemaal niet blijkt te bestaan.

Misschien moet ik dan toch voor iedere formulier pagina een eigen bestand maken, maar daar dan een viewhelper fucntie in maken?

createuser.phtml

<h1>User aanmaken</h1>
<?php $view->generateForm($this->user_data); ?>

Zoiets?

Hoe je met forms omgaat in zo'n framework is vrij ingewikkeld. Heel eenvoudig kan je forms in view partials doen en die dan handmatig in de controller uitlezen. Dan krijg je iets als dit:
view

<?php this->partial('forms/user', array('user'=>$userData)); ?>

controller
[code]
<?php
if($_SERVER['REQUEST_METHOD'] == 'POST') {
$validator = $this->container->validator;
try {
// validate($string, $method)
$validator->validate($_POST['email'], 'email');
$validator->validate($_POST['username'], 'username');
$validator->validate($_POST['password'], 'password');

$user = new User;
$user->setName($_POST['name']);
$user->setEmail($_POST['email']);
$user->setPassword($_POST['password']);

$user->save();
} catch(ValidationException $e) {
// Doe er iets leuks mee
}
}
?>
Maar dit wordt erg ingewikkeld. Mooier zijn dingen als:
<?php
if($_SERVER['REQUEST_METHOD'] == 'POST') {
$form = $this->container->form->get('user');
// Geef de post informatie aan het form
$form->setData($_POST);
if($form->validate()) {
// Vul het user object in
$user = $form->populate(new User);
$user->save();
} else {
$this->view->form = $form->render(); // Ingevuld
}
}
?>
Maar dat zit een stuk ingewikkelder in elkaar. Je krijgt dan een form klasse die aan de hand van een configuratie bestand weet hoe een formulier eruit moet zien, hoe hij ingevuld wordt, hoe hij gecontrolleerd wordt en hoe die gegevens dan in een user object moeten worden gestopt.

Maar als je dat eenmaal hebt, dan heb je ook wat ;)