public toGroupItem()

in source/packages/services/assetlibrary/src/groups/groups.assembler.ts [61:159]
86 lines of code
24 McCabe index (conditional complexity)

    public toGroupItem(node: Node): GroupItem {
        logger.debug(`groups.assembler toGroupItem: in: node: ${JSON.stringify(node)}`);

        if (node===undefined) {
            logger.debug(`groups.assembler toGroupItem: exit: model: undefined`);
            return undefined;
        }

        const model = new GroupItem();
        model.category = TypeCategory.Group;
        model.version = node.version;

        try {
            model.templateId = node.types.filter(t => t !== TypeCategory.Group)[0];
        } catch (err) {
            // do nothing, as templates don't exist in 'lite' mode
        }

        Object.keys(node.attributes).forEach( key => {
            switch(key) {
                case 'name':
                    model.name = <string> this.fullAssembler.extractPropertyValue(node.attributes[key]);
                    break;
                case 'groupPath':
                    model.groupPath = <string> this.fullAssembler.extractPropertyValue(node.attributes[key]);
                    break;
                case 'parentPath':
                    model.parentPath = <string> this.fullAssembler.extractPropertyValue(node.attributes[key]);
                    break;
                case 'description':
                    model.description = <string> this.fullAssembler.extractPropertyValue(node.attributes[key]);
                    break;
                default:
                    model.attributes[key] = this.fullAssembler.extractPropertyValue(node.attributes[key]);
            }
        });

        if (model.name===undefined) {
            model.name=model.groupPath;
        }

        Object.keys(node.in).forEach( key => {
            const others = node.in[key];
            if (others!==undefined) {
                if (model.groups===undefined) {
                    model.groups= {};
                }
                if (model.groups.in===undefined) {
                    model.groups.in= {};
                }
                others.forEach(other=> {
                    if (other.category===TypeCategory.Group) {
                        if (model.groups.in[key]===undefined) {
                            model.groups.in[key]=[];
                        }
                        model.groups.in[key].push((other.attributes['groupPath'] as string[])[0]);
                    }
                });
            }
        });

        Object.keys(node.out).forEach( key => {
            const others = node.out[key];
            if (others!==undefined) {
                if (model.groups===undefined) {
                    model.groups= {};
                }
                if (model.groups.out===undefined) {
                    model.groups.out= {};
                }
                others.forEach(other=> {
                    if (other.category===TypeCategory.Group) {
                        if (model.groups.out[key]===undefined) {
                            model.groups.out[key]=[];
                        }
                        model.groups.out[key].push((other.attributes['groupPath'] as string[])[0]);
                    }
                });

            }
        });

        // remove any empty collection attributes
        if (model.groups) {
            if (model.groups.in && Object.keys(model.groups.in).length===0) {
                delete model.groups.in;
            }
            if (model.groups.out && Object.keys(model.groups.out).length===0) {
                delete model.groups.out;
            }
            if (Object.keys(model.groups).length===0) {
                delete model.groups;
            }
        }

        logger.debug(`groups.assembler toGroupItem: exit: model: ${JSON.stringify(model)}`);
        return model;

    }