AbstractLoader.php

<?php
namespace Cygnus\CoreBundle\Loader;

use Symfony\Component\HttpFoundation\RequestStack;
use Cygnus\CMSBundle\API\Resource\AccountResource;
use Symfony\Component\HttpKernel\Event\GetResponseEvent;

/**
 * Creates a Doctrine connection from predefined attributes
 */
abstract class AbstractLoader
{
    const CACHE_EXPIRATION = 86400;
    protected $request;
    protected $cacheClient;
    protected $container;

    public function setRequest(RequestStack $request)
    {
        $this->request = $request->getCurrentRequest();
        return $this;
    }

    public function setCacheClient($cacheClient)
    {
        $this->cacheClient = $cacheClient;
        return $this;
    }

    public function setContainer($container)
    {
        $this->container = $container;
        return $this;
    }

    abstract public function onKernelRequest(GetResponseEvent $event);
}

AccountLoader.php

<?php
namespace Cygnus\CoreBundle\Loader;

use Symfony\Component\HttpFoundation\RequestStack;
use Cygnus\CMSBundle\API\Resource\AccountResource;
use Symfony\Component\HttpKernel\Event\GetResponseEvent;

/**
 * Creates a Doctrine connection from predefined attributes
 */
class AccountLoader extends AbstractLoader
{
    private $accountResource;

    public function setAccountResource(AccountResource $accountResource)
    {
        $this->accountResource = $accountResource;
        return $this;
    }

    public function setAccountKey($accountKey)
    {
        $this->accountKey = $accountKey;
        return $this;
    }

    public function onKernelRequest(GetResponseEvent $event)
    {
        $this->getAccount();
    }

    public function getAccount()
    {
        // Attempt to retrieve the cached Site object
        $cacheKey = sprintf('Base3:AccountLoader:%s', $this->accountKey);
        $account = $this->cacheClient->get($cacheKey);

        if (!$account) {
            // Site not found in cache. Load from database
            $account = $this->accountResource->findOneByShortName($this->accountKey);

            // Set to cache
            $this->cacheClient->setex($cacheKey, self::CACHE_EXPIRATION, serialize($account));
        } else {
            // Unserialize the cached account
            $account = unserialize($account);
        }

        // Set the account to the Request attributes
        $this->request->attributes->set('account', $account);
    }
}

AccountResource.php

<?php
namespace Cygnus\CMSBundle\API\Resource;

class AccountResource extends AbstractDocumentResource
{

    /**
     * The root Site document class name
     *
     */
    const ROOT_DOCUMENT = '\\Cygnus\\CoreBundle\\Document\\Account';

    /**
     * Returns the fully-qualified class name (FQCN) of Site Documents
     * All CRUD methods depend on this for proper operation
     *
     * @param    string|null $endpoint The Document class name endpoint
     * @return   string The FQCN for Site
     */
    public function getDocumentClass($endpoint = null)
    {
        if (is_null($endpoint)) {
            return static::ROOT_DOCUMENT;
        }
        return sprintf('%s\%s', static::ROOT_DOCUMENT, ltrim($endpoint, '\\'));
    }

    /**
     * Ensures Site identifiers are MongoIds
     * Overloads parent method
     *
     * @param    mixed $id
     * @return   object Site document
     */
    protected function findOneById($id)
    {
        $id = $this->getMongoId($id);
        return parent::findOneById($id);
    }
}

GroupLoader.php

<?php
namespace Cygnus\CoreBundle\Loader;

use Symfony\Component\HttpFoundation\RequestStack;
use Cygnus\CMSBundle\API\Resource\SiteResource;
use Cygnus\CMSBundle\SearchServices\ContentFilterBuilder;
use Symfony\Component\HttpKernel\Event\GetResponseEvent;
use Cygnus\CoreBundle\Document\Site as SiteDocument;
use Liip\ThemeBundle\ActiveTheme;
use \InvalidArgumentException;

/**
 * Creates a Doctrine connection from attributes in the Request
 */
class GroupLoader extends AbstractLoader
{
    private $siteResource;

    public function setSiteResource(SiteResource $siteResource)
    {
        $this->siteResource = $siteResource;
        return $this;
    }

    public function setActiveTheme(ActiveTheme $activeTheme)
    {
        $this->activeTheme = $activeTheme;
        return $this;
    }

    public function onKernelRequest(GetResponseEvent $event)
    {
        $this->getGroup();
    }

    public function getGroup()
    {
        // Load account chain for sub-requests?
        if (!$this->request->attributes->has('account')) {
            $this->container->get('cygnus.loader.account')->getAccount();
            if (!$this->request->attributes->has('account')) {
                throw new \Exception('No valid account loaded.');
            }
        }

        // Determine default site?

        if (!$this->request->attributes->has('site') || $this->request->attributes->has('siteObject')) {
            return $this->request->attributes->has('siteObject');
        }

        $site = $this->request->attributes->get('site');

        // Attempt to retrieve the cached Site object
        $cacheKey = sprintf('Base3:SiteLoader:%s', $site);
        $site = $this->cacheClient->get($cacheKey);

        if (!$site) {
            // Site not found in cache. Load from database
            $site = $this->siteResource->findOneByDomain($site);

            // Set to cache
            $this->cacheClient->setex($cacheKey, self::CACHE_EXPIRATION, serialize($site));
        } else {
            // Unserialize the cached site
            $site = unserialize($site);
        }

        // Set the site to the Request attributes
        $this->request->attributes->set('siteObject', $site);

        return $site;
    }
}

services.yml

    # Account Loader
    cygnus.loader.account:
        class: Cygnus\CoreBundle\Loader\AccountLoader
        calls:
         - [ setContainer, [@service_container]]
         - [ setRequest, [@request_stack]]
         - [ setCacheClient, [@snc_redis.default]]
         - [ setAccountResource, [@cygnus.api.account_resource]]
         - [ setAccountKey, [%account_key%]]
        scope: request
        tags:
         - { name: kernel.event_listener, event: kernel.request, method: onKernelRequest, priority: 128 }

    # Group Loader
    cygnus.loader.group:
        class: Cygnus\CoreBundle\Loader\GroupLoader
        calls:
         - [ setContainer, [@service_container]]
         - [ setRequest, [@request_stack]]
         - [ setCacheClient, [@snc_redis.default]]
         - [ setSiteResource, [@cygnus.api.site_resource]]
        scope: request
        tags:
         - { name: kernel.event_listener, event: kernel.request, method: onKernelRequest, priority: 127 }

    # Product Loader
    cygnus.loader.product:
        class: Cygnus\CoreBundle\Loader\ProductLoader
        calls:
         - [ setContainer, [@service_container]]
         - [ setRequest, [@request_stack]]
         - [ setCacheClient, [@snc_redis.default]]
         - [ setProductResource, [@cygnus.api.product_resource]]
         # - [ setFilterBuilder, [@cygnus.search_services.filter_builder.content]]
        scope: request
        tags:
         - { name: kernel.event_listener, event: kernel.request, method: onKernelRequest, priority: 126 }

    # Theme Loader
    cygnus.loader.theme:
        class: Cygnus\CoreBundle\Loader\ThemeLoader
        calls:
         - [ setContainer, [@service_container]]
         - [ setRequest, [@request_stack]]
         - [ setCacheClient, [@snc_redis.default]]
         - [ setActiveTheme, [@liip_theme.active_theme]]
        scope: request
        tags:
         - { name: kernel.event_listener, event: kernel.request, method: onKernelRequest, priority: 125 }