public toGroupItem()

in source/packages/services/assetlibrary/src/groups/groups.assembler.ts [81:191]
100 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({
                            id: (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({
                            id: (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;
    }