Custom Validators on Validation Groups in Symfony2.

If you are using validation groups and have created a custom validator, you will want to use it in your validation group, however its a bit different from how you would apply validators in the entity, and quite similar in-fact to how you define services.

Its similar to how you define services because you have 2 root nodes, first somewhat like services.yml’s parameters line, in this instance called ‘namespaces’, the second part matches the entities name which the validator will be applied to.

Starting out, your validator.yml file probably looks like this:

CCDNComponent\AttachmentBundle\Entity\Attachment:
    properties:
        description: 
            - Type: { type: string, groups: [upload] }
            - MaxLength: { limit: 1000, groups: [upload] }
        attachment:
            - NotNull: { groups: [upload] }
            - File: { groups: [upload] }

CCDNComponent\AttachmentBundle\Entity\Attachment:

properties:

description:

- Type: { type: string, groups: [upload] }

- MaxLength: { limit: 1000, groups: [upload] }

attachment:

- NotNull: { groups: [upload] }

- File: { groups: [upload] }

This is an example taken from my AttachmentBundle, which you can find here.

Now, when we have a custom validator, in this case, some validators to check a users quota on file uploads etc, we need to set a namespace for our custom validators, with the namespace parameter, and then reference that namespace below followed by our custom validator.

namespaces:
    CCDNComponentAttachmentBundle: CCDNComponent\AttachmentBundle\Form\Validator\Constraints\

CCDNComponent\AttachmentBundle\Entity\Attachment:
    properties:
        description: 
            - Type: { type: string, groups: [upload] }
            - MaxLength: { limit: 1000, groups: [upload] }
        attachment:
            - NotNull: { groups: [upload] }
            - File: { groups: [upload] }
            - "CCDNComponentAttachmentBundle:UploadQuotaFileSize": { groups: [upload] }
            - "CCDNComponentAttachmentBundle:UploadQuotaDiskSpace": { groups: [upload] }
            - "CCDNComponentAttachmentBundle:UploadQuotaFileQuantity": { groups: [upload] }

namespaces:

CCDNComponentAttachmentBundle: CCDNComponent\AttachmentBundle\Form\Validator\Constraints\

CCDNComponent\AttachmentBundle\Entity\Attachment:

properties:

description:

- Type: { type: string, groups: [upload] }

- MaxLength: { limit: 1000, groups: [upload] }

attachment:

- NotNull: { groups: [upload] }

- File: { groups: [upload] }

- "CCDNComponentAttachmentBundle:UploadQuotaFileSize": { groups: [upload] }

- "CCDNComponentAttachmentBundle:UploadQuotaDiskSpace": { groups: [upload] }

- "CCDNComponentAttachmentBundle:UploadQuotaFileQuantity": { groups: [upload] }

The name of the validator must be wrapped in double quotes so that Symfony2 is aware that this is using a custom validator, inside of which we first start the namespace, and secondly the validator alias.

We define the alias of our validator in our services.yml like so:

Parameters:
    ccdn_component_attachment.validator.upload_quota_disk_space.class:      CCDNComponent\AttachmentBundle\Form\Validator\UploadQuotaDiskSpaceValidator
    ccdn_component_attachment.validator.upload_quota_file_quantity.class:   CCDNComponent\AttachmentBundle\Form\Validator\UploadQuotaFileQuantityValidator
    ccdn_component_attachment.validator.upload_quota_file_size.class:       CCDNComponent\AttachmentBundle\Form\Validator\UploadQuotaFileSizeValidator

Services:
    ccdn_component_attachment.validator.upload_quota_disk_space:
        class: %ccdn_component_attachment.validator.upload_quota_disk_space.class%
        arguments: [@doctrine, @service_container]
        tags:
            - { name: validator.constraint_validator, alias: upload_quota_disk_space }
    ccdn_component_attachment.validator.upload_quota_file_quantity:
        class: %ccdn_component_attachment.validator.upload_quota_file_quantity.class%
        arguments: [@doctrine, @service_container]
        tags:
            - { name: validator.constraint_validator, alias: upload_quota_file_quantity }
    ccdn_component_attachment.validator.upload_quota_file_size:
        class: %ccdn_component_attachment.validator.upload_quota_file_size.class%
        arguments: [@doctrine, @service_container]
        tags:
            - { name: validator.constraint_validator, alias: upload_quota_file_size }

Parameters:

ccdn_component_attachment.validator.upload_quota_disk_space.class: CCDNComponent\AttachmentBundle\Form\Validator\UploadQuotaDiskSpaceValidator

ccdn_component_attachment.validator.upload_quota_file_quantity.class: CCDNComponent\AttachmentBundle\Form\Validator\UploadQuotaFileQuantityValidator

ccdn_component_attachment.validator.upload_quota_file_size.class: CCDNComponent\AttachmentBundle\Form\Validator\UploadQuotaFileSizeValidator

Services:

ccdn_component_attachment.validator.upload_quota_disk_space:

arguments: [@doctrine, @service_container]

tags:

- { name: validator.constraint_validator, alias: upload_quota_disk_space }

ccdn_component_attachment.validator.upload_quota_file_quantity:

arguments: [@doctrine, @service_container]

tags:

- { name: validator.constraint_validator, alias: upload_quota_file_quantity }

ccdn_component_attachment.validator.upload_quota_file_size:

arguments: [@doctrine, @service_container]

tags:

- { name: validator.constraint_validator, alias: upload_quota_file_size }

Symfony2 Voter Access Decision Strategy Explained!

The voter access decision strategy can be set in your Symfony2 app/config/security.yml. You have the choice of 3 approaches (Unanimous, Affirmative, Consensus). Set your strategy to 1 of them 3.

# app/config/security.yml
security:
    access_decision_manager: unanimous
    # Strategy can be: affirmative, unanimous or consensus strategy: unanimous

# app/config/security.yml

security:

access_decision_manager: unanimous

# Strategy can be: affirmative, unanimous or consensus strategy: unanimous

The approach of each is explained below.

Unanimous = 1 single voter denies access.
Affirmative = 1 single voter grants access.
Consensus = Majority wins.

So in Unanimous, if a single voter denies access, all other voters decisions are overridden and the bottom line is you will be denied access. If however you use Affirmative, a single voter only needs to grant access to override and the regardless of how many voters block you, you will always be granted access so long as a single voter permits it. Consensus, lastly; will weigh up and balance the number of denies or accesses being granted and decide that with the most voters wins. To put the Consensus another way, if more than half the voters grant access, then you have access. If more than half the voters deny access, then access will be denied.

Remember to return 1 of the 3 access types, the choices you have are:

return VoterInterface::ACCESS_GRANTED;

return VoterInterface::ACCESS_ABSTAIN;

return VoterInterface::ACCESS_DENIED;

return VoterInterface::ACCESS_GRANTED;

return VoterInterface::ACCESS_ABSTAIN;

return VoterInterface::ACCESS_DENIED;

Abstain will be impartial when using the consensus strategy for your security configuration.

You can set your class to be used, and listened for by the voting service in your bundles config, like so:

# YourNamespace\YourBundle\Resources\config\services.yml
ccdn_user_security.authorisation.voter:
    class: %ccdn_user_security.authorisation.voter.class%
    arguments: [@service_container, []]
    public: false
    tags:
        - { name: security.voter }

# YourNamespace\YourBundle\Resources\config\services.yml

ccdn_user_security.authorisation.voter:

arguments: [@service_container, []]

public: false

tags:

- { name: security.voter }

Authorisation on Roles in Symfony2

Following a discussion on the IRC room from someone who viewed my post about login/logout handlers in SF2, i wanted to clarify that when dealing with Roles, they should be dealt with in the controller actions.

For off, you need to make sure you got the right hierarchy of roles. In your app/config/security.yml you need something following the structure of:

security:
    role_hierarchy:
        ROLE_USER:          ROLE_USER
        ROLE_MODERATOR:     [ROLE_USER]
        ROLE_ADMIN:         [ROLE_USER, ROLE_MODERATOR]
        ROLE_SUPER_ADMIN:   [ROLE_USER, ROLE_MODERATOR, ROLE_ADMIN]

security:

role_hierarchy:

ROLE_USER: ROLE_USER

ROLE_MODERATOR: [ROLE_USER]

ROLE_ADMIN: [ROLE_USER, ROLE_MODERATOR]

ROLE_SUPER_ADMIN: [ROLE_USER, ROLE_MODERATOR, ROLE_ADMIN]

Where the lowest level of access is at the top and the higher levels of access envelope the last levels of access.

Then you inside your controller actions you would do:

class fooController
{
	public function showAction()
	{
		if ( ! $this->container->get('security.context')->isGranted('ROLE_USER')) {
			throw new AccessDeniedException('You do not have permission to use this resource!');
		}
	}
}

class fooController

{

public function showAction()

{

if ( ! $this->container->get('security.context')->isGranted('ROLE_USER')) {

throw new AccessDeniedException('You do not have permission to use this resource!');

}

According the order of the role hierarchy if you have the role or higher than specified the controller action will continue, if you have a lower level of access than the minimum required then you will get an AccessDeniedException.

Redirecting on login/logout in Symfony2 using LoginHandlers.

Using login handlers or even logout handlers, we can do a number of last minute things before the user is redirected to where they need to go. Being able to intercept the redirect at the last minute and make the user get redirected elsewhere is relatively simple.

Firstly though, i notice a lot of people now who are using Symfony 2 are cheating somewhat by using an EventListener and registering it with the security.interactive_login event listener. This is not the best way to go about this, namely because this event listener is not intended for this purpose. Sometimes event listeners are not the best way to go because they were defined for a specific purpose other than your intention and using them may have undesirable side effects you may not notice right away. Using handlers however allows a little more flexibility in that in all likelihood regardless of changes to Symfony in future revisions, they should still work and were designed specifically for the purposes we will need them for.

Firstly, we need to define our services, personally, i am a fan of YAML, so i define my services as such but feel free to do the same in XML:

parameters:
    ccdn_user_security.component.authentication.handler.login_failure_handler.class: CCDNUser\SecurityBundle\Component\Authentication\Handler\LoginFailureHandler
    ccdn_user_security.component.authentication.handler.logout_success_handler.class: CCDNUser\SecurityBundle\Component\Authentication\Handler\LogoutSuccessHandler
    
services:
    ccdn_user_security.component.authentication.handler.login_failure_handler:
        class:  %ccdn_user_security.component.authentication.handler.login_failure_handler.class%
        arguments:  [@service_container, @router, @security.context]
        tags:
            - { name: 'monolog.logger', channel: 'security' } 
    ccdn_user_security.component.authentication.handler.logout_success_handler:
        class:  %ccdn_user_security.component.authentication.handler.logout_success_handler.class%
        arguments:  [@service_container, @router]
        tags:
            - { name: 'monolog.logger', channel: 'security' }

parameters:

ccdn_user_security.component.authentication.handler.login_failure_handler.class: CCDNUser\SecurityBundle\Component\Authentication\Handler\LoginFailureHandler

ccdn_user_security.component.authentication.handler.logout_success_handler.class: CCDNUser\SecurityBundle\Component\Authentication\Handler\LogoutSuccessHandler

services:

ccdn_user_security.component.authentication.handler.login_failure_handler:

class: %ccdn_user_security.component.authentication.handler.login_failure_handler.class%

arguments: [@service_container, @router, @security.context]

tags:

- { name: 'monolog.logger', channel: 'security' }

ccdn_user_security.component.authentication.handler.logout_success_handler:

class: %ccdn_user_security.component.authentication.handler.logout_success_handler.class%

arguments: [@service_container, @router]

tags:

- { name: 'monolog.logger', channel: 'security' }

Now our services are defined, we need to define the handlers themselves. I like to create a directory named Services in my user bundle for this purpose, then create 2 files. The first file is LoginSuccessHandler, the second is LogoutSuccessHandler. Our handlers will implement the appropriate interface for either our login or logout handlers, which require usually only one method in these instances.

Here is what the login handler should look like:

<?php

namespace CCDNUser\SecurityBundle\Component\Authentication\Handler;

use Symfony\Component\Security\Http\Authentication\AuthenticationSuccessHandlerInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\SecurityContext;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\Routing\Router;

class LoginSuccessHandler implements AuthenticationSuccessHandlerInterface
{
	
	protected $router;
	protected $security;
	
	public function __construct(Router $router, SecurityContext $security)
	{
		$this->router = $router;
		$this->security = $security;
	}
	
	public function onAuthenticationSuccess(Request $request, TokenInterface $token)
	{
		
		if ($this->security->isGranted('ROLE_SUPER_ADMIN'))
		{
			$response = new RedirectResponse($this->router->generate('category_index'));			
		}
		elseif ($this->security->isGranted('ROLE_ADMIN'))
		{
			$response = new RedirectResponse($this->router->generate('category_index'));
		} 
		elseif ($this->security->isGranted('ROLE_USER'))
		{
			// redirect the user to where they were before the login process begun.
			$referer_url = $request->headers->get('referer');
						
			$response = new RedirectResponse($referer_url);
		}
			
		return $response;
	}
	
}

<?php

namespace CCDNUser\SecurityBundle\Component\Authentication\Handler;

use Symfony\Component\Security\Http\Authentication\AuthenticationSuccessHandlerInterface;

use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;

use Symfony\Component\Security\Core\SecurityContext;

use Symfony\Component\HttpFoundation\Request;

use Symfony\Component\HttpFoundation\RedirectResponse;

use Symfony\Component\Routing\Router;

class LoginSuccessHandler implements AuthenticationSuccessHandlerInterface

{

protected $router;

protected $security;

public function __construct(Router $router, SecurityContext $security)

{

$this->router = $router;

$this->security = $security;

}

public function onAuthenticationSuccess(Request $request, TokenInterface $token)

{

if ($this->security->isGranted('ROLE_SUPER_ADMIN'))

{

$response = new RedirectResponse($this->router->generate('category_index'));

}

elseif ($this->security->isGranted('ROLE_ADMIN'))

{

$response = new RedirectResponse($this->router->generate('category_index'));

}

elseif ($this->security->isGranted('ROLE_USER'))

{

// redirect the user to where they were before the login process begun.

$referer_url = $request->headers->get('referer');

$response = new RedirectResponse($referer_url);

}

return $response;

}

Note my namespace is CCDNUser, and my bundle is called SecurityBundle, so our service is named ccdn_user_security.component.authentication.handler.login_failure_handler. Change this to your own namespace and bundle name accordingly but ensure to use the same format as used here, underscore your namespace and append the bundle name with an additional underscore without the term ‘bundle’ in it. Failure to get this part correct will mean your namespace will not be loaded and you will get problems later on in this tutorial as exceptions will be thrown regarding the service not existing.

Here is what the logout handler should look like:

<?php

namespace CCDNUser\SecurityBundle\Component\Authentication\Handler;

use Symfony\Component\Security\Http\Logout\LogoutSuccessHandlerInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Bundle\FrameworkBundle\Routing\Router;

class LogoutSuccessHandler implements LogoutSuccessHandlerInterface
{
	
	protected $router;
	
	public function __construct(Router $router)
	{
		$this->router = $router;
	}
	
	public function onLogoutSuccess(Request $request)
	{
		// redirect the user to where they were before the login process begun.
		$referer_url = $request->headers->get('referer');
					
		$response = new RedirectResponse($referer_url);		
		return $response;
	}
	
}

<?php

namespace CCDNUser\SecurityBundle\Component\Authentication\Handler;

use Symfony\Component\Security\Http\Logout\LogoutSuccessHandlerInterface;

use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;

use Symfony\Component\HttpFoundation\Request;

use Symfony\Component\HttpFoundation\RedirectResponse;

use Symfony\Bundle\FrameworkBundle\Routing\Router;

class LogoutSuccessHandler implements LogoutSuccessHandlerInterface

{

protected $router;

public function __construct(Router $router)

{

$this->router = $router;

}

public function onLogoutSuccess(Request $request)

{

// redirect the user to where they were before the login process begun.

$referer_url = $request->headers->get('referer');

$response = new RedirectResponse($referer_url);

return $response;

}

Our service definitions inject some of the classes we need to make use of our handlers, namely a Router object and the SecurityContext object, we can store these in member variables for later use. Then we wait for the onAuthenticationSuccess method to be called in our LoginSuccessHandler, once this has happened, we have a request and token interface object at our disposal. Using the security context object we can determine what role they have (i.e; ROLE_USER, ROLE_ADMIN etc) and appropriately redirect them as needed.

I like to redirect members of ROLE_USER role to where they came from prior to logging in. This is achieved by passing the ‘referer’ header into the redirect response object we return. I took this step both in the login and logout handlers.

Last thing we now need to do, is inform our security config that it needs to use these handlers by doing the following:

# App/config/security.yml
security:
    providers:
        fos_userbundle:
            id: fos_user.user_manager

    firewalls:
        main:
            #pattern:    .*
            form_login:
                provider:       fos_userbundle
                login_path:     /login
                use_forward:    false
                check_path:     /login_check
                success_handler: ccdn_user_security.component.authentication.handler.login_success_handler
                failure_path:   null
            logout:
                path:   /logout
                target: /
                success_handler: ccdn_user_security.component.authentication.handler.logout_success_handler
            anonymous:  true

# App/config/security.yml

security:

providers:

fos_userbundle:

id: fos_user.user_manager

firewalls:

main:

#pattern: .*

form_login:

provider: fos_userbundle

login_path: /login

use_forward: false

check_path: /login_check

success_handler: ccdn_user_security.component.authentication.handler.login_success_handler

failure_path: null

logout:

path: /logout

target: /

success_handler: ccdn_user_security.component.authentication.handler.logout_success_handler

anonymous: true

In this instance i am using FOSUserBundle and extending it in my own UserBundle, though this code is contained in the SecurityBundle. Which is probably the best way to do this. As the handlers used here work in any bundle because they plugin to Symfony2 core and implement their login handlers, and should not be dependant on any user bundle.

You can see a complete implementation of this in my security bundle found on github

Once this is implemented your on your way to a better login/logout system. Enjoy.

Creating embedded forms in Symfony 2.0

If you are looking to create a form from 2 or more entities, like i have been then you probably find the documentation somewhat lacking and confusing. If you follow the guides you can get your form working if you start from the least dependant entity making that the first entity you use to build your form from your controller. I find if you start from the most dependant you usually get all manner of errors.

What i have is a basic forum i am working on, in my current form situation i have 3 entities, Board entity, a Thread entity and a Post entity. If you start by creating your form with Board then chances are it won’t work, i created my forms in separate ‘Type’ classes (PostType.php ThreadType.php and BoardType.php) and then created my PostType form in my controller, which then sorts out its dependencies on its own.

My controller class is very basic and not very polished, but here is what it looks like:

// In your controller 
public function createAction($board_id)
{
	$board = $this->getDoctrine()
		->getRepository('CodeConsortiumForumBundle:Board')
		->find($board_id);

	$post = new post();

	$form = $this->createForm(new PostType(), $post);

	$formHandler = new PostFormHandler($form, $this->getRequest(), $post);

	if ($formHandler->process()) 
	{
		$em = $this->get('doctrine')->getEntityManager();
		$em->persist($form->getData());
		$em->flush();

		//return $this->redirect($this->generateUrl('thread_show', array( 'thread_id' => $thread_id ) ));
	}
	else
	{
		return $this->render('CodeConsortiumForumBundle:Thread:create.html.twig', array(
			'board' => $board,
			'form' => $form->createView(),
			));
		}

	}
}

// In your controller

public function createAction($board_id)

{

$board = $this->getDoctrine()

->getRepository('CodeConsortiumForumBundle:Board')

->find($board_id);

$post = new post();

$form = $this->createForm(new PostType(), $post);

$formHandler = new PostFormHandler($form, $this->getRequest(), $post);

if ($formHandler->process())

{

$em = $this->get('doctrine')->getEntityManager();

$em->persist($form->getData());

$em->flush();

//return $this->redirect($this->generateUrl('thread_show', array( 'thread_id' => $thread_id ) ));

}

else

{

return $this->render('CodeConsortiumForumBundle:Thread:create.html.twig', array(

'board' => $board,

'form' => $form->createView(),

));

}

It probably looks somewhat messy as i say, its a rough work in progress, but it works, and here are the FormTypes i used, starting with; PostType.php:

<?php
// CodeConsortium/ForumBundle/Form/Type/PostType.php
namespace CodeConsortium\ForumBundle\Form\Type;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;

class PostType extends AbstractType
{

	private $options;

	public function __construct(array $options = null)
	{
		$this->options = $options;
	}

	public function buildForm(FormBuilder $builder, array $options)
	{
		$builder->add('Thread', new ThreadType($this->options) );
		$builder->add('body');
	}

	// for creating and replying to threads
	public function getDefaultOptions(array $options)
	{
		return array(
			'data_class' => 'CodeConsortium\ForumBundle\Entity\Post',
		);
	}

	public function getName()
	{
		return 'Post';
	}

}

<?php

// CodeConsortium/ForumBundle/Form/Type/PostType.php

namespace CodeConsortium\ForumBundle\Form\Type;

use Symfony\Component\Form\AbstractType;

use Symfony\Component\Form\FormBuilder;

class PostType extends AbstractType

{

private $options;

public function __construct(array $options = null)

{

$this->options = $options;

}

public function buildForm(FormBuilder $builder, array $options)

{

$builder->add('Thread', new ThreadType($this->options) );

$builder->add('body');

}

// for creating and replying to threads

public function getDefaultOptions(array $options)

{

return array(

'data_class' => 'CodeConsortium\ForumBundle\Entity\Post',

);

}

public function getName()

{

return 'Post';

}

ThreadType.php

<?php
// CodeConsortium/ForumBundle/Form/Type/PostType.php
namespace CodeConsortium\ForumBundle\Form\Type;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;

class PostType extends AbstractType
{

	private $options;

	public function __construct(array $options = null)
	{
		$this->options = $options;
	}

	public function buildForm(FormBuilder $builder, array $options)
	{
		$builder->add('Thread', new ThreadType($this->options) );
		$builder->add('body');
	}

	// for creating and replying to threads
	public function getDefaultOptions(array $options)
	{
		return array(
			'data_class' => 'CodeConsortium\ForumBundle\Entity\Post',
		);
	}

	public function getName()
	{
		return 'Post';
	}

}

<?php

// CodeConsortium/ForumBundle/Form/Type/PostType.php

namespace CodeConsortium\ForumBundle\Form\Type;

use Symfony\Component\Form\AbstractType;

use Symfony\Component\Form\FormBuilder;

class PostType extends AbstractType

{

private $options;

public function __construct(array $options = null)

{

$this->options = $options;

}

public function buildForm(FormBuilder $builder, array $options)

{

$builder->add('Thread', new ThreadType($this->options) );

$builder->add('body');

}

// for creating and replying to threads

public function getDefaultOptions(array $options)

{

return array(

'data_class' => 'CodeConsortium\ForumBundle\Entity\Post',

);

}

public function getName()

{

return 'Post';

}

And lastly, the BoardType.php

<?php
// CodeConsortium/ForumBundle/Form/Type/BoardType.php
namespace CodeConsortium\ForumBundle\Form\Type;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;

class BoardType extends AbstractType
{

	private $options;

	public function __construct(array $options = null)
	{
		$this->options = $options;
	}

	public function buildForm(FormBuilder $builder, array $options)
	{

	}

	// for creating and replying to threads
	public function getDefaultOptions(array $options)
	{
		return array(
			'data_class' => 'CodeConsortium\ForumBundle\Entity\Board',
		);
	}

	public function getName()
	{
		return 'Board';
	}

}

<?php

// CodeConsortium/ForumBundle/Form/Type/BoardType.php

namespace CodeConsortium\ForumBundle\Form\Type;

use Symfony\Component\Form\AbstractType;

use Symfony\Component\Form\FormBuilder;

class BoardType extends AbstractType

{

private $options;

public function __construct(array $options = null)

{

$this->options = $options;

}

public function buildForm(FormBuilder $builder, array $options)

{

}

// for creating and replying to threads

public function getDefaultOptions(array $options)

{

return array(

'data_class' => 'CodeConsortium\ForumBundle\Entity\Board',

);

}

public function getName()

{

return 'Board';

}

Notice how i added a constructor, this is so we can easily chain feed in from the first object any changes to the form, such as wether we wish to bother including a field or not, we can opt to have any field removed if the form is used under different circumstances such as different access controls for different users with different permissions or if the form is used in another way on the site.

One more thing we need to make sure, is that all the references in our entities make use of the cascade={“persist”} option so that it maintains relations between the relevant forms as new ones get processed, so if say a thread does not exist then when processing the post, it should create one and do the association for us.

Here is an example of a snip from my Post entity class Post.php

 /**
 * @ORM\ManyToOne(targetEntity="Thread", inversedBy="posts", cascade={"persist"})
 * @ORM\JoinColumn(name="thread_id", referencedColumnName="id")
 */
 protected $thread;

/**

* @ORM\ManyToOne(targetEntity="Thread", inversedBy="posts", cascade={"persist"})

* @ORM\JoinColumn(name="thread_id", referencedColumnName="id")

protected $thread;

Lastly, you will need a formHandler if your not working in your controller, if using my example code then the postFormHandler.php looks like this:

<?php
// CodeConsortium/ForumBundle/Form/Handler/PostFormHandler.php
namespace CodeConsortium\ForumBundle\Form\Handler;

use Symfony\Component\Form\Form;
use Symfony\Component\HttpFoundation\Request;

use CodeConsortium\ForumBundle\Form\Type\PostType;
use CodeConsortium\ForumBundle\Entity\Post;

class PostFormHandler
{

	protected $request;
	protected $form;
	protected $post;

	public function __construct(Form $form, Request $request, $post) //, $entityManager)
	{
		$this->form = $form;
		$this->request = $request;
		$this->post = $post;
	}

	public function process()
	{
		//$form = $this->createForm(new PostType(), $this->post);
		//$this->form->setData($this->post);

		if ($this->request->getMethod() == 'POST')
		{
			$this->form->bindRequest($this->request);

			if ($this->form->isValid())
			{ 

				return true; 
			}

		}

		return false;
	}

}

<?php

// CodeConsortium/ForumBundle/Form/Handler/PostFormHandler.php

namespace CodeConsortium\ForumBundle\Form\Handler;

use Symfony\Component\Form\Form;

use Symfony\Component\HttpFoundation\Request;

use CodeConsortium\ForumBundle\Form\Type\PostType;

use CodeConsortium\ForumBundle\Entity\Post;

class PostFormHandler

{

protected $request;

protected $form;

protected $post;

public function __construct(Form $form, Request $request, $post) //, $entityManager)

{

$this->form = $form;

$this->request = $request;

$this->post = $post;

}

public function process()

{

//$form = $this->createForm(new PostType(), $this->post);

//$this->form->setData($this->post);

if ($this->request->getMethod() == 'POST')

{

$this->form->bindRequest($this->request);

if ($this->form->isValid())

{

return true;

}

return false;

}

M	T	W	T	F	S	S
« Aug
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30

Reece Fowells Blog

The home of a lot of crapola…

Tag: MVC

Custom Validators on Validation Groups in Symfony2.

Symfony2 Voter Access Decision Strategy Explained!

Authorisation on Roles in Symfony2

Redirecting on login/logout in Symfony2 using LoginHandlers.

Creating embedded forms in Symfony 2.0