Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
69.83%
81 / 116
42.86%
3 / 7
 CRAP
0.00%
0 / 1
ObjectSerializer
69.83%
81 / 116
42.86%
3 / 7
 163.21
0.00%
0 / 1
 sanitizeForSerialization
69.23%
27 / 39
0.00%
0 / 1
 36.10
 toPathValue
100.00%
1 / 1
100.00%
1 / 1
 1
 toQueryValue
80.00%
4 / 5
0.00%
0 / 1
 4.13
 toString
66.67%
2 / 3
0.00%
0 / 1
 3.33
 deserialize
100.00%
3 / 3
100.00%
1 / 1
 1
 mapToClass
100.00%
11 / 11
100.00%
1 / 1
 6
 castData
61.11%
33 / 54
0.00%
0 / 1
 57.88
1<?php
2
3/**
4 * ObjectSerializer.
5 *
6 * PHP version 5
7 *
8 * @category Class
9 *
10 * @author   Swagger Codegen team
11 *
12 * @see     https://github.com/swagger-api/swagger-codegen
13 */
14
15/**
16 * Fingerprint Pro Server API.
17 *
18 * Fingerprint Pro Server API allows you to get information about visitors and about individual events in a server environment. It can be used for data exports, decision-making, and data analysis scenarios. Server API is intended for server-side usage, it's not intended to be used from the client side, whether it's a browser or a mobile device.
19 *
20 * OpenAPI spec version: 3
21 * Contact: support@fingerprint.com
22 * Generated by: https://github.com/swagger-api/swagger-codegen.git
23 * Swagger Codegen version: 3.0.34
24 */
25/**
26 * NOTE: This class is auto generated by the swagger code generator program.
27 * https://github.com/swagger-api/swagger-codegen
28 * Do not edit the class manually.
29 */
30
31namespace Fingerprint\ServerAPI;
32
33use Psr\Http\Message\ResponseInterface;
34
35/**
36 * ObjectSerializer Class Doc Comment.
37 *
38 * @category Class
39 *
40 * @author   Swagger Codegen team
41 *
42 * @see     https://github.com/swagger-api/swagger-codegen
43 */
44class ObjectSerializer
45{
46    /**
47     * Serialize data.
48     *
49     * @param mixed       $data   the data to serialize
50     * @param string|null $format the format of the Swagger type of the data
51     *
52     * @return array|object|string serialized form of $data
53     */
54    public static function sanitizeForSerialization(mixed $data, ?string $format = null): array|bool|object|string
55    {
56        if (is_scalar($data) || null === $data) {
57            return $data;
58        }
59        if ($data instanceof \DateTime) {
60            return ('date' === $format) ? $data->format('Y-m-d') : $data->format(\DateTime::ATOM);
61        }
62        if (is_array($data)) {
63            foreach ($data as $property => $value) {
64                if (is_scalar($value)) {
65                    $data[$property] = $value;
66                } else {
67                    $data[$property] = self::sanitizeForSerialization($value);
68                }
69            }
70
71            return $data;
72        }
73        if ($data instanceof \stdClass) {
74            foreach ($data as $property => $value) {
75                if (is_scalar($value)) {
76                    $data->{$property} = $value;
77                } else {
78                    $data->{$property} = self::sanitizeForSerialization($value);
79                }
80            }
81
82            return $data;
83        }
84
85        if (is_object($data)) {
86            $class = get_class($data);
87            if (enum_exists($class)) {
88                return $data->value;
89            }
90            $values = [];
91            $formats = $data::swaggerFormats();
92            foreach ($data::swaggerTypes() as $property => $swaggerType) {
93                $getter = $data::getters()[$property];
94                $value = $data->{$getter}();
95                if (null !== $value
96                    && !in_array($swaggerType, ['DateTime', 'bool', 'boolean', 'byte', 'double', 'float', 'int', 'integer', 'mixed', 'number', 'object', 'string', 'void'], true)
97                    && method_exists($swaggerType, 'getAllowableEnumValues')
98                    && !in_array($value, $swaggerType::getAllowableEnumValues())) {
99                    $imploded = implode("', '", $swaggerType::getAllowableEnumValues());
100
101                    throw new \InvalidArgumentException("Invalid value for enum '{$swaggerType}', must be one of: '{$imploded}'");
102                }
103                if (null !== $value) {
104                    if (is_scalar($value)) {
105                        $values[$data::attributeMap()[$property]] = $value;
106                    } elseif ('tag' === $property && empty($value)) {
107                        $values[$data::attributeMap()[$property]] = new \stdClass();
108                    } else {
109                        $values[$data::attributeMap()[$property]] = self::sanitizeForSerialization($value, $swaggerType, $formats[$property]);
110                    }
111                }
112            }
113
114            return (object) $values;
115        }
116
117        return (string) $data;
118    }
119
120    /**
121     * Take value and turn it into a string suitable for inclusion in
122     * the path, by url-encoding.
123     *
124     * @param string $value a string which will be part of the path
125     *
126     * @return string the serialized object
127     */
128    public static function toPathValue(string $value): string
129    {
130        return rawurlencode(self::toString($value));
131    }
132
133    /**
134     * Take value and turn it into a string suitable for inclusion in
135     * the query, by imploding comma-separated if it's an object.
136     * If it's a string, pass through unchanged. It will be url-encoded
137     * later.
138     *
139     * @param \DateTime|string|string[] $object an object to be serialized to a string
140     * @param string|null               $format the format of the parameter
141     *
142     * @return string the serialized object
143     */
144    public static function toQueryValue(array|bool|\DateTime|string $object, ?string $format = null): string
145    {
146        if (is_array($object)) {
147            return implode(',', $object);
148        }
149
150        if (is_bool($object)) {
151            return $object ? 'true' : 'false';
152        }
153
154        return self::toString($object, $format);
155    }
156
157    /**
158     * Take value and turn it into a string suitable for inclusion in
159     * the parameter. If it's a string, pass through unchanged
160     * If it's a datetime object, format it in RFC3339
161     * If it's a date, format it in Y-m-d.
162     *
163     * @param \DateTime|string $value  the value of the parameter
164     * @param string|null      $format the format of the parameter
165     *
166     * @return string the header string
167     */
168    public static function toString(\DateTime|string $value, ?string $format = null): string
169    {
170        if ($value instanceof \DateTime) {
171            return ('date' === $format) ? $value->format('Y-m-d') : $value->format(\DateTime::ATOM);
172        }
173
174        return $value;
175    }
176
177    /**
178     * Deserialize a JSON string into an object.
179     *
180     * @param string $class class name is passed as a string
181     *
182     * @throws \Exception
183     */
184    public static function deserialize(ResponseInterface $response, string $class): mixed
185    {
186        $data = $response->getBody()->getContents();
187        $response->getBody()->rewind();
188
189        return self::mapToClass($data, $class, $response);
190    }
191
192    protected static function mapToClass(mixed $data, string $class, ResponseInterface $response): mixed
193    {
194        if ('string' === gettype($data)) {
195            $data = json_decode($data, false);
196        }
197        $instance = new $class();
198        foreach ($instance::swaggerTypes() as $property => $type) {
199            $propertySetter = $instance::setters()[$property];
200
201            if (!isset($propertySetter) || !isset($data->{$instance::attributeMap()[$property]})) {
202                continue;
203            }
204
205            $propertyValue = $data->{$instance::attributeMap()[$property]};
206            if (isset($propertyValue)) {
207                $instance->{$propertySetter}(self::castData($propertyValue, $type, $response));
208            }
209        }
210
211        return $instance;
212    }
213
214    protected static function castData(mixed $data, string $class, ResponseInterface $response): mixed
215    {
216        if (null === $data) {
217            return null;
218        }
219        if (str_starts_with($class, 'map[')) { // for associative array e.g. map[string,int]
220            $inner = substr($class, 4, -1);
221            $deserialized = [];
222            if (false !== strrpos($inner, ',')) {
223                $subClass_array = explode(',', $inner, 2);
224                $subClass = $subClass_array[1];
225                foreach ($data as $key => $value) {
226                    $deserialized[$key] = self::castData($value, $subClass, $response);
227                }
228            }
229
230            return $deserialized;
231        }
232        if (0 === strcasecmp(substr($class, -2), '[]')) {
233            $subClass = substr($class, 0, -2);
234            $values = [];
235            foreach ($data as $key => $value) {
236                $values[] = self::castData($value, $subClass, $response);
237            }
238
239            return $values;
240        }
241        if ('mixed' === $class) {
242            if ($data instanceof \stdClass) {
243                if (empty(get_object_vars($data))) {
244                    return null;
245                }
246
247                return (array) $data;
248            }
249
250            return $data;
251        }
252        if ('object' === $class || 'array' === $class) {
253            settype($data, 'array');
254
255            return $data;
256        }
257        if ('\DateTime' === $class) {
258            // Some API's return an invalid, empty string as a
259            // date-time property. DateTime::__construct() will return
260            // the current time for empty input which is probably not
261            // what is meant. The invalid empty string is probably to
262            // be interpreted as a missing field/value. Let's handle
263            // this graceful.
264            if (!empty($data)) {
265                return new \DateTime($data);
266            }
267
268            return null;
269        }
270        if (in_array($class, ['DateTime', 'bool', 'boolean', 'byte', 'double', 'float', 'int', 'integer', 'mixed', 'number', 'object', 'string', 'void'], true)) {
271            $originalData = $data;
272            $normalizedClass = strtolower($class);
273
274            switch ($normalizedClass) {
275                case 'int':
276                    $normalizedClass = 'integer';
277
278                    break;
279
280                case 'bool':
281                    $normalizedClass = 'boolean';
282
283                    break;
284            }
285            if ('float' === $normalizedClass && is_numeric($originalData)) {
286                return (float) $originalData;
287            }
288            if ('string' === $normalizedClass && is_object($data)) {
289                throw new SerializationException($response);
290            }
291
292            settype($data, $class);
293            if (gettype($data) === $normalizedClass) {
294                return $data;
295            }
296
297            throw new SerializationException($response);
298        } elseif (enum_exists($class)) {
299            try {
300                return $class::from($data);
301            } catch (\ValueError $e) {
302                $allowedValues = array_map(fn ($case) => $case->value, $class::cases());
303                $imploded = implode("', '", $allowedValues);
304
305                throw new \InvalidArgumentException("Invalid value '{$data}' for enum '{$class}', must be one of: '{$imploded}'");
306            }
307
308            return $data;
309        }
310
311        return self::mapToClass($data, $class, $response);
312    }
313}