1 |
|
2 |
|
3 | import * as base64 from "./util/base64";
|
4 | import * as utils from "./util/utils";
|
5 | var Serializer = (function () {
|
6 | function Serializer(modelMappers, isXML) {
|
7 | if (modelMappers === void 0) { modelMappers = {}; }
|
8 | this.modelMappers = modelMappers;
|
9 | this.isXML = isXML;
|
10 | }
|
11 | Serializer.prototype.validateConstraints = function (mapper, value, objectName) {
|
12 | var failValidation = function (constraintName, constraintValue) {
|
13 | throw new Error("\"" + objectName + "\" with value \"" + value + "\" should satisfy the constraint \"" + constraintName + "\": " + constraintValue + ".");
|
14 | };
|
15 | if (mapper.constraints && value != undefined) {
|
16 | var _a = mapper.constraints, ExclusiveMaximum = _a.ExclusiveMaximum, ExclusiveMinimum = _a.ExclusiveMinimum, InclusiveMaximum = _a.InclusiveMaximum, InclusiveMinimum = _a.InclusiveMinimum, MaxItems = _a.MaxItems, MaxLength = _a.MaxLength, MinItems = _a.MinItems, MinLength = _a.MinLength, MultipleOf = _a.MultipleOf, Pattern = _a.Pattern, UniqueItems = _a.UniqueItems;
|
17 | if (ExclusiveMaximum != undefined && value >= ExclusiveMaximum) {
|
18 | failValidation("ExclusiveMaximum", ExclusiveMaximum);
|
19 | }
|
20 | if (ExclusiveMinimum != undefined && value <= ExclusiveMinimum) {
|
21 | failValidation("ExclusiveMinimum", ExclusiveMinimum);
|
22 | }
|
23 | if (InclusiveMaximum != undefined && value > InclusiveMaximum) {
|
24 | failValidation("InclusiveMaximum", InclusiveMaximum);
|
25 | }
|
26 | if (InclusiveMinimum != undefined && value < InclusiveMinimum) {
|
27 | failValidation("InclusiveMinimum", InclusiveMinimum);
|
28 | }
|
29 | if (MaxItems != undefined && value.length > MaxItems) {
|
30 | failValidation("MaxItems", MaxItems);
|
31 | }
|
32 | if (MaxLength != undefined && value.length > MaxLength) {
|
33 | failValidation("MaxLength", MaxLength);
|
34 | }
|
35 | if (MinItems != undefined && value.length < MinItems) {
|
36 | failValidation("MinItems", MinItems);
|
37 | }
|
38 | if (MinLength != undefined && value.length < MinLength) {
|
39 | failValidation("MinLength", MinLength);
|
40 | }
|
41 | if (MultipleOf != undefined && value % MultipleOf !== 0) {
|
42 | failValidation("MultipleOf", MultipleOf);
|
43 | }
|
44 | if (Pattern) {
|
45 | var pattern = typeof Pattern === "string" ? new RegExp(Pattern) : Pattern;
|
46 | if (typeof value !== "string" || value.match(pattern) === null) {
|
47 | failValidation("Pattern", Pattern);
|
48 | }
|
49 | }
|
50 | if (UniqueItems &&
|
51 | value.some(function (item, i, ar) { return ar.indexOf(item) !== i; })) {
|
52 | failValidation("UniqueItems", UniqueItems);
|
53 | }
|
54 | }
|
55 | };
|
56 | |
57 |
|
58 |
|
59 |
|
60 |
|
61 |
|
62 |
|
63 |
|
64 |
|
65 |
|
66 |
|
67 | Serializer.prototype.serialize = function (mapper, object, objectName) {
|
68 | var payload = {};
|
69 | var mapperType = mapper.type.name;
|
70 | if (!objectName) {
|
71 | objectName = mapper.serializedName;
|
72 | }
|
73 | if (mapperType.match(/^Sequence$/gi) !== null) {
|
74 | payload = [];
|
75 | }
|
76 | if (mapper.isConstant) {
|
77 | object = mapper.defaultValue;
|
78 | }
|
79 |
|
80 |
|
81 |
|
82 |
|
83 |
|
84 |
|
85 |
|
86 |
|
87 |
|
88 | var required = mapper.required, nullable = mapper.nullable;
|
89 | if (required && nullable && object === undefined) {
|
90 | throw new Error(objectName + " cannot be undefined.");
|
91 | }
|
92 | if (required && !nullable && object == undefined) {
|
93 | throw new Error(objectName + " cannot be null or undefined.");
|
94 | }
|
95 | if (!required && nullable === false && object === null) {
|
96 | throw new Error(objectName + " cannot be null.");
|
97 | }
|
98 | if (object == undefined) {
|
99 | payload = object;
|
100 | }
|
101 | else {
|
102 |
|
103 | this.validateConstraints(mapper, object, objectName);
|
104 | if (mapperType.match(/^any$/gi) !== null) {
|
105 | payload = object;
|
106 | }
|
107 | else if (mapperType.match(/^(Number|String|Boolean|Object|Stream|Uuid)$/gi) !== null) {
|
108 | payload = serializeBasicTypes(mapperType, objectName, object);
|
109 | }
|
110 | else if (mapperType.match(/^Enum$/gi) !== null) {
|
111 | var enumMapper = mapper;
|
112 | payload = serializeEnumType(objectName, enumMapper.type.allowedValues, object);
|
113 | }
|
114 | else if (mapperType.match(/^(Date|DateTime|TimeSpan|DateTimeRfc1123|UnixTime)$/gi) !== null) {
|
115 | payload = serializeDateTypes(mapperType, object, objectName);
|
116 | }
|
117 | else if (mapperType.match(/^ByteArray$/gi) !== null) {
|
118 | payload = serializeByteArrayType(objectName, object);
|
119 | }
|
120 | else if (mapperType.match(/^Base64Url$/gi) !== null) {
|
121 | payload = serializeBase64UrlType(objectName, object);
|
122 | }
|
123 | else if (mapperType.match(/^Sequence$/gi) !== null) {
|
124 | payload = serializeSequenceType(this, mapper, object, objectName);
|
125 | }
|
126 | else if (mapperType.match(/^Dictionary$/gi) !== null) {
|
127 | payload = serializeDictionaryType(this, mapper, object, objectName);
|
128 | }
|
129 | else if (mapperType.match(/^Composite$/gi) !== null) {
|
130 | payload = serializeCompositeType(this, mapper, object, objectName);
|
131 | }
|
132 | }
|
133 | return payload;
|
134 | };
|
135 | |
136 |
|
137 |
|
138 |
|
139 |
|
140 |
|
141 |
|
142 |
|
143 |
|
144 |
|
145 |
|
146 | Serializer.prototype.deserialize = function (mapper, responseBody, objectName) {
|
147 | if (responseBody == undefined) {
|
148 | if (this.isXML && mapper.type.name === "Sequence" && !mapper.xmlIsWrapped) {
|
149 |
|
150 |
|
151 |
|
152 | responseBody = [];
|
153 | }
|
154 |
|
155 | if (mapper.defaultValue !== undefined) {
|
156 | responseBody = mapper.defaultValue;
|
157 | }
|
158 | return responseBody;
|
159 | }
|
160 | var payload;
|
161 | var mapperType = mapper.type.name;
|
162 | if (!objectName) {
|
163 | objectName = mapper.serializedName;
|
164 | }
|
165 | if (mapperType.match(/^Composite$/gi) !== null) {
|
166 | payload = deserializeCompositeType(this, mapper, responseBody, objectName);
|
167 | }
|
168 | else {
|
169 | if (this.isXML) {
|
170 | |
171 |
|
172 |
|
173 |
|
174 |
|
175 | if (responseBody["$"] != undefined && responseBody["_"] != undefined) {
|
176 | responseBody = responseBody["_"];
|
177 | }
|
178 | }
|
179 | if (mapperType.match(/^Number$/gi) !== null) {
|
180 | payload = parseFloat(responseBody);
|
181 | if (isNaN(payload)) {
|
182 | payload = responseBody;
|
183 | }
|
184 | }
|
185 | else if (mapperType.match(/^Boolean$/gi) !== null) {
|
186 | if (responseBody === "true") {
|
187 | payload = true;
|
188 | }
|
189 | else if (responseBody === "false") {
|
190 | payload = false;
|
191 | }
|
192 | else {
|
193 | payload = responseBody;
|
194 | }
|
195 | }
|
196 | else if (mapperType.match(/^(String|Enum|Object|Stream|Uuid|TimeSpan|any)$/gi) !== null) {
|
197 | payload = responseBody;
|
198 | }
|
199 | else if (mapperType.match(/^(Date|DateTime|DateTimeRfc1123)$/gi) !== null) {
|
200 | payload = new Date(responseBody);
|
201 | }
|
202 | else if (mapperType.match(/^UnixTime$/gi) !== null) {
|
203 | payload = unixTimeToDate(responseBody);
|
204 | }
|
205 | else if (mapperType.match(/^ByteArray$/gi) !== null) {
|
206 | payload = base64.decodeString(responseBody);
|
207 | }
|
208 | else if (mapperType.match(/^Base64Url$/gi) !== null) {
|
209 | payload = base64UrlToByteArray(responseBody);
|
210 | }
|
211 | else if (mapperType.match(/^Sequence$/gi) !== null) {
|
212 | payload = deserializeSequenceType(this, mapper, responseBody, objectName);
|
213 | }
|
214 | else if (mapperType.match(/^Dictionary$/gi) !== null) {
|
215 | payload = deserializeDictionaryType(this, mapper, responseBody, objectName);
|
216 | }
|
217 | }
|
218 | if (mapper.isConstant) {
|
219 | payload = mapper.defaultValue;
|
220 | }
|
221 | return payload;
|
222 | };
|
223 | return Serializer;
|
224 | }());
|
225 | export { Serializer };
|
226 | function trimEnd(str, ch) {
|
227 | var len = str.length;
|
228 | while (len - 1 >= 0 && str[len - 1] === ch) {
|
229 | --len;
|
230 | }
|
231 | return str.substr(0, len);
|
232 | }
|
233 | function bufferToBase64Url(buffer) {
|
234 | if (!buffer) {
|
235 | return undefined;
|
236 | }
|
237 | if (!(buffer instanceof Uint8Array)) {
|
238 | throw new Error("Please provide an input of type Uint8Array for converting to Base64Url.");
|
239 | }
|
240 |
|
241 | var str = base64.encodeByteArray(buffer);
|
242 |
|
243 | return trimEnd(str, "=").replace(/\+/g, "-").replace(/\//g, "_");
|
244 | }
|
245 | function base64UrlToByteArray(str) {
|
246 | if (!str) {
|
247 | return undefined;
|
248 | }
|
249 | if (str && typeof str.valueOf() !== "string") {
|
250 | throw new Error("Please provide an input of type string for converting to Uint8Array");
|
251 | }
|
252 |
|
253 | str = str.replace(/\-/g, "+").replace(/\_/g, "/");
|
254 |
|
255 | return base64.decodeString(str);
|
256 | }
|
257 | function splitSerializeName(prop) {
|
258 | var classes = [];
|
259 | var partialclass = "";
|
260 | if (prop) {
|
261 | var subwords = prop.split(".");
|
262 | for (var _i = 0, subwords_1 = subwords; _i < subwords_1.length; _i++) {
|
263 | var item = subwords_1[_i];
|
264 | if (item.charAt(item.length - 1) === "\\") {
|
265 | partialclass += item.substr(0, item.length - 1) + ".";
|
266 | }
|
267 | else {
|
268 | partialclass += item;
|
269 | classes.push(partialclass);
|
270 | partialclass = "";
|
271 | }
|
272 | }
|
273 | }
|
274 | return classes;
|
275 | }
|
276 | function dateToUnixTime(d) {
|
277 | if (!d) {
|
278 | return undefined;
|
279 | }
|
280 | if (typeof d.valueOf() === "string") {
|
281 | d = new Date(d);
|
282 | }
|
283 | return Math.floor(d.getTime() / 1000);
|
284 | }
|
285 | function unixTimeToDate(n) {
|
286 | if (!n) {
|
287 | return undefined;
|
288 | }
|
289 | return new Date(n * 1000);
|
290 | }
|
291 | function serializeBasicTypes(typeName, objectName, value) {
|
292 | if (value !== null && value !== undefined) {
|
293 | if (typeName.match(/^Number$/gi) !== null) {
|
294 | if (typeof value !== "number") {
|
295 | throw new Error(objectName + " with value " + value + " must be of type number.");
|
296 | }
|
297 | }
|
298 | else if (typeName.match(/^String$/gi) !== null) {
|
299 | if (typeof value.valueOf() !== "string") {
|
300 | throw new Error(objectName + " with value \"" + value + "\" must be of type string.");
|
301 | }
|
302 | }
|
303 | else if (typeName.match(/^Uuid$/gi) !== null) {
|
304 | if (!(typeof value.valueOf() === "string" && utils.isValidUuid(value))) {
|
305 | throw new Error(objectName + " with value \"" + value + "\" must be of type string and a valid uuid.");
|
306 | }
|
307 | }
|
308 | else if (typeName.match(/^Boolean$/gi) !== null) {
|
309 | if (typeof value !== "boolean") {
|
310 | throw new Error(objectName + " with value " + value + " must be of type boolean.");
|
311 | }
|
312 | }
|
313 | else if (typeName.match(/^Stream$/gi) !== null) {
|
314 | var objectType = typeof value;
|
315 | if (objectType !== "string" &&
|
316 | objectType !== "function" &&
|
317 | !(value instanceof ArrayBuffer) &&
|
318 | !ArrayBuffer.isView(value) &&
|
319 | !(typeof Blob === "function" && value instanceof Blob)) {
|
320 | throw new Error(objectName + " must be a string, Blob, ArrayBuffer, ArrayBufferView, or a function returning NodeJS.ReadableStream.");
|
321 | }
|
322 | }
|
323 | }
|
324 | return value;
|
325 | }
|
326 | function serializeEnumType(objectName, allowedValues, value) {
|
327 | if (!allowedValues) {
|
328 | throw new Error("Please provide a set of allowedValues to validate " + objectName + " as an Enum Type.");
|
329 | }
|
330 | var isPresent = allowedValues.some(function (item) {
|
331 | if (typeof item.valueOf() === "string") {
|
332 | return item.toLowerCase() === value.toLowerCase();
|
333 | }
|
334 | return item === value;
|
335 | });
|
336 | if (!isPresent) {
|
337 | throw new Error(value + " is not a valid value for " + objectName + ". The valid values are: " + JSON.stringify(allowedValues) + ".");
|
338 | }
|
339 | return value;
|
340 | }
|
341 | function serializeByteArrayType(objectName, value) {
|
342 | if (value != undefined) {
|
343 | if (!(value instanceof Uint8Array)) {
|
344 | throw new Error(objectName + " must be of type Uint8Array.");
|
345 | }
|
346 | value = base64.encodeByteArray(value);
|
347 | }
|
348 | return value;
|
349 | }
|
350 | function serializeBase64UrlType(objectName, value) {
|
351 | if (value != undefined) {
|
352 | if (!(value instanceof Uint8Array)) {
|
353 | throw new Error(objectName + " must be of type Uint8Array.");
|
354 | }
|
355 | value = bufferToBase64Url(value);
|
356 | }
|
357 | return value;
|
358 | }
|
359 | function serializeDateTypes(typeName, value, objectName) {
|
360 | if (value != undefined) {
|
361 | if (typeName.match(/^Date$/gi) !== null) {
|
362 | if (!(value instanceof Date ||
|
363 | (typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))) {
|
364 | throw new Error(objectName + " must be an instanceof Date or a string in ISO8601 format.");
|
365 | }
|
366 | value =
|
367 | value instanceof Date
|
368 | ? value.toISOString().substring(0, 10)
|
369 | : new Date(value).toISOString().substring(0, 10);
|
370 | }
|
371 | else if (typeName.match(/^DateTime$/gi) !== null) {
|
372 | if (!(value instanceof Date ||
|
373 | (typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))) {
|
374 | throw new Error(objectName + " must be an instanceof Date or a string in ISO8601 format.");
|
375 | }
|
376 | value = value instanceof Date ? value.toISOString() : new Date(value).toISOString();
|
377 | }
|
378 | else if (typeName.match(/^DateTimeRfc1123$/gi) !== null) {
|
379 | if (!(value instanceof Date ||
|
380 | (typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))) {
|
381 | throw new Error(objectName + " must be an instanceof Date or a string in RFC-1123 format.");
|
382 | }
|
383 | value = value instanceof Date ? value.toUTCString() : new Date(value).toUTCString();
|
384 | }
|
385 | else if (typeName.match(/^UnixTime$/gi) !== null) {
|
386 | if (!(value instanceof Date ||
|
387 | (typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))) {
|
388 | throw new Error(objectName + " must be an instanceof Date or a string in RFC-1123/ISO8601 format " +
|
389 | "for it to be serialized in UnixTime/Epoch format.");
|
390 | }
|
391 | value = dateToUnixTime(value);
|
392 | }
|
393 | else if (typeName.match(/^TimeSpan$/gi) !== null) {
|
394 | if (!utils.isDuration(value)) {
|
395 | throw new Error(objectName + " must be a string in ISO 8601 format. Instead was \"" + value + "\".");
|
396 | }
|
397 | value = value;
|
398 | }
|
399 | }
|
400 | return value;
|
401 | }
|
402 | function serializeSequenceType(serializer, mapper, object, objectName) {
|
403 | if (!Array.isArray(object)) {
|
404 | throw new Error(objectName + " must be of type Array.");
|
405 | }
|
406 | var elementType = mapper.type.element;
|
407 | if (!elementType || typeof elementType !== "object") {
|
408 | throw new Error("element\" metadata for an Array must be defined in the " +
|
409 | ("mapper and it must of type \"object\" in " + objectName + "."));
|
410 | }
|
411 | var tempArray = [];
|
412 | for (var i = 0; i < object.length; i++) {
|
413 | tempArray[i] = serializer.serialize(elementType, object[i], objectName);
|
414 | }
|
415 | return tempArray;
|
416 | }
|
417 | function serializeDictionaryType(serializer, mapper, object, objectName) {
|
418 | if (typeof object !== "object") {
|
419 | throw new Error(objectName + " must be of type object.");
|
420 | }
|
421 | var valueType = mapper.type.value;
|
422 | if (!valueType || typeof valueType !== "object") {
|
423 | throw new Error("\"value\" metadata for a Dictionary must be defined in the " +
|
424 | ("mapper and it must of type \"object\" in " + objectName + "."));
|
425 | }
|
426 | var tempDictionary = {};
|
427 | for (var _i = 0, _a = Object.keys(object); _i < _a.length; _i++) {
|
428 | var key = _a[_i];
|
429 | tempDictionary[key] = serializer.serialize(valueType, object[key], objectName + "." + key);
|
430 | }
|
431 | return tempDictionary;
|
432 | }
|
433 |
|
434 |
|
435 |
|
436 |
|
437 |
|
438 | function resolveModelProperties(serializer, mapper, objectName) {
|
439 | var modelProps = mapper.type.modelProperties;
|
440 | if (!modelProps) {
|
441 | var className = mapper.type.className;
|
442 | if (!className) {
|
443 | throw new Error("Class name for model \"" + objectName + "\" is not provided in the mapper \"" + JSON.stringify(mapper, undefined, 2) + "\".");
|
444 | }
|
445 | var modelMapper = serializer.modelMappers[className];
|
446 | if (!modelMapper) {
|
447 | throw new Error("mapper() cannot be null or undefined for model \"" + className + "\".");
|
448 | }
|
449 | modelProps = modelMapper.type.modelProperties;
|
450 | if (!modelProps) {
|
451 | throw new Error("modelProperties cannot be null or undefined in the " +
|
452 | ("mapper \"" + JSON.stringify(modelMapper) + "\" of type \"" + className + "\" for object \"" + objectName + "\"."));
|
453 | }
|
454 | }
|
455 | return modelProps;
|
456 | }
|
457 | function serializeCompositeType(serializer, mapper, object, objectName) {
|
458 | var _a;
|
459 | if (getPolymorphicDiscriminatorRecursively(serializer, mapper)) {
|
460 | mapper = getPolymorphicMapper(serializer, mapper, object, "clientName");
|
461 | }
|
462 | if (object != undefined) {
|
463 | var payload = {};
|
464 | var modelProps = resolveModelProperties(serializer, mapper, objectName);
|
465 | for (var _i = 0, _b = Object.keys(modelProps); _i < _b.length; _i++) {
|
466 | var key = _b[_i];
|
467 | var propertyMapper = modelProps[key];
|
468 | if (propertyMapper.readOnly) {
|
469 | continue;
|
470 | }
|
471 | var propName = void 0;
|
472 | var parentObject = payload;
|
473 | if (serializer.isXML) {
|
474 | if (propertyMapper.xmlIsWrapped) {
|
475 | propName = propertyMapper.xmlName;
|
476 | }
|
477 | else {
|
478 | propName = propertyMapper.xmlElementName || propertyMapper.xmlName;
|
479 | }
|
480 | }
|
481 | else {
|
482 | var paths = splitSerializeName(propertyMapper.serializedName);
|
483 | propName = paths.pop();
|
484 | for (var _c = 0, paths_1 = paths; _c < paths_1.length; _c++) {
|
485 | var pathName = paths_1[_c];
|
486 | var childObject = parentObject[pathName];
|
487 | if (childObject == undefined && object[key] != undefined) {
|
488 | parentObject[pathName] = {};
|
489 | }
|
490 | parentObject = parentObject[pathName];
|
491 | }
|
492 | }
|
493 | if (parentObject != undefined) {
|
494 | var propertyObjectName = propertyMapper.serializedName !== ""
|
495 | ? objectName + "." + propertyMapper.serializedName
|
496 | : objectName;
|
497 | var toSerialize = object[key];
|
498 | var polymorphicDiscriminator = getPolymorphicDiscriminatorRecursively(serializer, mapper);
|
499 | if (polymorphicDiscriminator &&
|
500 | polymorphicDiscriminator.clientName === key &&
|
501 | toSerialize == undefined) {
|
502 | toSerialize = mapper.serializedName;
|
503 | }
|
504 | var serializedValue = serializer.serialize(propertyMapper, toSerialize, propertyObjectName);
|
505 | if (serializedValue !== undefined && propName != undefined) {
|
506 | if (propertyMapper.xmlIsAttribute) {
|
507 |
|
508 |
|
509 |
|
510 | parentObject.$ = parentObject.$ || {};
|
511 | parentObject.$[propName] = serializedValue;
|
512 | }
|
513 | else if (propertyMapper.xmlIsWrapped) {
|
514 | parentObject[propName] = (_a = {}, _a[propertyMapper.xmlElementName] = serializedValue, _a);
|
515 | }
|
516 | else {
|
517 | parentObject[propName] = serializedValue;
|
518 | }
|
519 | }
|
520 | }
|
521 | }
|
522 | var additionalPropertiesMapper = mapper.type.additionalProperties;
|
523 | if (additionalPropertiesMapper) {
|
524 | var propNames = Object.keys(modelProps);
|
525 | var _loop_1 = function (clientPropName) {
|
526 | var isAdditionalProperty = propNames.every(function (pn) { return pn !== clientPropName; });
|
527 | if (isAdditionalProperty) {
|
528 | payload[clientPropName] = serializer.serialize(additionalPropertiesMapper, object[clientPropName], objectName + '["' + clientPropName + '"]');
|
529 | }
|
530 | };
|
531 | for (var clientPropName in object) {
|
532 | _loop_1(clientPropName);
|
533 | }
|
534 | }
|
535 | return payload;
|
536 | }
|
537 | return object;
|
538 | }
|
539 | function isSpecialXmlProperty(propertyName) {
|
540 | return ["$", "_"].includes(propertyName);
|
541 | }
|
542 | function deserializeCompositeType(serializer, mapper, responseBody, objectName) {
|
543 | if (getPolymorphicDiscriminatorRecursively(serializer, mapper)) {
|
544 | mapper = getPolymorphicMapper(serializer, mapper, responseBody, "serializedName");
|
545 | }
|
546 | var modelProps = resolveModelProperties(serializer, mapper, objectName);
|
547 | var instance = {};
|
548 | var handledPropertyNames = [];
|
549 | for (var _i = 0, _a = Object.keys(modelProps); _i < _a.length; _i++) {
|
550 | var key = _a[_i];
|
551 | var propertyMapper = modelProps[key];
|
552 | var paths = splitSerializeName(modelProps[key].serializedName);
|
553 | handledPropertyNames.push(paths[0]);
|
554 | var serializedName = propertyMapper.serializedName, xmlName = propertyMapper.xmlName, xmlElementName = propertyMapper.xmlElementName;
|
555 | var propertyObjectName = objectName;
|
556 | if (serializedName !== "" && serializedName !== undefined) {
|
557 | propertyObjectName = objectName + "." + serializedName;
|
558 | }
|
559 | var headerCollectionPrefix = propertyMapper.headerCollectionPrefix;
|
560 | if (headerCollectionPrefix) {
|
561 | var dictionary = {};
|
562 | for (var _b = 0, _c = Object.keys(responseBody); _b < _c.length; _b++) {
|
563 | var headerKey = _c[_b];
|
564 | if (headerKey.startsWith(headerCollectionPrefix)) {
|
565 | dictionary[headerKey.substring(headerCollectionPrefix.length)] = serializer.deserialize(propertyMapper.type.value, responseBody[headerKey], propertyObjectName);
|
566 | }
|
567 | handledPropertyNames.push(headerKey);
|
568 | }
|
569 | instance[key] = dictionary;
|
570 | }
|
571 | else if (serializer.isXML) {
|
572 | if (propertyMapper.xmlIsAttribute && responseBody.$) {
|
573 | instance[key] = serializer.deserialize(propertyMapper, responseBody.$[xmlName], propertyObjectName);
|
574 | }
|
575 | else {
|
576 | var propertyName = xmlElementName || xmlName || serializedName;
|
577 | var unwrappedProperty = responseBody[propertyName];
|
578 | if (propertyMapper.xmlIsWrapped) {
|
579 | unwrappedProperty = responseBody[xmlName];
|
580 | unwrappedProperty = unwrappedProperty && unwrappedProperty[xmlElementName];
|
581 | var isEmptyWrappedList = unwrappedProperty === undefined;
|
582 | if (isEmptyWrappedList) {
|
583 | unwrappedProperty = [];
|
584 | }
|
585 | }
|
586 | instance[key] = serializer.deserialize(propertyMapper, unwrappedProperty, propertyObjectName);
|
587 | }
|
588 | }
|
589 | else {
|
590 |
|
591 | var propertyInstance = void 0;
|
592 | var res = responseBody;
|
593 |
|
594 | for (var _d = 0, paths_2 = paths; _d < paths_2.length; _d++) {
|
595 | var item = paths_2[_d];
|
596 | if (!res)
|
597 | break;
|
598 | res = res[item];
|
599 | }
|
600 | propertyInstance = res;
|
601 | var polymorphicDiscriminator = mapper.type.polymorphicDiscriminator;
|
602 |
|
603 |
|
604 |
|
605 |
|
606 |
|
607 |
|
608 |
|
609 |
|
610 |
|
611 | if (polymorphicDiscriminator &&
|
612 | key === polymorphicDiscriminator.clientName &&
|
613 | propertyInstance == undefined) {
|
614 | propertyInstance = mapper.serializedName;
|
615 | }
|
616 | var serializedValue = void 0;
|
617 |
|
618 | if (Array.isArray(responseBody[key]) && modelProps[key].serializedName === "") {
|
619 | propertyInstance = responseBody[key];
|
620 | var arrayInstance = serializer.deserialize(propertyMapper, propertyInstance, propertyObjectName);
|
621 |
|
622 |
|
623 | for (var _e = 0, _f = Object.entries(instance); _e < _f.length; _e++) {
|
624 | var _g = _f[_e], key_1 = _g[0], value = _g[1];
|
625 | if (!arrayInstance.hasOwnProperty(key_1)) {
|
626 | arrayInstance[key_1] = value;
|
627 | }
|
628 | }
|
629 | instance = arrayInstance;
|
630 | }
|
631 | else if (propertyInstance !== undefined || propertyMapper.defaultValue !== undefined) {
|
632 | serializedValue = serializer.deserialize(propertyMapper, propertyInstance, propertyObjectName);
|
633 | instance[key] = serializedValue;
|
634 | }
|
635 | }
|
636 | }
|
637 | var additionalPropertiesMapper = mapper.type.additionalProperties;
|
638 | if (additionalPropertiesMapper) {
|
639 | var isAdditionalProperty = function (responsePropName) {
|
640 | for (var clientPropName in modelProps) {
|
641 | var paths = splitSerializeName(modelProps[clientPropName].serializedName);
|
642 | if (paths[0] === responsePropName) {
|
643 | return false;
|
644 | }
|
645 | }
|
646 | return true;
|
647 | };
|
648 | for (var responsePropName in responseBody) {
|
649 | if (isAdditionalProperty(responsePropName)) {
|
650 | instance[responsePropName] = serializer.deserialize(additionalPropertiesMapper, responseBody[responsePropName], objectName + '["' + responsePropName + '"]');
|
651 | }
|
652 | }
|
653 | }
|
654 | else if (responseBody) {
|
655 | for (var _h = 0, _j = Object.keys(responseBody); _h < _j.length; _h++) {
|
656 | var key = _j[_h];
|
657 | if (instance[key] === undefined &&
|
658 | !handledPropertyNames.includes(key) &&
|
659 | !isSpecialXmlProperty(key)) {
|
660 | instance[key] = responseBody[key];
|
661 | }
|
662 | }
|
663 | }
|
664 | return instance;
|
665 | }
|
666 | function deserializeDictionaryType(serializer, mapper, responseBody, objectName) {
|
667 |
|
668 | var value = mapper.type.value;
|
669 | if (!value || typeof value !== "object") {
|
670 | throw new Error("\"value\" metadata for a Dictionary must be defined in the " +
|
671 | ("mapper and it must of type \"object\" in " + objectName));
|
672 | }
|
673 | if (responseBody) {
|
674 | var tempDictionary = {};
|
675 | for (var _i = 0, _a = Object.keys(responseBody); _i < _a.length; _i++) {
|
676 | var key = _a[_i];
|
677 | tempDictionary[key] = serializer.deserialize(value, responseBody[key], objectName);
|
678 | }
|
679 | return tempDictionary;
|
680 | }
|
681 | return responseBody;
|
682 | }
|
683 | function deserializeSequenceType(serializer, mapper, responseBody, objectName) {
|
684 |
|
685 | var element = mapper.type.element;
|
686 | if (!element || typeof element !== "object") {
|
687 | throw new Error("element\" metadata for an Array must be defined in the " +
|
688 | ("mapper and it must of type \"object\" in " + objectName));
|
689 | }
|
690 | if (responseBody) {
|
691 | if (!Array.isArray(responseBody)) {
|
692 |
|
693 | responseBody = [responseBody];
|
694 | }
|
695 | var tempArray = [];
|
696 | for (var i = 0; i < responseBody.length; i++) {
|
697 | tempArray[i] = serializer.deserialize(element, responseBody[i], objectName + "[" + i + "]");
|
698 | }
|
699 | return tempArray;
|
700 | }
|
701 | return responseBody;
|
702 | }
|
703 | function getPolymorphicMapper(serializer, mapper, object, polymorphicPropertyName) {
|
704 | var polymorphicDiscriminator = getPolymorphicDiscriminatorRecursively(serializer, mapper);
|
705 | if (polymorphicDiscriminator) {
|
706 | var discriminatorName = polymorphicDiscriminator[polymorphicPropertyName];
|
707 | if (discriminatorName != undefined) {
|
708 | var discriminatorValue = object[discriminatorName];
|
709 | if (discriminatorValue != undefined) {
|
710 | var typeName = mapper.type.uberParent || mapper.type.className;
|
711 | var indexDiscriminator = discriminatorValue === typeName
|
712 | ? discriminatorValue
|
713 | : typeName + "." + discriminatorValue;
|
714 | var polymorphicMapper = serializer.modelMappers.discriminators[indexDiscriminator];
|
715 | if (polymorphicMapper) {
|
716 | mapper = polymorphicMapper;
|
717 | }
|
718 | }
|
719 | }
|
720 | }
|
721 | return mapper;
|
722 | }
|
723 | function getPolymorphicDiscriminatorRecursively(serializer, mapper) {
|
724 | return (mapper.type.polymorphicDiscriminator ||
|
725 | getPolymorphicDiscriminatorSafely(serializer, mapper.type.uberParent) ||
|
726 | getPolymorphicDiscriminatorSafely(serializer, mapper.type.className));
|
727 | }
|
728 | function getPolymorphicDiscriminatorSafely(serializer, typeName) {
|
729 | return (typeName &&
|
730 | serializer.modelMappers[typeName] &&
|
731 | serializer.modelMappers[typeName].type.polymorphicDiscriminator);
|
732 | }
|
733 |
|
734 | export function serializeObject(toSerialize) {
|
735 | if (toSerialize == undefined)
|
736 | return undefined;
|
737 | if (toSerialize instanceof Uint8Array) {
|
738 | toSerialize = base64.encodeByteArray(toSerialize);
|
739 | return toSerialize;
|
740 | }
|
741 | else if (toSerialize instanceof Date) {
|
742 | return toSerialize.toISOString();
|
743 | }
|
744 | else if (Array.isArray(toSerialize)) {
|
745 | var array = [];
|
746 | for (var i = 0; i < toSerialize.length; i++) {
|
747 | array.push(serializeObject(toSerialize[i]));
|
748 | }
|
749 | return array;
|
750 | }
|
751 | else if (typeof toSerialize === "object") {
|
752 | var dictionary = {};
|
753 | for (var property in toSerialize) {
|
754 | dictionary[property] = serializeObject(toSerialize[property]);
|
755 | }
|
756 | return dictionary;
|
757 | }
|
758 | return toSerialize;
|
759 | }
|
760 |
|
761 |
|
762 |
|
763 | function strEnum(o) {
|
764 | var result = {};
|
765 | for (var _i = 0, o_1 = o; _i < o_1.length; _i++) {
|
766 | var key = o_1[_i];
|
767 | result[key] = key;
|
768 | }
|
769 | return result;
|
770 | }
|
771 | export var MapperType = strEnum([
|
772 | "Base64Url",
|
773 | "Boolean",
|
774 | "ByteArray",
|
775 | "Composite",
|
776 | "Date",
|
777 | "DateTime",
|
778 | "DateTimeRfc1123",
|
779 | "Dictionary",
|
780 | "Enum",
|
781 | "Number",
|
782 | "Object",
|
783 | "Sequence",
|
784 | "String",
|
785 | "Stream",
|
786 | "TimeSpan",
|
787 | "UnixTime",
|
788 | ]);
|
789 |
|
\ | No newline at end of file |