Writing a new controller

This is a quickstart guide to creating a new controller using the "Getting things done" package of Mouf. For a more complete documentation, read the Writing controllers documentation page from the Splash MVC framework.

Writing controllers is a 5 step processes summarized below:

• Create your controller class
• Create one or many views
• Purge the code cache
• Create the controller instance
• Purge the URL's cache

Create the controller class

Below is a sample class you can use as a model. It includes what you will most likely need:

• a template
• a logger
• an access to the TDBM factory (to access database)

The code below goes into the src/Test/Controllers/MyController.php file. It is important to respect that naming convention, as it is used by the class autoloader. If it seems strange to you, have a look at the PSR-0, and at the Composer autoload documentation.

<?php  
namespace Test\Controllers;

use Mouf\Mvc\Splash\Annotations\URL;
use Mouf\Html\Template\TemplateInterface;
use Mouf\Html\HtmlElement\HtmlBlock;
use Psr\Log\LoggerInterface;
use \Twig_Environment;
use Mouf\Html\Renderer\Twig\TwigTemplate;
use Mouf\Mvc\Splash\HtmlResponse;
use Zend\Diactoros\Response\JsonResponse;

class MyController {

    /**
     * The logger used by this controller.
     * @var LoggerInterface
     */
    private $logger;

    /**
     * The template used by this controller.
     * @var TemplateInterface
     */
    private $template;

    /**
     * The main content block of the page.
     * @var HtmlBlock
     */
    private $content;

    /**
     * The Twig environment (used to render Twig templates).
     * @var Twig_Environment
     */
    private $twig;

    /**
     * Controller's constructor.
     * @param LoggerInterface $logger The logger
     * @param TemplateInterface $template The template used by this controller
     * @param HtmlBlock $content The main content block of the page
     * @param Twig_Environment $twig The Twig environment (used to render Twig templates)
     */
    public function __construct(LoggerInterface $logger, TemplateInterface $template, HtmlBlock $content, Twig_Environment $twig) {
        $this->logger = $logger;
        $this->template = $template;
        $this->content = $content;
        $this->twig = $twig;
    }

    /**
     * This method will be called when we access the /helloworld URL.*
     * It accepts an optional "echo" parameter.
     * 
     * @URL("/helloworld")
     */
    public function helloworld($echo = '') {
        // Typical code to access database goes here.

        // We declare the view, and bind it to the "content" block.
        // The view is declared in a Twig file.
        // Let's add the twig file to the template.
        $this->content->addHtmlElement(new TwigTemplate($this->twig, 'views/myview.twig', ["echo"=>$echo]));

        // Finally, we draw the template.
        return new HtmlResponse($this->template);
    }

    /**
     * Just echoing some text will output the text directly.
     * This is useful for Ajax calls.
     * 
     * @URL("/helloworld_ajax")
     */
    public function helloworld2() {
        return new JsonResponse(array('hello'=>'world'));
    }
}

Note: there is absolutely no need to put your class in a "Controllers" namespace. You can put your class in whatever namespace you want, as long as Composer is aware of the top level namespace (aka the vendor-name).

Create a view

In this sample, we are loading a view named myview.twig. Let's write this file:

<h1>Hello world!</h1>
<p>echo: {{ echo }}</p>

This Twig file will be rendered in the view. If you are not used to Twig, you should check Twig documentation. Twig is a great templating engine for PHP. We recommend using it by default (you can of course use any templating engine you like).

Purge code cache

Enough coding! We now have some configuration to do. The first step is to connect to Mouf UI, and purge the code cache. You should know the URL to Mouf now: http://[your-server]/[your-app]/vendor/mouf/mouf/

When you are logged, click the "Purge code cache" button.

We need to purge the code cache to be sure Mouf will rescan the filesystem and find our new class.

Declare the new instance

Click the "Instances > Create instance" menu.

Now, you need to select the "MyController" class, and give a name to your instance. By convention, we name the instance as the class, except put the name in camelCase. This is because an instance is quite similar to a variable name.