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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
|
import { observable, action } from "mobx";
import { StrCast, Cast, FieldValue } from "../../new_fields/Types";
import { Doc, DocListCast } from "../../new_fields/Doc";
import { listSpec } from "../../new_fields/Schema";
import { List } from "../../new_fields/List";
import { Id } from "../../new_fields/FieldSymbols";
import { CurrentUserUtils } from "../../server/authentication/models/current_user_utils";
/*
* link doc:
* - anchor1: doc
* - anchor1page: number
* - anchor1groups: list of group docs representing the groups anchor1 categorizes this link/anchor2 in
* - anchor2: doc
* - anchor2page: number
* - anchor2groups: list of group docs representing the groups anchor2 categorizes this link/anchor1 in
*
* group doc:
* - type: string representing the group type/name/category
* - metadata: doc representing the metadata kvps
*
* metadata doc:
* - user defined kvps
*/
export class LinkManager {
// static Instance: LinkManager;
// private constructor() {
// LinkManager.Instance = this;
// }
private static _instance: LinkManager;
public static get Instance(): LinkManager {
return this._instance || (this._instance = new this());
}
private constructor() {
}
public get LinkManagerDoc(): Doc | undefined {
return FieldValue(Cast(CurrentUserUtils.UserDocument.linkManagerDoc, Doc));
}
// @observable public allLinks: Array<Doc> = []; //List<Doc> = new List<Doc>([]); // list of link docs
// @observable public groupMetadataKeys: Map<string, Array<string>> = new Map();
// map of group type to list of its metadata keys; serves as a dictionary of groups to what kind of metadata it holds
public getAllLinks(): Doc[] {
return LinkManager.Instance.LinkManagerDoc ? LinkManager.Instance.LinkManagerDoc.allLinks ? DocListCast(LinkManager.Instance.LinkManagerDoc.allLinks) : [] : [];
}
public addLink(linkDoc: Doc): boolean {
let linkList = LinkManager.Instance.getAllLinks();
linkList.push(linkDoc);
if (LinkManager.Instance.LinkManagerDoc) {
LinkManager.Instance.LinkManagerDoc.allLinks = new List<Doc>(linkList);
return true;
}
return false;
}
public deleteLink(linkDoc: Doc): boolean {
let linkList = LinkManager.Instance.getAllLinks();
let index = LinkManager.Instance.getAllLinks().indexOf(linkDoc);
if (index > -1) {
linkList.splice(index, 1);
if (LinkManager.Instance.LinkManagerDoc) {
LinkManager.Instance.LinkManagerDoc.allLinks = new List<Doc>(linkList);
return true;
}
}
return false;
}
// finds all links that contain the given anchor
public getAllRelatedLinks(anchor: Doc): Doc[] {//List<Doc> {
let related = LinkManager.Instance.getAllLinks().filter(link => {
let protomatch1 = Doc.AreProtosEqual(anchor, Cast(link.anchor1, Doc, new Doc));
let protomatch2 = Doc.AreProtosEqual(anchor, Cast(link.anchor2, Doc, new Doc));
return protomatch1 || protomatch2;
});
return related;
}
public addGroupType(groupType: string): boolean {
if (LinkManager.Instance.LinkManagerDoc) {
LinkManager.Instance.LinkManagerDoc[groupType] = new List<string>([]);
let groupTypes = LinkManager.Instance.getAllGroupTypes();
groupTypes.push(groupType);
LinkManager.Instance.LinkManagerDoc.allGroupTypes = new List<string>(groupTypes);
return true;
}
return false;
}
// removes all group docs from all links with the given group type
public deleteGroupType(groupType: string): boolean {
if (LinkManager.Instance.LinkManagerDoc) {
if (LinkManager.Instance.LinkManagerDoc[groupType]) {
let groupTypes = LinkManager.Instance.getAllGroupTypes();
let index = groupTypes.findIndex(type => type.toUpperCase() === groupType.toUpperCase());
if (index > -1) groupTypes.splice(index, 1);
LinkManager.Instance.LinkManagerDoc.allGroupTypes = new List<string>(groupTypes);
LinkManager.Instance.LinkManagerDoc[groupType] = undefined;
LinkManager.Instance.getAllLinks().forEach(linkDoc => {
LinkManager.Instance.removeGroupFromAnchor(linkDoc, Cast(linkDoc.anchor1, Doc, new Doc), groupType);
LinkManager.Instance.removeGroupFromAnchor(linkDoc, Cast(linkDoc.anchor2, Doc, new Doc), groupType);
});
}
return true;
} else return false;
}
public getAllGroupTypes(): string[] {
if (LinkManager.Instance.LinkManagerDoc) {
if (LinkManager.Instance.LinkManagerDoc.allGroupTypes) {
return Cast(LinkManager.Instance.LinkManagerDoc.allGroupTypes, listSpec("string"), []);
} else {
LinkManager.Instance.LinkManagerDoc.allGroupTypes = new List<string>([]);
return [];
}
}
return [];
}
// gets the groups associates with an anchor in a link
public getAnchorGroups(linkDoc: Doc, anchor: Doc): Array<Doc> {
if (Doc.AreProtosEqual(anchor, Cast(linkDoc.anchor1, Doc, new Doc))) {
return DocListCast(linkDoc.anchor1Groups);
} else {
return DocListCast(linkDoc.anchor2Groups);
}
}
// sets the groups of the given anchor in the given link
public setAnchorGroups(linkDoc: Doc, anchor: Doc, groups: Doc[]) {
if (Doc.AreProtosEqual(anchor, Cast(linkDoc.anchor1, Doc, new Doc))) {
linkDoc.anchor1Groups = new List<Doc>(groups);
} else {
linkDoc.anchor2Groups = new List<Doc>(groups);
}
}
public addGroupToAnchor(linkDoc: Doc, anchor: Doc, groupDoc: Doc, replace: boolean = false) {
let groups = LinkManager.Instance.getAnchorGroups(linkDoc, anchor);
let index = groups.findIndex(gDoc => {
return StrCast(groupDoc.type).toUpperCase() === StrCast(gDoc.type).toUpperCase();
});
if (index > -1 && replace) {
groups[index] = groupDoc;
}
if (index === -1) {
groups.push(groupDoc);
}
LinkManager.Instance.setAnchorGroups(linkDoc, anchor, groups);
}
// removes group doc of given group type only from given anchor on given link
public removeGroupFromAnchor(linkDoc: Doc, anchor: Doc, groupType: string) {
let groups = LinkManager.Instance.getAnchorGroups(linkDoc, anchor);
let newGroups = groups.filter(groupDoc => StrCast(groupDoc.type).toUpperCase() !== groupType.toUpperCase());
LinkManager.Instance.setAnchorGroups(linkDoc, anchor, newGroups);
}
// public doesAnchorHaveGroup(linkDoc: Doc, anchor: Doc, groupDoc: Doc): boolean {
// let groups = LinkManager.Instance.getAnchorGroups(linkDoc, anchor);
// let index = groups.findIndex(gDoc => {
// return StrCast(groupDoc.type).toUpperCase() === StrCast(gDoc.type).toUpperCase();
// });
// return index > -1;
// }
// returns map of group type to anchor's links in that group type
public getRelatedGroupedLinks(anchor: Doc): Map<string, Array<Doc>> {
let related = this.getAllRelatedLinks(anchor);
let anchorGroups = new Map<string, Array<Doc>>();
related.forEach(link => {
let groups = LinkManager.Instance.getAnchorGroups(link, anchor);
if (groups.length > 0) {
groups.forEach(groupDoc => {
let groupType = StrCast(groupDoc.type);
let group = anchorGroups.get(groupType);
if (group) group.push(link);
else group = [link];
anchorGroups.set(groupType, group);
});
} else {
// if link is in no groups then put it in default group
let group = anchorGroups.get("*");
if (group) group.push(link);
else group = [link];
anchorGroups.set("*", group);
}
});
return anchorGroups;
}
// public addMetadataKeyToGroup(groupType: string, key: string): boolean {
// if (LinkManager.Instance.LinkManagerDoc) {
// if (LinkManager.Instance.LinkManagerDoc[groupType]) {
// let keyList = LinkManager.Instance.findMetadataKeysInGroup(groupType);
// keyList.push(key);
// LinkManager.Instance.LinkManagerDoc[groupType] = new List<string>(keyList);
// return true;
// }
// return false;
// }
// return false;
// }
public getMetadataKeysInGroup(groupType: string): string[] {
if (LinkManager.Instance.LinkManagerDoc) {
return LinkManager.Instance.LinkManagerDoc[groupType] ? Cast(LinkManager.Instance.LinkManagerDoc[groupType], listSpec("string"), []) : [];
}
return [];
}
public setMetadataKeysForGroup(groupType: string, keys: string[]): boolean {
if (LinkManager.Instance.LinkManagerDoc) {
LinkManager.Instance.LinkManagerDoc[groupType] = new List<string>(keys);
return true;
}
return false;
}
// returns a list of all metadata docs associated with the given group type
public getAllMetadataDocsInGroup(groupType: string): Array<Doc> {
let md: Doc[] = [];
let allLinks = LinkManager.Instance.getAllLinks();
allLinks.forEach(linkDoc => {
let anchor1Groups = LinkManager.Instance.getAnchorGroups(linkDoc, Cast(linkDoc.anchor1, Doc, new Doc));
let anchor2Groups = LinkManager.Instance.getAnchorGroups(linkDoc, Cast(linkDoc.anchor2, Doc, new Doc));
anchor1Groups.forEach(groupDoc => { if (StrCast(groupDoc.type).toUpperCase() === groupType.toUpperCase()) md.push(Cast(groupDoc.metadata, Doc, new Doc)); });
anchor2Groups.forEach(groupDoc => { if (StrCast(groupDoc.type).toUpperCase() === groupType.toUpperCase()) md.push(Cast(groupDoc.metadata, Doc, new Doc)); });
});
return md;
}
// checks if a link with the given anchors exists
public doesLinkExist(anchor1: Doc, anchor2: Doc): boolean {
let allLinks = LinkManager.Instance.getAllLinks();
let index = allLinks.findIndex(linkDoc => {
return (Doc.AreProtosEqual(Cast(linkDoc.anchor1, Doc, new Doc), anchor1) && Doc.AreProtosEqual(Cast(linkDoc.anchor2, Doc, new Doc), anchor2)) ||
(Doc.AreProtosEqual(Cast(linkDoc.anchor1, Doc, new Doc), anchor2) && Doc.AreProtosEqual(Cast(linkDoc.anchor2, Doc, new Doc), anchor1));
});
return index !== -1;
}
// finds the opposite anchor of a given anchor in a link
public getOppositeAnchor(linkDoc: Doc, anchor: Doc): Doc {
if (Doc.AreProtosEqual(anchor, Cast(linkDoc.anchor1, Doc, new Doc))) {
return Cast(linkDoc.anchor2, Doc, new Doc);
} else {
return Cast(linkDoc.anchor1, Doc, new Doc);
}
}
// @action
// public addLinkProxy(proxy: Doc) {
// LinkManager.Instance.linkProxies.push(proxy);
// }
// public findLinkProxy(sourceViewId: string, targetViewId: string): Doc | undefined {
// let index = LinkManager.Instance.linkProxies.findIndex(p => {
// return StrCast(p.sourceViewId) === sourceViewId && StrCast(p.targetViewId) === targetViewId;
// });
// return index > -1 ? LinkManager.Instance.linkProxies[index] : undefined;
// }
}
|
