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         });
 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);
 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         });
 350     }
 351 }