@algotech-ce/interpretor 2.0.0

package/dist/@utils/so-utils.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+import { SmartObjectDto, SmartModelDto, SmartPropertyModelDto, ATSkillsDto, PairDto, WorkflowInstanceContextDto, GenericListDto, DocumentDto, SysFile, ImportOptionsDto } from '@algotech-ce/core';
+import { InterpretorAbstract } from '../interpretor-abstract/interpretor-abstract';
+import { Observable } from 'rxjs';
+import { SmartObjectMapped } from '../dto/interfaces/smart-object-mapped';
+export declare abstract class SoUtils {
+    protected interpretorAbstract: InterpretorAbstract;
+    static EXPAND: string;
+    constructor(interpretorAbstract: InterpretorAbstract);
+    abstract csvToSo(file: Blob | Buffer, smartModel: SmartModelDto, options: ImportOptionsDto): Observable<SmartObjectDto[]>;
+    abstract getAllByProperties(querySearch: any, context?: WorkflowInstanceContextDto): any;
+    abstract getAllByModel(model: string, context?: WorkflowInstanceContextDto): Observable<SmartObjectDto[]>;
+    getModel(key: string, models: SmartModelDto[]): SmartModelDto;
+    getModelByType(type: string, models: SmartModelDto[]): SmartModelDto;
+    typeIsSysObject(type: string): boolean;
+    typeIsSmartObject(type: string): boolean;
+    typeIsAbstract(type: string): boolean;
+    isSmartObject(value: any): boolean;
+    createInstance(model: SmartModelDto): SmartObjectDto;
+    isReset(value: any): boolean;
+    createObjectProperties(smartObject: SmartObjectDto, model: SmartModelDto, properties: PairDto[], cumul: boolean): void;
+    _csvDataToSo(data: string[][], smartModel: SmartModelDto, options: ImportOptionsDto): SmartObjectDto[];
+    _bindColumn(keys: string[], smartModel: SmartModelDto): PairDto[];
+    _resetProperty(prop: PairDto, smartObject: SmartObjectDto, model: SmartModelDto): void;
+    _assignProperty(prop: PairDto, smartObject: SmartObjectDto, model: SmartModelDto, cumul: boolean): void;
+    repairInstance(object: SmartObjectDto, model: SmartModelDto): boolean;
+    transformListObject(objects: Array<SmartObjectDto | SysFile>, documents: DocumentDto[]): SysFile[];
+    skToSysFile(doc: DocumentDto): SysFile;
+    getDocuments(so: SmartObjectDto, documents: DocumentDto[]): any[];
+    setPropertyValue(so: SmartObjectDto, sm: SmartModelDto, key: string, value: any, cumul?: boolean, format?: string): SmartObjectDto;
+    createSkill(key?: string): ATSkillsDto;
+    formatProperty(type: string, value: any, format?: string): any;
+    private strToBool;
+    private _createProperty;
+    propertyIsValid(property: SmartPropertyModelDto, value: any, checkFormat?: boolean): any;
+    private transformNestedData;
+    nestedSmartObjectsGetValue(smartobjects: SmartObjectDto[], prop: any, glists: GenericListDto[], lang: string, value: any): any;
+    respectConditions(conditions: string | string[], so: SmartObjectDto | SmartObjectDto[], strictEquality?: boolean, operator?: string): any;
+    buildJson(sos: SmartObjectDto[], allSmartObjects: SmartObjectDto[], smartModels: SmartModelDto[], indexes: Object, parents?: SmartObjectDto[]): any[];
+    buildJsonObject(so: SmartObjectDto, allSmartObjects: SmartObjectDto[], smartModels: SmartModelDto[], indexes: Object, parents: SmartObjectDto[]): Object;
+    nestedSmartObjectsProps(inputs: PairDto[], smartobjects: SmartObjectDto[], context: WorkflowInstanceContextDto, byClone?: boolean): any;
+    getSubDoc(uuid: string, context: WorkflowInstanceContextDto): Observable<SmartObjectDto[]>;
+    private _checkDefined;
+    private _checkFormat;
+    smartObjectMapped(smartModel: SmartModelDto, smartModels: SmartModelDto[], object: any, smartobjects?: SmartObjectDto[], objects?: SmartObjectDto[]): SmartObjectMapped;
+    smartObjectMappedProperty(soObject: SmartObjectDto, smartModel: SmartModelDto, prop: SmartPropertyModelDto, smartModels: SmartModelDto[], value: any, smartobjects: SmartObjectDto[], objects?: SmartObjectDto[]): void;
+    private isUUID;
+}

package/dist/@utils/so-utils.js

@@ -0,0 +1,605 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoUtils = void 0;
+const core_1 = require("@algotech-ce/core");
+const _ = __importStar(require("lodash"));
+const angular2_uuid_1 = require("angular2-uuid");
+const moment_1 = __importDefault(require("moment"));
+const interpretor_so_utils_1 = require("../interpretor-reader/interpretor-so/interpretor-so-utils");
+class SoUtils {
+    constructor(interpretorAbstract) {
+        this.interpretorAbstract = interpretorAbstract;
+    }
+    getModel(key, models) {
+        const model = _.find(models, (m) => m.key === key);
+        if (!model) {
+            throw new Error(`Model ${key} not found`);
+        }
+        return model;
+    }
+    getModelByType(type, models) {
+        return this.getModel(type.replace('so:', ''), models);
+    }
+    typeIsSysObject(type) {
+        return type && type.startsWith('sys:');
+    }
+    typeIsSmartObject(type) {
+        return type && (type.startsWith('so:') || type.startsWith('sk:'));
+    }
+    typeIsAbstract(type) {
+        return type && (type === 'so:*' || type.startsWith('sk:'));
+    }
+    isSmartObject(value) {
+        if (!_.isObject(value)) {
+            return false;
+        }
+        return !!value.modelKey && Array.isArray(value.properties) && value.properties.every((v) => v.key) && !!value.skills;
+    }
+    createInstance(model) {
+        const properties = model.properties.map((p) => this._createProperty(p));
+        const skills = this.createSkill();
+        const instance = {
+            uuid: angular2_uuid_1.UUID.UUID(),
+            modelKey: model.key,
+            properties,
+            skills
+        };
+        return instance;
+    }
+    isReset(value) {
+        return _.isEqual(value, { reset: true }) || _.isEqual(value, [{ reset: true }]);
+    }
+    createObjectProperties(smartObject, model, properties, cumul) {
+        _.forEach(properties, (prop) => {
+            if (prop.value != null) {
+                if (this.isReset(prop.value)) {
+                    this._resetProperty(prop, smartObject, model);
+                }
+                else {
+                    this._assignProperty(prop, smartObject, model, cumul);
+                }
+            }
+        });
+    }
+    _csvDataToSo(data, smartModel, options) {
+        const smartObjects = [];
+        if (data.length === 0) {
+            return [];
+        }
+        const soProps = {};
+        for (const item of options.columns ?? this._bindColumn(data[0], smartModel)) {
+            soProps[item.key] = item.value;
+        }
+        for (let iRow = 1; iRow < data.length; iRow++) {
+            const smartObject = this.createInstance(smartModel);
+            for (let iColumn = 0; iColumn < data[0].length; iColumn++) {
+                const soProp = soProps[data[0][iColumn]];
+                if (!soProp || this.typeIsSmartObject(soProp.keyType) || this.typeIsSysObject(soProp.keyType)) {
+                    continue;
+                }
+                let value = data[iRow][iColumn].trim();
+                value = soProp.multiple ? (value ? value.split('|') : []) : value;
+                const format = options.propertiesFormat?.find((format) => format.key === soProp.key)?.value ??
+                    options.dateDefaultFormat;
+                this.setPropertyValue(smartObject, smartModel, soProp.key, value, false, format);
+            }
+            smartObjects.push(smartObject);
+        }
+        return smartObjects;
+    }
+    _bindColumn(keys, smartModel) {
+        if (!keys) {
+            return [];
+        }
+        return keys.map((key) => {
+            const findProperty = smartModel.properties.find((prop) => {
+                if (this.typeIsSmartObject(prop.keyType) || this.typeIsSysObject(prop.keyType)) {
+                    return false;
+                }
+                if (key.toUpperCase() !== prop.key.toUpperCase()) {
+                    return false;
+                }
+                return true;
+            });
+            return {
+                key,
+                value: findProperty
+            };
+        });
+    }
+    _resetProperty(prop, smartObject, model) {
+        const index = _.findIndex(model.properties, (pr) => pr.key === prop.key);
+        const indexProp = _.findIndex(smartObject.properties, (pr) => pr.key === prop.key);
+        smartObject.properties[indexProp] = this._createProperty(model.properties[index]);
+    }
+    _assignProperty(prop, smartObject, model, cumul) {
+        const isArray = _.isArray(prop.value);
+        const datas = isArray ? (_.isArray(prop.value?.[0])) ? prop.value[0] : prop.value : [prop.value];
+        const values = _.map(datas, (data) => {
+            if (data instanceof core_1.SmartObjectDto) {
+                return data.uuid;
+            }
+            else {
+                return data;
+            }
+        });
+        if (isArray) {
+            this.setPropertyValue(smartObject, model, prop.key, values, cumul);
+        }
+        else {
+            if (values.length === 1) {
+                this.setPropertyValue(smartObject, model, prop.key, values[0]);
+            }
+        }
+    }
+    repairInstance(object, model) {
+        let repair = false;
+        const properties = model.properties.map((p) => this._createProperty(p));
+        for (const property of properties) {
+            const propertyObject = object.properties.find((p) => p.key === property.key);
+            const propertyModel = model.properties.find((p) => p.key === property.key);
+            // multiple && !array
+            if (propertyModel.multiple) {
+                if (propertyObject && propertyObject.value && !_.isArray(propertyObject.value)) {
+                    repair = true;
+                    this.setPropertyValue(object, model, property.key, [propertyObject.value], false);
+                }
+            }
+            // unknow or not assign
+            if ((!propertyObject) || (!propertyObject.value && property.value)) {
+                repair = true;
+                this.setPropertyValue(object, model, property.key, property.value);
+            }
+        }
+        return repair;
+    }
+    transformListObject(objects, documents) {
+        const versions = [];
+        _.map(objects, (document) => {
+            if (document instanceof core_1.SmartObjectDto) {
+                if (document.skills.atDocument && document.skills.atDocument.documents) {
+                    versions.push(..._.map(this.getDocuments(document, documents), (doc) => {
+                        return this.skToSysFile(doc);
+                    }));
+                }
+            }
+            else {
+                versions.push(document);
+            }
+        });
+        return versions;
+    }
+    skToSysFile(doc) {
+        const file = {
+            documentID: doc.uuid,
+            ext: doc.ext,
+            name: doc.name,
+            dateUpdated: doc.versions[0].dateUpdated,
+            versionID: doc.versions[0].uuid,
+            size: doc.versions[0].size,
+            user: doc.versions[0].userID,
+            reason: doc.versions[0].reason,
+            tags: doc.tags,
+            metadatas: doc.metadatas,
+            annotations: doc.versions[0].annotations
+        };
+        return file;
+    }
+    getDocuments(so, documents) {
+        return so.skills.atDocument.documents.reduce((results, docUuid) => {
+            const findDoc = documents.find((d) => d.uuid === docUuid);
+            if (findDoc) {
+                results.push(findDoc);
+            }
+            return results;
+        }, []);
+    }
+    setPropertyValue(so, sm, key, value, cumul = false, format) {
+        const propertyModel = _.find(sm.properties, { key });
+        const values = value == null ? null : (_.isArray(value)) ? value : [value];
+        // no model
+        if (!propertyModel) {
+            return so;
+        }
+        // data incorrect
+        if (!propertyModel.multiple && values && values.length !== 1) {
+            return so;
+        }
+        const formatValues = values ? _.map(values, (val) => {
+            return this.formatProperty(propertyModel.keyType, val, format);
+        }) : null;
+        const _value = formatValues == null ? null : propertyModel.multiple ? formatValues : formatValues[0];
+        // property not create
+        const indexProp = _.findIndex(so.properties, { key });
+        if (indexProp === -1) {
+            so.properties.push({ key, value: _value });
+            return so;
+        }
+        // cumul
+        if (propertyModel.multiple && cumul) {
+            if (_value != null) {
+                so.properties[indexProp].value.push(..._value);
+            }
+        }
+        else {
+            // replace
+            so.properties[indexProp].value = _value;
+        }
+        return so;
+    }
+    createSkill(key) {
+        const skills = {
+            atDocument: {
+                documents: []
+            },
+            atGeolocation: {
+                geo: []
+            },
+            atTag: {
+                tags: []
+            },
+            atSignature: null,
+            atMagnet: {
+                zones: []
+            },
+        };
+        if (key) {
+            return skills[key];
+        }
+        return skills;
+    }
+    formatProperty(type, value, format) {
+        if (value == null) {
+            return null;
+        }
+        switch (type) {
+            case 'boolean':
+                return this.strToBool(value);
+            case 'number':
+                return _.isString(value) ? +value.replace(',', '.') : +value;
+            case 'date':
+                return (0, moment_1.default)(value, format).isValid() ? (0, moment_1.default)(value, format).startOf('day').format() : null;
+            case 'time': {
+                if ((0, moment_1.default)(value, format).isValid()) {
+                    return (0, moment_1.default)(value, format).format('HH:mm:ss');
+                }
+                if ((0, moment_1.default)(value, 'HH:mm:ss').isValid()) {
+                    return (0, moment_1.default)(value, 'HH:mm:ss').format('HH:mm:ss');
+                }
+                if ((0, moment_1.default)(value, 'HH:mm').isValid()) {
+                    return (0, moment_1.default)(value, 'HH:mm').format('HH:mm:ss');
+                }
+                if ((0, moment_1.default)(value, 'LT').isValid()) {
+                    return (0, moment_1.default)(value, 'LT').format('HH:mm:ss');
+                }
+                return null;
+            }
+            case 'datetime':
+                return (0, moment_1.default)(value, format).isValid() ? (0, moment_1.default)(value, format).format() : null;
+            default:
+                return value;
+        }
+    }
+    strToBool(value) {
+        if (_.isBoolean(value)) {
+            return value;
+        }
+        return [
+            'yes',
+            'true',
+            true,
+            'y',
+            1,
+            '1'
+        ].includes(value);
+    }
+    _createProperty(property) {
+        let value = null;
+        if (property.defaultValue) {
+            value = property.defaultValue;
+        }
+        else if (property.multiple) {
+            value = [];
+        }
+        const prop = {
+            key: property.key,
+            value
+        };
+        return prop;
+    }
+    propertyIsValid(property, value, checkFormat = true) {
+        if (property.key.startsWith(SoUtils.EXPAND)) {
+            return true;
+        }
+        if (!property.required) {
+            if (!this._checkDefined(property, value)) {
+                return true;
+            }
+            return !checkFormat || this._checkFormat(property, value);
+        }
+        else {
+            return this._checkDefined(property, value) && (!checkFormat || this._checkFormat(property, value));
+        }
+    }
+    transformNestedData(value, smartobjects) {
+        if (value instanceof core_1.SmartObjectDto) {
+            const findSo = _.find(smartobjects, (so) => so.uuid === value.uuid);
+            return findSo;
+        }
+        if (Array.isArray(value) && value.length > 0 && value[0] instanceof core_1.SmartObjectDto) {
+            return _.map(value, (item) => {
+                const findSo = _.find(smartobjects, (so) => so.uuid === item.uuid);
+                return findSo;
+            });
+        }
+        return value;
+    }
+    nestedSmartObjectsGetValue(smartobjects, prop, glists, lang, value) {
+        const findSo = _.find(smartobjects, so => so.uuid === value);
+        if (findSo) {
+            return findSo;
+        }
+        else {
+            if (prop.items) {
+                let val = value;
+                if (!Array.isArray(prop.items)) {
+                    const g = (glists) ? _.find(glists, (gl) => gl.key === prop.items) : null;
+                    const Langs = (g) ? _.find(g.values, (v) => v.key === value) : { value: [] };
+                    const l = (Langs && Langs.value) ? _.find(Langs.value, (v) => v.lang === lang) : null;
+                    val = (l) ? l.value : val;
+                }
+                return val;
+            }
+            else {
+                switch (prop.keyType) {
+                    case 'date':
+                        return (0, moment_1.default)(value).format('DD/MM/YYYY');
+                    case 'datetime':
+                        return (0, moment_1.default)(value).format('DD/MM/YYYY hh:mm:ss');
+                    case 'time':
+                        return (0, moment_1.default)(value).format('hh:mm:ss');
+                    default:
+                        return value;
+                }
+            }
+        }
+    }
+    respectConditions(conditions, so, strictEquality = false, operator = 'and') {
+        const _conditions = _.isArray(conditions) ? conditions : [conditions];
+        const action = operator === 'and' ? _.every : _.some;
+        return action(_conditions, condition => {
+            // modelKey.PROP=value
+            try {
+                const path = condition.split('=')[0];
+                const propertyValue = condition.split('=')[1].toUpperCase();
+                const split = interpretor_so_utils_1.InterpretorSoUtils.split(path);
+                const modelKey = split[0];
+                const propertyKey = split[1];
+                const smartobjects = Array.isArray(so) ? so : _.compact([so]);
+                if (smartobjects.length === 0) {
+                    return false;
+                }
+                const smartobject = smartobjects.find((find) => find.modelKey === modelKey);
+                if (!smartobject) {
+                    return false;
+                }
+                const findProp = _.find(smartobject.properties, (p) => p.key === propertyKey);
+                if (!findProp || findProp.value === null || findProp.value === undefined) {
+                    return false;
+                }
+                if (propertyValue === '*') {
+                    return true;
+                }
+                // strict
+                if (strictEquality) {
+                    if (_.isArray(findProp.value)) {
+                        return _.some(_.compact(findProp.value), (value) => value.toString().toUpperCase() === propertyValue);
+                    }
+                    else {
+                        return findProp.value.toString().toUpperCase() === propertyValue.toUpperCase();
+                    }
+                }
+                // contains
+                if (_.isArray(findProp.value)) {
+                    return _.some(_.compact(findProp.value), (value) => value.toString().toUpperCase().includes(propertyValue));
+                }
+                else {
+                    return findProp.value.toString().toUpperCase().includes(propertyValue.toUpperCase());
+                }
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    buildJson(sos, allSmartObjects, smartModels, indexes, parents = null) {
+        let obj = [];
+        for (const so of sos) {
+            const existsObj = parents?.find((parent) => parent.uuid === so.uuid);
+            if (existsObj) {
+                return [];
+            }
+            obj.push(this.buildJsonObject(so, allSmartObjects, smartModels, indexes, parents ? [...parents, so] : [so]));
+        }
+        return obj;
+    }
+    buildJsonObject(so, allSmartObjects, smartModels, indexes, parents) {
+        const obj = {};
+        const model = this.getModel(so.modelKey, smartModels);
+        for (const prop of so.properties) {
+            const propModel = model.properties.find((prp) => prp.key === prop.key);
+            if (propModel && propModel.keyType.startsWith('so:')) {
+                const findObj = (propModel.multiple) ?
+                    _.compact(_.map(prop.value, (val) => interpretor_so_utils_1.InterpretorSoUtils.quickFind(allSmartObjects, indexes, val))) :
+                    _.compact([interpretor_so_utils_1.InterpretorSoUtils.quickFind(allSmartObjects, indexes, prop.value)]);
+                if (findObj.length !== 0) {
+                    const property = this.buildJson(findObj, allSmartObjects, smartModels, indexes, parents);
+                    if (propModel.multiple) {
+                        obj[prop.key] = property;
+                    }
+                    else if (property.length > 0) {
+                        obj[prop.key] = property[0];
+                    }
+                }
+            }
+            else {
+                obj[prop.key] = prop.value;
+            }
+        }
+        return obj;
+    }
+    nestedSmartObjectsProps(inputs, smartobjects, context, byClone = true) {
+        const _smartobjects = (byClone) ? _.uniqBy(_.cloneDeep(smartobjects), 'uuid') : smartobjects;
+        _.forEach(_smartobjects, (smartobject) => {
+            _.forEach(smartobject.properties, (property) => {
+                const sm = (context.smartmodels) ? _.find(context.smartmodels, (s) => s.key === smartobject.modelKey) : null;
+                const p = (sm) ? _.find(sm.properties, (p) => p.key === property.key) : { keyType: 'string' };
+                if (Array.isArray(property.value)) {
+                    smartobject[property.key] = _.map(property.value, (item) => {
+                        return this.nestedSmartObjectsGetValue(_smartobjects, (p) ? p : { keyType: 'string' }, context.glists, context.user.preferedLang, item);
+                    });
+                }
+                else {
+                    smartobject[property.key] = this.nestedSmartObjectsGetValue(_smartobjects, (p) ? p : { keyType: 'string' }, context.glists, context.user.preferedLang, property.value);
+                }
+            });
+            delete smartobject.properties;
+            delete smartobject.modelKey;
+            delete smartobject.skills;
+        });
+        return _.fromPairs(_.reduce(inputs, (results, pair) => {
+            if (pair && pair.value) {
+                results.push([`${pair.key}`, this.transformNestedData(pair.value, _smartobjects)]);
+            }
+            return results;
+        }, []));
+    }
+    getSubDoc(uuid, context) {
+        return this.interpretorAbstract.getSubDoc(context, { uuid }, true, false);
+    }
+    _checkDefined(property, value) {
+        if (property.multiple) {
+            if (!_.isArray(value) || value.length === 0) {
+                return false;
+            }
+        }
+        const values = _.isArray(value) ? value : [value];
+        return _.every(values, (v) => {
+            switch (property.keyType) {
+                case 'sys:comment':
+                    return v && v.message && v.message !== '';
+                default:
+                    return v !== '' && v !== null && v !== undefined;
+            }
+        });
+    }
+    _checkFormat(property, value) {
+        const values = _.isArray(value) ? value : [value];
+        return _.every(values, (v) => {
+            switch (property.keyType) {
+                case 'string':
+                    return _.isString(v);
+                case 'boolean':
+                    return _.isBoolean(v);
+                case 'number':
+                    return _.isNumber(v);
+                case 'date':
+                    return (0, moment_1.default)(v).isValid();
+                case 'time':
+                    return (0, moment_1.default)(v, 'HH:mm:ss').isValid();
+                case 'datetime':
+                    return (0, moment_1.default)(v).isValid();
+                case 'sys:comment':
+                    return v && v.message && v.message !== '';
+                default:
+                    return true;
+            }
+        });
+    }
+    /*  Mapped */
+    smartObjectMapped(smartModel, smartModels, object, smartobjects = [], objects = []) {
+        const soObject = this.createInstance(smartModel);
+        if (object.uuid) {
+            soObject.uuid = object.uuid;
+        }
+        const _object = {};
+        Object.entries(object).forEach(([key, value]) => {
+            _object[key.toUpperCase()] = value;
+        });
+        for (const prop of smartModel.properties) {
+            const key = prop.key.toUpperCase();
+            const value = _object.hasOwnProperty(key) ? _object[key] : null;
+            this.smartObjectMappedProperty(soObject, smartModel, prop, smartModels, value, smartobjects, objects);
+        }
+        smartobjects.push(soObject);
+        objects.push(object);
+        return {
+            smartobjects,
+            objects,
+            uuid: soObject.uuid
+        };
+    }
+    smartObjectMappedProperty(soObject, smartModel, prop, smartModels, value, smartobjects, objects = []) {
+        if (value === null || value === undefined || !this.propertyIsValid(prop, value)) {
+            return;
+        }
+        if (!this.typeIsSmartObject(prop.keyType)) {
+            this.setPropertyValue(soObject, smartModel, prop.key, value, true);
+            return;
+        }
+        const snModel = this.getModelByType(prop.keyType, smartModels);
+        const getUuid = (value) => {
+            if (_.isObject(value)) {
+                return this.smartObjectMapped(snModel, smartModels, value, smartobjects, objects).uuid;
+            }
+            else if (this.isUUID(value)) {
+                return value;
+            }
+            return null;
+        };
+        if (prop.multiple) {
+            const values = _.isArray(value) ? value : [value];
+            const uuids = _.compact(values.map((val) => getUuid(val)));
+            this.setPropertyValue(soObject, smartModel, prop.key, uuids, true);
+        }
+        else {
+            const uuid = getUuid(value);
+            if (uuid) {
+                this.setPropertyValue(soObject, smartModel, prop.key, uuid, true);
+            }
+        }
+    }
+    isUUID(str) {
+        const regexExp = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/gi;
+        return regexExp.test(str); // true
+    }
+}
+exports.SoUtils = SoUtils;
+SoUtils.EXPAND = '~__';
+//# sourceMappingURL=so-utils.js.map