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'];
}
