LP1885179 Staff catalog add results to basket
[Evergreen.git] / Open-ILS / src / eg2 / src / app / share / catalog / catalog.service.ts
1 import {Injectable, EventEmitter} from '@angular/core';
2 import {Observable} from 'rxjs';
3 import {map, tap, finalize} from 'rxjs/operators';
4 import {OrgService} from '@eg/core/org.service';
5 import {UnapiService} from '@eg/share/catalog/unapi.service';
6 import {IdlService, IdlObject} from '@eg/core/idl.service';
7 import {NetService} from '@eg/core/net.service';
8 import {PcrudService} from '@eg/core/pcrud.service';
9 import {CatalogSearchContext, CatalogSearchState} from './search-context';
10 import {BibRecordService, BibRecordSummary} from './bib-record.service';
11 import {BasketService} from './basket.service';
12 import {CATALOG_CCVM_FILTERS} from './search-context';
13
14 @Injectable()
15 export class CatalogService {
16
17     ccvmMap: {[ccvm: string]: IdlObject[]} = {};
18     cmfMap: {[cmf: string]: IdlObject} = {};
19     copyLocations: IdlObject[];
20
21     // Keep a reference to the most recently retrieved facet data,
22     // since facet data is consistent across a given search.
23     // No need to re-fetch with every page of search data.
24     lastFacetData: any;
25     lastFacetKey: string;
26
27     // Allow anyone to watch for completed searches.
28     onSearchComplete: EventEmitter<CatalogSearchContext>;
29
30     constructor(
31         private idl: IdlService,
32         private net: NetService,
33         private org: OrgService,
34         private unapi: UnapiService,
35         private pcrud: PcrudService,
36         private bibService: BibRecordService,
37         private basket: BasketService
38     ) {
39         this.onSearchComplete = new EventEmitter<CatalogSearchContext>();
40
41     }
42
43     search(ctx: CatalogSearchContext): Promise<void> {
44         ctx.searchState = CatalogSearchState.SEARCHING;
45
46         if (ctx.showBasket) {
47             return this.basketSearch(ctx);
48         } else if (ctx.marcSearch.isSearchable()) {
49             return this.marcSearch(ctx);
50         } else if (ctx.identSearch.isSearchable() &&
51             ctx.identSearch.queryType === 'item_barcode') {
52             return this.barcodeSearch(ctx);
53         } else if (
54             ctx.isStaff &&
55             ctx.identSearch.isSearchable() &&
56             ctx.identSearch.queryType === 'identifier|tcn') {
57             return this.tcnStaffSearch(ctx);
58         } else {
59             return this.termSearch(ctx);
60         }
61     }
62
63     barcodeSearch(ctx: CatalogSearchContext): Promise<void> {
64         return this.net.request(
65             'open-ils.search',
66             'open-ils.search.multi_home.bib_ids.by_barcode',
67             ctx.identSearch.value
68         ).toPromise().then(ids => {
69             // API returns an event for not-found barcodes
70             if (!Array.isArray(ids)) { ids = []; }
71             const result = {
72                 count: ids.length,
73                 ids: ids.map(id => [id])
74             };
75
76             this.applyResultData(ctx, result);
77             ctx.searchState = CatalogSearchState.COMPLETE;
78             this.onSearchComplete.emit(ctx);
79         });
80     }
81
82     tcnStaffSearch(ctx: CatalogSearchContext): Promise<void> {
83         return this.net.request(
84             'open-ils.search',
85             'open-ils.search.biblio.tcn',
86             ctx.identSearch.value, 1
87         ).toPromise().then(result => {
88             result.ids =  result.ids.map(id => [id]);
89             this.applyResultData(ctx, result);
90             ctx.searchState = CatalogSearchState.COMPLETE;
91             this.onSearchComplete.emit(ctx);
92         });
93     }
94
95
96     // "Search" the basket by loading the IDs and treating
97     // them like a standard query search results set.
98     basketSearch(ctx: CatalogSearchContext): Promise<void> {
99
100         return this.basket.getRecordIds().then(ids => {
101
102             const pageIds =
103                 ids.slice(ctx.pager.offset, ctx.pager.limit + ctx.pager.offset);
104
105             // Map our list of IDs into a search results object
106             // the search context can understand.
107             const result = {
108                 count: ids.length,
109                 ids: pageIds.map(id => [id])
110             };
111
112             this.applyResultData(ctx, result);
113             ctx.searchState = CatalogSearchState.COMPLETE;
114             this.onSearchComplete.emit(ctx);
115         });
116     }
117
118     marcSearch(ctx: CatalogSearchContext): Promise<void> {
119         let method = 'open-ils.search.biblio.marc';
120         if (ctx.isStaff) { method += '.staff'; }
121
122         const queryStruct = ctx.compileMarcSearchArgs();
123
124         return this.net.request('open-ils.search', method, queryStruct)
125         .toPromise().then(result => {
126             // Match the query search return format
127             result.ids = result.ids.map(id => [id]);
128
129             this.applyResultData(ctx, result);
130             ctx.searchState = CatalogSearchState.COMPLETE;
131             this.onSearchComplete.emit(ctx);
132         });
133     }
134
135     termSearch(ctx: CatalogSearchContext): Promise<void> {
136
137         let method = 'open-ils.search.biblio.multiclass.query';
138         let fullQuery;
139
140         if (ctx.identSearch.isSearchable()) {
141             fullQuery = ctx.compileIdentSearchQuery();
142
143         } else {
144             fullQuery = ctx.compileTermSearchQuery();
145
146             if (ctx.termSearch.groupByMetarecord
147                 && !ctx.termSearch.fromMetarecord) {
148                 method = 'open-ils.search.metabib.multiclass.query';
149             }
150
151             if (ctx.termSearch.hasBrowseEntry) {
152                 this.fetchBrowseEntry(ctx);
153             }
154         }
155
156         console.debug(`search query: ${fullQuery}`);
157
158         if (ctx.isStaff) {
159             method += '.staff';
160         }
161
162         return this.net.request(
163             'open-ils.search', method, {
164                 limit : ctx.pager.limit + 1,
165                 offset : ctx.pager.offset
166             }, fullQuery, true
167         ).toPromise()
168         .then(result => this.applyResultData(ctx, result))
169         .then(_ => this.fetchFieldHighlights(ctx))
170         .then(_ => {
171             ctx.searchState = CatalogSearchState.COMPLETE;
172             this.onSearchComplete.emit(ctx);
173         });
174     }
175
176     // When showing titles linked to a browse entry, fetch
177     // the entry data as well so the UI can display it.
178     fetchBrowseEntry(ctx: CatalogSearchContext) {
179         const ts = ctx.termSearch;
180
181         const parts = ts.hasBrowseEntry.split(',');
182         const mbeId = parts[0];
183         const cmfId = parts[1];
184
185         this.pcrud.retrieve('mbe', mbeId)
186         .subscribe(mbe => ctx.termSearch.browseEntry = mbe);
187     }
188
189     applyResultData(ctx: CatalogSearchContext, result: any): void {
190         ctx.result = result;
191         ctx.pager.resultCount = result.count;
192
193         // records[] tracks the current page of bib summaries.
194         result.records = [];
195
196         // If this is a new search, reset the result IDs collection.
197         if (this.lastFacetKey !== result.facet_key) {
198             ctx.resultIds = [];
199         }
200
201         result.ids.forEach((blob, idx) => ctx.addResultId(blob[0], idx));
202     }
203
204     // Appends records to the search result set as they arrive.
205     // Returns a void promise once all records have been retrieved
206     fetchBibSummaries(ctx: CatalogSearchContext): Promise<void> {
207
208         const depth = ctx.global ?
209             ctx.org.root().ou_type().depth() :
210             ctx.searchOrg.ou_type().depth();
211
212         const isMeta = ctx.termSearch.isMetarecordSearch();
213
214         let observable: Observable<BibRecordSummary>;
215
216         if (isMeta) {
217             observable = this.bibService.getMetabibSummaries(
218                 ctx.currentResultIds(), ctx.searchOrg.id(), ctx.isStaff);
219         } else {
220             observable = this.bibService.getBibSummaries(
221                 ctx.currentResultIds(), ctx.searchOrg.id(), ctx.isStaff);
222         }
223
224         return observable.pipe(map(summary => {
225             // Responses are not necessarily returned in request-ID order.
226             let idx;
227             if (isMeta) {
228                 idx = ctx.currentResultIds().indexOf(summary.metabibId);
229             } else {
230                 idx = ctx.currentResultIds().indexOf(summary.id);
231             }
232
233             if (ctx.result.records) {
234                 // May be reset when quickly navigating results.
235                 ctx.result.records[idx] = summary;
236             }
237
238             if (ctx.highlightData[summary.id]) {
239                 summary.displayHighlights = ctx.highlightData[summary.id];
240             }
241         })).toPromise();
242     }
243
244     fetchFieldHighlights(ctx: CatalogSearchContext): Promise<any> {
245
246         let hlMap;
247
248         // Extract the highlight map.  Not all searches have them.
249         if ((hlMap = ctx.result)            &&
250             (hlMap = hlMap.global_summary)  &&
251             (hlMap = hlMap.query_struct)    &&
252             (hlMap = hlMap.additional_data) &&
253             (hlMap = hlMap.highlight_map)   &&
254             (Object.keys(hlMap).length > 0)) {
255         } else { return Promise.resolve(); }
256
257         let ids;
258         if (ctx.getHighlightsFor) {
259             ids = [ctx.getHighlightsFor];
260         } else {
261             // ctx.currentResultIds() returns bib IDs or metabib IDs
262             // depending on the search type.  If we have metabib IDs, map
263             // them to bib IDs for highlighting.
264             ids = ctx.currentResultIds();
265             if (ctx.termSearch.groupByMetarecord) {
266                 // The 4th slot in the result ID reports the master record
267                 // for the metarecord in question.  Sometimes it's null?
268                 ids = ctx.result.ids.map(id => id[4]).filter(id => id !== null);
269             }
270         }
271
272         return this.net.requestWithParamList( // API is list-based
273             'open-ils.search',
274             'open-ils.search.fetch.metabib.display_field.highlight',
275             [hlMap].concat(ids)
276         ).pipe(map(fields => {
277
278             if (fields.length === 0) { return; }
279
280             // Each 'fields' collection is an array of display field
281             // values whose text is augmented with highlighting markup.
282             const highlights = ctx.highlightData[fields[0].source] = {};
283
284             fields.forEach(field => {
285                 const dfMap = this.cmfMap[field.field].display_field_map();
286                 if (!dfMap) { return; } // pretty sure this can't happen.
287
288                 if (dfMap.multi() === 't') {
289                     if (!highlights[dfMap.name()]) {
290                         highlights[dfMap.name()] = [];
291                     }
292                     (highlights[dfMap.name()] as string[]).push(field.highlight);
293                 } else {
294                     highlights[dfMap.name()] = field.highlight;
295                 }
296             });
297
298         })).toPromise();
299     }
300
301     fetchFacets(ctx: CatalogSearchContext): Promise<void> {
302
303         if (!ctx.result) {
304             return Promise.reject('Cannot fetch facets without results');
305         }
306
307         if (!ctx.result.facet_key) {
308             return Promise.resolve();
309         }
310
311         if (this.lastFacetKey === ctx.result.facet_key) {
312             ctx.result.facetData = this.lastFacetData;
313             return Promise.resolve();
314         }
315
316         return new Promise((resolve, reject) => {
317             this.net.request('open-ils.search',
318                 'open-ils.search.facet_cache.retrieve',
319                 ctx.result.facet_key
320             ).subscribe(facets => {
321                 const facetData = {};
322                 Object.keys(facets).forEach(cmfId => {
323                     const facetHash = facets[cmfId];
324                     const cmf = this.cmfMap[cmfId];
325
326                     const cmfData = [];
327                     Object.keys(facetHash).forEach(value => {
328                         const count = facetHash[value];
329                         cmfData.push({value : value, count : count});
330                     });
331
332                     if (!facetData[cmf.field_class()]) {
333                         facetData[cmf.field_class()] = {};
334                     }
335
336                     facetData[cmf.field_class()][cmf.name()] = {
337                         cmfLabel : cmf.label(),
338                         valueList : cmfData.sort((a, b) => {
339                             if (a.count > b.count) { return -1; }
340                             if (a.count < b.count) { return 1; }
341                             // secondary alpha sort on display value
342                             return a.value < b.value ? -1 : 1;
343                         })
344                     };
345                 });
346
347                 this.lastFacetKey = ctx.result.facet_key;
348                 this.lastFacetData = ctx.result.facetData = facetData;
349                 resolve();
350             });
351         });
352     }
353
354     fetchCcvms(): Promise<void> {
355
356         if (Object.keys(this.ccvmMap).length) {
357             return Promise.resolve();
358         }
359
360         return new Promise((resolve, reject) => {
361             this.pcrud.search('ccvm',
362                 {ctype : CATALOG_CCVM_FILTERS}, {},
363                 {atomic: true, anonymous: true}
364             ).subscribe(list => {
365                 this.compileCcvms(list);
366                 resolve();
367             });
368         });
369     }
370
371     compileCcvms(ccvms: IdlObject[]): void {
372         ccvms.forEach(ccvm => {
373             if (!this.ccvmMap[ccvm.ctype()]) {
374                 this.ccvmMap[ccvm.ctype()] = [];
375             }
376             this.ccvmMap[ccvm.ctype()].push(ccvm);
377         });
378
379         Object.keys(this.ccvmMap).forEach(cType => {
380             this.ccvmMap[cType] =
381                 this.ccvmMap[cType].sort((a, b) => {
382                     return a.value() < b.value() ? -1 : 1;
383                 });
384         });
385     }
386
387     iconFormatLabel(code: string): string {
388         if (this.ccvmMap) {
389             const ccvm = this.ccvmMap.icon_format.filter(
390                 format => format.code() === code)[0];
391             if (ccvm) {
392                 return ccvm.search_label();
393             }
394         }
395     }
396
397     fetchCmfs(): Promise<void> {
398         if (Object.keys(this.cmfMap).length) {
399             return Promise.resolve();
400         }
401
402         return new Promise((resolve, reject) => {
403             this.pcrud.search('cmf',
404                 {'-or': [{facet_field : 't'}, {display_field: 't'}]},
405                 {flesh: 1, flesh_fields: {cmf: ['display_field_map']}},
406                 {atomic: true, anonymous: true}
407             ).subscribe(
408                 cmfs => {
409                     cmfs.forEach(c => this.cmfMap[c.id()] = c);
410                     resolve();
411                 }
412             );
413         });
414     }
415
416     fetchCopyLocations(contextOrg: number | IdlObject): Promise<any> {
417         const orgIds = this.org.fullPath(contextOrg, true);
418         this.copyLocations = [];
419
420         return this.pcrud.search('acpl',
421             {deleted: 'f', opac_visible: 't', owning_lib: orgIds},
422             {order_by: {acpl: 'name'}},
423             {anonymous: true}
424         ).pipe(tap(loc => this.copyLocations.push(loc))).toPromise();
425     }
426
427     browse(ctx: CatalogSearchContext): Observable<any> {
428         ctx.searchState = CatalogSearchState.SEARCHING;
429         const bs = ctx.browseSearch;
430
431         let method = 'open-ils.search.browse';
432         if (ctx.isStaff) {
433             method += '.staff';
434         }
435
436         return this.net.request(
437             'open-ils.search',
438             'open-ils.search.browse.staff', {
439                 browse_class: bs.fieldClass,
440                 term: bs.value,
441                 limit : ctx.pager.limit,
442                 pivot: bs.pivot,
443                 org_unit: ctx.searchOrg.id()
444             }
445         ).pipe(
446             tap(result => ctx.searchState = CatalogSearchState.COMPLETE),
447             finalize(() => this.onSearchComplete.emit(ctx))
448         );
449     }
450
451     cnBrowse(ctx: CatalogSearchContext): Observable<any> {
452         ctx.searchState = CatalogSearchState.SEARCHING;
453         const cbs = ctx.cnBrowseSearch;
454
455         return this.net.request(
456             'open-ils.supercat',
457             'open-ils.supercat.call_number.browse',
458             cbs.value, ctx.searchOrg.shortname(), cbs.limit, cbs.offset
459         ).pipe(tap(result => ctx.searchState = CatalogSearchState.COMPLETE));
460     }
461 }