add logic for registered file types retrieval and usage

src/contents.ts

@@ -1,9 +1,7 @@
-// Copyright (c) Jupyter Development Team.
-// Distributed under the terms of the Modified BSD License.
-
+import { JupyterFrontEnd } from '@jupyterlab/application';
 import { Signal, ISignal } from '@lumino/signaling';
 import { Contents, ServerConnection } from '@jupyterlab/services';
-import { IDriveInfo } from './token';
+import { IDriveInfo, IRegisteredFileTypes } from './token';
 import { getContents, mountDrive } from './requests';
 
 let data: Contents.IModel = {
@@ -119,6 +117,20 @@ export class Drive implements Contents.IDrive {
     return this._serverSettings;
   }
 
+  /**
+   * The registered file types
+   */
+  get registeredFileTypes(): IRegisteredFileTypes {
+    return this._registeredFileTypes;
+  }
+
+  /**
+   * The registered file types
+   */
+  set registeredFileTypes(fileTypes: IRegisteredFileTypes) {
+    this._registeredFileTypes = fileTypes;
+  }
+
   /**
    * A signal emitted when a file operation takes place.
    */
@@ -182,13 +194,14 @@ export class Drive implements Contents.IDrive {
     localPath: string,
     options?: Contents.IFetchOptions
   ): Promise<Contents.IModel> {
-    let relativePath = '';
+    const relativePath = '';
+    console.log('GET localpath: ', localPath);
     if (localPath !== '') {
-      if (localPath.includes(this.name)) {
-        relativePath = localPath.split(this.name + '/')[1];
-      } else {
-        relativePath = localPath;
-      }
+      // if (localPath.includes(this.name)) {
+      //   relativePath = localPath.split(this.name + '/')[1];
+      // } else {
+      //   relativePath = localPath;
+      // }
 
       // extract current drive name
       const currentDrive = this._drivesList.filter(
@@ -207,7 +220,10 @@ export class Drive implements Contents.IDrive {
         }
       }
 
-      data = await getContents(currentDrive.name, { path: '' });
+      data = await getContents(currentDrive.name, {
+        path: '',
+        registeredFileTypes: this._registeredFileTypes
+      });
     } else {
       const drivesList: Contents.IModel[] = [];
       for (const drive of this._drivesList) {
@@ -589,6 +605,40 @@ export class Drive implements Contents.IDrive {
     return Promise.reject('Read only');
   }
 
+  /**
+   * Get all registered file types and store them accordingly with their file
+   * extension (e.g.: .txt, .pdf, .jpeg), file mimetype (e.g.: text/plain, application/pdf)
+   * and file format (e.g.: base64, text).
+   *
+   * @param app
+   */
+  getRegisteredFileTypes(app: JupyterFrontEnd) {
+    // get called when instating the toolbar
+    const registeredFileTypes = app.docRegistry.fileTypes();
+
+    for (const fileType of registeredFileTypes) {
+      // check if we are dealing with a directory
+      if (fileType.extensions.length === 0) {
+        this._registeredFileTypes[''] = {
+          fileType: 'directory',
+          fileFormat: 'json',
+          fileMimeTypes: ['text/directory']
+        };
+      }
+
+      // store the mimetype and fileformat for each file extension
+      fileType.extensions.forEach(extension => {
+        if (!this._registeredFileTypes[extension]) {
+          this._registeredFileTypes[extension] = {
+            fileType: fileType.name,
+            fileMimeTypes: [...fileType.mimeTypes],
+            fileFormat: fileType.fileFormat ? fileType.fileFormat : ''
+          };
+        }
+      });
+    }
+  }
+
   /**
    * Get a REST url for a file given a path.
    */
@@ -609,6 +659,7 @@ export class Drive implements Contents.IDrive {
   private _fileChanged = new Signal<this, Contents.IChangedArgs>(this);
   private _isDisposed: boolean = false;
   private _disposed = new Signal<this, void>(this);
+  private _registeredFileTypes: IRegisteredFileTypes = {};
 }
 
 export namespace Drive {

src/index.ts

@@ -224,6 +224,9 @@ const driveFileBrowser: JupyterFrontEndPlugin<void> = {
 
     app.serviceManager.contents.addDrive(drive);
 
+    // get registered file types
+    drive.getRegisteredFileTypes(app);
+
     // Manually restore and load the drive file browser.
     const driveBrowser = fileBrowserFactory.createFileBrowser('drivebrowser', {
       auto: false,

src/requests.ts

@@ -3,6 +3,7 @@ import { Contents } from '@jupyterlab/services';
 import { PathExt } from '@jupyterlab/coreutils';
 
 import { requestAPI } from './handler';
+import { getFileType, IRegisteredFileTypes } from './token';
 
 let data: Contents.IModel = {
   name: '',
@@ -47,7 +48,7 @@ export async function mountDrive(
 
 export async function getContents(
   driveName: string,
-  options: { path: string }
+  options: { path: string; registeredFileTypes: IRegisteredFileTypes }
 ) {
   const response = await requestAPI<any>(
     'drives/' + driveName + '/' + options.path,
@@ -60,17 +61,22 @@ export async function getContents(
     response.data.forEach((row: any) => {
       const fileName = PathExt.basename(row.path);
 
+      const [fileType, fileMimeType, fileFormat] = getFileType(
+        PathExt.extname(PathExt.basename(fileName)),
+        options.registeredFileTypes
+      );
+
       fileList[fileName] = fileList[fileName] ?? {
         name: fileName,
         path: driveName + '/' + row.path,
         last_modified: row.last_modified,
         created: '',
         content: !fileName.split('.')[1] ? [] : null,
-        format: null, //fileFormat as Contents.FileFormat,
-        mimetype: 'null', //fileMimeType,
+        format: fileFormat as Contents.FileFormat,
+        mimetype: fileMimeType,
         size: row.size,
         writable: true,
-        type: 'directory' //fileType
+        type: fileType
       };
     });
 

src/token.ts

@@ -32,3 +32,41 @@ export interface IDriveInfo {
    */
   mounted: boolean;
 }
+
+/**
+ * An interface that stores the registered file type, mimetype and format for each file extension.
+ */
+export interface IRegisteredFileTypes {
+  [fileExtension: string]: {
+    fileType: string;
+    fileMimeTypes: string[];
+    fileFormat: string;
+  };
+}
+
+/**
+ * Helping function to define file type, mimetype and format based on file extension.
+ * @param extension file extension (e.g.: txt, ipynb, csv)
+ * @returns
+ */
+export function getFileType(
+  extension: string,
+  registeredFileTypes: IRegisteredFileTypes
+) {
+  let fileType: string = 'text';
+  let fileMimetype: string = 'text/plain';
+  let fileFormat: string = 'text';
+
+  if (registeredFileTypes[extension]) {
+    fileType = registeredFileTypes[extension].fileType;
+    fileMimetype = registeredFileTypes[extension].fileMimeTypes[0];
+    fileFormat = registeredFileTypes[extension].fileFormat;
+  }
+
+  // the file format for notebooks appears as json, but should be text
+  if (extension === '.ipynb') {
+    fileFormat = 'text';
+  }
+
+  return [fileType, fileMimetype, fileFormat];
+}