1 files changed, 88 insertions, 23 deletions

diff --git a/src/fields/Document.ts b/src/fields/Document.ts
index c682d8e94..fcc8adbcf 100644
--- a/src/fields/Document.ts
+++ b/src/fields/Document.ts
@@ -1,14 +1,33 @@
-import { Field, Cast, Opt, FieldWaiting, FieldId, FieldValue } from "./Field"
-import { Key, KeyStore } from "./Key"
+import { Key } from "./Key"
+import { KeyStore } from "./KeyStore";
+import { Field, Cast, FieldWaiting, FieldValue, FieldId } from "./Field"
 import { NumberField } from "./NumberField";
-import { ObservableMap, computed, action, observable } from "mobx";
+import { ObservableMap, computed, action } from "mobx";
 import { TextField } from "./TextField";
 import { ListField } from "./ListField";
 import { Server } from "../client/Server";
+import { Types } from "../server/Message";
 
 export class Document extends Field {
-    public fields: ObservableMap<Key, Field> = new ObservableMap();
-    public _proxies: ObservableMap<Key, FieldId> = new ObservableMap();
+    public fields: ObservableMap<string, { key: Key, field: Field }> = new ObservableMap();
+    public _proxies: ObservableMap<string, FieldId> = new ObservableMap();
+
+    constructor(id?: string, save: boolean = true) {
+        super(id)
+
+        if (save) {
+            var title = (this._proxies.has(KeyStore.Title.Id) ? "???" : this.Title) + "(" + this.Id + ")";
+            console.log("Save " + title);
+            Server.UpdateField(this)
+        }
+    }
+
+    UpdateFromServer(data: [string, string][]) {
+        for (const key in data) {
+            const element = data[key];
+            this._proxies.set(element[0], element[1]);
+        }
+    }
 
     @computed
     public get Title() {
@@ -18,28 +37,53 @@ export class Document extends Field {
     Get(key: Key, ignoreProto: boolean = false): FieldValue<Field> {
         let field: FieldValue<Field>;
         if (ignoreProto) {
-            if (this.fields.has(key)) {
-                field = this.fields.get(key);
-            } else if (this._proxies.has(key)) {
-                field = Server.GetDocumentField(this, key);
+            if (this.fields.has(key.Id)) {
+                field = this.fields.get(key.Id)!.field;
+            } else if (this._proxies.has(key.Id)) {
+                Server.GetDocumentField(this, key);
+                /*
+                The field might have been instantly filled from the cache
+                Maybe we want to just switch back to returning the value
+                from Server.GetDocumentField if it's in the cache
+                */
+                if (this.fields.has(key.Id)) {
+                    field = this.fields.get(key.Id)!.field;
+                } else {
+                    field = "<Waiting>";
+                }
             }
         } else {
             let doc: FieldValue<Document> = this;
             while (doc && doc != FieldWaiting && field != FieldWaiting) {
-                if (!doc.fields.has(key)) {
-                    if (doc._proxies.has(key)) {
-                        field = Server.GetDocumentField(doc, key);
+                let curField = doc.fields.get(key.Id);
+                let curProxy = doc._proxies.get(key.Id);
+                if (!curField || (curProxy && curField.field.Id !== curProxy)) {
+                    if (curProxy) {
+                        Server.GetDocumentField(doc, key);
+                        /*
+                        The field might have been instantly filled from the cache
+                        Maybe we want to just switch back to returning the value
+                        from Server.GetDocumentField if it's in the cache
+                        */
+                        if (this.fields.has(key.Id)) {
+                            field = this.fields.get(key.Id)!.field;
+                        } else {
+                            field = "<Waiting>";
+                        }
                         break;
                     }
-                    if ((doc.fields.has(KeyStore.Prototype) || doc._proxies.has(KeyStore.Prototype))) {
+                    if ((doc.fields.has(KeyStore.Prototype.Id) || doc._proxies.has(KeyStore.Prototype.Id))) {
                         doc = doc.GetPrototype();
-                    } else
+                    } else {
                         break;
+                    }
                 } else {
-                    field = doc.fields.get(key);
+                    field = curField.field;
                     break;
                 }
             }
+            if (doc == FieldWaiting)
+                field = FieldWaiting;
         }
 
         return field;
@@ -83,13 +127,17 @@ export class Document extends Field {
 
     @action
     Set(key: Key, field: Field | undefined): void {
+        console.log("Assign: " + key.Name + " = " + (field ? field.GetValue() : "<undefined>") + " (" + (field ? field.Id : "<undefined>") + ")");
         if (field) {
-            this.fields.set(key, field);
-            Server.AddDocumentField(this, key, field);
+            this.fields.set(key.Id, { key, field });
+            this._proxies.set(key.Id, field.Id)
+            // Server.AddDocumentField(this, key, field);
         } else {
-            this.fields.delete(key);
-            Server.DeleteDocumentField(this, key);
+            this.fields.delete(key.Id);
+            this._proxies.delete(key.Id)
+            // Server.DeleteDocumentField(this, key);
         }
+        Server.UpdateField(this);
     }
 
     @action
@@ -99,7 +147,7 @@ export class Document extends Field {
         //if (field != WAITING) {  // do we want to wait for the field to come back from the server to set it, or do we overwrite?
         if (field instanceof ctor) {
             field.Data = value;
-            Server.SetFieldValue(field, value);
+            // Server.SetFieldValue(field, value);
         } else if (!field || replaceWrongType) {
             let newField = new ctor();
             newField.Data = value;
@@ -132,8 +180,8 @@ export class Document extends Field {
         return protos;
     }
 
-    MakeDelegate(): Document {
-        let delegate = new Document();
+    MakeDelegate(id?: string): Document {
+        let delegate = new Document(id);
 
         delegate.Set(KeyStore.Prototype, this);
 
@@ -148,11 +196,28 @@ export class Document extends Field {
         throw new Error("Method not implemented.");
     }
     GetValue() {
-        throw new Error("Method not implemented.");
+        var title = (this._proxies.has(KeyStore.Title.Id) ? "???" : this.Title) + "(" + this.Id + ")";
+        return title;
+        //throw new Error("Method not implemented.");
     }
     Copy(): Field {
         throw new Error("Method not implemented.");
     }
 
+    ToJson(): { type: Types, data: [string, string][], _id: string } {
+        // console.log(this.fields)
+        let fields: [string, string][] = []
+        this._proxies.forEach((field, key) => {
+            if (field) {
+                fields.push([key, field as string])
+            }
+        });
+        // console.log(fields)
 
+        return {
+            type: Types.Document,
+            data: fields,
+            _id: this.Id
+        }
+    }
 }
\ No newline at end of file