add-zip-library.ts

import { inject, injectable } from 'inversify';
import { remote } from 'electron';
import URI from '@theia/core/lib/common/uri';
import { ConfirmDialog } from '@theia/core/lib/browser/dialogs';
import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
import { ArduinoMenus } from '../menu/arduino-menus';
import { ResponseServiceImpl } from '../response-service-impl';
import { Installable, LibraryService } from '../../common/protocol';
import {
  SketchContribution,
  Command,
  CommandRegistry,
  MenuModelRegistry,
} from './contribution';

@injectable()
export class AddZipLibrary extends SketchContribution {
  @inject(EnvVariablesServer)
  protected readonly envVariableServer: EnvVariablesServer;

  @inject(ResponseServiceImpl)
  protected readonly responseService: ResponseServiceImpl;

  @inject(LibraryService)
  protected readonly libraryService: LibraryService;

  registerCommands(registry: CommandRegistry): void {
    registry.registerCommand(AddZipLibrary.Commands.ADD_ZIP_LIBRARY, {
      execute: () => this.addZipLibrary(),
    });
  }

  registerMenus(registry: MenuModelRegistry): void {
    const includeLibMenuPath = [
      ...ArduinoMenus.SKETCH__UTILS_GROUP,
      '0_include',
    ];
    // TODO: do we need it? calling `registerSubmenu` multiple times is noop, so it does not hurt.
    registry.registerSubmenu(includeLibMenuPath, 'Include Library', {
      order: '1',
    });
    registry.registerMenuAction([...includeLibMenuPath, '1_install'], {
      commandId: AddZipLibrary.Commands.ADD_ZIP_LIBRARY.id,
      label: 'Add .ZIP Library...',
      order: '1',
    });
  }

  async addZipLibrary(): Promise<void> {
    const homeUri = await this.envVariableServer.getHomeDirUri();
    const defaultPath = await this.fileService.fsPath(new URI(homeUri));
    const { canceled, filePaths } = await remote.dialog.showOpenDialog({
      title: "Select a zip file containing the library you'd like to add",
      defaultPath,
      properties: ['openFile'],
      filters: [
        {
          name: 'Library',
          extensions: ['zip'],
        },
      ],
    });
    if (!canceled && filePaths.length) {
      const zipUri = await this.fileSystemExt.getUri(filePaths[0]);
      try {
        await this.doInstall(zipUri);
      } catch (error) {
        if (error instanceof AlreadyInstalledError) {
          const result = await new ConfirmDialog({
            msg: error.message,
            title: 'Do you want to overwrite the existing library?',
            ok: 'Yes',
            cancel: 'No',
          }).open();
          if (result) {
            await this.doInstall(zipUri, true);
          }
        }
      }
    }
  }

  private async doInstall(zipUri: string, overwrite?: boolean): Promise<void> {
    try {
      await Installable.doWithProgress({
        messageService: this.messageService,
        progressText: `Processing ${new URI(zipUri).path.base}`,
        responseService: this.responseService,
        run: () => this.libraryService.installZip({ zipUri, overwrite }),
      });
      this.messageService.info(
        `Successfully installed library from ${
          new URI(zipUri).path.base
        } archive`,
        { timeout: 3000 }
      );
    } catch (error) {
      if (error instanceof Error) {
        const match = error.message.match(/library (.*?) already installed/);
        if (match && match.length >= 2) {
          const name = match[1].trim();
          if (name) {
            throw new AlreadyInstalledError(
              `A library folder named ${name} already exists. Do you want to overwrite it?`,
              name
            );
          } else {
            throw new AlreadyInstalledError(
              'A library already exists. Do you want to overwrite it?'
            );
          }
        }
      }
      this.messageService.error(error.toString());
      throw error;
    }
  }
}

class AlreadyInstalledError extends Error {
  constructor(message: string, readonly libraryName?: string) {
    super(message);
    Object.setPrototypeOf(this, AlreadyInstalledError.prototype);
  }
}

export namespace AddZipLibrary {
  export namespace Commands {
    export const ADD_ZIP_LIBRARY: Command = {
      id: 'arduino-add-zip-library',
    };
  }
}