Open-ILS/src/eg2/src/app/staff/share/hold.service.ts

   1 /**
   2  * Common code for mananging holdings
   3  */
   4 import {Injectable, EventEmitter} from '@angular/core';
   5 import {Observable} from 'rxjs/Observable';
   6 import {map} from 'rxjs/operators/map';
   7 import {mergeMap} from 'rxjs/operators/mergeMap';
   8 import {IdlObject} from '@eg/core/idl.service';
   9 import {NetService} from '@eg/core/net.service';
  10 import {PcrudService} from '@eg/core/pcrud.service';
  11 import {EventService, EgEvent} from '@eg/core/event.service';
  12 import {AuthService} from '@eg/core/auth.service';
  13 import {BibRecordService, BibRecordSummary}
  14     from '@eg/share/catalog/bib-record.service';
  15
  16 // Response from a place-holds API call.
  17 export interface HoldRequestResult {
  18     success: boolean;
  19     holdId?: number;
  20     evt?: EgEvent;
  21 };
  22
  23 // Values passed to the place-holds API call.
  24 export interface HoldRequest {
  25     holdType: string;
  26     holdTarget: number;
  27     recipient: number;
  28     requestor: number;
  29     pickupLib: number;
  30     override?: boolean;
  31     notifyEmail?: boolean;
  32     notifyPhone?: string;
  33     notifySms?: string;
  34     smsCarrier?: string;
  35     thawDate?: string; // ISO date
  36     frozen?: boolean;
  37     holdableFormats?: {[target: number]: string};
  38     result?: HoldRequestResult
  39 };
  40
  41 // A fleshed hold request target object containing whatever data is
  42 // available for each hold type / target.  E.g. a TITLE hold will
  43 // not have a value for 'volume', but a COPY hold will, since all
  44 // copies have volumes.  Every HoldRequestTarget will have a bibId and
  45 // bibSummary.  Some values come directly from the API call, others
  46 // applied locally.
  47 export interface HoldRequestTarget {
  48     target: number;
  49     metarecord?: IdlObject;
  50     bibrecord?: IdlObject;
  51     bibId?: number;
  52     bibSummary?: BibRecordSummary;
  53     part?: IdlObject;
  54     volume?: IdlObject;
  55     copy?: IdlObject;
  56     issuance?: IdlObject;
  57     metarecord_filters?: any;
  58 }
  59
  60 @Injectable()
  61 export class HoldService {
  62
  63     constructor(
  64         private evt: EventService,
  65         private net: NetService,
  66         private pcrud: PcrudService,
  67         private auth: AuthService,
  68         private bib: BibRecordService,
  69     ) {}
  70
  71     placeHold(request: HoldRequest): Observable<HoldRequest> {
  72
  73         let method = 'open-ils.circ.holds.test_and_create.batch';
  74         if (request.override) { method = method + '.override'; }
  75
  76         return this.net.request(
  77             'open-ils.circ', method, this.auth.token(), {
  78                 patronid:       request.recipient,
  79                 pickup_lib:     request.pickupLib,
  80                 hold_type:      request.holdType,
  81                 email_notify:   request.notifyEmail,
  82                 phone_notify:   request.notifyPhone,
  83                 thaw_date:      request.thawDate,
  84                 frozen:         request.frozen,
  85                 sms_notify:     request.notifySms,
  86                 sms_carrier:    request.smsCarrier,
  87                 holdable_formats_map: request.holdableFormats
  88             },
  89             [request.holdTarget]
  90         ).pipe(map(
  91             resp => {
  92                 let result = resp.result;
  93                 const holdResult: HoldRequestResult = {success: true};
  94
  95                 // API can return an ID, an array of events, or a hash
  96                 // of info.
  97
  98                 if (Number(result) > 0) {
  99                     // On success, the API returns the hold ID.
 100                     holdResult.holdId = result;
 101                     console.debug(`Hold successfully placed ${result}`);
 102
 103                 } else {
 104                     holdResult.success = false;
 105                     console.info('Hold request failed: ', result);
 106
 107                     if (Array.isArray(result)) { result = result[0]; }
 108
 109                     if (this.evt.parse(result)) {
 110                         holdResult.evt = this.evt.parse(result);
 111                     } else {
 112                         holdResult.evt = this.evt.parse(result.last_event);
 113                     }
 114                 }
 115
 116                 request.result = holdResult;
 117                 return request;
 118             }
 119         ));
 120     }
 121
 122     getHoldTargetMeta(holdType: string, holdTarget: number | number[],
 123         orgId?: number): Observable<HoldRequestTarget> {
 124
 125         const targetIds = [].concat(holdTarget);
 126
 127         return this.net.request(
 128             'open-ils.circ',
 129             'open-ils.circ.hold.get_metadata',
 130             holdType, targetIds, orgId
 131         ).pipe(mergeMap(meta => {
 132             const target: HoldRequestTarget = meta;
 133             target.bibId = target.bibrecord.id();
 134
 135             return this.bib.getBibSummary(target.bibId)
 136             .pipe(map(sum => {
 137                 target.bibSummary = sum;
 138                 return target;
 139             }));
 140         }));
 141     }
 142 }
 143