<?php

/*

* This file is part of the PablodipModuleBundle package.

*

* (c) Pablo Díez <pablodip@gmail.com>

*

* For the full copyright and license information, please view the LICENSE

* file that was distributed with this source code.

*/

namespace Pablodip\ModuleBundle\Module;

use Symfony\Component\DependencyInjection\ContainerInterface;

use Pablodip\ModuleBundle\Action\ActionInterface;

use Pablodip\ModuleBundle\Action\RouteActionInterface;

use Pablodip\ModuleBundle\Action\ActionCollectionInterface;

use Pablodip\ModuleBundle\Extension\ExtensionInterface;

/**

* Module.

*

* @author Pablo Díez <pablodip@gmail.com>

*/

abstract class Module implements ModuleInterface

{

private $container;

private $extensions;

private $routeNamePrefix;

private $routePatternPrefix;

private $parametersToPropagate;

private $options;

private $actions;

private $controllerPreExecutes;

/**

* Constructor.

*

* @param ContainerInterface $container A container.

*/

public function __construct(ContainerInterface $container)

{

$this->container = $container;

$this->extensions = array();

$this->routeNamePrefix = '';

$this->routePatternPrefix = '';

$this->parametersToPropagate = array();

$this->options = array();

$this->actions = array();

$this->controllerPreExecutes = array();

// register extensions

foreach ($this->registerExtensions() as $extension) {

if (!$extension instanceof ExtensionInterface) {

throw new \LogicException('The extensions must be an instance of ExtensionInterface.');

}

$name = $extension->getName();

if (isset($this->extensions[$name])) {

throw new \LogicException(sprintf('Trying to register two extensions with the same name: "%s".', $name));

}

$extension->setModule($this);

$this->extensions[$name] = $extension;

}

// define configuration

foreach ($this->extensions as $extension) {

$extension->defineConfiguration();

}

$this->defineConfiguration();

// configure

foreach ($this->extensions as $extension) {

$extension->configure();

}

$this->configure();

// parse configuration

foreach ($this->extensions as $extension) {

$extension->parseConfiguration();

}

$this->parseConfiguration();

}

/**

* Here you should register the extensions.

*

* Be aware to continue registering the parent extensions.

*/

protected function registerExtensions()

{

return array();

}

/**

* Here is where you should define your configuration.

*

* Defining configuration is add options, actions, parameters to propagate.

* These things can be modified later in the configure method by other users

* in reusable modules.

*/

abstract protected function defineConfiguration();

/**

* Here is where users can configure reusable modules.

*/

protected function configure()

{

}

/**

* Here is where you should check and/or parse the configuration for reusable modules.

*

* This is mostly for checking and parsing option values.

*/

protected function parseConfiguration()

{

}

/**

* {@inheritdoc}

*/

public function getContainer()

{

return $this->container;

}

/**

* {@inheritdoc}

*/

public function getExtension($name)

{

if (!isset($this->extensions[$name])) {

throw new \InvalidArgumentException(sprintf('The extension "%s" does not exist.', $name));

}

return $this->extensions[$name];

}

/**

* {@inheritdoc}

*/

public function getExtensions()

{

return $this->extensions;

}

/**

* Sets the route name prefix.

*

* @param string $routeNamePrefix The route name prefix.

*

* @return Module The module (fluent interface).

*/

public function setRouteNamePrefix($routeNamePrefix)

{

$this->routeNamePrefix = $routeNamePrefix;

return $this;

}

/**

* {@inheritdoc}

*/

public function getRouteNamePrefix()

{

return $this->routeNamePrefix;

}

/**

* Sets the route pattern prefix.

*

* @param string $routePatternPrefix The route pattern preffix.

*

* @return ModuleInterface The module (fluent interface).

*/

public function setRoutePatternPrefix($routePatternPrefix)

{

$this->routePatternPrefix = $routePatternPrefix;

return $this;

}

/**

* {@inheritdoc}

*/

public function getRoutePatternPrefix()

{

return $this->routePatternPrefix;

}

/**

* Sets the route name and pattern prefixes.

*

* @param string $routeNamePrefix The route name prefix.

* @param string $routePatternPrefix The route pattern prefix.

*

* @return ModuleInterface The module (fluent interface).

*/

public function setRoutePrefixes($routeNamePrefix, $routePatternPrefix)

{

$this->setRouteNamePrefix($routeNamePrefix);

$this->setRoutePatternPrefix($routePatternPrefix);

return $this;

}

/**

* Adds a parameter to propagate.

*

* @param string $parameter The parameter.

*

* @return ModuleInterface The module (fluent interface).

*/

public function addParameterToPropagate($parameter)

{

$this->parametersToPropagate[] = $parameter;

return $this;

}

/**

* Adds parameters to propagate.

*

* @param array $parameters The parameters.

*

* @return ModuleInterface The module (fluent interface).

*/

public function addParametersToPropagate(array $parameters)

{

foreach ($parameters as $parameter) {

$this->addParameterToPropagate($parameter);

}

return $this;

}

/**

* Sets the parameters to propagate.

*

* @param array $parameters The parameters.

*

* @return ModuleInterface The module (fluent interface).

*/

public function setParametersToPropagate(array $parameters)

{

$this->parametersToPropagate = array();

$this->addParametersToPropagate($parameters);

return $this;

}

/**

* {@inheritdoc}

*/

public function getParametersToPropagate()

{

return $this->parametersToPropagate;

}

/**

* Adds an option.

*

* @param string $name The name.

* @param mixed $defaultValue The default value.

*

* @return ModuleInterface The module (fluent interface).

*

* @throws \LogicException If the option already exists.

*/

public function addOption($name, $defaultValue)

{

if ($this->hasOption($name)) {

throw new \LogicException(sprintf('The option "%s" already exists.', $name));

}

$this->options[$name] = $defaultValue;

return $this;

}

/**

* Adds options.

*

* @param array $options The options as an array (the name as the key and the default value as the value).

*

* @return ModuleInterface The module (fluent interface).

*/

public function addOptions(array $options)

{

foreach ($options as $name => $defaultValue) {

$this->addOption($name, $defaultValue);

}

return $this;

}

/**

* Sets an option.

*

* @param string $name The name.

* @param mixed $value The value.

*

* @return ModuleInterface The module (fluent interface).

*

* @throws \InvalidArgumentException If the option does not exist.

*/

public function setOption($name, $value)

{

if (!$this->hasOption($name)) {

throw new \InvalidArgumentException(sprintf('The option "%s" does not exist.', $name));

}

$this->options[$name] = $value;

return $this;

}

/**

* {@inheritdoc}

*/

public function hasOption($name)

{

return array_key_exists($name, $this->options);

}

/**

* {@inheritdoc}

*/

public function getOption($name)

{

if (!$this->hasOption($name)) {

throw new \InvalidArgumentException(sprintf('The option "%s" does not exist.', $name));

}

return $this->options[$name];

}

/**

* {@inheritdoc}

*/

public function getOptions()

{

return $this->options;

}

/**

* Adds an action.

*

* @param ActionInterface $action An action.

*

* @return ModuleInterface The module (fluent interface).

*

* @throws \InvalidArgumentException If the action already exists.

*/

public function addAction(ActionInterface $action)

{

if (isset($this->actions[$action->getName()])) {

throw new \InvalidArgumentException(sprintf('The action "%s" already exists.', $action->getName()));

}

$action->setModule($this);

$this->actions[$action->getName()] = $action;

return $this;

}

/**

* Adds actions.

*

* @param array $actions An array of actions.

*

* @return ModuleInterface The module (fluent interface).

*/

public function addActions(array $actions)

{

foreach ($actions as $action) {

$this->addAction($action);

}

return $this;

}

/**

* {@inheritdoc}

*/

public function hasAction($name)

{

return isset($this->actions[$name]);

}

/**

* {@inheritdoc}

*/

public function getAction($name)

{

if (!isset($this->actions[$name])) {

throw new \InvalidArgumentException(sprintf('The action "%s" does not exist.', $name));

}

return $this->actions[$name];

}

/**

* {@inheritdoc}

*/

public function deleteAction($name)

{

if (!isset($this->actions[$name])) {

throw new \InvalidArgumentException(sprintf('The action "%s" does not exist.', $name));

}

unset($this->actions[$name]);

}

/**

* {@inheritdoc}

*/

public function getActions()

{

return $this->actions;

}

/**

* {@inheritdoc}

*/

public function getRouteActions()

{

$routeActions = array();

foreach ($this->actions as $name => $action) {

if ($action instanceof RouteActionInterface) {

$routeActions[$name] = $action;

}

}

return $routeActions;

}

/**

* Shortcut for setting options to actions.

*

* @param string $actionName The action name.

* @param string $optionName The option name.

* @param mixed $optionValue The option value.

*

* @return ModuleInterface The module (fluent interface).

*/

public function setActionOption($actionName, $optionName, $optionValue)

{

$this->getAction($actionName)->setOption($optionName, $optionValue);

return $this;

}

/**

* Adds a controller pre execute.

*

* @param mixed $controllerPreExecute A callable.

*

* @return ModuleInterface The module (fluent interface).

*/

public function addControllerPreExecute($controllerPreExecute)

{

if (!is_callable($controllerPreExecute)) {

throw new \InvalidArgumentException('The controller pre execute is not callable.');

}

$this->controllerPreExecutes[] = $controllerPreExecute;

return $this;

}

/**

* {@inheritdoc}

*/

public function getControllerPreExecutes()

{

return $this->controllerPreExecutes;

}

/**

* {@inheritdoc}

*/

public function generateModuleUrl($actionName, array $parameters = array(), $absolute = false)

{

$routeName = $this->getRouteNamePrefix().$this->getAction($actionName)->getRouteName();

if ($this->parametersToPropagate) {

$request = $this->container->get('request');

foreach ($this->parametersToPropagate as $parameter) {

if (!isset($parameters[$parameter]) && $value = $request->get($parameter)) {

$parameters[$parameter] = $value;

}

}

}

return $this->container->get('router')->generate($routeName, $parameters, $absolute);

}

/**

* {@inheritdoc}

*/

public function forward($actionName, array $attributes = array(), array $query = array())

{

$controller = 'PablodipModuleBundle:Module:execute';

$attributes['_module.module'] = get_class($this);

$attributes['_module.action'] = $actionName;

return $this->container->get('http_kernel')->forward($controller, $attributes, $query);

}

/**

* {@inheritdoc}

*/

public function createView()

{

return new ModuleView($this);

}

}