public function onSerializerPreDeserialize(PreDeserializeEvent $e)
{
$className = $e->getType();
$className = $className['name'];
/** Handle ArrayCollection or array JMS type. */
if ($className == "ArrayCollection" || $className == "array") {
$className = $e->getType();
$className = $className['params'][0]['name'];
}
$classMetadata = $e->getContext()->getMetadataFactory()->getMetadataForClass($className);
/** @var PropertyMetadata $propertyMetadata */
foreach ($classMetadata->propertyMetadata as $propertyMetadata) {
if ($propertyMetadata->reflection === null) {
continue;
}
/** @var JoinColumn $joinColumnAnnotation */
$joinColumnAnnotation = $this->reader->getPropertyAnnotation($propertyMetadata->reflection, 'Doctrine\\ORM\\Mapping\\JoinColumn');
if ($joinColumnAnnotation !== null) {
if (array_key_exists($joinColumnAnnotation->name, $e->getData())) {
$idValue = $e->getData();
$idValue = $idValue[$joinColumnAnnotation->name];
if ($idValue !== null) {
$e->setData($e->getData() + array($propertyMetadata->name => array('id' => $idValue)));
} else {
$e->setData($e->getData() + array($propertyMetadata->name => null));
}
}
}
}
}
public function onPreDeserialize(PreDeserializeEvent $event)
{
$type = $event->getType();
if ($type['name'] === 'DateTime' && $event->getData() === '') {
$event->setData(null);
}
}
/**
* remove translateable strings from object
*
* @param PreDeserializeEvent $event event
*
* @return void
*/
public function onPreDeserialize(PreDeserializeEvent $event)
{
$eventClass = $event->getType()['name'];
if (!class_exists($eventClass)) {
throw new DeserializationException(sprintf('Can\' find class %s to deserialize', $eventClass));
}
$object = new $eventClass();
if ($object instanceof TranslatableDocumentInterface) {
$data = $event->getData();
foreach ($object->getTranslatableFields() as $field) {
$isArray = substr($field, -2, 2) === '[]';
if ($isArray) {
$field = substr($field, 0, -2);
}
if (!isset($data[$field])) {
continue;
}
if ($isArray) {
$this->localizedFields = array_merge($this->localizedFields, array_values($data[$field]));
$data[$field] = array_map([$this, 'getDefaultTranslation'], array_values($data[$field]));
} else {
$this->localizedFields[] = $data[$field];
$data[$field] = $this->getDefaultTranslation($data[$field]);
}
}
$event->setData($data);
}
}
/**
* @param PreDeserializeEvent $event
*/
public function onPreDeserialize(PreDeserializeEvent $event)
{
$data = $event->getData();
$type = $event->getType();
if (is_array($data) && array_key_exists('queries', $data)) {
$event->setData($data['queries']);
}
}
public function wrapData(PreDeserializeEvent $event)
{
$type = $event->getType();
if (is_subclass_of($type['name'], 'XApi\\Model\\DocumentInterface')) {
$data = $event->getData();
$event->setData(array('data' => $data));
}
}
public function wrapData(PreDeserializeEvent $event)
{
$type = $event->getType();
$handledClass = 'Xabbuh\\XApi\\Model\\DocumentData';
if ($handledClass == $type['name'] || is_subclass_of($type['name'], $handledClass)) {
$data = $event->getData();
$event->setData(array('data' => $data));
}
}
public function preDeserialize(PreDeserializeEvent $event)
{
$postData = $event->getData();
$request = $this->requestStack->getCurrentRequest();
$id = $request->get('id');
if ($id !== null) {
$postData['id'] = $id;
$event->setData($postData);
}
}
/**
* @param PreDeserializeEvent $event
*/
public function __invoke(PreDeserializeEvent $event)
{
if ($event->getType()['name'] !== Video::class) {
return;
}
$data = $event->getData();
$this->formatTimestamp($data, 'createdDate');
$this->formatTimestamp($data, 'uploadDate');
$event->setData($data);
}
public function onPreDeserialize(PreDeserializeEvent $event)
{
$type = $event->getType();
if ($this->supportsClass($type['name'])) {
$data = $event->getData();
if ($this->isDataModificationNeeded($data)) {
$data = array_merge($data, $this->getAdditionalData());
}
$event->setData($data);
}
}
/**
* Appends an array element to the parameters of a job that provides information about the job type.
*
* @param PreDeserializeEvent $event
*/
public function onPreDeserialize(PreDeserializeEvent $event)
{
$type = $event->getType();
if (isset($type['name']) && ($type['name'] == Job::class || is_subclass_of($type['name'], Job::class))) {
$data = $event->getData();
if (isset($data['type']) && isset($data['parameters']) && is_array($data['parameters']) && count($data['parameters']) > 0) {
array_push($data['parameters'], ['abc.job.type' => $data['type']]);
$event->setData($data);
}
}
}
/**
* @param PreDeserializeEvent $event
*/
public function onPreDeserialize(PreDeserializeEvent $event)
{
$type = $event->getType();
$data = $event->getData();
if (is_subclass_of($type['name'], 'Bangpound\\Atom\\DataBundle\\Model\\CommonAttributes')) {
$namespaces = $data->getNamespaces(true);
foreach ($namespaces as $prefix => $namespace) {
foreach ($data->attributes($namespace) as $key => $value) {
$data->addAttribute($key, $value, null);
}
}
}
}
/**
* Bad dates cause fatal errors, and this is the best remedy I've found so far.
* The date time handler is brought in so that I can trap the exception that
* happens when feeds have dates like NaN/NaN/NaN NaN:NaN:NaN.
*
* @param PreDeserializeEvent $event
*/
public function onPreDeserialize(PreDeserializeEvent $event)
{
$type = $event->getType();
if ($type['name'] == 'DateTime') {
/** @var VisitorInterface $visitor */
$visitor = $event->getVisitor();
/** @var \SimpleXMLElement $data */
$data = $event->getData();
try {
$this->handler->deserializeDateTimeFromXml($visitor, $data, $type);
} catch (RuntimeException $e) {
$attributes = $data->attributes('xsi', true);
if (!isset($attributes['nil'][0]) || (string) $attributes['nil'][0] == !'true') {
$data->addAttribute('xsi:nil', 'true', 'http://www.w3.org/2001/XMLSchema-instance');
}
$event->setData($data);
}
}
}
/**
* remove translateable strings from object
*
* @param PreDeserializeEvent $event event
*
* @return void
*/
public function onPreDeserialize(PreDeserializeEvent $event)
{
$eventClass = $event->getType()['name'];
if (!class_exists($eventClass)) {
throw new DeserializationException(sprintf('Can\' find class %s to deserialize', $eventClass));
}
$object = new $eventClass();
if ($object instanceof TranslatableDocumentInterface) {
$defaultLanguage = $this->utils->getDefaultLanguage();
$data = $event->getData();
foreach ($object->getTranslatableFields() as $field) {
if (isset($data[$field])) {
$this->localizedFields[$field] = $data[$field];
$defaultValue = \reset($data[$field]);
if (array_key_exists($defaultLanguage, $data[$field])) {
$defaultValue = $data[$field][$defaultLanguage];
}
$data[$field] = $defaultValue;
}
}
$event->setData($data);
}
}
/**
* Called for each node of the graph that is being traversed.
*
* @param mixed $data the data depends on the direction, and type of visitor
* @param null|array $type array has the format ["name" => string, "params" => array]
*
* @return mixed the return value depends on the direction, and type of visitor
*/
public function accept($data, array $type = null, Context $context)
{
$visitor = $context->getVisitor();
// If the type was not given, we infer the most specific type from the
// input data in serialization mode.
if (null === $type) {
if ($context instanceof DeserializationContext) {
throw new RuntimeException('The type must be given for all properties when deserializing.');
}
$typeName = gettype($data);
if ('object' === $typeName) {
$typeName = get_class($data);
}
$type = array('name' => $typeName, 'params' => array());
} else {
if ($context instanceof SerializationContext && null === $data) {
$type = array('name' => 'NULL', 'params' => array());
}
}
switch ($type['name']) {
case 'NULL':
return $visitor->visitNull($data, $type, $context);
case 'string':
return $visitor->visitString($data, $type, $context);
case 'int':
case 'integer':
return $visitor->visitInteger($data, $type, $context);
case 'boolean':
return $visitor->visitBoolean($data, $type, $context);
case 'double':
case 'float':
return $visitor->visitDouble($data, $type, $context);
case 'array':
return $visitor->visitArray($data, $type, $context);
case 'resource':
$msg = 'Resources are not supported in serialized data.';
if ($context instanceof SerializationContext && null !== ($path = $context->getPath())) {
$msg .= ' Path: ' . $path;
}
throw new RuntimeException($msg);
default:
// TODO: The rest of this method needs some refactoring.
if ($context instanceof SerializationContext) {
if (null !== $data) {
if ($context->isVisiting($data)) {
return null;
}
$context->startVisiting($data);
}
// If we're serializing a polymorphic type, then we'll be interested in the
// metadata for the actual type of the object, not the base class.
if (class_exists($type['name'], false) || interface_exists($type['name'], false)) {
if (is_subclass_of($data, $type['name'], false)) {
$type = array('name' => get_class($data), 'params' => array());
}
}
} elseif ($context instanceof DeserializationContext) {
$context->increaseDepth();
}
// Trigger pre-serialization callbacks, and listeners if they exist.
// Dispatch pre-serialization event before handling data to have ability change type in listener
if ($context instanceof SerializationContext) {
if (null !== $this->dispatcher && $this->dispatcher->hasListeners('serializer.pre_serialize', $type['name'], $context->getFormat())) {
$this->dispatcher->dispatch('serializer.pre_serialize', $type['name'], $context->getFormat(), $event = new PreSerializeEvent($context, $data, $type));
$type = $event->getType();
}
} elseif ($context instanceof DeserializationContext) {
if (null !== $this->dispatcher && $this->dispatcher->hasListeners('serializer.pre_deserialize', $type['name'], $context->getFormat())) {
$this->dispatcher->dispatch('serializer.pre_deserialize', $type['name'], $context->getFormat(), $event = new PreDeserializeEvent($context, $data, $type));
$type = $event->getType();
$data = $event->getData();
}
}
// First, try whether a custom handler exists for the given type. This is done
// before loading metadata because the type name might not be a class, but
// could also simply be an artifical type.
if (null !== ($handler = $this->handlerRegistry->getHandler($context->getDirection(), $type['name'], $context->getFormat()))) {
$rs = call_user_func($handler, $visitor, $data, $type, $context);
$this->leaveScope($context, $data);
return $rs;
}
$exclusionStrategy = $context->getExclusionStrategy();
/** @var $metadata ClassMetadata */
$metadata = $this->metadataFactory->getMetadataForClass($type['name']);
if ($context instanceof DeserializationContext && !empty($metadata->discriminatorMap) && $type['name'] === $metadata->discriminatorBaseClass) {
$metadata = $this->resolveMetadata($data, $metadata);
}
if (null !== $exclusionStrategy && $exclusionStrategy->shouldSkipClass($metadata, $context)) {
$this->leaveScope($context, $data);
return null;
}
$context->pushClassMetadata($metadata);
if ($context instanceof SerializationContext) {
foreach ($metadata->preSerializeMethods as $method) {
$method->invoke($data);
}
}
$object = $data;
if ($context instanceof DeserializationContext) {
$object = $this->objectConstructor->construct($visitor, $metadata, $data, $type, $context);
}
if (isset($metadata->handlerCallbacks[$context->getDirection()][$context->getFormat()])) {
$rs = $object->{$metadata->handlerCallbacks[$context->getDirection()][$context->getFormat()]}($visitor, $context instanceof SerializationContext ? null : $data, $context);
$this->afterVisitingObject($metadata, $object, $type, $context);
return $context instanceof SerializationContext ? $rs : $object;
}
$visitor->startVisitingObject($metadata, $object, $type, $context);
foreach ($metadata->propertyMetadata as $propertyMetadata) {
if (null !== $exclusionStrategy && $exclusionStrategy->shouldSkipProperty($propertyMetadata, $context)) {
continue;
}
if ($context instanceof DeserializationContext && $propertyMetadata->readOnly) {
continue;
}
$context->pushPropertyMetadata($propertyMetadata);
$visitor->visitProperty($propertyMetadata, $data, $context);
$context->popPropertyMetadata();
}
if ($context instanceof SerializationContext) {
$this->afterVisitingObject($metadata, $data, $type, $context);
return $visitor->endVisitingObject($metadata, $data, $type, $context);
}
$rs = $visitor->endVisitingObject($metadata, $data, $type, $context);
$this->afterVisitingObject($metadata, $rs, $type, $context);
return $rs;
}
}
/**
* @param PreDeserializeEvent $event
*/
public function onSerializerPreDeserialize(PreDeserializeEvent $event)
{
if ($this->transformer->isResourcePath($event->getData()) && $this->transformer->isResource($event->getType()['name'])) {
$event->setType($this->typeNameStrict, [$this->originalTypeParamName => $event->getType()['name']]);
return;
}
// @JMS\Type("array<CLASSNAME>")
if (is_array($event->getData()) && $this->containsResources($event->getData()) && isset($event->getType()['params'][0]['name']) && $this->transformer->isResource($event->getType()['params'][0]['name'])) {
$event->setType($event->getType()['name'], [['name' => $this->typeNameStrict, 'params' => [$this->originalTypeParamName => $event->getType()['params'][0]['name']]]]);
}
}
