lp1739277 OrgSelect Class Callback Holdings Implementation
[Evergreen.git] / Open-ILS / src / eg2 / src / app / staff / catalog / record / holdings.component.ts
1 import {Component, OnInit, Input, ViewChild, ViewEncapsulation
2     } from '@angular/core';
3 import {Router} from '@angular/router';
4 import {Observable, Observer, of, empty} from 'rxjs';
5 import {map} from 'rxjs/operators';
6 import {Pager} from '@eg/share/util/pager';
7 import {IdlObject, IdlService} from '@eg/core/idl.service';
8 import {StaffCatalogService} from '../catalog.service';
9 import {OrgService} from '@eg/core/org.service';
10 import {NetService} from '@eg/core/net.service';
11 import {PcrudService} from '@eg/core/pcrud.service';
12 import {AuthService} from '@eg/core/auth.service';
13 import {GridDataSource, GridColumn, GridCellTextGenerator} from '@eg/share/grid/grid';
14 import {GridComponent} from '@eg/share/grid/grid.component';
15 import {GridToolbarCheckboxComponent
16     } from '@eg/share/grid/grid-toolbar-checkbox.component';
17 import {StoreService} from '@eg/core/store.service';
18 import {ServerStoreService} from '@eg/core/server-store.service';
19 import {MarkDamagedDialogComponent
20     } from '@eg/staff/share/holdings/mark-damaged-dialog.component';
21 import {MarkMissingDialogComponent
22     } from '@eg/staff/share/holdings/mark-missing-dialog.component';
23 import {AnonCacheService} from '@eg/share/util/anon-cache.service';
24 import {HoldingsService} from '@eg/staff/share/holdings/holdings.service';
25 import {CopyAlertsDialogComponent
26     } from '@eg/staff/share/holdings/copy-alerts-dialog.component';
27 import {CopyTagsDialogComponent
28     } from '@eg/staff/share/holdings/copy-tags-dialog.component';
29 import {CopyNotesDialogComponent
30     } from '@eg/staff/share/holdings/copy-notes-dialog.component';
31 import {ReplaceBarcodeDialogComponent
32     } from '@eg/staff/share/holdings/replace-barcode-dialog.component';
33 import {DeleteHoldingDialogComponent
34     } from '@eg/staff/share/holdings/delete-volcopy-dialog.component';
35 import {BucketDialogComponent
36     } from '@eg/staff/share/buckets/bucket-dialog.component';
37 import {ConjoinedItemsDialogComponent
38     } from '@eg/staff/share/holdings/conjoined-items-dialog.component';
39 import {MakeBookableDialogComponent
40     } from '@eg/staff/share/booking/make-bookable-dialog.component';
41 import {TransferItemsComponent
42     } from '@eg/staff/share/holdings/transfer-items.component';
43 import {TransferHoldingsComponent
44     } from '@eg/staff/share/holdings/transfer-holdings.component';
45 import {AlertDialogComponent} from '@eg/share/dialog/alert.component';
46 import {BroadcastService} from '@eg/share/util/broadcast.service';
47
48
49 // The holdings grid models a single HoldingsTree, composed of HoldingsTreeNodes
50 // flattened on-demand into a list of HoldingEntry objects.
51 export class HoldingsTreeNode {
52     children: HoldingsTreeNode[];
53     nodeType: 'org' | 'callNum' | 'copy';
54     target: any;
55     parentNode: HoldingsTreeNode;
56     expanded: boolean;
57     copyCount: number;
58     callNumCount: number;
59     constructor() {
60         this.children = [];
61     }
62 }
63
64 class HoldingsTree {
65     root: HoldingsTreeNode;
66     constructor() {
67         this.root = new HoldingsTreeNode();
68     }
69 }
70
71 export class HoldingsEntry {
72     index: number;
73     // org unit shortname, call number label, or copy barcode
74     locationLabel: string;
75     // location label indentation depth
76     locationDepth: number | null;
77     callNumCount: number | null;
78     copyCount: number | null;
79     callNumberLabel: string;
80     copy: IdlObject;
81     callNum: IdlObject;
82     circ: IdlObject;
83     treeNode: HoldingsTreeNode;
84 }
85
86 @Component({
87   selector: 'eg-holdings-maintenance',
88   templateUrl: 'holdings.component.html',
89   styleUrls: ['holdings.component.css'],
90   encapsulation: ViewEncapsulation.None
91 })
92 export class HoldingsMaintenanceComponent implements OnInit {
93
94     initDone = false;
95     gridDataSource: GridDataSource;
96     gridTemplateContext: any;
97     @ViewChild('holdingsGrid', { static: true }) holdingsGrid: GridComponent;
98
99     // Manage visibility of various sub-sections
100     @ViewChild('callNumsCheckbox', { static: true })
101         private callNumsCheckbox: GridToolbarCheckboxComponent;
102     @ViewChild('copiesCheckbox', { static: true })
103         private copiesCheckbox: GridToolbarCheckboxComponent;
104     @ViewChild('emptyCallNumsCheckbox', { static: true })
105         private emptyCallNumsCheckbox: GridToolbarCheckboxComponent;
106     @ViewChild('emptyLibsCheckbox', { static: true })
107         private emptyLibsCheckbox: GridToolbarCheckboxComponent;
108     @ViewChild('markDamagedDialog', { static: true })
109         private markDamagedDialog: MarkDamagedDialogComponent;
110     @ViewChild('markMissingDialog', { static: true })
111         private markMissingDialog: MarkMissingDialogComponent;
112     @ViewChild('copyAlertsDialog', { static: true })
113         private copyAlertsDialog: CopyAlertsDialogComponent;
114     @ViewChild('copyTagsDialog', {static: false})
115         private copyTagsDialog: CopyTagsDialogComponent;
116     @ViewChild('copyNotesDialog', {static: false})
117         private copyNotesDialog: CopyNotesDialogComponent;
118     @ViewChild('replaceBarcode', { static: true })
119         private replaceBarcode: ReplaceBarcodeDialogComponent;
120     @ViewChild('deleteHolding', { static: true })
121         private deleteHolding: DeleteHoldingDialogComponent;
122     @ViewChild('bucketDialog', { static: true })
123         private bucketDialog: BucketDialogComponent;
124     @ViewChild('conjoinedDialog', { static: true })
125         private conjoinedDialog: ConjoinedItemsDialogComponent;
126     @ViewChild('makeBookableDialog', { static: true })
127         private makeBookableDialog: MakeBookableDialogComponent;
128     @ViewChild('transferItems', {static: false})
129         private transferItems: TransferItemsComponent;
130     @ViewChild('transferHoldings', {static: false})
131         private transferHoldings: TransferHoldingsComponent;
132     @ViewChild('transferAlert', {static: false})
133         private transferAlert: AlertDialogComponent;
134
135     holdingsTree: HoldingsTree;
136
137     // nodeType => id => tree node cache
138     treeNodeCache: {[nodeType: string]: {[id: number]: HoldingsTreeNode}};
139
140     // When true and a grid reload is called, the holdings data will be
141     // re-fetched from the server.
142     refreshHoldings: boolean;
143
144     // Used as a row identifier in th grid, since we're mixing object types.
145     gridIndex: number;
146
147     // List of copies whose due date we need to retrieve.
148     itemCircsNeeded: IdlObject[];
149
150     // When true draw the grid based on the stored preferences.
151     // When not true, render based on the current "expanded" state of each node.
152     // Rendering from prefs happens on initial load and when any prefs change.
153     renderFromPrefs: boolean;
154
155     rowClassCallback: (row: any) => string;
156
157     cellTextGenerator: GridCellTextGenerator;
158     orgClassCallback: (orgId: number) => string;
159     marked_orgs: number[] = [];
160
161     private _recId: number;
162     @Input() set recordId(id: number) {
163         this._recId = id;
164         // Only force new data collection when recordId()
165         // is invoked after ngInit() has already run.
166         if (this.initDone) {
167             this.hardRefresh();
168         }
169     }
170     get recordId(): number {
171         return this._recId;
172     }
173
174     contextOrg: IdlObject;
175
176     // The context org may come from a workstation setting.
177     // Wait for confirmation from the org-select (via onchange in this
178     // case) that the desired context org unit has been found.
179     contextOrgLoaded = false;
180
181     constructor(
182         private router: Router,
183         private org: OrgService,
184         private idl: IdlService,
185         private pcrud: PcrudService,
186         private net: NetService,
187         private auth: AuthService,
188         private staffCat: StaffCatalogService,
189         private store: ServerStoreService,
190         private localStore: StoreService,
191         private holdings: HoldingsService,
192         private broadcaster: BroadcastService,
193         private anonCache: AnonCacheService
194     ) {
195         // Set some sane defaults before settings are loaded.
196         this.gridDataSource = new GridDataSource();
197         this.refreshHoldings = true;
198         this.renderFromPrefs = true;
199
200         // TODO: need a separate setting for this?
201         this.contextOrg = this.staffCat.searchContext.searchOrg;
202
203         this.rowClassCallback = (row: any): string => {
204             if (row.callNum) {
205                 if (row.copy) {
206                     return 'holdings-copy-row';
207                 } else {
208                     return 'holdings-callNum-row';
209                 }
210             } else {
211                 // Add a generic org unit class and a depth-specific
212                 // class for styling different levels of the org tree.
213                 return 'holdings-org-row holdings-org-row-' +
214                     row.treeNode.target.ou_type().depth();
215             }
216         };
217
218
219         // Text-ify function for cells that use display templates.
220         this.cellTextGenerator = {
221             owner_label: row => row.locationLabel,
222             holdable: row => row.copy ?
223                 this.gridTemplateContext.copyIsHoldable(row.copy) : ''
224         };
225
226         this.orgClassCallback = (orgId: number): string => {
227             if (this.marked_orgs.includes(orgId)) { return 'font-weight-bold'; }
228             return '';
229         };
230
231         this.gridTemplateContext = {
232             toggleExpandRow: (row: HoldingsEntry) => {
233                 row.treeNode.expanded = !row.treeNode.expanded;
234
235                 if (!row.treeNode.expanded) {
236                     // When collapsing a node, all child nodes should be
237                     // collapsed as well.
238                     const traverse = (node: HoldingsTreeNode) => {
239                         node.expanded = false;
240                         node.children.forEach(traverse);
241                     };
242                     traverse(row.treeNode);
243                 }
244
245                 this.holdingsGrid.reload();
246             },
247
248             copyIsHoldable: (copy: IdlObject): boolean => {
249                 return copy.holdable() === 't'
250                     && copy.location().holdable() === 't'
251                     && copy.status().holdable() === 't';
252             }
253         };
254     }
255
256     ngOnInit() {
257         this.initDone = true;
258
259         this.broadcaster.listen('eg.holdings.update').subscribe(data => {
260             if (data && data.records && data.records.includes(this.recordId)) {
261                 this.hardRefresh();
262                 // A hard refresh is needed to accommodate cases where
263                 // a new call number is created for a subset of copies.
264                 // We may revisit this later and use soft refresh
265                 // (below) vs. hard refresh (above) depending on what
266                 // specifically is changed.
267                 // this.refreshHoldings = true;
268                 // this.holdingsGrid.reload();
269             }
270         });
271
272         // These are pre-cached via the catalog resolver.
273         const settings = this.store.getItemBatchCached([
274             'cat.holdings_show_empty_org',
275             'cat.holdings_show_empty',
276             'cat.holdings_show_copies',
277             'cat.holdings_show_vols'
278         ]);
279
280         // Show call numbers by default when no preference is set.
281         let showCallNums = settings['cat.holdings_show_vols'];
282         if (showCallNums === null) { showCallNums = true; }
283
284         this.callNumsCheckbox.checked(showCallNums);
285         this.copiesCheckbox.checked(settings['cat.holdings_show_copies']);
286         this.emptyCallNumsCheckbox.checked(settings['cat.holdings_show_empty']);
287         this.emptyLibsCheckbox.checked(settings['cat.holdings_show_empty_org']);
288
289         this.gridDataSource.getRows = (pager: Pager, sort: any[]) => {
290             if (!this.contextOrgLoaded) { return empty(); }
291             return this.fetchHoldings(pager);
292         };
293
294         this.net.request(
295             'open-ils.search',
296             'open-ils.search.biblio.copy_counts.retrieve.staff',
297             this.recordId
298         ).toPromise().then(result => {
299             result.forEach(copy_count => {
300                 this.marked_orgs.push(copy_count[0]);
301             });
302         });
303     }
304
305     // No data is loaded until the first occurrence of the org change handler
306     contextOrgChanged(org: IdlObject) {
307         this.contextOrgLoaded = true;
308         this.contextOrg = org;
309         this.hardRefresh();
310     }
311
312     hardRefresh() {
313         this.renderFromPrefs = true;
314         this.refreshHoldings = true;
315         this.initHoldingsTree();
316         this.holdingsGrid.reload();
317     }
318
319     toggleShowCopies(value: boolean) {
320         this.store.setItem('cat.holdings_show_copies', value);
321         if (value) {
322             // Showing copies implies showing call numbers
323             this.callNumsCheckbox.checked(true);
324         }
325         this.renderFromPrefs = true;
326         this.holdingsGrid.reload();
327     }
328
329     toggleShowCallNums(value: boolean) {
330         this.store.setItem('cat.holdings_show_vols', value);
331         if (!value) {
332             // Hiding call numbers implies hiding empty call numbers and copies.
333             this.copiesCheckbox.checked(false);
334             this.emptyCallNumsCheckbox.checked(false);
335         }
336         this.renderFromPrefs = true;
337         this.holdingsGrid.reload();
338     }
339
340     toggleShowEmptyCallNums(value: boolean) {
341         this.store.setItem('cat.holdings_show_empty', value);
342         if (value) {
343             this.callNumsCheckbox.checked(true);
344         }
345         this.renderFromPrefs = true;
346         this.holdingsGrid.reload();
347     }
348
349     toggleShowEmptyLibs(value: boolean) {
350         this.store.setItem('cat.holdings_show_empty_org', value);
351         this.renderFromPrefs = true;
352         this.holdingsGrid.reload();
353     }
354
355     onRowActivate(row: any) {
356         if (row.copy) {
357             // Launch copy editor?
358         } else {
359             this.gridTemplateContext.toggleExpandRow(row);
360         }
361     }
362
363     initHoldingsTree() {
364
365         const visibleOrgs = this.org.fullPath(this.contextOrg, true);
366
367         // The initial tree simply matches the org unit tree
368         const traverseOrg = (node: HoldingsTreeNode) => {
369             node.target.children().forEach((org: IdlObject) => {
370                 if (visibleOrgs.indexOf(org.id()) === -1) {
371                     return; // Org is outside of scope
372                 }
373                 const nodeChild = new HoldingsTreeNode();
374                 nodeChild.nodeType = 'org';
375                 nodeChild.target = org;
376                 nodeChild.parentNode = node;
377                 node.children.push(nodeChild);
378                 this.treeNodeCache.org[org.id()] = nodeChild;
379                 traverseOrg(nodeChild);
380             });
381         };
382
383         this.treeNodeCache = {
384             org: {},
385             callNum: {},
386             copy: {}
387         };
388
389         this.holdingsTree = new HoldingsTree();
390         this.holdingsTree.root.nodeType = 'org';
391         this.holdingsTree.root.target = this.org.root();
392         this.treeNodeCache.org[this.org.root().id()] = this.holdingsTree.root;
393
394         traverseOrg(this.holdingsTree.root);
395     }
396
397     // Org node children are sorted with any child org nodes pushed to the
398     // front, followed by the call number nodes sorted alphabetcially by label.
399     sortOrgNodeChildren(node: HoldingsTreeNode) {
400         node.children = node.children.sort((a, b) => {
401             if (a.nodeType === 'org') {
402                 if (b.nodeType === 'org') {
403                     return a.target.shortname() < b.target.shortname() ? -1 : 1;
404                 } else {
405                     return -1;
406                 }
407             } else if (b.nodeType === 'org') {
408                 return 1;
409             } else {
410                 // TODO: should this use label sortkey instead of
411                 // the compiled call number label?
412                 return a.target._label < b.target._label ? -1 : 1;
413             }
414         });
415     }
416
417     // Sets call number and copy count sums to nodes that need it.
418     // Applies the initial expansed state of each container node.
419     setTreeCounts(node: HoldingsTreeNode) {
420
421         if (node.nodeType === 'org') {
422             node.copyCount = 0;
423             node.callNumCount = 0;
424         } else if (node.nodeType === 'callNum') {
425             node.copyCount = 0;
426         }
427
428         let hasChildOrgWithData = false;
429         let hasChildOrgSansData = false;
430         node.children.forEach(child => {
431             this.setTreeCounts(child);
432             if (node.nodeType === 'org') {
433                 node.copyCount += child.copyCount;
434                 if (child.nodeType === 'callNum') {
435                     node.callNumCount++;
436                 } else {
437                     hasChildOrgWithData = child.callNumCount > 0;
438                     hasChildOrgSansData = child.callNumCount === 0;
439                     node.callNumCount += child.callNumCount;
440                 }
441             } else if (node.nodeType === 'callNum') {
442                 node.copyCount = node.children.length;
443                 if (this.renderFromPrefs) {
444                     node.expanded = this.copiesCheckbox.checked();
445                 }
446             }
447         });
448
449         if (this.renderFromPrefs && node.nodeType === 'org') {
450             if (node.copyCount > 0 && this.callNumsCheckbox.checked()) {
451                 node.expanded = true;
452             } else if (node.callNumCount > 0 && this.emptyCallNumsCheckbox.checked()) {
453                 node.expanded = true;
454             } else if (hasChildOrgWithData) {
455                 node.expanded = true;
456             } else if (hasChildOrgSansData && this.emptyLibsCheckbox.checked()) {
457                 node.expanded = true;
458             } else {
459                 node.expanded = false;
460             }
461         }
462     }
463
464     // Create HoldingsEntry objects for tree nodes that should be displayed
465     // and relays them to the grid via the observer.
466     propagateTreeEntries(observer: Observer<HoldingsEntry>, node: HoldingsTreeNode) {
467         const entry = new HoldingsEntry();
468         entry.treeNode = node;
469         entry.index = this.gridIndex++;
470
471         switch (node.nodeType) {
472             case 'org':
473                 if (node.callNumCount === 0
474                     && !this.emptyLibsCheckbox.checked()) {
475                     return;
476                 }
477                 entry.locationLabel = node.target.shortname();
478                 entry.locationDepth = node.target.ou_type().depth();
479                 entry.copyCount = node.copyCount;
480                 entry.callNumCount = node.callNumCount;
481                 this.sortOrgNodeChildren(node);
482                 break;
483
484             case 'callNum':
485                 if (this.renderFromPrefs) {
486                     if (!this.callNumsCheckbox.checked()) {
487                         return;
488                     }
489                     if (node.copyCount === 0
490                         && !this.emptyCallNumsCheckbox.checked()) {
491                         return;
492                     }
493                 }
494                 entry.locationLabel = node.target._label;
495                 entry.locationDepth = node.parentNode.target.ou_type().depth() + 1;
496                 entry.callNumberLabel = entry.locationLabel;
497                 entry.callNum = node.target;
498                 entry.copyCount = node.copyCount;
499                 break;
500
501             case 'copy':
502                 entry.locationLabel = node.target.barcode();
503                 entry.locationDepth = node.parentNode.parentNode.target.ou_type().depth() + 2;
504                 entry.callNumberLabel = node.parentNode.target.label(); // TODO
505                 entry.callNum = node.parentNode.target;
506                 entry.copy = node.target;
507                 entry.circ = node.target._circ;
508                 break;
509         }
510
511         // Tell the grid about the node entry
512         observer.next(entry);
513
514         if (node.expanded) {
515             // Process the child nodes.
516             node.children.forEach(child =>
517                 this.propagateTreeEntries(observer, child));
518         }
519     }
520
521     // Turns the tree into a list of entries for grid display
522     flattenHoldingsTree(observer: Observer<HoldingsEntry>) {
523         this.gridIndex = 0;
524         this.setTreeCounts(this.holdingsTree.root);
525         this.propagateTreeEntries(observer, this.holdingsTree.root);
526         observer.complete();
527         this.renderFromPrefs = false;
528     }
529
530     // Grab call numbers, copies, and related data.
531     fetchHoldings(pager: Pager): Observable<any> {
532         if (!this.recordId) { return of([]); }
533
534         return new Observable<any>(observer => {
535
536             if (!this.refreshHoldings) {
537                 this.flattenHoldingsTree(observer);
538                 return;
539             }
540
541             this.itemCircsNeeded = [];
542             // Track vol IDs for the current fetch so we can prune
543             // any that were deleted in an out-of-band update.
544             const volsFetched: number[] = [];
545
546             this.pcrud.search('acn',
547                 {   record: this.recordId,
548                     owning_lib: this.org.fullPath(this.contextOrg, true),
549                     deleted: 'f',
550                     label: {'!=' : '##URI##'}
551                 }, {
552                     flesh: 3,
553                     flesh_fields: {
554                         acp: ['status', 'location', 'circ_lib', 'parts', 'notes',
555                             'tags', 'age_protect', 'copy_alerts', 'latest_inventory',
556                             'total_circ_count', 'last_circ'],
557                         acn: ['prefix', 'suffix', 'copies'],
558                         acli: ['inventory_workstation']
559                     }
560                 },
561                 {authoritative: true}
562             ).subscribe(
563                 callNum => {
564                     this.appendCallNum(callNum);
565                     volsFetched.push(callNum.id());
566                 },
567                 err => {},
568                 ()  => {
569                     this.refreshHoldings = false;
570                     this.pruneVols(volsFetched);
571                     this.fetchCircs().then(
572                         ok => this.flattenHoldingsTree(observer)
573                     );
574                 }
575             );
576         });
577     }
578
579     // Remove vols that were deleted out-of-band, via edit, merge, etc.
580     pruneVols(volsFetched: number[]) {
581
582         const toRemove: number[] = []; // avoid modifying mid-loop
583         Object.keys(this.treeNodeCache.callNum).forEach(volId => {
584             const id = Number(volId);
585             if (!volsFetched.includes(id)) {
586                 toRemove.push(id);
587             }
588         });
589
590         if (toRemove.length === 0) { return; }
591
592         const pruneNodes = (node: HoldingsTreeNode) => {
593             if (node.nodeType === 'callNum' &&
594                 toRemove.includes(node.target.id())) {
595
596                 console.debug('pruning deleted vol:', node.target.id());
597
598                 // Remove this node from the parents list of children
599                 node.parentNode.children =
600                     node.parentNode.children.filter(
601                         c => c.target.id() !== node.target.id());
602
603             } else {
604                 node.children.forEach(c => pruneNodes(c));
605             }
606         };
607
608         // remove from cache
609         toRemove.forEach(volId => delete this.treeNodeCache.callNum[volId]);
610
611         // remove from tree
612         pruneNodes(this.holdingsTree.root);
613
614         // refresh tree / grid
615         this.holdingsGrid.reload();
616     }
617
618     // Retrieve circulation objects for checked out items.
619     fetchCircs(): Promise<any> {
620         const copyIds = this.itemCircsNeeded.map(copy => copy.id());
621         if (copyIds.length === 0) { return Promise.resolve(); }
622
623         return this.pcrud.search('circ', {
624             target_copy: copyIds,
625             checkin_time: null
626         }).pipe(map(circ => {
627             const copy = this.itemCircsNeeded.filter(
628                 c => Number(c.id()) === Number(circ.target_copy()))[0];
629             copy._circ = circ;
630         })).toPromise();
631     }
632
633     // Compile prefix + label + suffix into field callNum._label;
634     setCallNumLabel(callNum: IdlObject) {
635         const pfx = callNum.prefix() ? callNum.prefix().label() : '';
636         const sfx = callNum.suffix() ? callNum.suffix().label() : '';
637         callNum._label = pfx ? pfx + ' ' : '';
638         callNum._label += callNum.label();
639         callNum._label += sfx ? ' ' + sfx : '';
640     }
641
642     // Create the tree node for the call number if it doesn't already exist.
643     // Do the same for its linked copies.
644     appendCallNum(callNum: IdlObject) {
645         let callNumNode = this.treeNodeCache.callNum[callNum.id()];
646         this.setCallNumLabel(callNum);
647
648         if (callNumNode) {
649             const pNode = this.treeNodeCache.org[callNum.owning_lib()];
650             if (callNumNode.parentNode.target.id() !== pNode.target.id()) {
651                 callNumNode.parentNode = pNode;
652                 callNumNode.parentNode.children.push(callNumNode);
653             }
654         } else {
655             callNumNode = new HoldingsTreeNode();
656             callNumNode.nodeType = 'callNum';
657             callNumNode.parentNode = this.treeNodeCache.org[callNum.owning_lib()];
658             callNumNode.parentNode.children.push(callNumNode);
659             this.treeNodeCache.callNum[callNum.id()] = callNumNode;
660         }
661
662         callNumNode.target = callNum;
663
664         callNum.copies()
665             .filter((copy: IdlObject) => (copy.deleted() !== 't'))
666             .sort((a: IdlObject, b: IdlObject) => a.barcode() < b.barcode() ? -1 : 1)
667             .forEach((copy: IdlObject) => this.appendCopy(callNumNode, copy));
668     }
669
670     // Find or create a copy node.
671     appendCopy(callNumNode: HoldingsTreeNode, copy: IdlObject) {
672         let copyNode = this.treeNodeCache.copy[copy.id()];
673
674         if (copyNode) {
675             const oldParent = copyNode.parentNode;
676             if (oldParent.target.id() !== callNumNode.target.id()) {
677                 // TODO: copy changed owning call number.  Remove it from
678                 // the previous call number before adding to the new call number.
679                 copyNode.parentNode = callNumNode;
680                 callNumNode.children.push(copyNode);
681             }
682         } else {
683             // New node required
684             copyNode = new HoldingsTreeNode();
685             copyNode.nodeType = 'copy';
686             callNumNode.children.push(copyNode);
687             copyNode.parentNode = callNumNode;
688             this.treeNodeCache.copy[copy.id()] = copyNode;
689         }
690
691         copyNode.target = copy;
692         const stat = Number(copy.status().id());
693         copy._monograph_parts = '';
694         if (copy.parts().length > 0) {
695             copy._monograph_parts =
696                 copy.parts().map(p => p.label()).join(',');
697         }
698
699         if (stat === 1 /* checked out */ || stat === 16 /* long overdue */) {
700             // Avoid looking up circs on items that are not checked out.
701             this.itemCircsNeeded.push(copy);
702         }
703     }
704
705     // Which copies in the grid are selected.
706     selectedCopyIds(rows: HoldingsEntry[], skipStatus?: number): number[] {
707         return this.selectedCopies(rows, skipStatus).map(c => Number(c.id()));
708     }
709
710     selectedVolIds(rows: HoldingsEntry[]): number[] {
711         return rows
712             .filter(r => Boolean(r.callNum))
713             .map(r => Number(r.callNum.id()));
714     }
715
716     selectedCopies(rows: HoldingsEntry[], skipStatus?: number): IdlObject[] {
717         let copyRows = rows.filter(r => Boolean(r.copy)).map(r => r.copy);
718         if (skipStatus) {
719             copyRows = copyRows.filter(
720                 c => Number(c.status().id()) !== Number(skipStatus));
721         }
722         return copyRows;
723     }
724
725     selectedCallNumIds(rows: HoldingsEntry[]): number[] {
726         return this.selectedCallNums(rows).map(cn => cn.id());
727     }
728
729     selectedCallNums(rows: HoldingsEntry[]): IdlObject[] {
730         return rows
731             .filter(r => r.treeNode.nodeType === 'callNum')
732             .map(r => r.callNum);
733     }
734
735
736     async showMarkDamagedDialog(rows: HoldingsEntry[]) {
737         const copyIds = this.selectedCopyIds(rows, 14 /* ignore damaged */);
738
739         if (copyIds.length === 0) { return; }
740
741         let rowsModified = false;
742
743         const markNext = async(ids: number[]) => {
744             if (ids.length === 0) {
745                 return Promise.resolve();
746             }
747
748             this.markDamagedDialog.copyId = ids.pop();
749             return this.markDamagedDialog.open({size: 'lg'}).subscribe(
750                 ok => {
751                     if (ok) { rowsModified = true; }
752                     return markNext(ids);
753                 },
754                 dismiss => markNext(ids)
755             );
756         };
757
758         await markNext(copyIds);
759         if (rowsModified) {
760             this.refreshHoldings = true;
761             this.holdingsGrid.reload();
762         }
763     }
764
765     showMarkMissingDialog(rows: any[]) {
766         const copyIds = this.selectedCopyIds(rows, 4 /* ignore missing */);
767         if (copyIds.length > 0) {
768             this.markMissingDialog.copyIds = copyIds;
769             this.markMissingDialog.open({}).subscribe(
770                 rowsModified => {
771                     if (rowsModified) {
772                         this.refreshHoldings = true;
773                         this.holdingsGrid.reload();
774                     }
775                 },
776                 dismissed => {} // avoid console errors
777             );
778         }
779     }
780
781     // Mark record, library, and potentially the selected call number
782     // as the current transfer target.
783     markLibCnForTransfer(rows: HoldingsEntry[]) {
784         if (rows.length === 0) {
785             return;
786         }
787
788         // Action may only apply to a single org or call number row.
789         const node = rows[0].treeNode;
790         if (node.nodeType === 'copy') { return; }
791
792         let orgId: number;
793
794         if (node.nodeType === 'org') {
795             orgId = node.target.id();
796
797             // Clear call number target when performed on an org unit row
798             this.localStore.removeLocalItem('eg.cat.transfer_target_vol');
799
800         } else if (node.nodeType === 'callNum') {
801
802             // All call number nodes are children of org nodes.
803             orgId = node.parentNode.target.id();
804
805             // Add call number target when performed on a call number row.
806             this.localStore.setLocalItem(
807                 'eg.cat.transfer_target_vol', node.target.id());
808         }
809
810         // Track lib and record to support transfering items from
811         // a different bib record to this record at the selected
812         // owning lib.
813         this.localStore.setLocalItem('eg.cat.transfer_target_lib', orgId);
814         this.localStore.setLocalItem('eg.cat.transfer_target_record', this.recordId);
815     }
816
817     openAngJsWindow(path: string) {
818         const url = `/eg/staff/${path}`;
819         window.open(url, '_blank');
820     }
821
822     openItemHolds(rows: HoldingsEntry[]) {
823         if (rows.length > 0 && rows[0].copy) {
824             this.openAngJsWindow(`cat/item/${rows[0].copy.id()}/holds`);
825         }
826     }
827
828     openItemStatusList(rows: HoldingsEntry[]) {
829         const ids = this.selectedCopyIds(rows);
830         if (ids.length > 0) {
831             return this.openAngJsWindow(`cat/item/search/${ids.join(',')}`);
832         }
833     }
834
835     openItemStatus(rows: HoldingsEntry[]) {
836         if (rows.length > 0 && rows[0].copy) {
837            return this.openAngJsWindow(`cat/item/${rows[0].copy.id()}`);
838         }
839     }
840
841     openItemTriggeredEvents(rows: HoldingsEntry[]) {
842         if (rows.length > 0 && rows[0].copy) {
843            return this.openAngJsWindow(
844                `cat/item/${rows[0].copy.id()}/triggered_events`);
845         }
846     }
847
848     openItemPrintLabels(rows: HoldingsEntry[]) {
849         const ids = this.selectedCopyIds(rows);
850         if (ids.length === 0) { return; }
851
852         this.anonCache.setItem(null, 'print-labels-these-copies', {copies: ids})
853         .then(key => this.openAngJsWindow(`cat/printlabels/${key}`));
854     }
855
856     openHoldingEdit(rows: HoldingsEntry[], hideVols: boolean, hideCopies: boolean) {
857
858         // Avoid adding call number edit entries for call numbers
859         // that are already represented by selected items.
860
861         const copies = this.selectedCopies(rows);
862         const copyVols = copies.map(c => Number(c.call_number()));
863
864         const volIds = [];
865         this.selectedVolIds(rows).forEach(id => {
866             if (!copyVols.includes(id)) {
867                 volIds.push(id);
868             }
869         });
870
871         this.holdings.spawnAddHoldingsUi(
872             this.recordId,
873             volIds,
874             null,
875             copies.map(c => Number(c.id())),
876             hideCopies,
877             hideVols
878         );
879     }
880
881     openHoldingAdd(rows: HoldingsEntry[], addCallNums: boolean, addCopies: boolean) {
882
883         // The user may select a set of call numbers by selecting call
884         // number and/or item rows.  Owning libs for new call numbers may
885         // also come from org unit row selection.
886         const orgs = {};
887         const callNums = [];
888         rows.forEach(r => {
889             if (r.treeNode.nodeType === 'callNum') {
890                 callNums.push(r.callNum);
891
892             } else if (r.treeNode.nodeType === 'copy') {
893                 callNums.push(r.treeNode.parentNode.target);
894
895             } else if (r.treeNode.nodeType === 'org') {
896                 const org = r.treeNode.target;
897                 if (org.ou_type().can_have_vols() === 't') {
898                     orgs[org.id()] = true;
899                 }
900             }
901         });
902
903         if (addCopies && !addCallNums) {
904             // Adding copies to an existing set of call numbers.
905             if (callNums.length > 0) {
906                 const callNumIds = callNums.map(v => Number(v.id()));
907                 this.holdings.spawnAddHoldingsUi(this.recordId, callNumIds);
908             }
909
910         } else if (addCallNums) {
911             const entries = [];
912
913             // Use selected call numbers as basis for new call numbers.
914             callNums.forEach(v =>
915                 entries.push({label: v.label(), owner: v.owning_lib()}));
916
917             // Use selected org units as owning libs for new call numbers
918             Object.keys(orgs).forEach(id => entries.push({owner: id}));
919
920             if (entries.length === 0) {
921                 // Otherwise create new call numbers for "here"
922                 entries.push({owner: this.auth.user().ws_ou()});
923             }
924
925             this.holdings.spawnAddHoldingsUi(
926                 this.recordId, null, entries, null, !addCopies);
927         }
928     }
929
930     openItemAlerts(rows: HoldingsEntry[], mode: string) {
931         const copyIds = this.selectedCopyIds(rows);
932         if (copyIds.length === 0) { return; }
933
934         this.copyAlertsDialog.copyIds = copyIds;
935         this.copyAlertsDialog.mode = mode;
936         this.copyAlertsDialog.open({size: 'lg'}).subscribe(
937             modified => {
938                 if (modified) {
939                     this.hardRefresh();
940                 }
941             }
942         );
943     }
944
945     openItemTags(rows: HoldingsEntry[]) {
946         const copyIds = this.selectedCopyIds(rows);
947         if (copyIds.length === 0) { return; }
948
949         this.copyTagsDialog.copyIds = copyIds;
950         this.copyTagsDialog.open({size: 'lg'}).subscribe(
951             modified => {
952                 if (modified) {
953                     this.hardRefresh();
954                 }
955             }
956         );
957     }
958
959     openItemNotes(rows: HoldingsEntry[]) {
960         const copyIds = this.selectedCopyIds(rows);
961         if (copyIds.length === 0) { return; }
962
963         this.copyNotesDialog.copyIds = copyIds;
964         this.copyNotesDialog.open({size: 'lg'}).subscribe(
965             modified => {
966                 if (modified) {
967                     this.hardRefresh();
968                 }
969             }
970         );
971     }
972
973     openReplaceBarcodeDialog(rows: HoldingsEntry[]) {
974         const ids = this.selectedCopyIds(rows);
975         if (ids.length === 0) { return; }
976         this.replaceBarcode.copyIds = ids;
977         this.replaceBarcode.open({}).subscribe(
978             modified => {
979                 if (modified) {
980                     this.hardRefresh();
981                 }
982             }
983         );
984     }
985
986     // mode 'callNums' -- only delete empty call numbers
987     // mode 'copies' -- only delete selected copies
988     // mode 'both' -- delete selected copies and selected call numbers, plus all
989     // copies linked to selected call numbers, regardless of whether they are selected.
990     deleteHoldings(rows: HoldingsEntry[], mode: 'callNums' | 'copies' | 'both') {
991         const callNumHash: any = {};
992
993         if (mode === 'callNums' || mode === 'both') {
994             // Collect the call numbers to be deleted.
995             rows.filter(r => r.treeNode.nodeType === 'callNum').forEach(r => {
996                 const callNum = this.idl.clone(r.callNum);
997                 if (mode === 'callNums') {
998                     if (callNum.copies().length > 0) {
999                         // cannot delete non-empty call number in this mode.
1000                         return;
1001                     }
1002                 } else {
1003                     callNum.copies().forEach(c => c.isdeleted(true));
1004                 }
1005                 callNum.isdeleted(true);
1006                 callNumHash[callNum.id()] = callNum;
1007             });
1008         }
1009
1010         if (mode === 'copies' || mode === 'both') {
1011             // Collect the copies to be deleted, including their call numbers
1012             // since the API expects fleshed call number objects.
1013             rows.filter(r => r.treeNode.nodeType === 'copy').forEach(r => {
1014                 const callNum = r.treeNode.parentNode.target;
1015                 if (!callNumHash[callNum.id()]) {
1016                     callNumHash[callNum.id()] = this.idl.clone(callNum);
1017                     callNumHash[callNum.id()].copies([]);
1018                 }
1019                 const copy = this.idl.clone(r.copy);
1020                 copy.isdeleted(true);
1021                 callNumHash[callNum.id()].copies().push(copy);
1022             });
1023         }
1024
1025         if (Object.keys(callNumHash).length === 0) {
1026             // No data to process.
1027             return;
1028         }
1029
1030         // Note forceDeleteCopies should not be necessary here, since we
1031         // manually marked all copies as deleted on deleted call numbers in
1032         // "both" mode.
1033         this.deleteHolding.forceDeleteCopies = mode === 'both';
1034         this.deleteHolding.callNums = Object.values(callNumHash);
1035         this.deleteHolding.open({size: 'sm'}).subscribe(
1036             modified => {
1037                 if (modified) {
1038                     this.hardRefresh();
1039                 }
1040             }
1041         );
1042     }
1043
1044     requestItems(rows: HoldingsEntry[]) {
1045         const copyIds = this.selectedCopyIds(rows);
1046         if (copyIds.length === 0) { return; }
1047         const params = {target: copyIds, holdFor: 'staff'};
1048         this.router.navigate(['/staff/catalog/hold/C'], {queryParams: params});
1049     }
1050
1051     openBucketDialog(rows: HoldingsEntry[]) {
1052         const copyIds = this.selectedCopyIds(rows);
1053         if (copyIds.length > 0) {
1054             this.bucketDialog.bucketClass = 'copy';
1055             this.bucketDialog.itemIds = copyIds;
1056             this.bucketDialog.open({size: 'lg'});
1057         }
1058     }
1059
1060     openConjoinedDialog(rows: HoldingsEntry[]) {
1061         const copyIds = this.selectedCopyIds(rows);
1062         if (copyIds.length > 0) {
1063             this.conjoinedDialog.copyIds = copyIds;
1064             this.conjoinedDialog.open({size: 'sm'});
1065         }
1066     }
1067
1068     bookItems(rows: HoldingsEntry[]) {
1069         const copyIds = this.selectedCopyIds(rows);
1070         if (copyIds.length > 0) {
1071             this.router.navigate(
1072                 ['staff', 'booking', 'create_reservation', 'for_resource', rows.filter(r => Boolean(r.copy))[0].copy.barcode()]
1073             );
1074         }
1075     }
1076
1077     makeBookable(rows: HoldingsEntry[]) {
1078         const copyIds = this.selectedCopyIds(rows);
1079         if (copyIds.length > 0) {
1080             this.makeBookableDialog.copyIds = copyIds;
1081             this.makeBookableDialog.open({});
1082         }
1083     }
1084
1085     manageReservations(rows: HoldingsEntry[]) {
1086         const copyIds = this.selectedCopyIds(rows);
1087         if (copyIds.length > 0) {
1088             this.router.navigate(
1089                 ['staff', 'booking', 'manage_reservations', 'by_resource', rows.filter(r => Boolean(r.copy))[0].copy.barcode()]
1090             );
1091         }
1092     }
1093
1094     transferSelectedItems(rows: HoldingsEntry[]) {
1095         if (rows.length === 0) { return; }
1096
1097         const cnId =
1098             this.localStore.getLocalItem('eg.cat.transfer_target_vol');
1099
1100         const orgId =
1101             this.localStore.getLocalItem('eg.cat.transfer_target_lib');
1102
1103         const recId =
1104             this.localStore.getLocalItem('eg.cat.transfer_target_record');
1105
1106         let promise;
1107
1108         if (cnId) { // Direct call number transfer
1109
1110             const itemIds = this.selectedCopyIds(rows);
1111             promise = this.transferItems.transferItems(itemIds, cnId);
1112
1113         } else if (orgId && recId) { // "Auto" transfer
1114
1115             // Clone the items to be modified to avoid any unexpected
1116             // modifications and fesh the call numbers.
1117             const items = this.idl.clone(this.selectedCopies(rows));
1118             items.forEach(i => i.call_number(
1119                 this.treeNodeCache.callNum[i.call_number()].target));
1120
1121             console.log(items);
1122             promise = this.transferItems.autoTransferItems(items, recId, orgId);
1123
1124         } else {
1125             promise = this.transferAlert.open().toPromise();
1126         }
1127
1128         promise.then(success => success ?  this.hardRefresh() : null);
1129     }
1130
1131     transferSelectedHoldings(rows: HoldingsEntry[]) {
1132         const callNums = this.selectedCallNums(rows);
1133         if (callNums.length === 0) { return; }
1134
1135         const orgId =
1136             this.localStore.getLocalItem('eg.cat.transfer_target_lib');
1137
1138         let recId =
1139             this.localStore.getLocalItem('eg.cat.transfer_target_record');
1140
1141         if (orgId) {
1142             // When transferring holdings (call numbers) between org units,
1143             // limit transfers to within the current record.
1144             recId = this.recordId;
1145
1146         } else if (!recId) {
1147             // No destinations applied.
1148             return this.transferAlert.open();
1149         }
1150
1151         this.transferHoldings.targetRecId = recId;
1152         this.transferHoldings.targetOrgId = orgId;
1153         this.transferHoldings.callNums = callNums;
1154
1155         this.transferHoldings.transferHoldings()
1156         .then(success => success ?  this.hardRefresh() : null);
1157     }
1158 }
1159