public function testCustomSubscribingHandler() { $fixture = file_get_contents(FIXTURE_ROOT . '/Unit/Serializer/JmsSerializer/test_entity_1.json'); $resultEntity = $this->realJms->deserialize($fixture, 'Elastification\\Client\\Serializer\\JmsSerializer\\SearchResponseEntity', 'json'); $this->assertInstanceOf('Elastification\\Client\\Serializer\\JmsSerializer\\SearchResponseEntity', $resultEntity); /* @var $resultEntity \Elastification\Client\Serializer\JmsSerializer\SearchResponseEntity */ $this->assertEquals(1, $resultEntity->took); $this->assertEquals(false, $resultEntity->timed_out); $this->assertInstanceOf('Elastification\\Client\\Serializer\\JmsSerializer\\Shards', $resultEntity->_shards); $this->assertEquals(1, $resultEntity->_shards->total); $this->assertEquals(1, $resultEntity->_shards->successful); $this->assertEquals(0, $resultEntity->_shards->failed); $this->assertInstanceOf('Elastification\\Client\\Serializer\\JmsSerializer\\Hits', $resultEntity->hits); $this->assertEquals(1, $resultEntity->hits->total); $this->assertEquals(0, $resultEntity->hits->maxScore); $this->assertCount(1, $resultEntity->hits->hits); $hit = $resultEntity->hits->hits[0]; $this->assertInstanceOf('Elastification\\Client\\Serializer\\JmsSerializer\\Hit', $hit); $this->assertEquals('4372-4412104-928-DL', $hit->_id); $this->assertEquals('elastification', $hit->_index); $this->assertEquals('test', $hit->_type); $this->assertEquals(1.993935, $hit->_score); $entity = $hit->_source; $this->assertInstanceOf('Elastification\\Client\\Tests\\Fixtures\\Unit\\Serializer\\JmsSerializer\\TestEntity', $entity); $this->assertEquals(123, $entity->a); }
/** * @param \Doctrine\ORM\Event\LifecycleEventArgs $args */ public function postPersist(LifecycleEventArgs $args) { $layoutBlock = $args->getEntity(); if ($layoutBlock instanceof LayoutBlock) { if ($contentObject = $layoutBlock->getSnapshotContent()) { $contentObject = $this->serializer->deserialize($contentObject, $layoutBlock->getClassType(), 'json'); $em = $args->getEntityManager(); try { $em->persist($contentObject); $contentObject = $em->merge($contentObject); $reflection = new \ReflectionClass($contentObject); foreach ($reflection->getProperties() as $property) { $method = sprintf('get%s', ucfirst($property->getName())); if ($reflection->hasMethod($method) && ($var = $contentObject->{$method}())) { if ($var instanceof ArrayCollection) { foreach ($var as $v) { $em->merge($v); } } } } } catch (EntityNotFoundException $e) { $em->detach($contentObject); $classType = $layoutBlock->getClassType(); $contentObject = new $classType(); $em->persist($contentObject); } $em->flush($contentObject); $layoutBlock->setObjectId($contentObject->getId()); $em->persist($layoutBlock); $em->flush($layoutBlock); } } }
/** * @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(); } }
public function put($resource, $body, $type, $options = []) { $options['body'] = $this->serializer->serialize($body, 'json'); $options['headers'] = ['Content-Type' => 'application/json']; $content = $this->client->put($resource, $options)->getBody()->getContents(); return $this->deserialize($content, $type); }
/** * @param mixed $object * @return array */ public function unmapObject($object) { if (is_array($object)) { return $object; } return $this->serializer->toArray($object); }
/** * @param array $data * @param Serializer $serializer * @return LegalEntity * @throws \Exception */ public static function create(array $data, Serializer $serializer) { $caseType = null; $data['caseType'] = isset($data['caseType']) ? $data['caseType'] : 'Lpa'; if (!empty($data['caseType'])) { switch ($data['caseType']) { case "Epa": $caseType = "Opg\\Core\\Model\\Entity\\CaseItem\\PowerOfAttorney\\Epa"; break; case "Order": $caseType = "Opg\\Core\\Model\\Entity\\CaseItem\\Deputyship\\Order"; break; default: $caseType = "Opg\\Core\\Model\\Entity\\CaseItem\\PowerOfAttorney\\Lpa"; break; } } else { throw new \Exception('Cannot build unknown case type.'); } try { /** @var CaseItem $case */ $case = $serializer->deserialize(json_encode($data), $caseType, 'json'); } catch (\Exception $e) { throw $e; } return $case; }
public function testDeserializeJson() { $json = '{"foo":"bar","baz":[1,2,3]}'; /** @var Metadata $metadata */ $metadata = $this->serializer->deserialize($json, Metadata::class, 'json'); $this->assertInstanceOf(Metadata::class, $metadata); $this->assertEquals(['baz' => [1, 2, 3], 'foo' => 'bar'], $metadata->toArray()); }
/** * @param InputInterface $input * @param OutputInterface $output * * @return bool */ protected function execute(InputInterface $input, OutputInterface $output) { foreach ($this->sources as $name => $class) { $result = $this->serializer->deserialize(file_get_contents(getcwd() . '/tests/Common/Api/test_cases/protocols/output/fixtures/' . $name . '.xml'), $class, 'xml'); file_put_contents(getcwd() . '/tests/Common/Api/test_cases/protocols/output/fixtures/' . $name . '.serialized', serialize($result->getBody())); $output->writeln('Processed ' . $name . ' serialized file.'); } }
/** * 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); }
/** * @param ServiceEvent $event */ public function onResponseEvent(ServiceEvent $event) { $service = $event->getService(); if ($service instanceof ServiceConfigurableInterface && null !== $service->getOption('response_type')) { /** @var Service $service */ $service->getResponse()->setDeserializedContent($this->serializer->deserialize($service->getResponse()->getContent(), $service->getOption('response_type'), $service->getOption('response_format'))); } }
public function json($data, $groups = null) { if ($groups) { $this->context->setGroups($groups); } $serializedData = $this->serializer->serialize($data, 'json', $this->context); return $serializedData; }
/** * @param AbstractJsonEvent $event * * @return AbstractJsonEvent */ public function deserialize(AbstractJsonEvent $event) { $deSerialized = $this->serializer->deserialize($event->getJson(), get_class($event), self::JSON_FORMAT); $deSerialized->type = $event->type; $deSerialized->content = $event->content; $deSerialized->setName($event->getName()); return $deSerialized; }
/** * Deserializes request content. * * @param ResponseInterface $response * @param string $type * @param string $format * * @return mixed * * @throws \Exception */ protected function deserialize(ResponseInterface $response, $type, $format = 'json') { try { return $this->serializer->deserialize((string) $response->getBody(), $type, $format); } catch (\Exception $exception) { $this->logger->error('[WebServiceClient] Deserialization problem on webservice call.', array('response' => (string) $response->getBody(), 'exception' => $exception)); throw $exception; } }
public function testDeserializeJson() { $json = '{"uuid":"ed34c88e-78b0-11e3-9ade-406c8f20ad00"}'; /** @var ObjectWithUuid $object */ $object = $this->serializer->deserialize($json, ObjectWithUuid::class, 'json'); $uuid = $object->getUuid(); $this->assertInstanceOf(UuidInterface::class, $uuid); $this->assertEquals('ed34c88e-78b0-11e3-9ade-406c8f20ad00', (string) $uuid); }
/** * @inheritDoc */ public function getResponse($responseType, $view, $templateName, $params, $status = 200, $headers = [], $groups = ['Default']) { if ($responseType === 'html') { $response = $this->getHtml($view, $templateName, $params); } else { $response = $this->serializer->serialize($params, $responseType, SerializationContext::create()->setGroups($groups)); } return new Response($response, $status, $headers); }
protected function setUp() { $this->channel = $this->prophesize(AMQPChannel::class); $this->serializer = $this->prophesize(Serializer::class); $this->eventDispatcher = $this->prophesize(EventDispatcherInterface::class); $this->parser = $this->prophesize(Parser::class); $this->manager = new ConsumerManager($this->channel->reveal(), self::EXCHANGE_NAME, $this->serializer->reveal(), $this->parser->reveal()); $this->manager->setEventDispatcher($this->eventDispatcher->reveal()); }
/** * @test */ public function it_can_be_deserialized() { $modelData = $this->getModelData(); $modelClass = $this->getModelClass(); /** @var AbstractModel $model */ $model = $this->serializer->deserialize(json_encode($modelData), $modelClass, 'json'); $this->assertInstanceOf($modelClass, $model); $this->assertInstanceOf('CL\\Slack\\Model\\AbstractModel', $model); $this->assertModel($modelData, $model); }
/** * @param $data * @param $entityName * @return mixed */ public function hydrateEntity($data, $entityName) { if (empty($data)) { $data = array(); } if (is_string($data)) { $data = json_decode($data, true); } return $this->serializer->deserialize(json_encode($this->transformer->transformHydrateData($data)), $entityName, 'json'); }
public function put($resource, $body, $type, $options = []) { $options['future'] = true; $options['body'] = $this->serializer->serialize($body, 'json'); $options['headers'] = ['Content-Type' => 'application/json']; return $this->client->put($resource, $options)->then(function (Response $reponse) { return $reponse->getBody()->getContents(); })->then(function ($content) use($type) { return $this->deserialize($content, $type); }); }
/** * @param array|object $data * @param string $dtoClassName * @param string $outputFormat * @return array */ public function serialize($data, $dtoClassName, $outputFormat = 'json') { // TODO: check if $data is object or array $itemArray = []; foreach ($data as $item) { $dto = $this->shifter->toDto($item, new $dtoClassName()); $serializedData = $this->serializer->serialize($dto, $outputFormat); $itemArray[] = (array) json_decode($serializedData); } return $itemArray; }
/** * * @param string $filename * * @return \CSanquer\FakeryGenerator\Model\Config * * @throws \InvalidArgumentException */ public function load($filename) { $file = new \SplFileInfo($filename); if (!in_array($file->getExtension(), ['json', 'xml'])) { throw new \InvalidArgumentException('The config file must be an XML or a JSON file.'); } if (!file_exists($file->getRealPath())) { throw new \InvalidArgumentException('The config file must exist.'); } return $this->serializer->deserialize(file_get_contents($file->getRealPath()), 'CSanquer\\FakeryGenerator\\Model\\Config', $file->getExtension()); }
/** * @param AMQPMessage $msg * @return bool */ public function execute(AMQPMessage $msg) { $post = $this->serializer->deserialize($msg->body, 'AppBundle\\Entity\\Post', 'json'); $targetPath = $this->container->get('kernel')->getRootDir() . '/../web/downloads/pdf/' . $post->getPdfName() . '.pdf'; $this->container->get('knp_snappy.pdf')->generateFromHtml($this->templating->render('RabbitMQBundle::pdf_post_view.html.twig', array('post' => $post)), $targetPath); if (file_exists($targetPath)) { return true; } else { return false; } }
/** * @param object $entidad * @param string $contenido */ public function store($entidad, $contenido) { if (!method_exists($entidad, 'getDetalles')) { throw new HttpException(400, "No el objeto no tiene detalles serializables"); } $observacion = new Observacion(); $observacion->setContenido($contenido); $observacion->setRelated($entidad->getId()); $observacion->setLastState($this->serializer->serialize($entidad->getDetalles(), 'json')); $this->manager->persist($observacion); }
/** * {@inheritdoc} */ public function reverseTransform($data) { if ($data === null) { return null; } try { return $this->serializer->deserialize($data, $this->class, $this->format); } catch (JMSException $e) { throw new StorageException('The JMS serializer failed deserializing the data: ' . $e->getMessage(), 0, $e); } }
/** * @param GetResponseForControllerResultEvent $event */ public function onKernelView(GetResponseForControllerResultEvent $event) { $result = $event->getControllerResult(); if ($result instanceof Response) { return $result; } $serialized = $this->serializer->serialize($result, 'json'); $response = new Response(); $response->setContent($serialized); $response->headers->add(array('Content-type' => 'application/json')); $event->setResponse($response); }
/** * @param Request $requestModel * @param string $responseType * * @throws Exception\FastBillException * @return \DVelopment\FastBill\Model\FbApi */ public function call(Request $requestModel, $responseType = 'DVelopment\\FastBill\\Model\\FbApi') { $request = new GetRequest(self::API_BASE_URL); $request->setUseAuthentication(true)->setUsername($this->username)->setPassword($this->apiKey)->setFormat('json')->setContentType('application/json'); $request->setBody($this->serializer->serialize($requestModel, 'json')); /** @var FbApi $fbApi */ $fbApi = $this->client->execute($request, null, $responseType)->getContent(); if (count($fbApi->getResponse()->errors)) { throw new FastBillException($fbApi->getResponse()->errors); } return $fbApi; }
/** * Stores the object in the request. * * @param Request $request The request * @param ParamConverter $configuration Contains the name, class and options of the object * * @throws \InvalidArgumentException * * @return bool True if the object has been successfully set, else false */ public function apply(Request $request, ParamConverter $configuration) { $name = $configuration->getName(); $class = $configuration->getClass(); $options = $configuration->getOptions(); if (isset($options['query'])) { $content = new \stdClass(); $metadata = $this->serializer->getMetadataFactory()->getMetadataForClass($class); foreach ($metadata->propertyMetadata as $propertyMetadata) { if (!$propertyMetadata->readOnly) { $property = $propertyMetadata->name; $value = $request->query->get($propertyMetadata->name); if (!is_null($value)) { $content->{$property} = $request->query->get($propertyMetadata->name); } } } $content = json_encode($content); } else { $content = $request->getContent(); } if (!class_exists($class)) { throw new \InvalidArgumentException($class . ' class does not exist.'); } $success = false; try { $model = $this->serializer->deserialize($content, $class, 'json'); $success = true; } catch (\Exception $e) { $model = new $class(); } /** * Validate if possible */ if ($model instanceof ValidatableInterface) { $violations = $this->validator->validate($model); $valid = $success && !(bool) $violations->count(); $model->setViolations($violations); $model->setValid($valid); } /** * Adding transformed collection * to request attribute. */ $request->attributes->set($name, $model); /** * Alias to access current collection * Used by exception listener */ $request->attributes->set(Alias::DATA, $name); return true; }
/** * Tests getting ident codes with XML response * * @param int $expectedStatusCode * @param string $account * @param int $serial * @param string $expectedResponse * * @dataProvider provideIdentCodeData */ public function testIdentCodeXml($expectedStatusCode, $account, $serial, $expectedResponse) { $this->client->request('GET', sprintf('/dhl/b2b/identcode/%s/%d.xml', $account, $serial)); // Assert if the response status code isn't equal to the expected one $this->assertEquals($expectedStatusCode, $this->client->getResponse()->getStatusCode(), $this->client->getResponse()->getContent()); // Assert that the "Content-Type" header is "application/json" $this->assertTrue($this->client->getResponse()->headers->contains('Content-Type', 'text/xml; charset=UTF-8'), $this->client->getResponse()->headers->get('Content-Type')); // Check if it's a valid XML $doc = new DOMDocument(); $this->assertTrue($doc->loadXML($this->client->getResponse()->getContent()), 'Is no valid XML'); // Assert that the expected response is equal to the current one $this->assertEquals($this->serializer->serialize($expectedResponse, 'xml'), $this->client->getResponse()->getContent(), 'XML is not equal'); }
/** * @covers phpDocumentor\Transformer\Template\Factory::get * @covers phpDocumentor\Transformer\Template\Factory::fetchTemplateXmlFromPath * @covers phpDocumentor\Transformer\Template\Factory::createTemplateFromXml */ public function testRetrieveInstantiatedTemplate() { // Arrange $templateName = 'clean'; $template = new Template($templateName); vfsStream::setup('exampleDir')->addChild(vfsStream::newFile('template.xml')->setContent('xml')); $this->pathResolverMock->shouldReceive('resolve')->with($templateName)->andReturn(vfsStream::url('exampleDir')); $this->serializerMock->shouldReceive('deserialize')->with('xml', 'phpDocumentor\\Transformer\\Template', 'xml')->andReturn($template); // Act $result = $this->fixture->get($templateName); // Assert $this->assertSame($template, $result); }
/** * @param bool $deserialize * @return Post[]|null * @throws \Doctrine\DBAL\DBALException */ public function getAllInJson($deserialize = true) { $stmt = $this->getEntityManager()->getConnection()->prepare(file_get_contents(__DIR__ . self::RESOURCES_QUERY_PATH . 'get_all_posts_json.sql')); $stmt->execute(); $result = $stmt->fetchAll(); if ($deserialize) { if (!empty($result[0]['array_to_json'])) { return $this->serializer->deserialize($result[0]['array_to_json'], 'array<AppBundle\\Entity\\Post>', 'json'); } return null; } return $result[0]['array_to_json']; }