1 files changed, 65 insertions, 15 deletions

diff --git a/src/client/Server.ts b/src/client/Server.ts
index a08fc2e87..e9edb7b9c 100644
--- a/src/client/Server.ts
+++ b/src/client/Server.ts
@@ -1,42 +1,79 @@
-import { Field, FieldWaiting, FIELD_ID, FIELD_WAITING, FieldValue } from "../fields/Field"
+import { Field, FieldWaiting, FIELD_ID, FIELD_WAITING, FieldValue, Opt } from "../fields/Field"
 import { Key, KeyStore } from "../fields/Key"
 import { ObservableMap, action } from "mobx";
 import { Document } from "../fields/Document"
 import { SocketStub } from "./SocketStub";
 import * as OpenSocket from 'socket.io-client';
 import { Utils } from "./../Utils";
-import { MessageStore } from "./../server/Message";
+import { MessageStore, Types } from "./../server/Message";
 
 export class Server {
     private static ClientFieldsCached: ObservableMap<FIELD_ID, Field | FIELD_WAITING> = new ObservableMap();
-    static Socket: SocketIOClient.Socket = OpenSocket("http://localhost:1234")
+    static Socket: SocketIOClient.Socket = OpenSocket("http://localhost:1234");
     static GUID: string = Utils.GenerateGuid()
 
+    private static Cache: { [id: string]: Field } = {};
+
+    @action
+    static updateField(field: { _id: string, data: any, type: Types }) {
+        if (field._id in Server.Cache) {
+            const f = Server.Cache[field._id];
+            f.UpdateFromServer(field.data);
+            f.init(() => { });
+        }
+    }
+
     // Retrieves the cached value of the field and sends a request to the server for the real value (if it's not cached).
     // Call this is from within a reaction and test whether the return value is FieldWaiting.
     // 'hackTimeout' is here temporarily for simplicity when debugging things.
-    public static GetField(fieldid: FIELD_ID, callback: (field: Field) => void = (f) => { }, hackTimeout: number = -1) {
+    public static GetField(fieldid: FIELD_ID, callback: (field: Opt<Field>) => void = (f) => { }, hackTimeout: number = -1) {
         if (!this.ClientFieldsCached.get(fieldid)) {
-            this.ClientFieldsCached.set(fieldid, FieldWaiting);
+            // this.ClientFieldsCached.set(fieldid, FieldWaiting);
             //simulating a server call with a registered callback action
-            SocketStub.SEND_FIELD_REQUEST(fieldid,
-                action((field: Field) => callback(Server.cacheField(field))));
+            SocketStub.SEND_FIELD_REQUEST(fieldid, (field) => {
+                if (field) {
+                    this.Cache[field.Id] = field;
+                }
+                callback(field)
+            });
         } else if (this.ClientFieldsCached.get(fieldid) != FieldWaiting) {
             callback(this.ClientFieldsCached.get(fieldid) as Field);
         }
         return this.ClientFieldsCached.get(fieldid);
     }
 
+    public static GetFields(fieldIds: FIELD_ID[], callback: (fields: { [id: string]: Field }) => any) {
+        SocketStub.SEND_FIELDS_REQUEST(fieldIds, (fields) => {
+            for (let key in fields) {
+                let field = fields[key];
+                this.Cache[field.Id] = field;
+            }
+            callback(fields)
+        });
+    }
+
     static times = 0; // hack for testing
     public static GetDocumentField(doc: Document, key: Key) {
-        var hackTimeout: number = key == KeyStore.Data ? (this.times++ == 0 ? 5000 : 1000) : key == KeyStore.X ? 2500 : 500;
+        // let keyId: string = element[0]
+        // let valueId: string = element[1]
+        // Server.GetField(keyId, (key: Field) => {
+        //     if (key instanceof Key) {
+        //         Server.GetField(valueId, (field: Field) => {
+        //             console.log(field)
+        //             doc.Set(key as Key, field)
+        //         })
+        //     }
+        //     else {
+        //         console.log("how did you get a key that isnt a key wtf")
+        //     }
+        // })
 
         return this.GetField(doc._proxies.get(key.Id),
-            action((fieldfromserver: Field) => {
-                doc._proxies.delete(key.Id);
-                doc.fields.set(key, fieldfromserver);
-            })
-            , hackTimeout);
+            action((fieldfromserver: Opt<Field>) => {
+                if (fieldfromserver) {
+                    doc.fields.set(key.Id, { key, field: fieldfromserver });
+                }
+            }));
     }
 
     public static AddDocument(document: Document) {
@@ -48,8 +85,20 @@ export class Server {
     public static DeleteDocumentField(doc: Document, key: Key) {
         SocketStub.SEND_DELETE_DOCUMENT_FIELD(doc, key);
     }
+
+    private static lock: boolean = false;
+
     public static UpdateField(field: Field) {
-        SocketStub.SEND_SET_FIELD(field);
+        if (this.lock) {
+            // setTimeout(this.UpdateField, 1000, field)
+        }
+        this.lock = true
+        // console.log("updating field " + field.Id)
+        SocketStub.SEND_SET_FIELD(field, (args: any) => {
+            if (this.lock) {
+                this.lock = false
+            }
+        });
     }
 
     static connected(message: string) {
@@ -68,4 +117,5 @@ export class Server {
     }
 }
 
-Server.Socket.on(MessageStore.Foo.Message, Server.connected);
\ No newline at end of file
+Server.Socket.on(MessageStore.Foo.Message, Server.connected);
+Server.Socket.on(MessageStore.SetField.Message, Server.updateField);
\ No newline at end of file