await callWithTelemetryAndErrorHandling()

in src/funcCoreTools/validateFuncCoreToolsIsLatest.ts [26:106]
70 lines of code
19 McCabe index (conditional complexity)

    await callWithTelemetryAndErrorHandling('azureFunctions.validateFuncCoreToolsIsLatest', async (context: IActionContext) => {
        context.errorHandling.suppressDisplay = true;
        context.telemetry.properties.isActivationEvent = 'true';

        const showMultiCoreToolsWarningKey: string = 'showMultiCoreToolsWarning';
        const showMultiCoreToolsWarning: boolean = !!getWorkspaceSetting<boolean>(showMultiCoreToolsWarningKey);

        const showCoreToolsWarningKey: string = 'showCoreToolsWarning';
        const showCoreToolsWarning: boolean = !!getWorkspaceSetting<boolean>(showCoreToolsWarningKey);

        if (showCoreToolsWarning || showMultiCoreToolsWarning) {
            validateNoFuncCliSetting();

            const packageManagers: PackageManager[] = await getFuncPackageManagers(true /* isFuncInstalled */);
            let packageManager: PackageManager;
            if (packageManagers.length === 0) {
                return;
            } else if (packageManagers.length === 1) {
                packageManager = packageManagers[0];
                context.telemetry.properties.packageManager = packageManager;
            } else {
                context.telemetry.properties.multiFunc = 'true';
                if (showMultiCoreToolsWarning) {
                    const message: string = localize('multipleInstalls', 'Detected multiple installs of the func cli.');
                    const selectUninstall: vscode.MessageItem = { title: localize('selectUninstall', 'Select version to uninstall') };
                    const result: vscode.MessageItem = await context.ui.showWarningMessage(message, selectUninstall, DialogResponses.dontWarnAgain);
                    if (result === selectUninstall) {
                        await uninstallFuncCoreTools(context, packageManagers);
                    } else if (result === DialogResponses.dontWarnAgain) {
                        await updateGlobalSetting(showMultiCoreToolsWarningKey, false);
                    }
                }

                return;
            }

            if (showCoreToolsWarning) {
                const localVersion: string | null = await getLocalFuncCoreToolsVersion(context, undefined);
                if (!localVersion) {
                    return;
                }
                context.telemetry.properties.localVersion = localVersion;

                const versionFromSetting: FuncVersion | undefined = tryParseFuncVersion(localVersion);
                if (versionFromSetting === undefined) {
                    return;
                }

                const newestVersion: string | undefined = await getNewestFunctionRuntimeVersion(packageManager, versionFromSetting, context);
                if (!newestVersion) {
                    return;
                }

                if (semver.major(newestVersion) === semver.major(localVersion) && semver.gt(newestVersion, localVersion)) {
                    context.telemetry.properties.outOfDateFunc = 'true';
                    const message: string = localize(
                        'outdatedFunctionRuntime',
                        'Update your Azure Functions Core Tools ({0}) to the latest ({1}) for the best experience.',
                        localVersion,
                        newestVersion
                    );

                    const update: vscode.MessageItem = { title: 'Update' };
                    let result: vscode.MessageItem;

                    do {
                        result = packageManager !== undefined ? await context.ui.showWarningMessage(message, update, DialogResponses.learnMore, DialogResponses.dontWarnAgain) :
                            await context.ui.showWarningMessage(message, DialogResponses.learnMore, DialogResponses.dontWarnAgain);
                        if (result === DialogResponses.learnMore) {
                            await openUrl('https://aka.ms/azFuncOutdated');
                        } else if (result === update) {
                            await updateFuncCoreTools(context, packageManager, versionFromSetting);
                        } else if (result === DialogResponses.dontWarnAgain) {
                            await updateGlobalSetting(showCoreToolsWarningKey, false);
                        }
                    }
                    while (result === DialogResponses.learnMore);
                }
            }
        }
    });