Merge branch 'master' of https://github.com/browngraphicslab/Dash-Web

4 files changed, 81 insertions, 9 deletions

diff --git a/src/client/DocServer.ts b/src/client/DocServer.ts
index 652a9b701..443f70bb1 100644
--- a/src/client/DocServer.ts
+++ b/src/client/DocServer.ts
@@ -7,11 +7,14 @@ import { RefField } from '../new_fields/RefField';
 import { Id, HandleUpdate } from '../new_fields/FieldSymbols';
 
 export namespace DocServer {
-    const _cache: { [id: string]: RefField | Promise<Opt<RefField>> } = {};
+    let _cache: { [id: string]: RefField | Promise<Opt<RefField>> } = {};
     const _socket = OpenSocket(`${window.location.protocol}//${window.location.hostname}:4321`);
     const GUID: string = Utils.GenerateGuid();
 
+    let _isReadOnly = false;
     export function makeReadOnly() {
+        if (_isReadOnly) return;
+        _isReadOnly = true;
         _CreateField = field => {
             _cache[field[Id]] = field;
         };
@@ -19,6 +22,16 @@ export namespace DocServer {
         _respondToUpdate = emptyFunction;
     }
 
+    export function makeEditable() {
+        if (!_isReadOnly) return;
+        location.reload();
+        // _isReadOnly = false;
+        // _CreateField = _CreateFieldImpl;
+        // _UpdateField = _UpdateFieldImpl;
+        // _respondToUpdate = _respondToUpdateImpl;
+        // _cache = {};
+    }
+
     export function prepend(extension: string): string {
         return window.location.origin + extension;
     }
@@ -27,6 +40,14 @@ export namespace DocServer {
         Utils.Emit(_socket, MessageStore.DeleteAll, {});
     }
 
+    export function DeleteDocument(id: string) {
+        Utils.Emit(_socket, MessageStore.DeleteField, id);
+    }
+
+    export function DeleteDocuments(ids: string[]) {
+        Utils.Emit(_socket, MessageStore.DeleteFields, ids);
+    }
+
     export async function GetRefField(id: string): Promise<Opt<RefField>> {
         let cached = _cache[id];
         if (cached === undefined) {
@@ -97,29 +118,33 @@ export namespace DocServer {
         return map;
     }
 
-    let _UpdateField = (id: string, diff: any) => {
+    function _UpdateFieldImpl(id: string, diff: any) {
         if (id === updatingId) {
             return;
         }
         Utils.Emit(_socket, MessageStore.UpdateField, { id, diff });
-    };
+    }
+
+    let _UpdateField = _UpdateFieldImpl;
 
     export function UpdateField(id: string, diff: any) {
         _UpdateField(id, diff);
     }
 
-    let _CreateField = (field: RefField) => {
+    function _CreateFieldImpl(field: RefField) {
         _cache[field[Id]] = field;
         const initialState = SerializationHelper.Serialize(field);
         Utils.Emit(_socket, MessageStore.CreateField, initialState);
-    };
+    }
+
+    let _CreateField = _CreateFieldImpl;
 
     export function CreateField(field: RefField) {
         _CreateField(field);
     }
 
     let updatingId: string | undefined;
-    let _respondToUpdate = (diff: any) => {
+    function _respondToUpdateImpl(diff: any) {
         const id = diff.id;
         if (id === undefined) {
             return;
@@ -141,15 +166,36 @@ export namespace DocServer {
         } else {
             update(field);
         }
-    };
+    }
+
+    function _respondToDeleteImpl(ids: string | string[]) {
+        function deleteId(id: string) {
+            delete _cache[id];
+        }
+        if (typeof ids === "string") {
+            deleteId(ids);
+        } else if (Array.isArray(ids)) {
+            ids.map(deleteId);
+        }
+    }
+
+    let _respondToUpdate = _respondToUpdateImpl;
+    let _respondToDelete = _respondToDeleteImpl;
+
     function respondToUpdate(diff: any) {
         _respondToUpdate(diff);
     }
 
+    function respondToDelete(ids: string | string[]) {
+        _respondToDelete(ids);
+    }
+
     function connected() {
         _socket.emit(MessageStore.Bar.Message, GUID);
     }
 
     Utils.AddServerHandler(_socket, MessageStore.Foo, connected);
     Utils.AddServerHandler(_socket, MessageStore.UpdateField, respondToUpdate);
+    Utils.AddServerHandler(_socket, MessageStore.DeleteField, respondToDelete);
+    Utils.AddServerHandler(_socket, MessageStore.DeleteFields, respondToDelete);
 }
\ No newline at end of file
diff --git a/src/client/views/MainView.tsx b/src/client/views/MainView.tsx
index b37ba1cb0..dd07fdc3a 100644
--- a/src/client/views/MainView.tsx
+++ b/src/client/views/MainView.tsx
@@ -13,7 +13,7 @@ import { Id } from '../../new_fields/FieldSymbols';
 import { InkTool } from '../../new_fields/InkField';
 import { List } from '../../new_fields/List';
 import { listSpec } from '../../new_fields/Schema';
-import { Cast, FieldValue, NumCast } from '../../new_fields/Types';
+import { Cast, FieldValue, NumCast, BoolCast } from '../../new_fields/Types';
 import { CurrentUserUtils } from '../../server/authentication/models/current_user_utils';
 import { RouteStore } from '../../server/RouteStore';
 import { emptyFunction, returnOne, returnTrue } from '../../Utils';
@@ -194,6 +194,11 @@ export class MainView extends React.Component {
     openWorkspace = async (doc: Doc, fromHistory = false) => {
         CurrentUserUtils.MainDocId = doc[Id];
         this.mainContainer = doc;
+        if (BoolCast(doc.readOnly)) {
+            DocServer.makeReadOnly();
+        } else {
+            DocServer.makeEditable();
+        }
         fromHistory || HistoryUtil.pushState({ type: "doc", docId: doc[Id], initializers: {} });
         const col = await Cast(CurrentUserUtils.UserDocument.optionalRightCollection, Doc);
         // if there is a pending doc, and it has new data, show it (syip: we use a timeout to prevent collection docking view from being uninitialized)
diff --git a/src/server/Message.ts b/src/server/Message.ts
index e9a8b0f0c..19e0a48aa 100644
--- a/src/server/Message.ts
+++ b/src/server/Message.ts
@@ -45,4 +45,6 @@ export namespace MessageStore {
     export const GetRefFields = new Message<string[]>("Get Ref Fields");
     export const UpdateField = new Message<Diff>("Update Ref Field");
     export const CreateField = new Message<Reference>("Create Ref Field");
+    export const DeleteField = new Message<string>("Delete field");
+    export const DeleteFields = new Message<string[]>("Delete fields");
 }
diff --git a/src/server/index.ts b/src/server/index.ts
index 2073046ce..21adff9e5 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -25,7 +25,7 @@ import { getForgot, getLogin, getLogout, getReset, getSignup, postForgot, postLo
 import { DashUserModel } from './authentication/models/user_model';
 import { Client } from './Client';
 import { Database } from './database';
-import { MessageStore, Transferable, Types, Diff } from "./Message";
+import { MessageStore, Transferable, Types, Diff, Message } from "./Message";
 import { RouteStore } from './RouteStore';
 const app = express();
 const config = require('../../webpack.config');
@@ -465,6 +465,8 @@ server.on("connection", function (socket: Socket) {
 
     Utils.AddServerHandler(socket, MessageStore.CreateField, CreateField);
     Utils.AddServerHandler(socket, MessageStore.UpdateField, diff => UpdateField(socket, diff));
+    Utils.AddServerHandler(socket, MessageStore.DeleteField, id => DeleteField(socket, id));
+    Utils.AddServerHandler(socket, MessageStore.DeleteFields, ids => DeleteFields(socket, ids));
     Utils.AddServerHandlerCallback(socket, MessageStore.GetRefField, GetRefField);
     Utils.AddServerHandlerCallback(socket, MessageStore.GetRefFields, GetRefFields);
 });
@@ -591,6 +593,23 @@ function UpdateField(socket: Socket, diff: Diff) {
     }
 }
 
+function DeleteField(socket: Socket, id: string) {
+    Database.Instance.delete({ _id: id }, "newDocuments").then(() => {
+        socket.broadcast.emit(MessageStore.DeleteField.Message, id);
+    });
+
+    Search.Instance.deleteDocuments([id]);
+}
+
+function DeleteFields(socket: Socket, ids: string[]) {
+    Database.Instance.delete({ _id: { $in: ids } }, "newDocuments").then(() => {
+        socket.broadcast.emit(MessageStore.DeleteFields.Message, ids);
+    });
+
+    Search.Instance.deleteDocuments(ids);
+
+}
+
 function CreateField(newValue: any) {
     Database.Instance.insert(newValue, "newDocuments");
 }