vendor/univapay/php-sdk/src/Univapay/Utility/Json/JsonSchema.php line 105

Open in your IDE?
  1. <?php
  3. namespace Univapay\Utility\Json;
  5. use Univapay\Utility\FunctionalUtils;
  6. use ReflectionClass;
  7. use Univapay\Utility\StringUtils;
  9. class JsonSchema
  10. {
  11.     public $components;
  12.     public $prefix;
  13.     public $targetClass;
  15.     public function __construct($targetClass, $prefix = null)
  16.     {
  17.         $this->components = [];
  18.         $this->targetClass = $targetClass;
  19.         $this->prefix = $prefix;
  20.     }
  21.     
  22.     /**
  23.      * @param Callable $formatter - Take in the following variables:
  24.      *      $value - The value at the path
  25.      *      $contextRoot - The root at the same level with $value
  26.      *      $root - The original object that is being parsed
  27.      *      $additionalArgs - An array that usually contains the context,
  28.      *          but may be injected with additional args for object construction
  29.      */
  30.     public function with($path, $required = false, $formatter = 'Univapay\Utility\FunctionalUtils::identity')
  31.     {
  32.         array_push($this->components, new SchemaComponent($this->prefix . '/' .$path, $required, $formatter));
  33.         return $this;
  34.     }
  36.     public function withNested(JsonSchema $schema)
  37.     {
  38.         foreach ($schema->components as $element) {
  39.             array_push($this->components, $element);
  40.         }
  41.         return $this;
  42.     }
  44.     public function upsert($path, $required = false, $formatter = 'Univapay\Utility\FunctionalUtils::identity')
  45.     {
  46.         $index = FunctionalUtils::arrayFindIndex($this->components, function ($value) use ($path) {
  47.             return $value->path === $path;
  48.         });
  49.         if ($index !== null) {
  50.             $this->components = array_replace(
  51.                 $this->components,
  52.                 [$index => new SchemaComponent($this->prefix . '/' .$path, $required, $formatter)]
  53.             );
  54.             return $this;
  55.         } else {
  56.             return $this->with($path, $required = $required, $formatter = $formatter);
  57.         }
  58.     }
  60.     private function getValues($json, array $parent = null, array $additionalArgs = [])
  61.     {
  62.         return array_map(function ($component) use ($json, $parent, $additionalArgs) {
  63.             $path_parts = explode('/', $component->path);
  64.             $value = JsonSchema::getField($json, $component->required, $path_parts);
  65.             if ($value === null) {
  66.                 if ($component->required) {
  67.                     throw new RequiredValueNotFoundException($component->path);
  68.                 } else {
  69.                     return null;
  70.                 }
  71.             }
  72.             return call_user_func($component->formatter, $value, $json, $parent, $additionalArgs);
  73.         }, $this->components);
  74.     }
  76.     public function parse($json, array $additionalArgs = [], array $parent = null)
  77.     {
  78.         $targetClass = new ReflectionClass($this->targetClass);
  79.         $arguments = array_merge($this->getValues($json, $parent, $additionalArgs), $additionalArgs);
  80.         return $targetClass->newInstanceArgs($arguments);
  81.     }
  83.     public function getParser(array $context = [])
  84.     {
  85.         return function ($json, $contextRoot = null, array $root = null, array $additionalArgs = []) use ($context) {
  86.             $additionalArgs = empty($context) ? $additionalArgs : $context;
  87.             return $this->parse($json, $additionalArgs, isset($root) ? $root : $contextRoot);
  88.         };
  89.     }
  91.     public static function fromClass($targetClass, $snakeCase = true, $includeParentVars = true)
  92.     {
  93.         $classVars = FunctionalUtils::getClassVarsAssoc($targetClass, $includeParentVars);
  94.         $newSchema = new JsonSchema($targetClass);
  95.         return array_reduce(
  96.             $classVars,
  97.             function ($schema, $path) use ($snakeCase) {
  98.                 $realPath = $snakeCase ? StringUtils::toSnakeCase($path) : $path;
  99.                 return $schema->with($realPath);
  100.             },
  101.             $newSchema
  102.         );
  103.     }
  105.     public static function getField($json, $required, array $paths)
  106.     {
  107.         if ($json === null && !$required) {
  108.             return $json;
  109.         }
  110.         if (sizeof($paths) === 0) {
  111.             throw new NoSuchPathException(null);
  112.         }
  113.         $nextKey = $paths[0];
  115.         if (!array_key_exists($nextKey, $json)) {
  116.             if ($required) {
  117.                 throw new NoSuchPathException($nextKey);
  118.             } else {
  119.                 return null;
  120.             }
  121.         }
  122.         $nextJson = $json[$nextKey];
  123.         if (sizeof($paths) === 1) {
  124.             return $nextJson;
  125.         } else {
  126.             try {
  127.                 return JsonSchema::getField($nextJson, $required, array_slice($paths, 1));
  128.             } catch (NoSuchPathException $except) {
  129.                 throw new NoSuchPathException($nextKey . '/' . $except->path);
  130.             }
  131.         }
  132.     }
  133. }