public function onPostSerialize(ObjectEvent $event)
{
$embeds = $this->embedsFactory->create($event->getObject(), $event->getContext());
$links = $this->linksFactory->createLinks($event->getObject(), $event->getContext());
if (count($links) > 0) {
$this->xmlSerializer->serializeLinks($links, $event->getVisitor());
}
if (count($embeds) > 0) {
$this->xmlSerializer->serializeEmbedded($embeds, $event->getVisitor(), $event->getContext());
}
}
public function onPostDeserialize(ObjectEvent $event)
{
if ($event->getContext()->getDepth() > 1) {
return;
}
$class = get_class($event->getObject());
// Locate possible ObjectManager
$objectManager = $this->managerRegistry->getManagerForClass($class);
if (!$objectManager) {
// No ObjectManager found
return;
}
// Locate possible ClassMetadata
$classMetadataFactory = $objectManager->getMetadataFactory();
if ($classMetadataFactory->isTransient($class)) {
// No ClassMetadata found
return;
}
// Fallback to default constructor if missing identifier(s)
$classMetadata = $objectManager->getClassMetadata($class);
if (!$classMetadata instanceof ClassMetadataInfo || !$objectManager instanceof EntityManagerInterface) {
return;
}
$propertyAccessor = PropertyAccess::createPropertyAccessor();
foreach ($classMetadata->getAssociationMappings() as $mapping) {
switch ($mapping['type']) {
case ClassMetadataInfo::ONE_TO_MANY:
foreach ($event->getObject()->{$mapping['fieldName']} as $association) {
$propertyAccessor->setValue($association, $mapping['mappedBy'], $event->getObject());
}
break;
}
}
$this->rootObject = null;
}
/**
* onPostSerializeDirectory
*
* @param ObjectEvent $event
* @access private
* @return void
*/
private function onPostSerializeDirectory(ObjectEvent $event)
{
$directory = $event->getObject();
$request = $this->requestStack->getMasterRequest();
$width = $request->headers->get('X-Device-Width', 1170);
$gutter = $request->query->get('gutter', 0);
$lines = $this->lineLayout->computeRectangleList($directory->getChildren(), $width, 200, $gutter);
$outLines = [];
if ($event->getContext()->getDepth() == 0) {
foreach ($lines as $key => $line) {
$outLines[$key] = [];
foreach ($line as $itemContainer) {
$item = $itemContainer['item'];
$geometry = $itemContainer['geometry'];
if ($item instanceof Directory) {
$slug = $item->getDirectoryThumbnail() ? $item->getDirectoryThumbnail()->getSlug() : null;
} else {
$slug = $item->getSlug();
}
$outLines[$key][$item->getId()]['geometry'] = $geometry;
if ($slug) {
$outLines[$key][$item->getId()]['thumbs'] = $this->router->generate('image_crop', ['slug' => $slug, 'cropWidth' => $geometry->getWidth(), 'cropHeight' => $geometry->getHeight()], true);
}
}
}
$event->getVisitor()->addData('image_lines', $outLines);
}
}
/**
* @param ObjectEvent $event
*/
public function onPostSerialize(ObjectEvent $event)
{
// getSubscribedEvents doesn't seem to support parent classes
if (!$event->getObject() instanceof MediaInterface) {
return;
}
$provider = $this->pool->getProvider($event->getObject()->getProvider());
if ($provider->getName() == 'image') {
$reference = $provider->getThumb($event->getObject());
$groups = $event->getContext()->attributes->get('groups');
if (!$groups instanceof None && in_array('detail', $groups->get())) {
$filters = array_keys($this->filterConfig->all());
} else {
$filters = ['medialibrary'];
}
$variants = [];
foreach ($filters as $filter) {
if ($event->getObject()->getContentType() == 'image/svg+xml') {
$variants[$filter] = $provider->getUrl($event->getObject());
} else {
$variants[$filter] = $this->cacheManager->getBrowserPath($reference, $filter);
}
}
$event->getVisitor()->addData('images', $variants);
}
$event->getVisitor()->addData('original', $provider->getUrl($event->getObject()));
}
public function onPreSerialize(ObjectEvent $event)
{
if ($event->getContext()->getDepth() > 1 || null !== $this->rootObject) {
return;
}
$this->stopwatch->start('jms_serializer');
$this->rootObject = $event->getObject();
}
/**
* Add uniqueid and media-data to serialized data.
*
* @param ObjectEvent $event
*/
public function onPostSerialize(ObjectEvent $event)
{
$teaser = $event->getObject();
$visitor = $event->getVisitor();
$context = $event->getContext();
if (!$teaser instanceof Teaser) {
return;
}
$visitor->addData('teaserId', $context->accept(sprintf('%s;%s', $teaser->getType(), $teaser->getId())));
}
/**
* @param ObjectEvent $event
*/
public function onPostSerialize(ObjectEvent $event)
{
$attribures = $event->getContext()->attributes;
if ($attribures->containsKey('wallet_data')) {
/** @var Wallet $wallet */
$wallet = $event->getObject();
/** @var Some $walletData */
$walletData = $attribures->get('wallet_data')->get()[$wallet->getId()];
$event->getVisitor()->addData('withdrawnAmount', $walletData['withdrawnAmount']);
$event->getVisitor()->addData('lastOperationDate', $walletData['lastOperationDate']);
}
}
public function onPostSerialize(ObjectEvent $event)
{
$webspace = $event->getObject();
$visitor = $event->getVisitor();
$context = $event->getContext();
if (!$webspace instanceof Webspace) {
return;
}
$this->appendPortalInformation($webspace, $context, $visitor);
$this->appendUrls($webspace, $context, $visitor);
$this->appendCustomUrls($webspace, $context, $visitor);
$visitor->addData('allLocalizations', $webspace->getAllLocalizations());
}
public function onPostSerialize(ObjectEvent $event)
{
$analytics = $event->getObject();
if (!$analytics instanceof Analytics) {
return;
}
if ($analytics->isAllDomains()) {
$metadata = new PropertyMetadata($event->getType()['name'], 'domains');
$value = new \stdClass();
$value->domains = true;
$event->getVisitor()->visitProperty($metadata, $value, $event->getContext());
}
}
public function onPostSerialize(ObjectEvent $event)
{
$object = $event->getObject();
$context = $event->getContext();
$embeddeds = $this->embeddedsFactory->create($object, $context);
$links = $this->linksFactory->create($object, $context);
$embeddeds = $this->embeddedsInlineDeferrer->handleItems($object, $embeddeds, $context);
$links = $this->linksInlineDeferrer->handleItems($object, $links, $context);
if (count($links) > 0) {
$this->jsonSerializer->serializeLinks($links, $event->getVisitor(), $context);
}
if (count($embeddeds) > 0) {
$this->jsonSerializer->serializeEmbeddeds($embeddeds, $event->getVisitor(), $context);
}
}
public function onPostSerialize(ObjectEvent $event)
{
$object = $event->getObject();
$context = $event->getContext();
$context->startVisiting($object);
$embeddeds = $this->embeddedsFactory->create($object, $context);
$links = $this->linksFactory->create($object, $context);
if (count($links) > 0) {
$this->xmlSerializer->serializeLinks($links, $event->getVisitor(), $context);
}
if (count($embeddeds) > 0) {
$this->xmlSerializer->serializeEmbeddeds($embeddeds, $event->getVisitor(), $context);
}
$context->stopVisiting($object);
}
/**
* @param ObjectEvent $event
*/
public function postSerialize(ObjectEvent $event)
{
/** @var DataInterface $data */
$data = $event->getObject();
if (!$data instanceof DataInterface) {
return;
}
$context = $event->getContext();
$visitor = $event->getVisitor();
$family = $data->getFamily();
foreach ($family->getAttributes() as $attribute) {
$propertyMetadata = new VirtualPropertyMetadata(get_class($data), 'get' . ucfirst($attribute->getCode()));
$context->pushPropertyMetadata($propertyMetadata);
$visitor->visitProperty($propertyMetadata, $data, $context);
/** @noinspection DisconnectedForeachInstructionInspection */
$context->popPropertyMetadata();
}
}
/**
* Serialize images styles if the provider is an image type
*
* @param ObjectEvent $event
*/
public function onPostSerialize(ObjectEvent $event)
{
$visitor = $event->getVisitor();
$object = $event->getObject();
$context = $event->getContext();
if ($object instanceof Media) {
$styles = [];
$provider = $this->mediaPool->getProvider($object->getProviderName());
$formats = $this->mediaPool->getFormatNamesByContext($object->getContext());
if (is_array($formats)) {
foreach ($formats as $formatName => $format) {
$styles[$formatName] = $provider->generatePublicUrl($object, $formatName);
}
}
$visitor->addData('src', $provider->generatePublicUrl($object, 'reference'));
$visitor->addData('styles', $styles);
}
}
public function onSerializeUser(ObjectEvent $event)
{
$object = $event->getObject();
/** @var GenericSerializationVisitor $visitor */
$visitor = $event->getVisitor();
$groups = $event->getContext()->attributes->get('groups')->get();
if ($object instanceof User) {
//Cash Portfolio value
if (in_array('summaryTable', $groups)) {
$portfolioValue = $this->em->getRepository('WealthbotClientBundle:ClientAccount')->getAccountsSum($object);
$visitor->addData('portfolioValue', $portfolioValue);
}
if ($object->additionalSerializerFields) {
foreach ($object->additionalSerializerFields as $key => $value) {
$visitor->addData($key, $value);
}
}
}
}
public function onPostSerialize(ObjectEvent $event)
{
if (in_array('api', (array) $event->getContext()->attributes->get('groups'))) {
return;
}
$object = $event->getObject();
$deviceDetector = $this->container->get('mobile_detect.mobile_detector');
$mediaFormat = 'big1300';
if ($deviceDetector->isMobile() || $deviceDetector->isTablet()) {
$mediaFormat = 'big300';
}
if ($deviceDetector->isTablet()) {
$mediaFormat = 'medium';
}
$provider = $this->container->get($object->getImage()->getProviderName());
$formatBig = $provider->getFormatName($object->getImage(), $mediaFormat);
$formatLow = $provider->getFormatName($object->getImage(), 'big200');
$event->getVisitor()->addData('lowsrc', $provider->generatePublicUrl($object->getImage(), $formatLow));
$event->getVisitor()->addData('fullsrc', $provider->generatePublicUrl($object->getImage(), $formatBig));
}
/**
* Adds all the structure specific data (template, structure properties and breadcrumb) to the serialization.
*
* @param ObjectEvent $event
*/
public function onPostSerialize(ObjectEvent $event)
{
$document = $event->getObject();
$context = $event->getContext();
if (!$document instanceof StructureBehavior) {
return;
}
$visitor = $event->getVisitor();
$structureMetadata = $this->inspector->getStructureMetadata($document);
$visitor->addData('template', $document->getStructureType());
$visitor->addData('originTemplate', $document->getStructureType());
$visitor->addData('internal', false);
$visitor->addData('localizedTemplate', $structureMetadata->getTitle($this->inspector->getLocale($document)));
if (array_search('defaultPage', $context->attributes->get('groups')->getOrElse([])) !== false) {
$this->addStructureProperties($structureMetadata, $document, $visitor);
}
// create bread crumbs
if (array_search('breadcrumbPage', $context->attributes->get('groups')->getOrElse([])) !== false) {
$this->addBreadcrumb($document, $visitor);
}
}
/**
* @param ObjectEvent $event
*/
public function onPostSerialize(ObjectEvent $event)
{
/** @var Campaign $campaign */
$campaign = $event->getObject();
$attribures = $event->getContext()->attributes;
// если кампания в списке забаненных, то добавляет сериализованной кампании свойство "banned: true"
if ($attribures->containsKey('banned_campaigns')) {
$bannedCampaigns = $attribures->get('banned_campaigns');
if (in_array($campaign, $bannedCampaigns->get(), true)) {
$banned = true;
} else {
$banned = false;
}
$event->getVisitor()->addData('banned', $banned);
}
$groups = $attribures->get('groups')->get();
if (in_array('default', $groups)) {
$campaignData = $this->campaignManager->getCampaignParametersForPartner($campaign);
$event->getVisitor()->addData('bid', $campaignData['bid']);
$event->getVisitor()->addData('general_budget', $campaignData['budget']);
$event->getVisitor()->addData('general_budget_remains', $campaignData['budgetRemains']);
}
}
public function onPostSerialize(ObjectEvent $event)
{
$object = $event->getObject();
if (false === $object instanceof AutoAclSerializableInterface) {
return true;
}
$objectClass = get_class($object);
$visitor = $event->getVisitor();
$context = $event->getContext();
$propertyMetadata = $context->getmetadataFactory()->getMetadataForClass($objectClass)->propertyMetadata;
$aclMetaData = $propertyMetadata['acl'];
$exclusionStrategy = $context->getExclusionStrategy();
if (false == $exclusionStrategy->shouldSkipProperty($aclMetaData, $context)) {
$acl = [];
$permissions = ['edit'];
foreach ($permissions as $permission) {
if ($this->authorizationChecker->isGranted($permission, $object)) {
$acl[$permission] = 1;
}
}
$visitor->addData('acl', $acl);
}
}
/**
* @param ObjectEvent $event
*
* @return void
*/
public function onPostSerialize(ObjectEvent $event)
{
// Reset links array
$this->links = [];
// Get Exclusion Groups from the Serialization Context
$attr = iterator_to_array($event->getContext()->attributes);
$groups = !empty($attr['groups']) ? $attr['groups'] : [];
// Reflection Class of the Entity being Serialized
$reflClass = new \ReflectionClass($event->getObject());
// Custom Annotations not found in doctrine Proxy class - use the parent
if ($reflClass->implementsInterface("Doctrine\\Common\\Persistence\\Proxy")) {
$reflClass = $reflClass->getParentClass();
}
// Get the Class Level Hateoas Annotation, if it exists
$annotation = $this->reader->getClassAnnotation($reflClass, $this->annotationClass);
if (null !== $annotation) {
// Check to see if the hateoas groups match the exclusion groups
if (empty($annotation->groups) || sizeof(array_intersect($annotation->groups, $groups))) {
$this->addLinkUrl($annotation, $event->getObject());
}
}
// Get the Property Level Hateoas Annotations, if they exist
foreach ($reflClass->getProperties() as $property) {
$annotation = $this->reader->getPropertyAnnotation($property, $this->annotationClass);
if (null === $annotation) {
continue;
}
// Check to see if the hateoas groups match the exclusion groups
if (empty($annotation->groups) || sizeof(array_intersect($annotation->groups, $groups))) {
$this->addLinkUrl($annotation, $event->getObject());
}
}
// Only return the _links property if necessary
if (sizeof($this->links)) {
$event->getVisitor()->addData('_links', $this->links);
}
}
/**
* @param \JMS\Serializer\EventDispatcher\ObjectEvent $event
*/
public function onPostDeserialize(\JMS\Serializer\EventDispatcher\ObjectEvent $event)
{
/** @var $page PageInterface */
$page = $event->getObject();
if ($page instanceof PageInterface) {
$context = $event->getContext();
$er = $this->getPageManager();
if (!$page->getId()) {
return;
}
if ($parent = $page->getParent()) {
$parent = $er->find($page->getParent());
$page->setParent($parent);
} else {
$page->setParent(null);
}
if ($alias = $page->getAlias()) {
$alias = $er->find($page->getAlias());
$page->setAlias($alias);
} else {
$page->setAlias(null);
}
if ($parents = $page->getParents()) {
foreach ($parents as $key => $parent) {
if (is_array($parent) && array_key_exists('id', $parent)) {
$parent = $parent['id'];
}
$parents[$key] = $er->find($parent);
}
$page->setParents($parents);
} else {
$page->setParents(array());
}
if ($children = $page->getChildren()) {
foreach ($children as $key => $child) {
$children[$key] = $er->find($child);
}
$page->setChildren($children);
} else {
$page->setChildren(array());
}
if ($originals = $page->getOriginals()) {
foreach ($originals as $key => $original) {
$originals[$key] = $er->find($original);
}
$page->setOriginals($originals);
} else {
$page->setOriginals(array());
}
if ($context instanceof PageSnapshotDeserializationContext && $context->deserializeTranslations()) {
if ($translations = $page->getTranslations()) {
foreach ($translations as $key => $translation) {
$translations[$key] = $er->find($translation);
}
$page->setTranslations($translations);
} else {
$originalPageId = $page->getId();
$originalPage = $er->find($originalPageId);
$page->setTranslations($originalPage->getAllTranslations()->toArray());
}
}
if (!($contentRoute = $page->getContentRoute()->getId())) {
$pageSnapshotManager = $this->getPageSnapshotManager();
$pageSnapshots = $pageSnapshotManager->findSnapshotByPageId($page->getId());
$lastPageSnapshot = reset($pageSnapshots);
$page->setContentRoute($lastPageSnapshot->getContentRoute());
}
}
}
public function onPostSerialize(ObjectEvent $event)
{
$visitor = $event->getVisitor();
$object = $event->getObject();
$context = $event->getContext();
/** @var ClassMetadata $metadata */
$metadata = $this->hateoasMetadataFactory->getMetadataForClass(get_class($object));
// if it has no json api metadata, skip it
if (null === $metadata) {
return;
}
/** @var \JMS\Serializer\Metadata\ClassMetadata $jmsMetadata */
$jmsMetadata = $this->jmsMetadataFactory->getMetadataForClass(get_class($object));
$propertyAccessor = PropertyAccess::createPropertyAccessor();
if ($visitor instanceof JsonApiSerializationVisitor) {
$visitor->addData(self::EXTRA_DATA_KEY, $this->getRelationshipDataArray($metadata, $this->getId($metadata, $object)));
$relationships = array();
foreach ($metadata->getRelationships() as $relationship) {
$relationshipPropertyName = $relationship->getName();
$relationshipObject = $propertyAccessor->getValue($object, $relationshipPropertyName);
// JMS Serializer support
if (!isset($jmsMetadata->propertyMetadata[$relationshipPropertyName])) {
continue;
}
$jmsPropertyMetadata = $jmsMetadata->propertyMetadata[$relationshipPropertyName];
$relationshipPayloadKey = $this->namingStrategy->translateName($jmsPropertyMetadata);
$relationshipData =& $relationships[$relationshipPayloadKey];
$relationshipData = array();
// add `links`
$links = $this->processRelationshipLinks($object, $relationship, $relationshipPayloadKey);
if ($links) {
$relationshipData['links'] = $links;
}
$include = [];
if ($request = $this->requestStack->getCurrentRequest()) {
$include = $request->query->get('include');
$include = $this->parseInclude($include);
}
// FIXME: $includePath always is relative to the primary resource, so we can build our way with
// class metadata to find out if we can include this relationship.
foreach ($include as $includePath) {
$last = end($includePath);
if ($last === $relationship->getName()) {
// keep track of the path we are currently following (e.x. comments -> author)
$this->currentPath = $includePath;
$relationship->setIncludedByDefault(true);
// we are done here, since we have found out we can include this relationship :)
break;
}
}
// We show the relationships data if it is included or if there are no links. We do this
// because there MUST be links or data (see: http://jsonapi.org/format/#document-resource-object-relationships).
if ($relationship->isIncludedByDefault() || !$links || $relationship->getShowData()) {
// hasMany relationship
if ($this->isIteratable($relationshipObject)) {
$relationshipData['data'] = array();
foreach ($relationshipObject as $item) {
$relationshipData['data'][] = $this->processRelationship($item, $relationship, $context);
}
} else {
$relationshipData['data'] = $this->processRelationship($relationshipObject, $relationship, $context);
}
}
}
if ($relationships) {
$visitor->addData('relationships', $relationships);
}
// TODO: Improve link handling
if (true === $metadata->getResource()->getShowLinkSelf()) {
$visitor->addData('links', array('self' => $this->baseUrl . '/' . $metadata->getResource()->getType() . '/' . $this->getId($metadata, $object)));
}
$root = (array) $visitor->getRoot();
$root['included'] = array_values($this->includedRelationships);
$visitor->setRoot($root);
}
}
/**
* Adds a link to the value object to serialize
*
* @param ObjectEvent $event
* @param string[] $config
*
* @throws \LogicException If the visitor is not valid
* @throws \LogicException If the id getter is invalid
*/
private function addLink(ObjectEvent $event, $config)
{
$valueObject = $event->getObject();
/** @var $visitor GenericSerializationVisitor */
if (!($visitor = $event->getVisitor()) instanceof GenericSerializationVisitor) {
throw new \LogicException('The default Visitor contract does not support addData()!');
}
$getter = $config['id_getter'];
if (!method_exists($valueObject, $getter)) {
throw new \LogicException(sprintf('The identity getter "%s" on object "%s" does not exist or its accessibility is restricted!', $getter, get_class($valueObject)));
}
$userId = ['id' => call_user_func([$valueObject, $getter])];
$params = isset($config['params']) ? array_merge($config['params'], $userId) : $userId;
if (!isset($params['_format'])) {
$params['_format'] = $event->getContext()->getFormat();
}
$visitor->addData('link', $this->urlGenerator->generate($config['url_name'], $params));
}
