LP1901760 Improve SharedWorker non-support handling (Angular)
[Evergreen.git] / Open-ILS / src / eg2 / src / app / core / org.service.ts
1 import {Injectable} from '@angular/core';
2 import {Observable} from 'rxjs';
3 import {tap} from 'rxjs/operators';
4 import {IdlObject, IdlService} from './idl.service';
5 import {NetService} from './net.service';
6 import {AuthService} from './auth.service';
7 import {PcrudService} from './pcrud.service';
8 import {DbStoreService} from './db-store.service';
9
10 type OrgNodeOrId = number | IdlObject;
11
12 interface OrgFilter {
13     canHaveUsers?: boolean;
14     canHaveVolumes?: boolean;
15     opacVisible?: boolean;
16     inList?: number[];
17     notInList?: number[];
18 }
19
20 interface OrgSettingsBatch {
21     [key: string]: any;
22 }
23
24 @Injectable({providedIn: 'root'})
25 export class OrgService {
26
27     private orgList: IdlObject[] = [];
28     private orgTree: IdlObject; // root node + children
29     private orgMap: {[id: number]: IdlObject} = {};
30     private settingsCache: OrgSettingsBatch = {};
31
32     private orgTypeMap: {[id: number]: IdlObject} = {};
33     private orgTypeList: IdlObject[] = [];
34
35     constructor(
36         private db: DbStoreService,
37         private net: NetService,
38         private auth: AuthService,
39         private pcrud: PcrudService
40     ) {}
41
42     get(nodeOrId: OrgNodeOrId): IdlObject {
43         if (typeof nodeOrId === 'object') {
44             return nodeOrId;
45         }
46         return this.orgMap[nodeOrId];
47     }
48
49     list(): IdlObject[] {
50         return this.orgList;
51     }
52
53     typeList(): IdlObject[] {
54         return this.orgTypeList;
55     }
56
57     typeMap(): {[id: number]: IdlObject} {
58         return this.orgTypeMap;
59     }
60
61     /**
62      * Returns a list of org units that match the selected criteria.
63      * All filters must match for an org to be included in the result set.
64      * Unset filter options are ignored.
65      */
66     filterList(filter: OrgFilter, asId?: boolean): any[] {
67         const list = [];
68         this.list().forEach(org => {
69
70             const chu = filter.canHaveUsers;
71             if (chu && !this.canHaveUsers(org)) { return; }
72             if (chu === false && this.canHaveUsers(org)) { return; }
73
74             const chv = filter.canHaveVolumes;
75             if (chv && !this.canHaveVolumes(org)) { return; }
76             if (chv === false && this.canHaveVolumes(org)) { return; }
77
78             const ov = filter.opacVisible;
79             if (ov && !this.opacVisible(org)) { return; }
80             if (ov === false && this.opacVisible(org)) { return; }
81
82             if (filter.inList && !filter.inList.includes(org.id())) {
83                 return;
84             }
85
86             if (filter.notInList && filter.notInList.includes(org.id())) {
87                 return;
88             }
89
90             // All filter tests passed.  Add it to the list
91             list.push(asId ? org.id() : org);
92         });
93
94         return list;
95     }
96
97     tree(): IdlObject {
98         return this.orgTree;
99     }
100
101     // get the root OU
102     root(): IdlObject {
103         return this.orgList[0];
104     }
105
106     // list of org_unit objects or IDs for ancestors + me
107     ancestors(nodeOrId: OrgNodeOrId, asId?: boolean): any[] {
108         let node = this.get(nodeOrId);
109         if (!node) { return []; }
110         const nodes = [node];
111         while ( (node = this.get(node.parent_ou())) ) {
112             nodes.push(node);
113         }
114         if (asId) {
115             return nodes.map(n => n.id());
116         }
117         return nodes;
118     }
119
120     // tests that a node can have users
121     canHaveUsers(nodeOrId): boolean {
122         return this.get(nodeOrId).ou_type().can_have_users() === 't';
123     }
124
125     // tests that a node can have volumes
126     canHaveVolumes(nodeOrId): boolean {
127         return this
128             .get(nodeOrId)
129             .ou_type()
130             .can_have_vols() === 't';
131     }
132
133     opacVisible(nodeOrId): boolean {
134         return this.get(nodeOrId).opac_visible() === 't';
135     }
136
137     // list of org_unit objects  or IDs for me + descendants
138     descendants(nodeOrId: OrgNodeOrId, asId?: boolean): any[] {
139         const node = this.get(nodeOrId);
140         if (!node) { return []; }
141         const nodes = [];
142         const descend = (n) => {
143             nodes.push(n);
144             n.children().forEach(descend);
145         };
146         descend(node);
147         if (asId) {
148             return nodes.map(n => n.id());
149         }
150         return nodes;
151     }
152
153     // list of org_unit objects or IDs for ancestors + me + descendants
154     fullPath(nodeOrId: OrgNodeOrId, asId?: boolean): any[] {
155         const list = this.ancestors(nodeOrId, false).concat(
156           this.descendants(nodeOrId, false).slice(1));
157         if (asId) {
158             return list.map(n => n.id());
159         }
160         return list;
161     }
162
163     sortTree(sortField?: string, node?: IdlObject): void {
164         if (!sortField) { sortField = 'shortname'; }
165         if (!node) { node = this.orgTree; }
166         node.children(
167             node.children().sort((a, b) => {
168                 return a[sortField]() < b[sortField]() ? -1 : 1;
169             })
170         );
171         node.children().forEach(n => this.sortTree(sortField, n));
172     }
173
174     absorbTree(node?: IdlObject): void {
175         if (!node) {
176             node = this.orgTree;
177             this.orgMap = {};
178             this.orgList = [];
179             this.orgTypeMap = {};
180         }
181         this.orgMap[node.id()] = node;
182         this.orgList.push(node);
183
184         this.orgTypeMap[node.ou_type().id()] = node.ou_type();
185         if (!this.orgTypeList.filter(t => t.id() === node.ou_type().id())[0]) {
186             this.orgTypeList.push(node.ou_type());
187         }
188
189         node.children().forEach(c => this.absorbTree(c));
190     }
191
192     /**
193      * Grabs all of the org units from the server, chops them up into
194      * various shapes, then returns an "all done" promise.
195      */
196     fetchOrgs(): Promise<void> {
197         return this.pcrud.search('aou', {parent_ou : null},
198             {flesh : -1, flesh_fields : {aou : ['children', 'ou_type']}},
199             {anonymous : true}
200         ).toPromise().then(tree => {
201             // ingest tree, etc.
202             this.orgTree = tree;
203             this.absorbTree();
204         });
205     }
206
207     private appendSettingsFromCache(names: string[], batch: OrgSettingsBatch) {
208         names.forEach(name => {
209             if (name in this.settingsCache) {
210                 batch[name] = this.settingsCache[name];
211             }
212         });
213     }
214
215     // Pulls setting values from IndexedDB.
216     // Update local cache with any values found.
217     private appendSettingsFromDb(names: string[],
218         batch: OrgSettingsBatch): Promise<OrgSettingsBatch> {
219
220         if (names.length === 0) { return Promise.resolve(batch); }
221
222         return this.db.request({
223             schema: 'cache',
224             table: 'Setting',
225             action: 'selectWhereIn',
226             field: 'name',
227             value: names
228         }).then(settings => {
229
230             // array of key => JSON-string objects
231             settings.forEach(setting => {
232                 const value = JSON.parse(setting.value);
233                 // propagate to local cache as well
234                 batch[setting.name] = this.settingsCache[setting.name] = value;
235             });
236
237             return batch;
238         }).catch(_ => batch);
239     }
240
241     // Add values for the list of named settings from the 'batch' to
242     // IndexedDB, copying the local cache as well.
243     private addSettingsToDb(names: string[],
244         batch: OrgSettingsBatch): Promise<OrgSettingsBatch> {
245
246         const rows = [];
247         names.forEach(name => {
248             // Anything added to the db should also be cached locally.
249             this.settingsCache[name] = batch[name];
250             rows.push({name: name, value: JSON.stringify(batch[name])});
251         });
252
253         if (rows.length === 0) { return Promise.resolve(batch); }
254
255         return this.db.request({
256             schema: 'cache',
257             table: 'Setting',
258             action: 'insertOrReplace',
259             rows: rows
260         }).then(_ => batch).catch(_ => batch);
261     }
262
263     /**
264      * Append the named settings from the network to the in-progress
265      * batch of settings.  'auth' is null for anonymous lookup.
266      */
267     private appendSettingsFromNet(orgId: number, names: string[],
268         batch: OrgSettingsBatch, auth?: string): Promise<OrgSettingsBatch> {
269
270         if (names.length === 0) { return Promise.resolve(batch); }
271
272         return this.net.request(
273             'open-ils.actor',
274             'open-ils.actor.ou_setting.ancestor_default.batch',
275             orgId, names, auth
276
277         ).pipe(tap(settings => {
278             Object.keys(settings).forEach(key => {
279                 const val = settings[key]; // null or hash
280                 batch[key] = val ? val.value : null;
281             });
282         })).toPromise().then(_ => batch);
283     }
284
285     // Given a set of setting names and an in-progress settings batch,
286     // return the list of names which are not yet represented in the ,
287     // indicating their data needs to be fetched from the next layer up
288     // (cache, network, etc.).
289     settingNamesRemaining(names: string[], settings: OrgSettingsBatch): string[] {
290         return names.filter(name => !(name in settings));
291     }
292
293     // Returns a key/value batch of org unit settings.
294     // Cacheable settings (orgId === here) are pulled from local cache,
295     // then IndexedDB, then the network.  Non-cacheable settings are
296     // fetched from the network each time.
297     settings(name: string | string[],
298         orgId?: number, anonymous?: boolean): Promise<OrgSettingsBatch> {
299
300         let names = [].concat(name);
301         let auth: string = null;
302         let useCache = false;
303         const batch: OrgSettingsBatch = {};
304
305         if (names.length === 0) { return Promise.resolve(batch); }
306
307         if (this.auth.user()) {
308             if (orgId) {
309                 useCache = Number(orgId) === Number(this.auth.user().ws_ou());
310             } else {
311                 orgId = this.auth.user().ws_ou();
312                 useCache = true;
313             }
314
315             // avoid passing auth token when anonymous is requested.
316             if (!anonymous) {
317                 auth = this.auth.token();
318             }
319
320         } else if (!anonymous) {
321             console.warn('Attempt to fetch org setting(s)',
322                 name, 'in non-anonymous mode without an authtoken');
323             return Promise.resolve({});
324         }
325
326         if (!useCache) {
327             return this.appendSettingsFromNet(orgId, names, batch, auth);
328         }
329
330         this.appendSettingsFromCache(names, batch);
331         names = this.settingNamesRemaining(names, batch);
332
333         return this.appendSettingsFromDb(names, batch)
334         .then(_ => {
335
336             names = this.settingNamesRemaining(names, batch);
337
338             return this.appendSettingsFromNet(orgId, names, batch, auth)
339             .then(__ => this.addSettingsToDb(names, batch));
340         });
341     }
342
343     // remove setting values cached in the indexeddb settings table.
344     clearCachedSettings(): Promise<any> {
345         return this.db.request({
346             schema: 'cache',
347             table: 'Setting',
348             action: 'deleteAll'
349         }).catch(_ => null)
350     }
351 }