Merge pull request #517 from browngraphicslab/hypothesis_annotation

Hypothesis annotation

3 files changed, 172 insertions, 4 deletions

diff --git a/src/client/util/CurrentUserUtils.ts b/src/client/util/CurrentUserUtils.ts
index c205acb99..49377a728 100644
--- a/src/client/util/CurrentUserUtils.ts
+++ b/src/client/util/CurrentUserUtils.ts
@@ -447,8 +447,9 @@ export class CurrentUserUtils {
             // { title: "use stamp", icon: "stamp", click: 'activateStamp(this.activeInkPen = sameDocs(this.activeInkPen, this) ? undefined : this)', backgroundColor: "orange", ischecked: `sameDocs(this.activeInkPen, this)`, activeInkPen: doc },
             // { title: "use eraser", icon: "eraser", click: 'activateEraser(this.activeInkPen = sameDocs(this.activeInkPen, this) ? undefined : this);', ischecked: `sameDocs(this.activeInkPen, this)`, backgroundColor: "pink", activeInkPen: doc },
             // { title: "use drag", icon: "mouse-pointer", click: 'deactivateInk();this.activeInkPen = this;', ischecked: `sameDocs(this.activeInkPen, this)`, backgroundColor: "white", activeInkPen: doc },
-            { toolTip: "Drag a document previewer", title: "Prev", icon: "expand", click: 'openOnRight(getCopy(this.dragFactory, true))', drag: 'getCopy(this.dragFactory, true)', dragFactory: doc.emptyDocHolder as Doc },
+            { toolTip: "Drag a document previewer", title: "Prev", icon: "expand", click: 'openOnRight(getCopy(this.dragFactory, true))', drag: 'getCopy(this.dragFactory,true)', dragFactory: doc.emptyDocHolder as Doc },
             { toolTip: "Toggle a Calculator REPL", title: "repl", icon: "calculator", click: 'addOverlayWindow("ScriptingRepl", { x: 300, y: 100, width: 200, height: 200, title: "Scripting REPL" })' },
+            { toolTip: "Connect a Google Account", title: "Google Account", icon: "external-link-alt", click: 'GoogleAuthenticationManager.Instance.fetchOrGenerateAccessToken(true)' },
         ];
 
     }
diff --git a/src/client/util/HypothesisUtils.ts b/src/client/util/HypothesisUtils.ts
new file mode 100644
index 000000000..9ede94e4b
--- /dev/null
+++ b/src/client/util/HypothesisUtils.ts
@@ -0,0 +1,170 @@
+import { StrCast, Cast } from "../../fields/Types";
+import { SearchUtil } from "./SearchUtil";
+import { action, runInAction } from "mobx";
+import { Doc, Opt } from "../../fields/Doc";
+import { DocumentType } from "../documents/DocumentTypes";
+import { Docs } from "../documents/Documents";
+import { SelectionManager } from "./SelectionManager";
+import { WebField } from "../../fields/URLField";
+import { DocumentManager } from "./DocumentManager";
+import { DocumentLinksButton } from "../views/nodes/DocumentLinksButton";
+import { simulateMouseClick, Utils } from "../../Utils";
+import { DocumentView } from "../views/nodes/DocumentView";
+import { Id } from "../../fields/FieldSymbols";
+
+export namespace Hypothesis {
+
+    /**
+     * Retrieve a WebDocument with the given url, prioritizing results that are on screen.  
+     * If none exist, create and return a new WebDocument.
+     */
+    export const getSourceWebDoc = async (uri: string) => {
+        const result = await findWebDoc(uri);
+        console.log(result ? "existing doc found" : "existing doc NOT found");
+        return result || Docs.Create.WebDocument(uri, { title: uri, _nativeWidth: 850, _nativeHeight: 962, _width: 400, UseCors: true }); // create and return a new Web doc with given uri if no matching docs are found
+    };
+
+
+    /**
+     * Search for a WebDocument whose url field matches the given uri, return undefined if not found
+     */
+    export const findWebDoc = async (uri: string) => {
+        const currentDoc = SelectionManager.SelectedDocuments().length && SelectionManager.SelectedDocuments()[0].props.Document;
+        if (currentDoc && Cast(currentDoc.data, WebField)?.url.href === uri) return currentDoc; // always check first whether the currently selected doc is the annotation's source, only use Search otherwise
+
+        const results: Doc[] = [];
+        await SearchUtil.Search("web", true).then(action(async (res: SearchUtil.DocSearchResult) => {
+            const docs = await Promise.all(res.docs.map(async doc => (await Cast(doc.extendsDoc, Doc)) || doc));
+            const filteredDocs = docs.filter(doc =>
+                doc.author === Doc.CurrentUserEmail && doc.type === DocumentType.WEB && doc.data
+            );
+            filteredDocs.forEach(doc => {
+                uri === Cast(doc.data, WebField)?.url.href && results.push(doc); // TODO check visited sites history? 
+            });
+        }));
+
+        const onScreenResults = results.filter(doc => DocumentManager.Instance.getFirstDocumentView(doc));
+        return onScreenResults.length ? onScreenResults[0] : (results.length ? results[0] : undefined); // prioritize results that are currently on the screen
+    };
+
+    /**
+     * listen for event from Hypothes.is plugin to link an annotation to Dash
+     */
+    export const linkListener = async (e: any) => {
+        const annotationId: string = e.detail.id;
+        const annotationUri: string = StrCast(e.detail.uri).split("#annotations:")[0]; // clean hypothes.is URLs that reference a specific annotation 
+        const sourceDoc: Doc = await getSourceWebDoc(annotationUri);
+
+        if (!DocumentLinksButton.StartLink || sourceDoc === DocumentLinksButton.StartLink) { // start new link if there were none already started, or if the old startLink came from the same web document (prevent links to itself)
+            runInAction(() => {
+                DocumentLinksButton.AnnotationId = annotationId;
+                DocumentLinksButton.AnnotationUri = annotationUri;
+                DocumentLinksButton.StartLink = sourceDoc;
+            });
+        } else { // if a link has already been started, complete the link to sourceDoc
+            runInAction(() => {
+                DocumentLinksButton.AnnotationId = annotationId;
+                DocumentLinksButton.AnnotationUri = annotationUri;
+            });
+            const endLinkView = DocumentManager.Instance.getFirstDocumentView(sourceDoc);
+            const rect = document.body.getBoundingClientRect();
+            const x = rect.x + rect.width / 2;
+            const y = 250;
+            DocumentLinksButton.finishLinkClick(x, y, DocumentLinksButton.StartLink, sourceDoc, false, endLinkView);
+        }
+    };
+
+    /**
+     *  Send message to Hypothes.is client to edit an annotation to add a Dash hyperlink
+     */
+    export const makeLink = async (title: string, url: string, annotationId: string, annotationSourceDoc: Doc) => {
+        // if the annotation's source webpage isn't currently loaded in Dash, we're not able to access and edit the annotation from the client
+        // so we're loading the webpage and its annotations invisibly in a WebBox in MainView.tsx, until the editing is done
+        !DocumentManager.Instance.getFirstDocumentView(annotationSourceDoc) && runInAction(() => DocumentLinksButton.invisibleWebDoc = annotationSourceDoc);
+
+        var success = false;
+        const onSuccess = action(() => {
+            console.log("Edit success!!");
+            success = true;
+            clearTimeout(interval);
+            DocumentLinksButton.invisibleWebDoc = undefined;
+            document.removeEventListener("editSuccess", onSuccess);
+        });
+
+        const newHyperlink = `[${title}\n](${url})`;
+        const interval = setInterval(() => // keep trying to edit until annotations have loaded and editing is successful
+            !success && document.dispatchEvent(new CustomEvent<{ newHyperlink: string, id: string }>("addLink", {
+                detail: { newHyperlink: newHyperlink, id: annotationId },
+                bubbles: true
+            })), 300);
+
+        setTimeout(action(() => {
+            if (!success) {
+                clearInterval(interval);
+                DocumentLinksButton.invisibleWebDoc = undefined;
+            }
+        }), 10000); // give up if no success after 10s
+        document.addEventListener("editSuccess", onSuccess);
+    };
+
+    /**
+     * Send message Hypothes.is client request to edit an annotation to find and delete the target Dash hyperlink
+     */
+    export const deleteLink = async (linkDoc: Doc, sourceDoc: Doc, destinationDoc: Doc) => {
+        if (Cast(destinationDoc.data, WebField)?.url.href !== StrCast(linkDoc.annotationUri)) return; // check that the destinationDoc is a WebDocument containing the target annotation
+
+        !DocumentManager.Instance.getFirstDocumentView(destinationDoc) && runInAction(() => DocumentLinksButton.invisibleWebDoc = destinationDoc); // see note in makeLink
+
+        var success = false;
+        const onSuccess = action(() => {
+            console.log("Edit success!");
+            success = true;
+            clearTimeout(interval);
+            DocumentLinksButton.invisibleWebDoc = undefined;
+            document.removeEventListener("editSuccess", onSuccess);
+        });
+
+        const annotationId = StrCast(linkDoc.annotationId);
+        const linkUrl = Utils.prepend("/doc/" + sourceDoc[Id]);
+        const interval = setInterval(() => {// keep trying to edit until annotations have loaded and editing is successful
+            !success && document.dispatchEvent(new CustomEvent<{ targetUrl: string, id: string }>("deleteLink", {
+                detail: { targetUrl: linkUrl, id: annotationId },
+                bubbles: true
+            }));
+        }, 300);
+
+        setTimeout(action(() => {
+            if (!success) {
+                clearInterval(interval);
+                DocumentLinksButton.invisibleWebDoc = undefined;
+            }
+        }), 10000); // give up if no success after 10s
+        document.addEventListener("editSuccess", onSuccess);
+    };
+
+    /**
+     *  Send message to Hypothes.is client to scroll to an annotation when it loads
+     */
+    export const scrollToAnnotation = (annotationId: string, target: Doc) => {
+        var success = false;
+        const onSuccess = () => {
+            console.log("Scroll success!!");
+            document.removeEventListener('scrollSuccess', onSuccess);
+            clearInterval(interval);
+            success = true;
+        };
+
+        const interval = setInterval(() => { // keep trying to scroll every 250ms until annotations have loaded and scrolling is successful
+            document.dispatchEvent(new CustomEvent('scrollToAnnotation', {
+                detail: annotationId,
+                bubbles: true
+            }));
+            const targetView: Opt<DocumentView> = DocumentManager.Instance.getFirstDocumentView(target);
+            const position = targetView?.props.ScreenToLocalTransform().inverse().transformPoint(0, 0);
+            targetView && position && simulateMouseClick(targetView.ContentDiv!, position[0], position[1], position[0], position[1], false);
+        }, 300);
+
+        document.addEventListener('scrollSuccess', onSuccess); // listen for success message from client
+        setTimeout(() => !success && clearInterval(interval), 10000); // give up if no success after 10s
+    };
+}
\ No newline at end of file
diff --git a/src/client/util/SettingsManager.tsx b/src/client/util/SettingsManager.tsx
index 9ffd4ff20..8b58880d4 100644
--- a/src/client/util/SettingsManager.tsx
+++ b/src/client/util/SettingsManager.tsx
@@ -11,7 +11,6 @@ import { CurrentUserUtils } from "./CurrentUserUtils";
 import { Utils, addStyleSheet, addStyleSheetRule, removeStyleSheetRule } from "../../Utils";
 import { Doc } from "../../fields/Doc";
 import GroupManager from "./GroupManager";
-import HypothesisAuthenticationManager from "../apis/HypothesisAuthenticationManager";
 import GoogleAuthenticationManager from "../apis/GoogleAuthenticationManager";
 import { DocServer } from "../DocServer";
 import { BoolCast, StrCast, NumCast } from "../../fields/Types";
@@ -44,7 +43,6 @@ export default class SettingsManager extends React.Component<{}> {
     public open = action(() => (this.isOpen = true) && SelectionManager.DeselectAll());
 
     private googleAuthorize = action(() => GoogleAuthenticationManager.Instance.fetchOrGenerateAccessToken(true));
-    private hypothesisAuthorize = action(() => HypothesisAuthenticationManager.Instance.fetchAccessToken(true));
     private changePassword = async () => {
         if (!(this.curr_password && this.new_password && this.new_confirm)) {
             runInAction(() => this.passwordResultText = "Error: Hey, we're missing some fields!");
@@ -144,7 +142,6 @@ export default class SettingsManager extends React.Component<{}> {
     @computed get accountsContent() {
         return <div className="accounts-content">
             <button onClick={this.googleAuthorize} value="data">Link to Google</button>
-            <button onClick={this.hypothesisAuthorize} value="data">Link to Hypothes.is</button>
             <button onClick={GroupManager.Instance?.open}>Manage groups</button>
         </div>;
     }