Agregar campos adicionales usando JMS Serializer bundle

Me sorprende que nadie haya sugerido una manera mucho más fácil. Solo necesitas usar @VirtualProperty:

<?php

// ...
/**
 * @JMS\VirtualProperty
 * @JMS\SerializedName("someField")
 */
public function getSomeField()
{
    return $this->getTitle() . $this->getPromo();
}

Para responder más a la pregunta original. Así es como limita los datos agregados para algunos grupos serializados (en este ejemplo, some_data solo se agrega cuando no estamos usando el grupo list:

public function onPostSerializeSomeEntityJson(ObjectEvent $event) {

    $entity = $event->getObject();

    if (!in_array('list', (array)$event->getContext()->attributes->get('groups'))) {

        $event->getVisitor()->addData('user_access', array(
            'some_data' => 'some_value'
        ));
    }
}

(array)$event->getContext()->attributes->get('groups') contiene una matriz de los grupos serializados utilizados.

La respuesta aceptada solo funciona cuando el visitante se deriva de \JMS\Serializer\GenericSerializationVisitor. Esto significa que funcionará para JSON, pero fallará para XML.

Aquí hay un método de ejemplo que hará frente a XML. Observa las interfaces que soporta el objeto visitante y actúa apropiadamente. Muestra cómo puede agregar un elemento de enlace a objetos serializados JSON y XML...

public function onPostSerialize(ObjectEvent $event)
{
    //obtain some data we want to add
    $link=array(
        'rel'=>'self',
        'href'=>'http://example.org/thing/1',
        'type'=>'application/thing+xml'
    );

    //see what our visitor supports...
    $visitor= $event->getVisitor();
    if ($visitor instanceof \JMS\Serializer\XmlSerializationVisitor)
    {
        //do XML things
        $doc=$visitor->getDocument();

        $element = $doc->createElement('link');
        foreach($link as $name => $value) {
            $element->setAttribute($name, $value);
        }
        $doc->documentElement->appendChild($element);
    } elseif ($visitor instanceof \JMS\Serializer\GenericSerializationVisitor)
    {
        $visitor->addData('link', $link);
    }


}

Qué hay de esto: http://jmsyst.com/libs/serializer/master/handlers

En resumen, se define una clase que recibe un objeto y devuelve texto o una matriz (que se convertirá a json).

Usted tiene la clase "IndexedStuff" que contiene un extraño campo calculado que por alguna razón debe ser calculado en tiempo de serialización.

<?php

namespace Project/Model;

class IndexedStuff
{
   public $name;
   public $value;
   public $rawData;
}

Ahora crea el controlador

<?php

namespace Project/Serializer;

use JMS\Serializer\Handler\SubscribingHandlerInterface;
use JMS\Serializer\GraphNavigator;
use JMS\Serializer\JsonSerializationVisitor;
use JMS\Serializer\Context;

class MyHandler implements SubscribingHandlerInterface
{
    public function setEntityManager(Registry $registry) {
         // Inject registry instead of entity manager to avoid circular dependency
         $this->em = $registry->getEntityManager();
    }
    public static function getSubscribingMethods()
    {
        return array(
            array(
                'direction' => GraphNavigator::DIRECTION_SERIALIZATION,
                'format' => 'json',
                'type' => 'Project/Model/IndexedStuff',
                'method' => 'serializeIndexedStuffToJson',
            ),
        );
    }

    public function serializeIndexedStuffToJson(JsonSerializationVisitor $visitor, Project/Model/IndexedStuff $stuff, array $type, Context $context)
    {
        // Build your object here and return it
        $score = $this->em->find("ProjectBundle:Calculator", $stuff->value)
        return array("score" => $score->getIndexScore(), "name"=> $score->name
    }
}

Finalmente registrar el servicio

services:
  project.serializer.stuff:
      class: Project\Serializer\MyHandler
      calls:
        - [setEntityManager, ["@doctrine"]]

Ahora donde quieras serializar un objeto de tipo "IndexedStuff" obtendrá un json como este

{"name": "myName", "score" => 0.3432}

De esta manera puede personalizar completamente cómo se serializa su entidad