@mediusinc/mng-commons 2.6.0-rc.2 → 3.0.0-rc.0

package/esm2022/lib/api/utils/object-serializer.util.mjs

@@ -0,0 +1,258 @@
+import { DateUtil, TypeUtil } from '../../utils';
+import { enumsMapBase, typeMapBase } from '../models';
+export class ObjectSerializer {
+    constructor() {
+        this._primitives = ['string', 'boolean', 'double', 'integer', 'long', 'float', 'number', 'any'];
+        this._typeMap = {
+            ...typeMapBase
+        };
+        this._enumMap = {
+            ...enumsMapBase
+        };
+        this.dateTimeInUtc = true;
+        this.dateTimeWithTimezone = true;
+        this.dateTimeWithMillis = true;
+    }
+    static { this._instance = new ObjectSerializer(); }
+    get primitives() {
+        return this._primitives;
+    }
+    get typeMap() {
+        return this._typeMap;
+    }
+    get enumMap() {
+        return this._enumMap;
+    }
+    /**
+     * Only use one instance of object (out of Angular context)
+     */
+    static get() {
+        return ObjectSerializer._instance;
+    }
+    findAttributeDefinitionByClassType(type, attributeName) {
+        return this.findAttributeDefinition(TypeUtil.findTypeName(type), attributeName);
+    }
+    findAttributeDefinition(typeName, attributeName) {
+        const attributeDefs = this.findAttributesDefinition(typeName);
+        if (!attributeDefs) {
+            return null;
+        }
+        for (const attribute of attributeDefs) {
+            if (attribute.name === attributeName) {
+                return attribute;
+            }
+        }
+        return null;
+    }
+    findAttributesDefinitionByClassType(type) {
+        return this.findAttributesDefinition(TypeUtil.findTypeName(type));
+    }
+    findAttributesDefinition(typeName) {
+        const typeDef = this.findType(typeName);
+        if (!typeDef || typeof typeDef.getAttributeTypeMap !== 'function') {
+            return null;
+        }
+        return typeDef.getAttributeTypeMap();
+    }
+    findByClassType(type) {
+        return this.findType(TypeUtil.findTypeName(type));
+    }
+    findType(typeName) {
+        return this._typeMap[typeName];
+    }
+    findEnum(enumName) {
+        return this._enumMap[enumName];
+    }
+    configure(config) {
+        if (config.dateTimeInUtc !== undefined) {
+            this.dateTimeInUtc = config.dateTimeInUtc;
+        }
+        if (config.dateTimeWithTimezone !== undefined) {
+            this.dateTimeWithTimezone = config.dateTimeWithTimezone;
+        }
+        if (config.dateTimeWithMillis !== undefined) {
+            this.dateTimeWithMillis = config.dateTimeWithMillis;
+        }
+    }
+    registerTypes(types) {
+        for (const key in types) {
+            this.registerType(types[key], key);
+        }
+    }
+    registerType(type, optTypeName) {
+        // try to find name from metadata
+        let typeName;
+        if (TypeUtil.typeNameExists(type)) {
+            // defined name from optional type name
+            typeName = TypeUtil.findTypeName(type);
+        }
+        else if (optTypeName) {
+            typeName = optTypeName;
+            // register metadata
+            TypeUtil.defineReflectTypeName(type, typeName);
+        }
+        if (!typeName) {
+            console.warn(`Registering type ${type} failed, because typeName could not be determined and optional name was not provided.`);
+            return;
+        }
+        if (typeof this._typeMap[typeName] !== 'undefined') {
+            console.warn(`Registering type ${type} under key ${typeName} skipped, because type already exists for this key.`);
+        }
+        else {
+            this._typeMap[typeName] = type;
+        }
+    }
+    registerEnums(enums) {
+        for (const key in enums) {
+            this.registerEnum(enums[key], key);
+        }
+    }
+    registerEnum(enumType, enumName) {
+        // try to find name from decorator
+        if (typeof this._enumMap[enumName] !== 'undefined') {
+            console.warn(`Registering enum ${enumName} skipped, because enum already exists.`);
+        }
+        else {
+            TypeUtil.defineReflectEnumName(enumType, enumName);
+            this._enumMap[enumName] = enumType;
+        }
+    }
+    findCorrectType(data, expectedType) {
+        if (data == undefined) {
+            return expectedType;
+        }
+        else if (this._primitives.indexOf(expectedType.toLowerCase()) !== -1) {
+            return expectedType;
+        }
+        else if (expectedType === 'Date') {
+            return expectedType;
+        }
+        else {
+            if (this._enumMap[expectedType]) {
+                return expectedType;
+            }
+            if (!this._typeMap[expectedType]) {
+                return expectedType; // w/e we don't know the type
+            }
+            // Check the discriminator
+            const discriminatorProperty = this._typeMap[expectedType].discriminator;
+            if (discriminatorProperty == null) {
+                return expectedType; // the type does not have a discriminator. use it.
+            }
+            else {
+                if (data[discriminatorProperty]) {
+                    const discriminatorType = data[discriminatorProperty];
+                    if (this._typeMap[discriminatorType]) {
+                        return discriminatorType; // use the type given in the discriminator
+                    }
+                    else {
+                        return expectedType; // discriminator did not map to a type
+                    }
+                }
+                else {
+                    return expectedType; // discriminator was not present (or an empty string)
+                }
+            }
+        }
+    }
+    serializeClass(data, type) {
+        return this.serialize(data, TypeUtil.findTypeName(type));
+    }
+    serializeClassArray(data, type) {
+        return this.serialize(data, `Array<${TypeUtil.findTypeName(type)}>`);
+    }
+    serialize(data, type, subtype = undefined) {
+        if (data == undefined) {
+            return data;
+        }
+        else if (this._primitives.indexOf(type.toLowerCase()) !== -1) {
+            return data;
+        }
+        else if (type.lastIndexOf('Array<', 0) === 0) {
+            // string.startsWith pre es6
+            let subType = type.replace('Array<', ''); // Array<Type> => Type>
+            subType = subType.substring(0, subType.length - 1); // Type> => Type
+            const transformedData = [];
+            // tslint:disable-next-line:prefer-for-of
+            for (let index = 0; index < data.length; index++) {
+                const datum = data[index];
+                transformedData.push(this.serialize(datum, subType));
+            }
+            return transformedData;
+        }
+        else if (type === 'Date') {
+            const dateOnly = subtype === 'date';
+            return DateUtil.toIsoString(data, this.dateTimeInUtc, this.dateTimeWithTimezone, this.dateTimeWithMillis, dateOnly);
+        }
+        else {
+            if (this._enumMap[type]) {
+                return data;
+            }
+            if (!this._typeMap[type]) {
+                // in case we dont know the type
+                return data;
+            }
+            // Get the actual type of this object
+            type = this.findCorrectType(data, type);
+            // get the map for the correct type.
+            const attributeTypes = this._typeMap[type].getAttributeTypeMap();
+            const instance = {};
+            // tslint:disable-next-line:prefer-for-of
+            for (let index = 0; index < attributeTypes.length; index++) {
+                const attributeType = attributeTypes[index];
+                instance[attributeType.baseName] = this.serialize(data[attributeType.name], attributeType.type, attributeType.subtype);
+            }
+            return instance;
+        }
+    }
+    deserializeClass(data, type) {
+        return this.deserialize(data, TypeUtil.findTypeName(type));
+    }
+    deserializeClassArray(data, type) {
+        return this.deserialize(data, `Array<${TypeUtil.findTypeName(type)}>`);
+    }
+    deserialize(data, type) {
+        // polymorphism may change the actual type.
+        type = this.findCorrectType(data, type);
+        if (data == undefined) {
+            return data;
+        }
+        else if (this._primitives.indexOf(type.toLowerCase()) !== -1) {
+            return data;
+        }
+        else if (type.lastIndexOf('Array<', 0) === 0) {
+            // string.startsWith pre es6
+            let subType = type.replace('Array<', ''); // Array<Type> => Type>
+            subType = subType.substring(0, subType.length - 1); // Type> => Type
+            const transformedData = [];
+            // tslint:disable-next-line:prefer-for-of
+            for (let index = 0; index < data.length; index++) {
+                const datum = data[index];
+                transformedData.push(this.deserialize(datum, subType));
+            }
+            return transformedData;
+        }
+        else if (type === 'Date') {
+            return new Date(data);
+        }
+        else {
+            if (this._enumMap[type]) {
+                // is Enum
+                return data;
+            }
+            if (!this._typeMap[type]) {
+                // dont know the type
+                return data;
+            }
+            const instance = new this._typeMap[type]();
+            const attributeTypes = this._typeMap[type].getAttributeTypeMap();
+            // tslint:disable-next-line:prefer-for-of
+            for (let index = 0; index < attributeTypes.length; index++) {
+                const attributeType = attributeTypes[index];
+                instance[attributeType.name] = this.deserialize(data[attributeType.baseName], attributeType.type);
+            }
+            return instance;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-serializer.util.js","sourceRoot":"","sources":["../../../../../src/lib/api/utils/object-serializer.util.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,QAAQ,EAAE,QAAQ,EAAC,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAoC,YAAY,EAAE,WAAW,EAAC,MAAM,WAAW,CAAC;AAEvF,MAAM,OAAO,gBAAgB;IAA7B;QAEqB,gBAAW,GAAa,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;QACrG,aAAQ,GAAwB;YAC7C,GAAG,WAAW;SACjB,CAAC;QACe,aAAQ,GAAwB;YAC7C,GAAG,YAAY;SAClB,CAAC;QAEM,kBAAa,GAAG,IAAI,CAAC;QACrB,yBAAoB,GAAG,IAAI,CAAC;QAC5B,uBAAkB,GAAG,IAAI,CAAC;IA6PtC,CAAC;aAxQkB,cAAS,GAAqB,IAAI,gBAAgB,EAAE,AAA3C,CAA4C;IAapE,IAAW,UAAU;QACjB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAED,IAAW,OAAO;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED,IAAW,OAAO;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,GAAG;QACb,OAAO,gBAAgB,CAAC,SAAS,CAAC;IACtC,CAAC;IAEM,kCAAkC,CAAC,IAAoB,EAAE,aAAqB;QACjF,OAAO,IAAI,CAAC,uBAAuB,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,CAAC;IACpF,CAAC;IAEM,uBAAuB,CAAC,QAAgB,EAAE,aAAqB;QAClE,MAAM,aAAa,GAAG,IAAI,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC;QAC9D,IAAI,CAAC,aAAa,EAAE;YAChB,OAAO,IAAI,CAAC;SACf;QACD,KAAK,MAAM,SAAS,IAAI,aAAa,EAAE;YACnC,IAAI,SAAS,CAAC,IAAI,KAAK,aAAa,EAAE;gBAClC,OAAO,SAAS,CAAC;aACpB;SACJ;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,mCAAmC,CAAC,IAAoB;QAC3D,OAAO,IAAI,CAAC,wBAAwB,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;IACtE,CAAC;IAEM,wBAAwB,CAAC,QAAgB;QAC5C,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACxC,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,CAAC,mBAAmB,KAAK,UAAU,EAAE;YAC/D,OAAO,IAAI,CAAC;SACf;QACD,OAAO,OAAO,CAAC,mBAAmB,EAAyB,CAAC;IAChE,CAAC;IAEM,eAAe,CAAC,IAAoB;QACvC,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;IACtD,CAAC;IAEM,QAAQ,CAAC,QAAgB;QAC5B,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACnC,CAAC;IAEM,QAAQ,CAAC,QAAgB;QAC5B,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACnC,CAAC;IAEM,SAAS,CAAC,MAA+F;QAC5G,IAAI,MAAM,CAAC,aAAa,KAAK,SAAS,EAAE;YACpC,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,aAAa,CAAC;SAC7C;QACD,IAAI,MAAM,CAAC,oBAAoB,KAAK,SAAS,EAAE;YAC3C,IAAI,CAAC,oBAAoB,GAAG,MAAM,CAAC,oBAAoB,CAAC;SAC3D;QACD,IAAI,MAAM,CAAC,kBAAkB,KAAK,SAAS,EAAE;YACzC,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,CAAC;SACvD;IACL,CAAC;IAEM,aAAa,CAAC,KAA0B;QAC3C,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE;YACrB,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;SACtC;IACL,CAAC;IAEM,YAAY,CAAC,IAAoB,EAAE,WAAoB;QAC1D,iCAAiC;QACjC,IAAI,QAA4B,CAAC;QACjC,IAAI,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE;YAC/B,uCAAuC;YACvC,QAAQ,GAAG,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;SAC1C;aAAM,IAAI,WAAW,EAAE;YACpB,QAAQ,GAAG,WAAW,CAAC;YACvB,oBAAoB;YACpB,QAAQ,CAAC,qBAAqB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;SAClD;QAED,IAAI,CAAC,QAAQ,EAAE;YACX,OAAO,CAAC,IAAI,CAAC,oBAAoB,IAAI,uFAAuF,CAAC,CAAC;YAC9H,OAAO;SACV;QACD,IAAI,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,WAAW,EAAE;YAChD,OAAO,CAAC,IAAI,CAAC,oBAAoB,IAAI,cAAc,QAAQ,qDAAqD,CAAC,CAAC;SACrH;aAAM;YACH,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;SAClC;IACL,CAAC;IAEM,aAAa,CAAC,KAA0B;QAC3C,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE;YACrB,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;SACtC;IACL,CAAC;IAEM,YAAY,CAAC,QAAa,EAAE,QAAgB;QAC/C,kCAAkC;QAClC,IAAI,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,WAAW,EAAE;YAChD,OAAO,CAAC,IAAI,CAAC,oBAAoB,QAAQ,wCAAwC,CAAC,CAAC;SACtF;aAAM;YACH,QAAQ,CAAC,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YACnD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC;SACtC;IACL,CAAC;IAEM,eAAe,CAAC,IAAS,EAAE,YAAoB;QAClD,IAAI,IAAI,IAAI,SAAS,EAAE;YACnB,OAAO,YAAY,CAAC;SACvB;aAAM,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE;YACpE,OAAO,YAAY,CAAC;SACvB;aAAM,IAAI,YAAY,KAAK,MAAM,EAAE;YAChC,OAAO,YAAY,CAAC;SACvB;aAAM;YACH,IAAI,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE;gBAC7B,OAAO,YAAY,CAAC;aACvB;YAED,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE;gBAC9B,OAAO,YAAY,CAAC,CAAC,6BAA6B;aACrD;YAED,0BAA0B;YAC1B,MAAM,qBAAqB,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,aAAa,CAAC;YACxE,IAAI,qBAAqB,IAAI,IAAI,EAAE;gBAC/B,OAAO,YAAY,CAAC,CAAC,kDAAkD;aAC1E;iBAAM;gBACH,IAAI,IAAI,CAAC,qBAAqB,CAAC,EAAE;oBAC7B,MAAM,iBAAiB,GAAG,IAAI,CAAC,qBAAqB,CAAC,CAAC;oBACtD,IAAI,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,EAAE;wBAClC,OAAO,iBAAiB,CAAC,CAAC,0CAA0C;qBACvE;yBAAM;wBACH,OAAO,YAAY,CAAC,CAAC,sCAAsC;qBAC9D;iBACJ;qBAAM;oBACH,OAAO,YAAY,CAAC,CAAC,qDAAqD;iBAC7E;aACJ;SACJ;IACL,CAAC;IAEM,cAAc,CAAI,IAAO,EAAE,IAAkB;QAChD,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;IAC7D,CAAC;IAEM,mBAAmB,CAAI,IAAc,EAAE,IAAkB;QAC5D,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACzE,CAAC;IAEM,SAAS,CAAC,IAAS,EAAE,IAAY,EAAE,UAA8B,SAAS;QAC7E,IAAI,IAAI,IAAI,SAAS,EAAE;YACnB,OAAO,IAAI,CAAC;SACf;aAAM,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE;YAC5D,OAAO,IAAI,CAAC;SACf;aAAM,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE;YAC5C,4BAA4B;YAC5B,IAAI,OAAO,GAAW,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,uBAAuB;YACzE,OAAO,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,gBAAgB;YACpE,MAAM,eAAe,GAAU,EAAE,CAAC;YAClC,yCAAyC;YACzC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;gBAC9C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC1B,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;aACxD;YACD,OAAO,eAAe,CAAC;SAC1B;aAAM,IAAI,IAAI,KAAK,MAAM,EAAE;YACxB,MAAM,QAAQ,GAAG,OAAO,KAAK,MAAM,CAAC;YACpC,OAAO,QAAQ,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,oBAAoB,EAAE,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;SACvH;aAAM;YACH,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;gBACrB,OAAO,IAAI,CAAC;aACf;YACD,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;gBACtB,gCAAgC;gBAChC,OAAO,IAAI,CAAC;aACf;YAED,qCAAqC;YACrC,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAExC,oCAAoC;YACpC,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,mBAAmB,EAAyB,CAAC;YACxF,MAAM,QAAQ,GAA2B,EAAE,CAAC;YAC5C,yCAAyC;YACzC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;gBACxD,MAAM,aAAa,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;gBAC5C,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;aAC1H;YACD,OAAO,QAAQ,CAAC;SACnB;IACL,CAAC;IAEM,gBAAgB,CAAI,IAAS,EAAE,IAAkB;QACpD,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;IAC/D,CAAC;IAEM,qBAAqB,CAAI,IAAS,EAAE,IAAkB;QACzD,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,SAAS,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC3E,CAAC;IAEM,WAAW,CAAC,IAAS,EAAE,IAAY;QACtC,2CAA2C;QAC3C,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACxC,IAAI,IAAI,IAAI,SAAS,EAAE;YACnB,OAAO,IAAI,CAAC;SACf;aAAM,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE;YAC5D,OAAO,IAAI,CAAC;SACf;aAAM,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE;YAC5C,4BAA4B;YAC5B,IAAI,OAAO,GAAW,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,uBAAuB;YACzE,OAAO,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,gBAAgB;YACpE,MAAM,eAAe,GAAU,EAAE,CAAC;YAClC,yCAAyC;YACzC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;gBAC9C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC1B,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;aAC1D;YACD,OAAO,eAAe,CAAC;SAC1B;aAAM,IAAI,IAAI,KAAK,MAAM,EAAE;YACxB,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;SACzB;aAAM;YACH,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;gBACrB,UAAU;gBACV,OAAO,IAAI,CAAC;aACf;YAED,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;gBACtB,qBAAqB;gBACrB,OAAO,IAAI,CAAC;aACf;YACD,MAAM,QAAQ,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YAC3C,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,mBAAmB,EAAyB,CAAC;YACxF,yCAAyC;YACzC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;gBACxD,MAAM,aAAa,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;gBAC5C,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;aACrG;YACD,OAAO,QAAQ,CAAC;SACnB;IACL,CAAC","sourcesContent":["import {ClassType} from '../../types';\nimport {DateUtil, TypeUtil} from '../../utils';\nimport {AttributeDef, SerializableTypeMap, enumsMapBase, typeMapBase} from '../models';\n\nexport class ObjectSerializer {\n    private static _instance: ObjectSerializer = new ObjectSerializer();\n    private readonly _primitives: string[] = ['string', 'boolean', 'double', 'integer', 'long', 'float', 'number', 'any'];\n    private readonly _typeMap: SerializableTypeMap = {\n        ...typeMapBase\n    };\n    private readonly _enumMap: SerializableTypeMap = {\n        ...enumsMapBase\n    };\n\n    private dateTimeInUtc = true;\n    private dateTimeWithTimezone = true;\n    private dateTimeWithMillis = true;\n\n    public get primitives() {\n        return this._primitives;\n    }\n\n    public get typeMap() {\n        return this._typeMap;\n    }\n\n    public get enumMap() {\n        return this._enumMap;\n    }\n\n    /**\n     * Only use one instance of object (out of Angular context)\n     */\n    public static get(): ObjectSerializer {\n        return ObjectSerializer._instance;\n    }\n\n    public findAttributeDefinitionByClassType(type: ClassType<any>, attributeName: string): AttributeDef | null {\n        return this.findAttributeDefinition(TypeUtil.findTypeName(type), attributeName);\n    }\n\n    public findAttributeDefinition(typeName: string, attributeName: string): AttributeDef | null {\n        const attributeDefs = this.findAttributesDefinition(typeName);\n        if (!attributeDefs) {\n            return null;\n        }\n        for (const attribute of attributeDefs) {\n            if (attribute.name === attributeName) {\n                return attribute;\n            }\n        }\n        return null;\n    }\n\n    public findAttributesDefinitionByClassType(type: ClassType<any>): Array<AttributeDef> | null {\n        return this.findAttributesDefinition(TypeUtil.findTypeName(type));\n    }\n\n    public findAttributesDefinition(typeName: string): Array<AttributeDef> | null {\n        const typeDef = this.findType(typeName);\n        if (!typeDef || typeof typeDef.getAttributeTypeMap !== 'function') {\n            return null;\n        }\n        return typeDef.getAttributeTypeMap() as Array<AttributeDef>;\n    }\n\n    public findByClassType(type: ClassType<any>): any {\n        return this.findType(TypeUtil.findTypeName(type));\n    }\n\n    public findType(typeName: string): any {\n        return this._typeMap[typeName];\n    }\n\n    public findEnum(enumName: string): any {\n        return this._enumMap[enumName];\n    }\n\n    public configure(config: {dateTimeInUtc?: boolean; dateTimeWithTimezone?: boolean; dateTimeWithMillis?: boolean}): void {\n        if (config.dateTimeInUtc !== undefined) {\n            this.dateTimeInUtc = config.dateTimeInUtc;\n        }\n        if (config.dateTimeWithTimezone !== undefined) {\n            this.dateTimeWithTimezone = config.dateTimeWithTimezone;\n        }\n        if (config.dateTimeWithMillis !== undefined) {\n            this.dateTimeWithMillis = config.dateTimeWithMillis;\n        }\n    }\n\n    public registerTypes(types: SerializableTypeMap) {\n        for (const key in types) {\n            this.registerType(types[key], key);\n        }\n    }\n\n    public registerType(type: ClassType<any>, optTypeName?: string) {\n        // try to find name from metadata\n        let typeName: string | undefined;\n        if (TypeUtil.typeNameExists(type)) {\n            // defined name from optional type name\n            typeName = TypeUtil.findTypeName(type);\n        } else if (optTypeName) {\n            typeName = optTypeName;\n            // register metadata\n            TypeUtil.defineReflectTypeName(type, typeName);\n        }\n\n        if (!typeName) {\n            console.warn(`Registering type ${type} failed, because typeName could not be determined and optional name was not provided.`);\n            return;\n        }\n        if (typeof this._typeMap[typeName] !== 'undefined') {\n            console.warn(`Registering type ${type} under key ${typeName} skipped, because type already exists for this key.`);\n        } else {\n            this._typeMap[typeName] = type;\n        }\n    }\n\n    public registerEnums(enums: SerializableTypeMap) {\n        for (const key in enums) {\n            this.registerEnum(enums[key], key);\n        }\n    }\n\n    public registerEnum(enumType: any, enumName: string) {\n        // try to find name from decorator\n        if (typeof this._enumMap[enumName] !== 'undefined') {\n            console.warn(`Registering enum ${enumName} skipped, because enum already exists.`);\n        } else {\n            TypeUtil.defineReflectEnumName(enumType, enumName);\n            this._enumMap[enumName] = enumType;\n        }\n    }\n\n    public findCorrectType(data: any, expectedType: string) {\n        if (data == undefined) {\n            return expectedType;\n        } else if (this._primitives.indexOf(expectedType.toLowerCase()) !== -1) {\n            return expectedType;\n        } else if (expectedType === 'Date') {\n            return expectedType;\n        } else {\n            if (this._enumMap[expectedType]) {\n                return expectedType;\n            }\n\n            if (!this._typeMap[expectedType]) {\n                return expectedType; // w/e we don't know the type\n            }\n\n            // Check the discriminator\n            const discriminatorProperty = this._typeMap[expectedType].discriminator;\n            if (discriminatorProperty == null) {\n                return expectedType; // the type does not have a discriminator. use it.\n            } else {\n                if (data[discriminatorProperty]) {\n                    const discriminatorType = data[discriminatorProperty];\n                    if (this._typeMap[discriminatorType]) {\n                        return discriminatorType; // use the type given in the discriminator\n                    } else {\n                        return expectedType; // discriminator did not map to a type\n                    }\n                } else {\n                    return expectedType; // discriminator was not present (or an empty string)\n                }\n            }\n        }\n    }\n\n    public serializeClass<T>(data: T, type: ClassType<T>) {\n        return this.serialize(data, TypeUtil.findTypeName(type));\n    }\n\n    public serializeClassArray<T>(data: Array<T>, type: ClassType<T>) {\n        return this.serialize(data, `Array<${TypeUtil.findTypeName(type)}>`);\n    }\n\n    public serialize(data: any, type: string, subtype: string | undefined = undefined) {\n        if (data == undefined) {\n            return data;\n        } else if (this._primitives.indexOf(type.toLowerCase()) !== -1) {\n            return data;\n        } else if (type.lastIndexOf('Array<', 0) === 0) {\n            // string.startsWith pre es6\n            let subType: string = type.replace('Array<', ''); // Array<Type> => Type>\n            subType = subType.substring(0, subType.length - 1); // Type> => Type\n            const transformedData: any[] = [];\n            // tslint:disable-next-line:prefer-for-of\n            for (let index = 0; index < data.length; index++) {\n                const datum = data[index];\n                transformedData.push(this.serialize(datum, subType));\n            }\n            return transformedData;\n        } else if (type === 'Date') {\n            const dateOnly = subtype === 'date';\n            return DateUtil.toIsoString(data, this.dateTimeInUtc, this.dateTimeWithTimezone, this.dateTimeWithMillis, dateOnly);\n        } else {\n            if (this._enumMap[type]) {\n                return data;\n            }\n            if (!this._typeMap[type]) {\n                // in case we dont know the type\n                return data;\n            }\n\n            // Get the actual type of this object\n            type = this.findCorrectType(data, type);\n\n            // get the map for the correct type.\n            const attributeTypes = this._typeMap[type].getAttributeTypeMap() as Array<AttributeDef>;\n            const instance: {[index: string]: any} = {};\n            // tslint:disable-next-line:prefer-for-of\n            for (let index = 0; index < attributeTypes.length; index++) {\n                const attributeType = attributeTypes[index];\n                instance[attributeType.baseName] = this.serialize(data[attributeType.name], attributeType.type, attributeType.subtype);\n            }\n            return instance;\n        }\n    }\n\n    public deserializeClass<T>(data: any, type: ClassType<T>): T {\n        return this.deserialize(data, TypeUtil.findTypeName(type));\n    }\n\n    public deserializeClassArray<T>(data: any, type: ClassType<T>): Array<T> {\n        return this.deserialize(data, `Array<${TypeUtil.findTypeName(type)}>`);\n    }\n\n    public deserialize(data: any, type: string) {\n        // polymorphism may change the actual type.\n        type = this.findCorrectType(data, type);\n        if (data == undefined) {\n            return data;\n        } else if (this._primitives.indexOf(type.toLowerCase()) !== -1) {\n            return data;\n        } else if (type.lastIndexOf('Array<', 0) === 0) {\n            // string.startsWith pre es6\n            let subType: string = type.replace('Array<', ''); // Array<Type> => Type>\n            subType = subType.substring(0, subType.length - 1); // Type> => Type\n            const transformedData: any[] = [];\n            // tslint:disable-next-line:prefer-for-of\n            for (let index = 0; index < data.length; index++) {\n                const datum = data[index];\n                transformedData.push(this.deserialize(datum, subType));\n            }\n            return transformedData;\n        } else if (type === 'Date') {\n            return new Date(data);\n        } else {\n            if (this._enumMap[type]) {\n                // is Enum\n                return data;\n            }\n\n            if (!this._typeMap[type]) {\n                // dont know the type\n                return data;\n            }\n            const instance = new this._typeMap[type]();\n            const attributeTypes = this._typeMap[type].getAttributeTypeMap() as Array<AttributeDef>;\n            // tslint:disable-next-line:prefer-for-of\n            for (let index = 0; index < attributeTypes.length; index++) {\n                const attributeType = attributeTypes[index];\n                instance[attributeType.name] = this.deserialize(data[attributeType.baseName], attributeType.type);\n            }\n            return instance;\n        }\n    }\n}\n"]}