PHP Assertion::isJsonString方法代碼示例

 /**
  * @param string $jsonString
  * @return Result
  */
 public static function fromJSON($jsonString)
 {
     Assertion::isJsonString($jsonString);
     $itemJsonStrings = json_decode($jsonString, true);
     $items = array();
     foreach ($itemJsonStrings as $anItemJsonString) {
         $items[] = Item::fromJSON($anItemJsonString);
     }
     return new ItemCollection($items);
     $p = new Paginator();
 }

 /**
  * @param string $jsonString
  * @return LazyItemsLoader
  * @throws \RuntimeException
  */
 public static function fromJSON($jsonString)
 {
     if (is_null(static::$itemsLoaderManager)) {
         throw new \RuntimeException('ItemsLoaderManager is missing');
     }
     Assertion::isJsonString($jsonString);
     $anItemsLoaderName = json_decode($jsonString);
     Assertion::string($anItemsLoaderName);
     $anItemsLoader = static::$itemsLoaderManager->get($anItemsLoaderName);
     return new LazyItemsLoader($anItemsLoader);
 }

 public function execute(Request $request, Response $response, callable $next = null)
 {
     $pathParams = $request->getAttribute('pathParams');
     $params = $request->getQueryParams();
     $body = $request->getBody();
     \Assert\Assertion::keyExists($pathParams, 'name');
     \Assert\Assertion::keyExists($pathParams, 'id');
     \Assert\Assertion::isJsonString($body);
     $collection = $pathParams['name'];
     $id = $pathParams['id'];
     $data = json_decode($body, true);
     $this->boot()->db->table($collection)->update($data, "`id` = {$id}");
     $item = $this->boot()->db->table($collection)->fetchRow("`id` = {$id}");
     $hal = new Hal("/collection/{$collection}/{$id}", $item->toArray());
     $response = $response->withBody($this->toStream($hal->asJson()));
     if ($next) {
         $response = $next($request, $response);
     }
     return $response;
 }

 /**
  * @param string $requestMethod
  * @param string $path
  * @param array $options
  * @return array
  * @throws RequestException If the request fails
  * @throws ResponseException If the response does not contain valid json / the expected structure
  */
 public function request($requestMethod, $path, array $options = [])
 {
     $url = $this->buildRequestUrl($path);
     $options = $this->buildRequestConfiguration($options);
     try {
         $response = $this->client->request($requestMethod, $url, $options);
         if (!$response instanceof Response) {
             throw new \Exception('An error occurred while calling the API');
         }
         $content = $response->getBody()->getContents();
         Assertion::isJsonString($content);
         $content = json_decode($content, true);
         return $this->getResult($content);
     } catch (GuzzleException $exception) {
         throw new RequestException('An error occurred while calling the API');
     } catch (InvalidArgumentException $exception) {
         throw new ResponseException('The response did not contain valid JSON');
     } catch (\Exception $exception) {
         throw new RequestException('An error occurred while calling the API');
     }
 }

 public function execute(Request $request, Response $response, callable $next = null)
 {
     try {
         $pathParams = $request->getAttribute('pathParams');
         \Assert\Assertion::keyExists($pathParams, 'name');
         $body = $request->getBody();
         \Assert\Assertion::isJsonString($body);
         $collection = $pathParams['name'];
         $data = json_decode($body, true);
         $id = $this->boot()->db->table($collection)->insert($data);
         $item = $this->boot()->db->table($collection)->fetchRow("`id` = {$id}");
         $hal = new Hal("/collection/{$collection}/{$id}", $item->toArray());
         $response = $response->withBody($this->toStream($hal->asJson()));
     } catch (\Exception $ex) {
         $problem = new \Crell\ApiProblem\ApiProblem($ex->getMessage(), $request->getUri()->getPath());
         $problem->setDetail($ex->getTraceAsString())->setStatus($ex->getCode());
         return $response->withStatus(500)->withBody($this->toStream($problem->asJson()));
     }
     if ($next) {
         $response = $next($request, $response);
     }
     return $response;
 }

 /**
  * @dataProvider isJsonStringInvalidStringDataprovider
  */
 public function testIsJsonStringExpectingException($invalidString)
 {
     $this->setExpectedException('Assert\\AssertionFailedException', null, Assertion::INVALID_JSON_STRING);
     Assertion::isJsonString($invalidString);
 }

 /**
  * @param string $jsonString
  * @return Item
  * @throws \Assert\AssertionFailedException
  */
 public static function fromJSON($jsonString)
 {
     Assertion::isJsonString($jsonString);
     return new Item(json_decode($jsonString, true));
 }

 /**
  * @param $argumentsString
  * @return Arguments
  */
 public function fromString($argumentsString)
 {
     Assertion::isJsonString($argumentsString, "ArgumentsString must be valid JSON Format");
     return new Arguments(json_decode($argumentsString, true));
 }