Open-ILS/src/eg2/src/app/core/server-store.service.ts

   1 /**
   2  * Set and get server-stored settings.
   3  */
   4 import {Injectable} from '@angular/core';
   5 import {AuthService} from './auth.service';
   6 import {NetService} from './net.service';
   7
   8 // Settings summary objects returned by the API
   9 interface ServerSettingSummary {
  10     name: string;
  11     value: string;
  12     has_org_setting: boolean;
  13     has_user_setting: boolean;
  14     has_workstation_setting: boolean;
  15 }
  16
  17 @Injectable({providedIn: 'root'})
  18 export class ServerStoreService {
  19
  20     cache: {[key: string]: ServerSettingSummary};
  21
  22     constructor(
  23         private net: NetService,
  24         private auth: AuthService) {
  25         this.cache = {};
  26     }
  27
  28     setItem(key: string, value: any): Promise<any> {
  29
  30         if (!this.auth.token()) {
  31             return Promise.reject('Auth required to apply settings');
  32         }
  33
  34         const setting: any = {};
  35         setting[key] = value;
  36
  37         return this.net.request(
  38             'open-ils.actor',
  39             'open-ils.actor.settings.apply.user_or_ws',
  40             this.auth.token(), setting)
  41
  42         .toPromise().then(appliedCount => {
  43
  44             if (Number(appliedCount) > 0) { // value applied
  45                 return this.cache[key] = value;
  46             }
  47
  48             return Promise.reject(
  49                 `No user or workstation setting type exists for: "${key}".\n` +
  50                 'Create a ws/user setting type or use setLocalItem() to ' +
  51                 'store the value locally.'
  52             );
  53         });
  54     }
  55
  56     // Returns a single setting value
  57     getItem(key: string): Promise<any> {
  58         return this.getItemBatch([key]).then(
  59             settings => settings[key]
  60         );
  61     }
  62
  63     // Sync call for items known to be cached locally.
  64     getItemCached(key: string): any {
  65         return this.cache[key];
  66     }
  67
  68     // Sync batch call for items known to be cached locally
  69     getItemBatchCached(keys: string[]): {[key: string]: any} {
  70         const values: any = {};
  71         keys.forEach(key => {
  72             if (key in this.cache) {
  73                 values[key] = this.cache[key];
  74             }
  75         });
  76         return values;
  77     }
  78
  79     // Returns a set of key/value pairs for the requested settings
  80     getItemBatch(keys: string[]): Promise<any> {
  81
  82         const values: any = {};
  83         keys.forEach(key => {
  84             if (key in this.cache) {
  85                 values[key] = this.cache[key];
  86             }
  87         });
  88
  89         if (keys.length === Object.keys(values).length) {
  90             // All values are cached already
  91             return Promise.resolve(values);
  92         }
  93
  94         if (!this.auth.token()) {
  95             // Authtokens require for fetching server settings, but
  96             // calls to retrieve settings could potentially occur
  97             // before auth completes -- Ideally not, but just to be safe.
  98             return Promise.resolve({});
  99         }
 100
 101         // Server call required.  Limit the settings to lookup to those
 102         // we don't already have cached.
 103         const serverKeys = [];
 104         keys.forEach(key => {
 105             if (!Object.keys(values).includes(key)) {
 106                 serverKeys.push(key);
 107             }
 108         });
 109
 110         return new Promise((resolve, reject) => {
 111             this.net.request(
 112                 'open-ils.actor',
 113                 'open-ils.actor.settings.retrieve',
 114                 serverKeys, this.auth.token()
 115             ).subscribe(
 116                 summary => {
 117                     this.cache[summary.name] =
 118                         values[summary.name] = summary.value;
 119                 },
 120                 err => reject,
 121                 () => resolve(values)
 122             );
 123         });
 124     }
 125
 126     removeItem(key: string): Promise<any> {
 127         return this.setItem(key, null);
 128     }
 129 }
 130