1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
import { Field, FieldWaiting, FIELD_ID, DOC_ID, FIELD_WAITING, FieldValue } from "./fields/Field"
import { Key, KeyStore } from "./fields/Key"
import { ObservableMap, computed, action, observable } from "mobx";
import { Document } from "./fields/Document"
export class Server {
static FieldStore: ObservableMap<FIELD_ID, Field> = new ObservableMap();
static DocumentStore: ObservableMap<DOC_ID, ObservableMap<Key, FIELD_ID>> = new ObservableMap();
public static ClientFieldsCached: ObservableMap<DOC_ID, Field | FIELD_WAITING> = new ObservableMap();
// 'hack' is here temoporarily for simplicity when debugging things.
// normally, you can't assume this will return a document since the server responds asynchronously
// and there might not actually be a matching document on the server.
// the right way to call this is from within a reaction where you test whether the return value is FieldWaiting.
public static GetDocument(docid: DOC_ID, hack: boolean = false) {
if (!this.ClientFieldsCached.has(docid)) {
this.SEND_DOCUMENT_REQUEST(docid, hack);
}
return this.ClientFieldsCached.get(docid) as Document;
}
public static AddDocument(document: Document) {
// Replace with call to server
this.DocumentStore.set(document.Id, new ObservableMap());
document.fields.forEach((field, key) => {
this.FieldStore.set((field as Field).Id, (field as Field));
this.DocumentStore.get(document.Id)!.set(key, (field as Field).Id);
});
}
public static AddDocumentField(doc: Document, key: Key, value: Field) {
// Replace with call to server
if (this.DocumentStore.get(doc.Id))
this.DocumentStore.get(doc.Id)!.set(key, value.Id);
}
public static DeleteDocumentField(doc: Document, key: Key) {
// Replace with call to server
if (this.DocumentStore.get(doc.Id))
this.DocumentStore.get(doc.Id)!.delete(key);
}
public static SetFieldValue(field: Field, value: any) {
// Replace with call to server
if (this.FieldStore.get(field.Id))
this.FieldStore.get(field.Id)!.TrySetValue(value);
}
@action
public static GetDocumentField(doc: Document, key: Key): FieldValue<Field> {
var fieldid = doc._proxies.get(key);
if (!this.ClientFieldsCached.has(fieldid)) {
this.ClientFieldsCached.set(fieldid, FieldWaiting);
this.SEND_DOCUMENT_FIELD_REQUEST(doc, key, fieldid);
}
var field = this.ClientFieldsCached.get(fieldid);
if (field != FieldWaiting) {
doc._proxies.delete(key); // perhaps another document inquired the same field
}
return field;
}
static times = 0; // hack for testing
@action
static cacheField(clientField: Field) {
var cached = this.ClientFieldsCached.get(clientField.Id);
if (!cached || cached == FieldWaiting) {
this.ClientFieldsCached.set(clientField.Id, clientField);
} else {
// probably should overwrite the values within any field that was already here...
}
return this.ClientFieldsCached.get(clientField.Id) as Field;
}
public static SEND_DOCUMENT_FIELD_REQUEST(doc: Document, key: Key, fieldid: FIELD_ID) {
//simulating a server call with a registered callback action
setTimeout(() => this.receivedDocumentField(doc, key, fieldid, this.FieldStore.get(fieldid)), 50
// key == KeyStore.Data ? (this.times++ == 0 ? 5000 : 1000) : key == KeyStore.X ? 2500 : 500
)
}
public static SEND_DOCUMENT_REQUEST(docid: DOC_ID, hack: boolean = false) {
if (hack) { // temporary for debugging
this.receivedDocument(docid, this.DocumentStore.get(docid)!)
} else {
//simulating a server call with a registered callback action
setTimeout(() => this.receivedDocument(docid, this.DocumentStore.get(docid)!), 50);
}
}
@action
static receivedDocument(docid: DOC_ID, fieldlist: ObservableMap<Key, FIELD_ID>) {
var cachedDoc = this.cacheField(new Document(docid));
fieldlist!.forEach((field: FIELD_ID, key: Key) => (cachedDoc as Document)._proxies.set(key, field));
}
@action
static receivedDocumentField(doc: Document, key: Key, fieldid: FIELD_ID, fieldfromserver: Field | undefined) {
doc._proxies.delete(key);
var cachedField = this.cacheField(fieldfromserver!);
// if the field is a document and it wasn't already cached, then we need to inquire all of its fields from the server...
if (cachedField instanceof Document && fieldfromserver! == cachedField) {
this.SEND_DOCUMENT_REQUEST(cachedField.Id);
}
doc.fields.set(key, cachedField);
}
}
|
