refactor(agent): refactor host-broswer to es6 (#4088)

* refactor(host): replace host-browser with es6 class

* refactor(host): replace promises with async

* refactor(hosts): replace delete promise with async

* refactor(host): replace upload file with async

* refactor(host): replace template strings

* fix(host): replace host root

* feat(agent): rename main file

app/agent/components/host-browser/hostBrowserController.js

@@ -0,0 +1,158 @@
+import _ from 'lodash-es';
+
+const ROOT_PATH = '/host';
+
+export class HostBrowserController {
+  constructor($async, HostBrowserService, Notifications, FileSaver, ModalService) {
+    Object.assign(this, { $async, HostBrowserService, Notifications, FileSaver, ModalService });
+
+    this.state = {
+      path: ROOT_PATH,
+    };
+
+    this.goToParent = this.goToParent.bind(this);
+    this.browse = this.browse.bind(this);
+    this.confirmDeleteFile = this.confirmDeleteFile.bind(this);
+    this.isRoot = this.isRoot.bind(this);
+    this.getRelativePath = this.getRelativePath.bind(this);
+    this.getFilesForPath = this.getFilesForPath.bind(this);
+    this.getFilesForPathAsync = this.getFilesForPathAsync.bind(this);
+    this.downloadFile = this.downloadFile.bind(this);
+    this.downloadFileAsync = this.downloadFileAsync.bind(this);
+    this.renameFile = this.renameFile.bind(this);
+    this.renameFileAsync = this.renameFileAsync.bind(this);
+    this.deleteFile = this.deleteFile.bind(this);
+    this.deleteFileAsync = this.deleteFileAsync.bind(this);
+    this.onFileSelectedForUpload = this.onFileSelectedForUpload.bind(this);
+    this.onFileSelectedForUploadAsync = this.onFileSelectedForUploadAsync.bind(this);
+  }
+
+  getRelativePath(path) {
+    path = path || this.state.path;
+    const rootPathRegex = new RegExp(`^${ROOT_PATH}/?`);
+    const relativePath = path.replace(rootPathRegex, '/');
+    return relativePath;
+  }
+
+  goToParent() {
+    this.getFilesForPath(this.parentPath(this.state.path));
+  }
+
+  isRoot() {
+    return this.state.path === ROOT_PATH;
+  }
+
+  browse(folder) {
+    this.getFilesForPath(this.buildPath(this.state.path, folder));
+  }
+
+  getFilesForPath(path) {
+    return this.$async(this.getFilesForPathAsync, path);
+  }
+  async getFilesForPathAsync(path) {
+    try {
+      const files = await this.HostBrowserService.ls(path);
+      this.state.path = path;
+      this.files = files;
+    } catch (err) {
+      this.Notifications.error('Failure', err, 'Unable to browse');
+    }
+  }
+
+  renameFile(name, newName) {
+    return this.$async(this.renameFileAsync, name, newName);
+  }
+  async renameFileAsync(name, newName) {
+    const filePath = this.buildPath(this.state.path, name);
+    const newFilePath = this.buildPath(this.state.path, newName);
+    try {
+      await this.HostBrowserService.rename(filePath, newFilePath);
+      this.Notifications.success('File successfully renamed', this.getRelativePath(newFilePath));
+      const files = await this.HostBrowserService.ls(this.state.path);
+      this.files = files;
+    } catch (err) {
+      this.Notifications.error('Failure', err, 'Unable to rename file');
+    }
+  }
+
+  downloadFile(fileName) {
+    return this.$async(this.downloadFileAsync, fileName);
+  }
+  async downloadFileAsync(fileName) {
+    const filePath = this.buildPath(this.state.path, fileName);
+    try {
+      const { file } = await this.HostBrowserService.get(filePath);
+      const downloadData = new Blob([file], {
+        type: 'text/plain;charset=utf-8',
+      });
+      this.FileSaver.saveAs(downloadData, fileName);
+    } catch (err) {
+      this.Notifications.error('Failure', err, 'Unable to download file');
+    }
+  }
+
+  confirmDeleteFile(name) {
+    const filePath = this.buildPath(this.state.path, name);
+
+    this.ModalService.confirmDeletion(`Are you sure that you want to delete ${this.getRelativePath(filePath)} ?`, (confirmed) => {
+      if (!confirmed) {
+        return;
+      }
+      return this.deleteFile(filePath);
+    });
+  }
+
+  deleteFile(path) {
+    this.$async(this.deleteFileAsync, path);
+  }
+  async deleteFileAsync(path) {
+    try {
+      await this.HostBrowserService.delete(path);
+      this.Notifications.success('File successfully deleted', this.getRelativePath(path));
+      const files = await this.HostBrowserService.ls(this.state.path);
+      this.files = files;
+    } catch (err) {
+      this.Notifications.error('Failure', err, 'Unable to delete file');
+    }
+  }
+
+  $onInit() {
+    this.getFilesForPath(ROOT_PATH);
+  }
+
+  parentPath(path) {
+    if (path === ROOT_PATH) {
+      return ROOT_PATH;
+    }
+
+    const split = _.split(path, '/');
+    return _.join(_.slice(split, 0, split.length - 1), '/');
+  }
+
+  buildPath(parent, file) {
+    if (parent.lastIndexOf('/') === parent.length - 1) {
+      return parent + file;
+    }
+    return parent + '/' + file;
+  }
+
+  onFileSelectedForUpload(file) {
+    return this.$async(this.onFileSelectedForUploadAsync, file);
+  }
+  async onFileSelectedForUploadAsync(file) {
+    try {
+      await this.HostBrowserService.upload(this.state.path, file);
+      this.onFileUploaded();
+    } catch (err) {
+      this.Notifications.error('Failure', err, 'Unable to upload file');
+    }
+  }
+
+  onFileUploaded() {
+    this.refreshList();
+  }
+
+  refreshList() {
+    this.getFilesForPath(this.state.path);
+  }
+}