private async generateClasspaths()

in src/exportJarSteps/GenerateJarExecutor.ts [100:206]
107 lines of code
19 McCabe index (conditional complexity)

    private async generateClasspaths(stepMetadata: IStepMetadata): Promise<boolean> {
        const extensionApi: any = await getExtensionApi();
        const dependencyItems: IJarQuickPickItem[] = await window.withProgress({
            location: ProgressLocation.Window,
            title: "Exporting Jar : Resolving classpaths...",
            cancellable: true,
        }, (_progress, token) => {
            return new Promise<IJarQuickPickItem[]>(async (resolve, reject) => {
                token.onCancellationRequested(() => {
                    return reject();
                });
                const pickItems: IJarQuickPickItem[] = [];
                const uriSet: Set<string> = new Set<string>();
                const projectList: INodeData[] = stepMetadata.projectList;
                if (_.isEmpty(projectList)) {
                    return reject(new Error(ExportJarMessages.WORKSPACE_EMPTY));
                }
                const workspaceFolder: WorkspaceFolder | undefined = stepMetadata.workspaceFolder;
                if (!workspaceFolder) {
                    return reject(new Error(ExportJarMessages.fieldUndefinedMessage(ExportJarMessages.Field.WORKSPACEFOLDER, this.currentStep)));
                }
                for (const project of projectList) {
                    const projectUri: string = project.metaData?.UnmanagedFolderInnerPath || project.uri;
                    let classpaths: IClasspathResult;
                    let testClasspaths: IClasspathResult;
                    try {
                        classpaths = await extensionApi.getClasspaths(projectUri, { scope: "runtime" });
                        testClasspaths = await extensionApi.getClasspaths(projectUri, { scope: "test" });
                    } catch (e) {
                        return reject(new Error(e));
                    }
                    pickItems.push(
                        ...await this.parseDependencyItems(classpaths.classpaths, uriSet, workspaceFolder.uri.fsPath, "runtime"),
                        ...await this.parseDependencyItems(classpaths.modulepaths, uriSet, workspaceFolder.uri.fsPath, "runtime"));
                    pickItems.push(
                        ...await this.parseDependencyItems(testClasspaths.classpaths, uriSet, workspaceFolder.uri.fsPath, "test"),
                        ...await this.parseDependencyItems(testClasspaths.modulepaths, uriSet, workspaceFolder.uri.fsPath, "test"));
                }
                return resolve(pickItems);
            });
        });
        if (_.isEmpty(dependencyItems)) {
            throw new Error(ExportJarMessages.PROJECT_EMPTY);
        } else if (dependencyItems.length === 1) {
            await this.setStepMetadataFromOutputFolder(dependencyItems[0].path, stepMetadata.classpaths);
            return true;
        }
        dependencyItems.sort((node1, node2) => {
            if (node1.description !== node2.description) {
                return (node1.description || "").localeCompare(node2.description || "");
            }
            if (node1.type !== node2.type) {
                return node2.type.localeCompare(node1.type);
            }
            return node1.label.localeCompare(node2.label);
        });
        const pickedDependencyItems: IJarQuickPickItem[] = [];
        for (const item of dependencyItems) {
            if (item.picked) {
                pickedDependencyItems.push(item);
            }
        }
        const disposables: Disposable[] = [];
        let result: boolean = false;
        try {
            result = await new Promise<boolean>(async (resolve, reject) => {
                const pickBox = createPickBox<IJarQuickPickItem>("Export Jar : Determine elements", "Select the elements",
                    dependencyItems, stepMetadata.steps.length > 0, true);
                pickBox.selectedItems = pickedDependencyItems;
                disposables.push(
                    pickBox.onDidTriggerButton((item) => {
                        if (item === QuickInputButtons.Back) {
                            return resolve(false);
                        }
                    }),
                    pickBox.onDidAccept(async () => {
                        if (_.isEmpty(pickBox.selectedItems)) {
                            return;
                        }
                        for (const item of pickBox.selectedItems) {
                            if (item.type === "artifact") {
                                const classpath: IClasspath = {
                                    source: item.path,
                                    destination: undefined,
                                    isArtifact: true,
                                };
                                stepMetadata.classpaths.push(classpath);
                            } else {
                                await this.setStepMetadataFromOutputFolder(item.path, stepMetadata.classpaths);
                            }
                        }
                        return resolve(true);
                    }),
                    pickBox.onDidHide(() => {
                        return reject();
                    }),
                );
                disposables.push(pickBox);
                pickBox.show();
            });
        } finally {
            for (const d of disposables) {
                d.dispose();
            }
        }
        return result;
    }