PHP SerializerInterface::serialize方法代码示例

 /**
  * @param array $data
  * @param string|null|array $serializationLevel
  * @return Response
  */
 public function createResponse(array $data, $serializationLevel = null)
 {
     $responseData = [static::KEY_STATUS => static::STATUS_SUCCESS, static::KEY_DATA => $data];
     $serializedData = $this->serializer->serialize($responseData, self::STANDARD_RESPONSE_FORMAT, $serializationLevel ? SerializationContext::create()->setGroups($serializationLevel) : SerializationContext::create());
     $response = $this->getJsonResponse($serializedData);
     return $response;
 }

 /**
  * @param $track
  * @param $debug
  *
  * @throws RussianPostApiException
  * @throws InvalidTrackException
  *
  * @return OperationHistoryData
  */
 public function getTrackOperationHistory($track, &$debug, $language = "RUS")
 {
     if (!TrackValidator::validateTrack($track)) {
         throw new InvalidTrackException();
     }
     $track = TrackValidator::filterTrack($track);
     $client = $this->initClient();
     $AuthorizationHeader = self::createAuthorizationHeader($this->login, $this->password);
     $historyRequest = self::createOperationHistoryRequest($track, 0, $language);
     $parameters = ["AuthorizationHeader" => $this->serializer->serialize($AuthorizationHeader, 'array'), "historyRequest" => $this->serializer->serialize($historyRequest, 'array')];
     //($operation, $params=array(), $namespace='http://tempuri.org', $soapAction='', $headers=false, $rpcParams=null, $style='rpc', $use='encoded')
     $result = $client->call('GetOperationHistory', $parameters, 'http://russianpost.org/operationhistory');
     $debug = array("Request" => $client->request, "Response" => $client->response, "Debug" => $client->debug_str);
     if ($client->fault) {
         throw new RussianPostApiException(print_r($result, true));
     } else {
         $err = $client->getError();
         if ($err) {
             throw new RussianPostApiException($err);
         } else {
             /** @var OperationHistoryData $object */
             $object = $this->serializer->deserialize($result, 'a3mg\\RussianPostBundle\\Model\\OperationHistoryData', 'array');
             return $object;
         }
     }
 }

 public function testSerializationToJson()
 {
     $subject = new Message('to', 'from', 'subject', 'message');
     $data = $this->serializer->serialize($subject, 'json');
     $object = $this->serializer->deserialize($data, get_class($subject), 'json');
     $this->assertEquals($subject, $object);
 }

 /**
  * @param $data
  * @param int $status
  * @param array $headers
  * @return \Symfony\Component\HttpFoundation\Response|static
  */
 protected function success($data, $status = 200, $headers = [])
 {
     $serialized_data = $this->serializer->serialize($data, 'json');
     $response = $this->jsonResponse;
     $response->setContent($serialized_data)->setStatusCode($status)->headers->add($headers);
     return $response;
 }

 /** @test */
 public function shouldSerializeDateTimesAsTimestamps()
 {
     $birthdayBoy = new BirthdayBoy();
     $birthdayBoy->setBirthDate(self::FromTimestamp(1234567));
     $json = $this->serializer->serialize($birthdayBoy, 'json');
     $this->assertJsonStringEqualsJsonString($json, '{"birthDate": 1234567 }');
 }

 /**
  * {@inheritdoc}
  */
 public function notifyCallback($callbackUrl, $statusResponse)
 {
     $requestBody = $this->serializer->serialize($statusResponse, 'json');
     $request = new \cURL\Request($callbackUrl);
     $request->getOptions()->set(CURLOPT_FILE, fopen('/dev/null', 'w'))->set(CURLOPT_TIMEOUT, 5)->set(CURLOPT_RETURNTRANSFER, false)->set(CURLOPT_CUSTOMREQUEST, 'POST')->set(CURLOPT_POSTFIELDS, $requestBody)->set(CURLOPT_HTTPHEADER, array('Content-Type: application/json', sprintf('Content-Length: %d', strlen($requestBody))));
     $request->send();
 }

 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 publish(Event $event)
 {
     try {
         $this->client->post(self::PUBLISH_URL, ['body' => $this->serializer->serialize($event, 'json')]);
     } catch (BadResponseException $exception) {
         throw new PublishException($exception->getMessage());
     }
 }

 /**
  * @param GameInterface $data
  * @param string        $format
  *
  * @return array|string
  */
 public function serialize($data, $format)
 {
     $serialized = $this->serializer->serialize($data, self::FORMAT_JSON, $this->serializationContext);
     if ($format === self::FORMAT_ARRAY) {
         $serialized = json_decode($serialized, true);
     }
     return $serialized;
 }

 /**
  * @param ApiResponse $apiResponse to convert to a Symfony Response.
  * @param Request $request that needs this Response.
  *
  * @return Response
  */
 public function toSymfonyResponse(ApiResponse $apiResponse, Request $request)
 {
     $format = $request->getRequestFormat($this->defaultResponseFormat);
     $serialized = $this->serializer->serialize($apiResponse->getData(), $format);
     $response = new Response($serialized, $apiResponse->getStatusCode(), $apiResponse->getHeaders());
     $response->headers->set('Content-Type', $request->getMimeType($format));
     return $response;
 }

 public function testSerializationToJson()
 {
     $exception = new \Exception('foobar', 100);
     $subject = new ExceptionResponse($exception);
     $data = $this->serializer->serialize($subject, 'json');
     $object = $this->serializer->deserialize($data, ExceptionResponse::class, 'json');
     $this->assertEquals($subject, $object);
 }

 /**
  * {@inheritdoc}
  */
 public function post($uri, $data = null, array $options = array())
 {
     if (is_array($data)) {
         $options = array_merge($data, $options);
         $data = new \StdClass();
     }
     $this->request('post', $uri, array('body' => $this->serializer->serialize($data, 'json', SerializationContext::create()->setAttribute('options', $options))));
 }

 public function testSerialize()
 {
     $pageDocument = $this->createPage();
     $managedPage = $this->contentMapper->load($pageDocument->getUuid(), 'sulu_io', 'fr');
     $this->assertInstanceOf(StructureBridge::class, $managedPage);
     $result = $this->serializer->serialize($managedPage, 'json');
     return $result;
 }

 /**
  * @inheritdoc
  */
 public function serialize($data, $format, $groups = null)
 {
     $context = null;
     if ($groups) {
         $context = SerializationContext::create()->setGroups($groups);
     }
     return $this->serializer->serialize($data, $format, $context);
 }

 /**
  * @param Request $request
  * @param string  $data
  *
  * @return string
  */
 public function serializeRequest(Request $request, $data)
 {
     $format = $this->checkAcceptHeader($request);
     try {
         return $this->serializer->serialize($data, $format);
     } catch (\Exception $e) {
         throw new \RuntimeException('Could not serialize content to \'' . $format . '\' format.');
     }
 }