private groupTasks()

in src/gantt.ts [1740:1799]
52 lines of code
11 McCabe index (conditional complexity)

    private groupTasks(tasks: Task[]): GroupedTask[] {
        if (this.viewModel.settings.general.groupTasks) {
            let groupedTasks: _.Dictionary<Task[]> = _.groupBy(tasks,
                x => (x.parent ? `${x.parent}.${x.name}` : x.name));

            let result: GroupedTask[] = [];
            const taskKeys: string[] = Object.keys(groupedTasks);
            let alreadyReviewedKeys: string[] = [];

            taskKeys.forEach((key: string) => {
                const isKeyAlreadyReviewed = _.includes(alreadyReviewedKeys, key);
                if (!isKeyAlreadyReviewed) {
                    let name: string = key;
                    if (groupedTasks[key] && groupedTasks[key].length && groupedTasks[key][0].parent && key.indexOf(groupedTasks[key][0].parent) !== -1) {
                        name = key.substr(groupedTasks[key][0].parent.length + 1, key.length);
                    }

                    // add current task
                    const taskRecord = <GroupedTask>{
                        name,
                        tasks: groupedTasks[key]
                    };
                    result.push(taskRecord);
                    alreadyReviewedKeys.push(key);

                    // see all the children and add them
                    groupedTasks[key].forEach((task: Task) => {
                        if (task.children && !_.includes(this.collapsedTasks, task.name)) {
                            task.children.forEach((childrenTask: Task) => {
                                const childrenFullName = `${name}.${childrenTask.name}`;
                                const isChildrenKeyAlreadyReviewed = _.includes(alreadyReviewedKeys, childrenFullName);

                                if (!isChildrenKeyAlreadyReviewed) {
                                    const childrenRecord = <GroupedTask>{
                                        name: childrenTask.name,
                                        tasks: groupedTasks[childrenFullName]
                                    };
                                    result.push(childrenRecord);
                                    alreadyReviewedKeys.push(childrenFullName);
                                }
                            });
                        }
                    });
                }
            });

            result.forEach((x, i) => {
                x.tasks.forEach(t => t.index = i);
                x.index = i;
            });

            return result;
        }

        return tasks.map(x => <GroupedTask>{
            name: x.name,
            index: x.index,
            tasks: [x]
        });
    }