LP1852782 Context menu nagivation and FF repairs
[working/Evergreen.git] / Open-ILS / src / eg2 / src / app / staff / share / marc-edit / tagtable.service.ts
1 import {Injectable, EventEmitter} from '@angular/core';
2 import {map, tap} from 'rxjs/operators';
3 import {StoreService} from '@eg/core/store.service';
4 import {IdlObject} from '@eg/core/idl.service';
5 import {AuthService} from '@eg/core/auth.service';
6 import {NetService} from '@eg/core/net.service';
7 import {PcrudService} from '@eg/core/pcrud.service';
8 import {EventService} from '@eg/core/event.service';
9 import {ContextMenuEntry} from '@eg/share/context-menu/context-menu.service';
10
11 interface TagTableSelector {
12     marcFormat?: string;
13     marcRecordType?: string;
14 }
15
16 const defaultTagTableSelector: TagTableSelector = {
17     marcFormat     : 'marc21',
18     marcRecordType : 'biblio'
19 };
20
21 @Injectable()
22 export class TagTableService {
23
24     // Current set of tags in list and map form.
25     tagMap: {[tag: string]: any} = {};
26     ffPosMap: {[rtype: string]: any[]} = {};
27     ffValueMap: {[rtype: string]: any} = {};
28
29     extractedValuesCache:
30         {[valueType: string]: {[which: string]: any}} = {};
31
32     constructor(
33         private store: StoreService,
34         private auth: AuthService,
35         private net: NetService,
36         private pcrud: PcrudService,
37         private evt: EventService
38     ) {
39
40         this.extractedValuesCache = {
41             fieldtags: {},
42             indicators: {},
43             sfcodes: {},
44             sfvalues: {},
45             ffvalues: {}
46         };
47     }
48
49     // Various data needs munging for display.  Cached the modified
50     // values since they are refernced repeatedly by the UI code.
51     fromCache(dataType: string, which?: string, which2?: string): ContextMenuEntry[] {
52         const part1 = this.extractedValuesCache[dataType][which];
53         if (which2) {
54             if (part1) {
55                 return part1[which2];
56             }
57         } else {
58             return part1;
59         }
60     }
61
62     toCache(dataType: string, which: string,
63         which2: string, values: ContextMenuEntry[]): ContextMenuEntry[] {
64         const base = this.extractedValuesCache[dataType];
65         const part1 = base[which];
66
67         if (which2) {
68             if (!base[which]) { base[which] = {}; }
69             base[which][which2] = values;
70         } else {
71             base[which] = values;
72         }
73
74         return values;
75     }
76
77     getFfPosTable(rtype: string): Promise<any> {
78         const storeKey = 'FFPosTable_' + rtype;
79
80         if (this.ffPosMap[rtype]) {
81             return Promise.resolve(this.ffPosMap[rtype]);
82         }
83
84         this.ffPosMap[rtype] = this.store.getLocalItem(storeKey);
85
86         if (this.ffPosMap[rtype]) {
87             return Promise.resolve(this.ffPosMap[rtype]);
88         }
89
90         return this.net.request(
91             'open-ils.fielder', 'open-ils.fielder.cmfpm.atomic',
92             {query: {tag: {'!=' : '006'}, rec_type: rtype}}
93
94         ).toPromise().then(table => {
95             this.store.setLocalItem(storeKey, table);
96             return this.ffPosMap[rtype] = table;
97         });
98     }
99
100     getFfValueTable(rtype: string): Promise<any> {
101
102         const storeKey = 'FFValueTable_' + rtype;
103
104         if (this.ffValueMap[rtype]) {
105             return Promise.resolve(this.ffValueMap[rtype]);
106         }
107
108         this.ffValueMap[rtype] = this.store.getLocalItem(storeKey);
109
110         if (this.ffValueMap[rtype]) {
111             return Promise.resolve(this.ffValueMap[rtype]);
112         }
113
114         return this.net.request(
115             'open-ils.cat',
116             'open-ils.cat.biblio.fixed_field_values.by_rec_type', rtype
117
118         ).toPromise().then(table => {
119             this.store.setLocalItem(storeKey, table);
120             return this.ffValueMap[rtype] = table;
121         });
122     }
123
124     loadTagTable(selector?: TagTableSelector): Promise<any> {
125
126         if (selector) {
127             if (!selector.marcFormat) {
128                 selector.marcFormat = defaultTagTableSelector.marcFormat;
129             }
130             if (!selector.marcRecordType) {
131                 selector.marcRecordType =
132                     defaultTagTableSelector.marcRecordType;
133             }
134         } else {
135             selector = defaultTagTableSelector;
136         }
137
138         const cacheKey =
139             `current_tag_table_${selector.marcFormat}_${selector.marcRecordType}`;
140
141         this.tagMap = this.store.getLocalItem(cacheKey);
142
143         if (this.tagMap) {
144             return Promise.resolve(this.tagMap);
145         }
146
147         return this.fetchTagTable(selector).then(_ => {
148             this.store.setLocalItem(cacheKey, this.tagMap);
149             return this.tagMap;
150         });
151     }
152
153     fetchTagTable(selector?: TagTableSelector): Promise<any> {
154         this.tagMap = [];
155         return this.net.request(
156             'open-ils.cat',
157             'open-ils.cat.tag_table.all.retrieve.local',
158             this.auth.token(), selector.marcFormat, selector.marcRecordType
159         ).pipe(tap(tagData => {
160             this.tagMap[tagData.tag] = tagData;
161         })).toPromise();
162     }
163
164     getSubfieldCodes(tag: string): ContextMenuEntry[] {
165         if (!tag || !this.tagMap[tag]) { return null; }
166
167         const cached = this.fromCache('sfcodes', tag);
168
169         const list = this.tagMap[tag].subfields.map(sf => ({
170             value: sf.code,
171             label: `${sf.code}: ${sf.description}`
172         }))
173         .sort((a, b) => a.label < b.label ? -1 : 1);
174
175         return this.toCache('sfcodes', tag, null, list);
176     }
177
178     getFieldTags(): ContextMenuEntry[] {
179
180         const cached = this.fromCache('fieldtags');
181         if (cached) { return cached; }
182
183         return Object.keys(this.tagMap)
184         .filter(tag => Boolean(this.tagMap[tag]))
185         .map(tag => ({
186             value: tag,
187             label: `${tag}: ${this.tagMap[tag].name}`
188         }))
189         .sort((a, b) => a.label < b.label ? -1 : 1);
190     }
191
192     getSubfieldValues(tag: string, sfCode: string): ContextMenuEntry[] {
193         if (!tag || !this.tagMap[tag]) { return []; }
194
195         const cached = this.fromCache('sfvalues', tag, sfCode);
196         if (cached) { return cached; }
197
198         const list: ContextMenuEntry[] = [];
199
200         this.tagMap[tag].subfields
201         .filter(sf =>
202             sf.code === sfCode && sf.hasOwnProperty('value_list'))
203         .forEach(sf => {
204             sf.value_list.forEach(value => {
205
206                 let label = value.description || value.code;
207                 const code = value.code || label;
208                 if (code !== label) { label = `${code}: ${label}`; }
209
210                 list.push({value: code, label: label});
211             });
212         });
213
214         return this.toCache('sfvalues', tag, sfCode, list);
215     }
216
217     getIndicatorValues(tag: string, which: 'ind1' | 'ind2'): ContextMenuEntry[] {
218         if (!tag || !this.tagMap[tag]) { return; }
219
220         const cached = this.fromCache('indicators', tag, which);
221         if (cached) { return cached; }
222
223         let values = this.tagMap[tag][which];
224         if (!values) { return; }
225
226         values = values.map(value => ({
227             value: value.code,
228             label: `${value.code}: ${value.description}`
229         }))
230         .sort((a, b) => a.label < b.label ? -1 : 1);
231
232         return this.toCache('indicators', tag, which, values);
233     }
234
235
236     getFfFieldMeta(fieldCode: string, recordType: string): Promise<IdlObject> {
237         return this.getFfPosTable(recordType).then(table => {
238
239             // Note the AngJS MARC editor stores the full POS table
240             // for all record types in every copy of the table, hence
241             // the seemingly extraneous check in recordType.
242             return table.filter(
243                 field =>
244                     field.fixed_field === fieldCode
245                  && field.rec_type === recordType
246             )[0];
247         });
248     }
249
250
251     // Assumes getFfPosTable and getFfValueTable have already been
252     // invoked for the request record type.
253     getFfValues(fieldCode: string, recordType: string): ContextMenuEntry[] {
254
255         const cached = this.fromCache('ffvalues', recordType, fieldCode);
256         if (cached) { return cached; }
257
258         let values = this.ffValueMap[recordType];
259
260         if (!values || !values[fieldCode]) { return null; }
261
262         // extract the canned set of possible values for our
263         // fixed field.  Ignore those whose value exceeds the
264         // specified field length.
265         values = values[fieldCode]
266             .filter(val => val[0].length <= val[2])
267             .map(val => ({value: val[0], label: `${val[0]}: ${val[1]}`}))
268             .sort((a, b) => a.label < b.label ? -1 : 1);
269
270         return this.toCache('ffvalues', recordType, fieldCode, values);
271     }
272 }
273
274
275