Add cell/clipboard copy & paste tracking

Copying and pasting a whole cell or from the clipboard is tracked and sent to the backend, along with the copied/pasted content.

Author: dyvrl

src/PanelManager.ts

@@ -13,12 +13,15 @@ import { ExecutionDisposable } from './trackers/ExecutionDisposable';
 import { AlterationDisposable } from './trackers/AlterationDisposable';
 import { FocusDisposable } from './trackers/FocusDisposable';
 import { disabledNotebooksSignaler } from '.';
+import { JupyterFrontEnd } from '@jupyterlab/application';
 
 export class PanelManager {
   constructor(
+    app: JupyterFrontEnd,
     settings: ISettingRegistry.ISettings,
     dialogShownSettings: ISettingRegistry.ISettings
   ) {
+    this._app = app;
     this._panel = null;
 
     this._isDataCollectionEnabled = settings.get(EXTENSION_SETTING_NAME)
@@ -108,6 +111,7 @@ export class PanelManager {
             this._isDataCollectionEnabled
           ) {
             this._focusDisposable = new FocusDisposable(
+              this._app.commands,
               this._panel,
               notebookId
             );
@@ -209,6 +213,7 @@ export class PanelManager {
     this.panel = null;
   }
 
+  private _app: JupyterFrontEnd;
   private _panel: NotebookPanel | null;
   private _ongoingContextId = '';
   private _websocketManager: WebsocketManager;

src/api.ts

@@ -7,7 +7,10 @@ import {
   ICodeExecObject,
   INotebookClickObject,
   IMarkdownExecObject,
-  PostDataObject
+  PostDataObject,
+  ICellCopyObject,
+  ICellPasteObject,
+  IClipBoardObject
 } from './utils/types';
 
 const postRequest = (data: PostDataObject, endpoint: string): void => {
@@ -58,6 +61,22 @@ export const postCellClick = (cellClick: ICellClickObject): void => {
   postRequest(cellClick, 'clickevent/cell');
 };
 
+export const postCellCopy = (cellCopy: ICellCopyObject): void => {
+  postRequest(cellCopy, 'copyevent/cell');
+};
+
+export const postCellPaste = (cellPaste: ICellPasteObject): void => {
+  postRequest(cellPaste, 'pasteevent/cell');
+};
+
+export const postClipboardCopy = (clipboardCopy: IClipBoardObject): void => {
+  postRequest(clipboardCopy, 'copyevent/clipboard');
+};
+
+export const postClipboardPaste = (clipboardPaste: IClipBoardObject): void => {
+  postRequest(clipboardPaste, 'pasteevent/clipboard');
+};
+
 export const postNotebookClick = (
   notebookClick: INotebookClickObject
 ): void => {

src/dataCollectionPlugin.ts

@@ -43,7 +43,7 @@ export const dataCollectionPlugin = async (
     onEndpointChanged(endpointSettings);
     endpointSettings.changed.connect(onEndpointChanged);
 
-    const panelManager = new PanelManager(settings, dialogShownSettings);
+    const panelManager = new PanelManager(app, settings, dialogShownSettings);
 
     const labShell = app.shell as LabShell;
 

src/trackers/FocusDisposable.ts

@@ -1,15 +1,36 @@
 import { Signal } from '@lumino/signaling';
 import { IDisposable } from '@lumino/disposable';
-import { Cell, ICellModel } from '@jupyterlab/cells';
+import { CommandRegistry } from '@lumino/commands';
+import { Cell, CodeCell, ICellModel } from '@jupyterlab/cells';
 import { Notebook, NotebookPanel } from '@jupyterlab/notebook';
-import { postNotebookClick, postCellClick } from '../api';
+import {
+  postNotebookClick,
+  postCellClick,
+  postCellCopy,
+  postCellPaste,
+  postClipboardCopy,
+  postClipboardPaste
+} from '../api';
 import { Selectors } from '../utils/constants';
 import { CompatibilityManager } from '../utils/compatibility';
 
 type ClickType = 'OFF' | 'ON';
+interface CellCopyData {
+  lastCopyCellId: string;
+  lastCopyNotebookId: string;
+  lastCopyTime: string;
+  lastCopyContent: string;
+}
+
+const CELL_COPY_ID: string = 'notebook:copy-cell';
+const CELL_PASTE_ID: string = 'notebook:paste-cell-below';
 
 export class FocusDisposable implements IDisposable {
-  constructor(panel: NotebookPanel, notebookId: string) {
+  constructor(
+    commands: CommandRegistry,
+    panel: NotebookPanel,
+    notebookId: string
+  ) {
     this._panel = panel;
 
     this._notebookId = notebookId;
@@ -22,6 +43,13 @@ export class FocusDisposable implements IDisposable {
     // connect to active cell changes
     panel.content.activeCellChanged.connect(this._onCellChanged, this);
 
+    // connect to commands executed
+    commands.commandExecuted.connect(this._onCommandExecuted, this);
+
+    // Add listener to copy and paste (to clipbaord)
+    document.addEventListener('copy', this._onClipboardCopy);
+    document.addEventListener('paste', this._onClipboardPaste);
+
     // panel.content is disposed before panel itself, so release the associated connection before
     panel.content.disposed.connect(this._onContentDisposed, this);
   }
@@ -44,10 +72,56 @@ export class FocusDisposable implements IDisposable {
     this._sendCellClick('ON');
   };
 
+  private _onCommandExecuted = (
+    commandR: CommandRegistry,
+    args: CommandRegistry.ICommandExecutedArgs
+  ) => {
+    if (args.id === CELL_COPY_ID) {
+      this._onCopyCommandExecuted();
+    } else if (args.id === CELL_PASTE_ID) {
+      this._onPasteCommandExecuted();
+    }
+  };
+
+  private _onCopyCommandExecuted = () => {
+    console.log('A cell was copied!');
+    if (this._lastActiveCellId && this._lastActiveCellContent) {
+      this._cellCopyData = {
+        lastCopyNotebookId: this._notebookId,
+        lastCopyCellId: this._lastActiveCellId,
+        lastCopyTime: new Date().toISOString(),
+        lastCopyContent: this._lastActiveCellContent
+      };
+      this._sendCellCopy();
+    }
+  };
+
+  private _onPasteCommandExecuted = () => {
+    console.log('A cell was pasted!');
+    this._sendCellPaste();
+  };
+
+  private _onClipboardCopy = (event: ClipboardEvent) => {
+    const content = event.clipboardData?.getData('text');
+    console.log('Clipboard copied ', content);
+    if (content) {
+      this._sendClipboardCopy(content);
+    }
+  };
+
+  private _onClipboardPaste = (event: ClipboardEvent) => {
+    const content = event.clipboardData?.getData('text');
+    console.log('Clipboard pasted ', content);
+    if (content) {
+      this._sendClipboardPaste(content);
+    }
+  };
+
   private _setActiveCellAndOrigCellId = (
     activeCell: Cell<ICellModel> | null
   ) => {
     this._lastActiveCellId = activeCell?.model.sharedModel.getId();
+    this._lastActiveCellContent = activeCell?.model.toJSON().source.toString();
     if (this._lastActiveCellId) {
       this._lastOrigCellId = CompatibilityManager.getMetadataComp(
         this._panel?.model,
@@ -83,6 +157,53 @@ export class FocusDisposable implements IDisposable {
     }
   };
 
+  private _sendCellCopy = () => {
+    if (this._cellCopyData) {
+      postCellCopy({
+        notebook_id: this._cellCopyData.lastCopyNotebookId,
+        cell_id: this._cellCopyData.lastCopyCellId,
+        time: this._cellCopyData.lastCopyTime,
+        content: this._cellCopyData.lastCopyContent
+      });
+    }
+  };
+
+  private _sendCellPaste = () => {
+    if (this._cellCopyData && this._lastActiveCellId) {
+      postCellPaste({
+        notebook_id: this._notebookId,
+        copied_notebook_id: this._cellCopyData.lastCopyNotebookId,
+        copied_cell_id: this._cellCopyData.lastCopyCellId,
+        copied_time: this._cellCopyData.lastCopyTime,
+        cell_id: this._lastActiveCellId,
+        time: new Date().toISOString(),
+        content: this._cellCopyData.lastCopyContent
+      });
+    }
+  };
+
+  private _sendClipboardCopy = (content: string) => {
+    if (this._lastActiveCellId) {
+      postClipboardCopy({
+        notebook_id: this._notebookId,
+        cell_id: this._lastActiveCellId,
+        time: new Date().toISOString(),
+        content: content
+      });
+    }
+  };
+
+  private _sendClipboardPaste = (content: string) => {
+    if (this._lastActiveCellId) {
+      postClipboardPaste({
+        notebook_id: this._notebookId,
+        cell_id: this._lastActiveCellId,
+        time: new Date().toISOString(),
+        content: content
+      });
+    }
+  };
+
   private _sendNotebookClick = (clickType: ClickType) => {
     let notebookDurationSec: number | null = null;
     if (clickType === 'ON') {
@@ -116,15 +237,20 @@ export class FocusDisposable implements IDisposable {
 
     this._isDisposed = true;
     this._lastActiveCellId = null;
+    this._cellCopyData = null;
 
+    document.removeEventListener('copy', this._onClipboardCopy);
+    document.removeEventListener('paste', this._onClipboardPaste);
     Signal.clearData(this);
   }
 
   private _isDisposed = false;
   private _panel: NotebookPanel;
   private _notebookId: string;
   private _lastActiveCellId: string | null | undefined = null;
+  private _lastActiveCellContent: string | null | undefined = null;
   private _lastOrigCellId: string | null | undefined = null;
+  private _cellCopyData: CellCopyData | null | undefined = null;
 
   private _notebookStart: Date = new Date();
   private _cellStart: Date = new Date();

src/utils/types.d.ts

@@ -44,9 +44,28 @@ export interface ICellAlterationObject extends IBaseEvent {
   time: string;
 }
 
+interface ICopyPaste extends IBaseEvent {
+  cell_id: string;
+  time: string;
+  content: string;
+}
+
+export interface ICellCopyObject extends ICopyPaste {}
+
+export interface ICellPasteObject extends ICopyPaste {
+  copied_notebook_id: string;
+  copied_cell_id: string;
+  copied_time: string;
+}
+
+export interface IClipBoardObject extends ICopyPaste {}
+
 export type PostDataObject =
   | ICodeExecObject
   | IMarkdownExecObject
   | INotebookClickObject
   | ICellClickObject
-  | ICellAlterationObject;
+  | ICellAlterationObject
+  | ICellCopyObject
+  | ICellPasteObject
+  | IClipBoardObject;