/**
* @param Serializer $serializer
* @param SqsClient $sqsClient
*/
public function __construct(Serializer $serializer, SqsClient $sqsClient)
{
$this->serializer = $serializer;
$this->sqsClient = $sqsClient;
$this->serializationContext = new SerializationContext();
$this->serializationContext->setSerializeNull(true);
}
/**
* @param SerializerInterface $serializer
*/
public function __construct(SerializerInterface $serializer = null)
{
$this->serializer = $serializer ?: SerializerBuilder::create()->build();
$this->serializationContext = new SerializationContext();
$this->serializationContext->setSerializeNull(true);
$this->deserializationContext = new DeserializationContext();
$this->deserializationContext->setSerializeNull(true);
}
/**
* @param GetResponseForControllerResultEvent $event
*/
public function serializeResponse(GetResponseForControllerResultEvent $event)
{
if ($this->doSerialize) {
$data = $event->getControllerResult();
$apiResponse = new ApiResponse(200, $data);
$data = array_merge($apiResponse->toArray(), $this->data->all());
$data = array_filter($data);
if (!isset($data['data'])) {
$data['data'] = [];
}
$context = new SerializationContext();
$context->setSerializeNull(true);
if (method_exists($context, 'enableMaxDepthChecks')) {
$context->enableMaxDepthChecks();
}
if ($action = $this->getAction($event)) {
$context->setGroups($action->getSerializationGroups());
}
if ($fields = $event->getRequest()->query->get('fields')) {
$context->addExclusionStrategy(new FieldsListExclusionStrategy($fields));
}
$json = $this->serializer->serialize($data, 'json', $context);
$response = new Response($json, 200, ['Content-Type' => 'application/json']);
$event->setResponse($response);
$event->stopPropagation();
}
}
/**
* Render the view into a string and return for output
*
* @param mixed $input
* @return string
* @throws \Exception
*/
public function render($input = null)
{
$context = new SerializationContext();
$context->setSerializeNull(true);
$context->enableMaxDepthChecks();
FrontController::getInstance()->getResponse()->headers->set('Content-Type', 'application/json');
return $this->serializer->serialize($input, $this->format, $context);
}
protected function serializeObject($object)
{
$serializer = SerializerBuilder::create()->build();
$serializationContext = new SerializationContext();
$serializationContext->setSerializeNull(true);
$objectJson = $serializer->serialize($object, 'json', $serializationContext);
return json_decode($objectJson);
}
protected function jsonResponse($data)
{
$context = new SerializationContext();
$context->setSerializeNull(true);
$content = $this->serializer->serialize($data, 'json', $context);
$this->response->setContent($content);
return $this->response;
}
/**
* {@inheritdoc}
*/
public function setData($data = array())
{
$this->originalData = $data;
$context = new SerializationContext();
$context->setSerializeNull(true);
$serializer = SerializerBuilder::create()->build();
$this->data = $serializer->serialize($data, 'json', $context);
return $this->update();
}
/**
* Create a new serialization context
*
* @param array $groups [optional]
* @return SerializationContext
*/
protected function createNewContext(array $groups = null)
{
$context = new SerializationContext();
$context->setSerializeNull($this->serializeNull);
if (null !== $groups) {
$context->setGroups($groups);
}
return $context;
}
public function testToArrayUseProvidedSerializationContext()
{
$contextFactoryMock = $this->getMockForAbstractClass('JMS\\Serializer\\ContextFactory\\SerializationContextFactoryInterface');
$context = new SerializationContext();
$context->setSerializeNull(true);
$contextFactoryMock->expects($this->once())->method('createSerializationContext')->will($this->returnValue($context));
$this->serializer->setDefaultSerializationContextFactory($contextFactoryMock);
$result = $this->serializer->toArray(array('value' => null));
$this->assertEquals(array('value' => null), $result);
}
public function getmailAction()
{
try {
$jsonData = $this->getRequest()->getContent();
$data = $this->serializer->deserialize($jsonData, "Application\\API\\Canonicals\\Dto\\ThirdPartyEmailTransport", "json");
$emailRepo = $this->getServiceLocator()->get('EMailSvc');
$emails = $emailRepo->fetchMail($data->mailapikey);
$context = new SerializationContext();
$context->setSerializeNull(true);
$content = $this->serializer->serialize($emails, 'json', $context);
$this->response->setContent($content);
return $this->response;
} catch (\Exception $ex) {
error_log($ex->getMessage());
}
exit;
}
public function processForm(WebsiteOptions $options, array $parameters, $method = 'PUT')
{
$form = $this->formFactory->create(new WebsiteOptionsType(), $options, array('method' => $method));
$form->submit($parameters, 'PATCH' !== $method);
if ($form->isValid()) {
$options = $form->getData();
$this->om->persist($options);
$this->om->flush();
$serializationContext = new SerializationContext();
$serializationContext->setSerializeNull(true);
return json_decode($this->serializer->serialize($options, 'json', $serializationContext));
}
/*else {
return $this->getErrorMessages($form);
}*/
throw new \InvalidArgumentException();
}
public function testAbc()
{
$client = new Entity\Client();
$location = new Entity\Location();
$orders = new Collections\ArrayCollection();
$orders->add(new Entity\Order('Order 001'));
$orders->add(new Entity\Order('Order 002'));
$orders->add(new Entity\Order('Order 003'));
$session = new Entity\Session('981be8ae41ba4a148f20a04508ab1ab');
$request = new Request\SaveOrder($session, $orders);
$context = new SerializationContext();
$context->setSerializeNull(true);
$serializer = SerializerBuilder::create()->build();
// serialize
$xml = $serializer->serialize($request, 'xml', $context);
//var_dump($xml);
// deserialize
$object = $serializer->deserialize($xml, Request\SaveOrder::class, 'xml');
var_dump($object);
}
public function cgetAction(Request $request)
{
$adminCode = $request->get('_sonata_admin');
if (!$adminCode) {
throw new \RuntimeException(sprintf('There is no `_sonata_admin` defined for the controller `%s` and the current route `%s`', get_class($this), $request->get('_route')));
}
$admin = $this->get('sonata.admin.pool')->getAdminByAdminCode($adminCode);
if (false === $admin->isGranted('LIST')) {
throw new AccessDeniedException();
}
/** @var MenuItemRepository $menuRepository */
$menuRepository = $this->get('doctrine.orm.entity_manager')->getRepository('GravityMenuBundle:MenuItem');
$menus = $menuRepository->findBy(['parent' => null], null, 20, 0);
$view = new View($menus);
$context = new SerializationContext();
$context->setSerializeNull(true);
$context->setGroups(['gravity_api_read']);
$view->setSerializationContext($context);
return $this->get('fos_rest.view_handler')->handle($view);
}
/**
* @param PaginationInterface $pagination
* @param Request $request
* @param Router $router
* @param array $serializationGroups
*
* @return mixed
*/
public function buildMultiObjectResponse(PaginationInterface $pagination, Request $request, Router $router, array $serializationGroups = array())
{
if (empty($pagination->getItems())) {
return $this->handle(View::create(null, Response::HTTP_NO_CONTENT));
}
$paginationData = $pagination->getPaginationData();
$link = $this->buildPaginationLink($paginationData, $request, $router);
$headers = [];
if (!empty($link)) {
$headers['Link'] = $link;
}
if (isset($paginationData['totalCount'])) {
$headers['X-Total-Count'] = $paginationData['totalCount'];
}
$view = View::create($pagination->getItems(), Response::HTTP_OK, $headers);
$context = new SerializationContext();
$context->setSerializeNull(true);
if (!empty($serializationGroups)) {
$context->setGroups($serializationGroups);
}
$view->setSerializationContext($context);
return $this->handle($view);
}
/**
* Create serialization context with settings taken from the controller's annotation
*
* @param MappingInterface $mapping
* @return SerializationContext
*/
protected function createSerializationContext(MappingInterface $mapping)
{
$context = new SerializationContext();
if ($mapping->getAnnotation()->getSerializerEnableMaxDepthChecks()) {
$context->enableMaxDepthChecks();
}
if ($mapping->getAnnotation()->getSerializerGroups()) {
$context->setGroups($mapping->getAnnotation()->getSerializerGroups());
}
if ($mapping->getAnnotation()->getSerializerSerializeNull()) {
$context->setSerializeNull(true);
}
return $context;
}
protected function serialize($data, $format = 'json')
{
$context = new SerializationContext();
$context->setSerializeNull(true);
return $this->container->get('jms_serializer')->serialize($data, $format, $context);
}
public function testSetSerializationContext()
{
$contextFactoryMock = $this->getMockForAbstractClass('JMS\\Serializer\\ContextFactory\\SerializationContextFactoryInterface');
$context = new SerializationContext();
$context->setSerializeNull(true);
$contextFactoryMock->expects($this->once())->method('createSerializationContext')->will($this->returnValue($context));
$this->builder->setSerializationContextFactory($contextFactoryMock);
$serializer = $this->builder->build();
$result = $serializer->serialize(array('value' => null), 'json');
$this->assertEquals('{"value":null}', $result);
}
/**
* Custom serializer context.
*
* This is required in order to set options for the serializer. We require
* all nulls to actually be rendered instead of left off the databset.
*
* @return SerializationContext
*/
private function createSerializerContext()
{
$context = new SerializationContext();
$context->setSerializeNull(true);
return $context;
}
/**
* @return SerializationContext
*/
protected function getSerializerContext()
{
$context = new SerializationContext();
$context->setSerializeNull(true);
return $context;
}
/**
* @param NQLQuery $nqlQuery
* @param bool $skipSelection
*
* @return mixed|string
* @throws \Trinity\Bundle\SearchBundle\Exception\SyntaxErrorException
*/
public function convertToJson(NQLQuery $nqlQuery, bool $skipSelection)
{
$entities = $nqlQuery->getQueryBuilder($skipSelection)->getQuery()->getResult();
if (!$skipSelection) {
return SerializerBuilder::create()->setPropertyNamingStrategy(new SerializedNameAnnotationStrategy(new PassThroughNamingStrategy()))->build()->serialize($entities, 'json');
}
$result = [];
/** @var Select $select */
$select = $nqlQuery->getSelect();
foreach ($entities as $entity) {
$result[] = $this->select($select->getColumns(), $entity);
}
$context = new SerializationContext();
$context->setSerializeNull(true);
return SerializerBuilder::create()->setPropertyNamingStrategy(new SerializedNameAnnotationStrategy(new PassThroughNamingStrategy()))->build()->serialize($result, 'json', $context);
}
private function getJson($data)
{
$context = new SerializationContext();
$context->setSerializeNull(true);
return $this->serializer->serialize($data, 'json', $context);
}
/**
* converts content to correct output format
*
* @param FilterResponseEvent $event
*/
public function onResponse(FilterResponseEvent $event)
{
if (!$this->isActive($event)) {
return;
}
$request = $event->getRequest();
$response = $event->getResponse();
$content = $response->getContent();
// convert content to content container
if (!$content instanceof ResponseContainer) {
$content = ResponseContainer::createAutoDetect($response);
}
// override http status code if needed
$statusCode = $content->getStatusCode();
if (!empty($statusCode)) {
$response->setStatusCode($content->getStatusCode());
}
// set 204 header for empty content
if ($content->isEmpty() && !$response->isRedirect()) {
$response->setStatusCode(Response::HTTP_NO_CONTENT);
$content->setStatusCode(Response::HTTP_NO_CONTENT);
}
// put statusCode in response and force 200 OK in header?
if ($request->headers->has('X-Force-Status-Code-200') || $request->getRequestFormat() == self::FORMAT_JSON && $request->query->has('callback')) {
$content->setReturnStatusCode(true);
$response->setStatusCode(Response::HTTP_OK);
$response->headers->set('X-Status-Code', Response::HTTP_OK);
}
// serialize content container
try {
$context = new SerializationContext();
$context->setSerializeNull(true);
$format = $event->getRequest()->getRequestFormat();
$contentSerialized = $this->serializer->serialize($content->toArray(), $format, $context);
switch ($format) {
case self::FORMAT_XML:
$response->setContent($contentSerialized);
break;
default:
$headers = $response->headers;
$response = new JsonResponse(null, $response->getStatusCode());
$response->headers = $headers;
$response->setContent($contentSerialized);
break;
}
} catch (\Exception $e) {
$response = new JsonResponse(['error' => ['code' => 'error.api.middleware', 'message' => $e->getMessage()]]);
}
// force empty output on a no-content response
if ($content->isEmpty() && $response->isEmpty()) {
$response->setContent('');
}
$event->setResponse($response);
}
public function processForm(Website $website, WebsitePage $page, array $parameters, $method = 'PUT')
{
$form = $this->formFactory->create(new WebsitePageType(), $page, array('method' => $method));
$form->submit($parameters, 'PATCH' !== $method);
if ($form->isValid()) {
$page = $form->getData();
/*
* Test if section and set other values to null
* Test if richText is set, set resourceNode and url to null
* Test if resourceNode is set, set url to null
*/
if ($method == 'POST' && $website->getHomePage() === null) {
$this->setHomepage($website, $page);
} else {
$this->objectManager->persist($page);
$this->objectManager->flush();
}
$serializationContext = new SerializationContext();
$serializationContext->setSerializeNull(true);
return json_decode($this->serializer->serialize($page, 'json', $serializationContext));
}
throw new \InvalidArgumentException();
}
/**
* Serializes an object.
*
* Implements FormatterInterface::formatItem($item)
*
* @param mixed $item
*
* @return array
*/
public function formatItem($item, $format = 'json')
{
$formatted = null;
switch ($format) {
case 'json':
// serialize properties with null values
$context = new SerializationContext();
$context->setSerializeNull(true);
$context->enableMaxDepthChecks(true);
$formatted = $this->getSerializer()->serialize($item, 'json', $context);
break;
case 'jsonp':
$callback = $this->getRequest()->query->get('jsonp.callback', 'JSONP.callback');
// validate against XSS
$validator = new \JsonpCallbackValidator();
if (!$validator->validate($callback)) {
throw new BadRequestHttpException('Invalid JSONP callback value');
}
$context = new SerializationContext();
$context->setSerializeNull(true);
$json = $this->getSerializer()->serialize($item, 'json');
$formatted = sprintf('/**/%s(%s)', $callback, $json);
break;
default:
// any other format is not supported
throw new \InvalidArgumentException(sprintf('Format not supported: %s', $format));
}
return $formatted;
}
