boards-auto-installer.ts

import { injectable, inject } from 'inversify';
import { MessageService } from '@theia/core/lib/common/message-service';
import { FrontendApplicationContribution } from '@theia/core/lib/browser/frontend-application';
import {
    BoardsService,
    BoardsPackage,
    Board,
} from '../../common/protocol/boards-service';
import { BoardsServiceProvider } from './boards-service-provider';
import { BoardsListWidgetFrontendContribution } from './boards-widget-frontend-contribution';
import { BoardsConfig } from './boards-config';
import { Installable } from '../../common/protocol';
import { ResponseServiceImpl } from '../response-service-impl';

/**
 * Listens on `BoardsConfig.Config` changes, if a board is selected which does not
 * have the corresponding core installed, it proposes the user to install the core.
 */
@injectable()
export class BoardsAutoInstaller implements FrontendApplicationContribution {
    @inject(MessageService)
    protected readonly messageService: MessageService;

    @inject(BoardsService)
    protected readonly boardsService: BoardsService;

    @inject(BoardsServiceProvider)
    protected readonly boardsServiceClient: BoardsServiceProvider;

    @inject(ResponseServiceImpl)
    protected readonly responseService: ResponseServiceImpl;

    @inject(BoardsListWidgetFrontendContribution)
    protected readonly boardsManagerFrontendContribution: BoardsListWidgetFrontendContribution;

    // Workaround for https://github.com/eclipse-theia/theia/issues/9349
    protected notifications: Board[] = [];

    onStart(): void {
        this.boardsServiceClient.onBoardsConfigChanged(
            this.ensureCoreExists.bind(this)
        );
        this.ensureCoreExists(this.boardsServiceClient.boardsConfig);
    }

    protected ensureCoreExists(config: BoardsConfig.Config): void {
        const { selectedBoard } = config;
        if (
            selectedBoard &&
            !this.notifications.find((board) =>
                Board.sameAs(board, selectedBoard)
            )
        ) {
            this.notifications.push(selectedBoard);
            this.boardsService.search({}).then((packages) => {
                // filter packagesForBoard selecting matches from the cli (installed packages)
                // and matches based on the board name
                // NOTE: this ensures the Deprecated & new packages are all in the array
                // so that we can check if any of the valid packages is already installed
                const packagesForBoard = packages.filter(
                    (pkg) =>
                        BoardsPackage.contains(selectedBoard, pkg) ||
                        pkg.boards.some(
                            (board) => board.name === selectedBoard.name
                        )
                );

                // check if one of the packages for the board is already installed. if so, no hint
                if (
                    packagesForBoard.some(
                        ({ installedVersion }) => !!installedVersion
                    )
                ) {
                    return;
                }

                // filter the installable (not installed) packages,
                // CLI returns the packages already sorted with the deprecated ones at the end of the list
                // in order to ensure the new ones are preferred
                const candidates = packagesForBoard.filter(
                    ({ installable, installedVersion }) =>
                        installable && !installedVersion
                );

                const candidate = candidates[0];
                if (candidate) {
                    const version = candidate.availableVersions[0]
                        ? `[v ${candidate.availableVersions[0]}]`
                        : '';
                    // tslint:disable-next-line:max-line-length
                    this.messageService
                        .info(
                            `The \`"${candidate.name} ${version}"\` core has to be installed for the currently selected \`"${selectedBoard.name}"\` board. Do you want to install it now?`,
                            'Install Manually',
                            'Yes'
                        )
                        .then(async (answer) => {
                            const index = this.notifications.findIndex(
                                (board) => Board.sameAs(board, selectedBoard)
                            );
                            if (index !== -1) {
                                this.notifications.splice(index, 1);
                            }
                            if (answer === 'Yes') {
                                await Installable.installWithProgress({
                                    installable: this.boardsService,
                                    item: candidate,
                                    messageService: this.messageService,
                                    responseService: this.responseService,
                                    version: candidate.availableVersions[0],
                                });
                                return;
                            }
                            if (answer) {
                                this.boardsManagerFrontendContribution
                                    .openView({ reveal: true })
                                    .then((widget) =>
                                        widget.refresh(
                                            candidate.name.toLocaleLowerCase()
                                        )
                                    );
                            }
                        });
                }
            });
        }
    }
}