How to render Twig template from database in symfony2

Question

I'm working on application written in symfony2 and I want to send email after some action/event... the problem is, that the users can define something like "email templates" which are stores in db like simple string, for example: "This is some email from {{ user }}" and I need to render body for that email which should use that template...

In symfony documentation from this link: https://symfony.com/doc/2.0/cookbook/email/email.html#sending-emails the method for render view is $this->renderView and it expects the path to file such as "bundle:controller:file.html.twig", but my template is simple string from database...

How can I render it?

$this->renderView() is supposed to return a simple string. Have you tried return "some_string", instead of return $this->renderView(), just to see what happens? — greg0ire
you should have a look at this bundle github.com/Remixjobs/RjEmailBundle, which handle exactly what you want. — jeremymarc
Things have changed, since 2011. For anyone bumping on this question now - please read relevant recipes from Twig documentation: twig.sensiolabs.org/doc/… twig.sensiolabs.org/doc/… — Luigi

Clamburger Clamburger · Accepted Answer · 2018-09-18T13:22:37

Here's a solution that works with Symfony 4 (and possibly older versions as well, although I haven't tested it) and allows you to work with templates stored in the database the same way you would work with templates in the filesystem.

This answer assumes you're using Doctrine, but is relatively easy to adapt if you're using another database library.

Create the Template entity

This is an example class that uses annotations, but you can use whatever configuration method you're already using.

src/Entity/Template.php

<?php
namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Table(name="templates")
 * @ORM\Entity
 */
class Template
{
    /**
     * @var int
     *
     * @ORM\Column(name="id", type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="IDENTITY")
     */
    private $id;

    /**
     * @var string
     *
     * @ORM\Column(type="string", nullable=false)
     */
    private $filename;

    /**
     * @var string
     *
     * @ORM\Column(type="text", nullable=false)
     */
    private $source;

    /**
     * @var \DateTime
     *
     * @ORM\Column(type="datetime", nullable=false)
     */
    private $last_updated;
}

The bare minimum fields are filename and source, but it's a very good idea to include last_updated or you'll lose the benefits of caching.

Create a DatabaseLoader class

src/Twig/Loader/DatabaseLoader.php

<?php
namespace App\Twig\Loader;

use App\Entity\Template;
use Doctrine\ORM\EntityManagerInterface;
use Twig_Error_Loader;
use Twig_LoaderInterface;
use Twig_Source;

class DatabaseLoader implements Twig_LoaderInterface
{
    protected $repo;

    public function __construct(EntityManagerInterface $em)
    {
        $this->repo = $em->getRepository(Template::class);
    }

    public function getSourceContext($name)
    {
        if (false === $template = $this->getTemplate($name)) {
            throw new Twig_Error_Loader(sprintf('Template "%s" does not exist.', $name));
        }

        return new Twig_Source($template->getSource(), $name);
    }

    public function exists($name)
    {
        return (bool)$this->getTemplate($name);
    }

    public function getCacheKey($name)
    {
        return $name;
    }

    public function isFresh($name, $time)
    {
        if (false === $template = $this->getTemplate($name)) {
            return false;
        }

        return $template->getLastUpdated()->getTimestamp() <= $time;
    }

    /**
     * @param $name
     * @return Template|null
     */
    protected function getTemplate($name)
    {
        return $this->repo->findOneBy(['filename' => $name]);  
    }
}

The class is relatively simple. getTemplate looks up the template filename from the database, and the rest of the methods use getTemplate to implement the interface that Twig needs.

Add the DatabaseLoader to your service config

config/services.yaml

services:
    App\Twig\Loader\DatabaseLoader:
        tags:
        - { name: twig.loader }

Now you can use your database templates in the same way as filesystem templates.

Rendering from a controller:

return $this->render('home.html.twig');

Including from another Twig template (which can be in the database or filesystem):

{{ include('welcome.html.twig') }}

Rendering to a string (where $twig is an instance of Twig\Environment)

$html = $twig->render('email.html.twig')

In each of these cases, Twig will check the database first. If getTemplate in your DatabaseLoader returns null, Twig will then check the filesystem. If the template isn't available in the database or the filesystem, Twig will throw a Twig_Error_Loader.

How to render Twig template from database in symfony2

11 Answers

Create the Template entity

Create a DatabaseLoader class

Add the DatabaseLoader to your service config

From a controller:

From a twig template: