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         }
 180         this.orgMap[node.id()] = node;
 181         this.orgList.push(node);
 182
 183         node.children().forEach(c => this.absorbTree(c));
 184     }
 185
 186     /**
 187      * Grabs all of the org units from the server, chops them up into
 188      * various shapes, then returns an "all done" promise.
 189      */
 190     fetchOrgs(): Promise<void> {
 191
 192         // Grab org types separately so we are guaranteed to fetch types
 193         // that are not yet in use by an org unit.
 194         return this.pcrud.retrieveAll(
 195             'aout', {}, {anonymous: true, atomic: true}).toPromise()
 196         .then(types => {
 197             this.orgTypeList = types;
 198             types.forEach(t => this.orgTypeMap[Number(t.id())] = t);
 199
 200             return this.pcrud.search('aou', {parent_ou : null},
 201                 {flesh : -1, flesh_fields : {aou : ['children', 'ou_type']}},
 202                 {anonymous : true}
 203             ).toPromise()
 204         })
 205
 206         .then(tree => {
 207             // ingest tree, etc.
 208             this.orgTree = tree;
 209             this.absorbTree();
 210         });
 211     }
 212
 213     private appendSettingsFromCache(names: string[], batch: OrgSettingsBatch) {
 214         names.forEach(name => {
 215             if (name in this.settingsCache) {
 216                 batch[name] = this.settingsCache[name];
 217             }
 218         });
 219     }
 220
 221     // Pulls setting values from IndexedDB.
 222     // Update local cache with any values found.
 223     private appendSettingsFromDb(names: string[],
 224         batch: OrgSettingsBatch): Promise<OrgSettingsBatch> {
 225
 226         if (names.length === 0) { return Promise.resolve(batch); }
 227
 228         return this.db.request({
 229             schema: 'cache',
 230             table: 'Setting',
 231             action: 'selectWhereIn',
 232             field: 'name',
 233             value: names
 234         }).then(settings => {
 235
 236             // array of key => JSON-string objects
 237             settings.forEach(setting => {
 238                 const value = JSON.parse(setting.value);
 239                 // propagate to local cache as well
 240                 batch[setting.name] = this.settingsCache[setting.name] = value;
 241             });
 242
 243             return batch;
 244         }).catch(_ => batch);
 245     }
 246
 247     // Add values for the list of named settings from the 'batch' to
 248     // IndexedDB, copying the local cache as well.
 249     private addSettingsToDb(names: string[],
 250         batch: OrgSettingsBatch): Promise<OrgSettingsBatch> {
 251
 252         const rows = [];
 253         names.forEach(name => {
 254             // Anything added to the db should also be cached locally.
 255             this.settingsCache[name] = batch[name];
 256             rows.push({name: name, value: JSON.stringify(batch[name])});
 257         });
 258
 259         if (rows.length === 0) { return Promise.resolve(batch); }
 260
 261         return this.db.request({
 262             schema: 'cache',
 263             table: 'Setting',
 264             action: 'insertOrReplace',
 265             rows: rows
 266         }).then(_ => batch).catch(_ => batch);
 267     }
 268
 269     /**
 270      * Append the named settings from the network to the in-progress
 271      * batch of settings.  'auth' is null for anonymous lookup.
 272      */
 273     private appendSettingsFromNet(orgId: number, names: string[],
 274         batch: OrgSettingsBatch, auth?: string): Promise<OrgSettingsBatch> {
 275
 276         if (names.length === 0) { return Promise.resolve(batch); }
 277
 278         return this.net.request(
 279             'open-ils.actor',
 280             'open-ils.actor.ou_setting.ancestor_default.batch',
 281             orgId, names, auth
 282
 283         ).pipe(tap(settings => {
 284             Object.keys(settings).forEach(key => {
 285                 const val = settings[key]; // null or hash
 286                 batch[key] = val ? val.value : null;
 287             });
 288         })).toPromise().then(_ => batch);
 289     }
 290
 291     // Given a set of setting names and an in-progress settings batch,
 292     // return the list of names which are not yet represented in the ,
 293     // indicating their data needs to be fetched from the next layer up
 294     // (cache, network, etc.).
 295     settingNamesRemaining(names: string[], settings: OrgSettingsBatch): string[] {
 296         return names.filter(name => !(name in settings));
 297     }
 298
 299     // Returns a key/value batch of org unit settings.
 300     // Cacheable settings (orgId === here) are pulled from local cache,
 301     // then IndexedDB, then the network.  Non-cacheable settings are
 302     // fetched from the network each time.
 303     settings(name: string | string[],
 304         orgId?: number, anonymous?: boolean): Promise<OrgSettingsBatch> {
 305
 306         let names = [].concat(name);
 307         let auth: string = null;
 308         let useCache = false;
 309         const batch: OrgSettingsBatch = {};
 310
 311         if (names.length === 0) { return Promise.resolve(batch); }
 312
 313         if (this.auth.user()) {
 314             if (orgId) {
 315                 useCache = Number(orgId) === Number(this.auth.user().ws_ou());
 316             } else {
 317                 orgId = this.auth.user().ws_ou();
 318                 useCache = true;
 319             }
 320
 321             // avoid passing auth token when anonymous is requested.
 322             if (!anonymous) {
 323                 auth = this.auth.token();
 324             }
 325
 326         } else if (!anonymous) {
 327             console.warn('Attempt to fetch org setting(s)',
 328                 name, 'in non-anonymous mode without an authtoken');
 329             return Promise.resolve({});
 330         }
 331
 332         if (!useCache) {
 333             return this.appendSettingsFromNet(orgId, names, batch, auth);
 334         }
 335
 336         this.appendSettingsFromCache(names, batch);
 337         names = this.settingNamesRemaining(names, batch);
 338
 339         return this.appendSettingsFromDb(names, batch)
 340         .then(_ => {
 341
 342             names = this.settingNamesRemaining(names, batch);
 343
 344             return this.appendSettingsFromNet(orgId, names, batch, auth)
 345             .then(__ => this.addSettingsToDb(names, batch));
 346         });
 347     }
 348
 349     // remove setting values cached in the indexeddb settings table.
 350     clearCachedSettings(): Promise<any> {
 351         return this.db.request({
 352             schema: 'cache',
 353             table: 'Setting',
 354             action: 'deleteAll'
 355         }).catch(_ => null);
 356     }
 357 }