Open-ILS/src/eg2/src/app/staff/share/holds/grid.component.ts

   1 import {Component, OnInit, Input, Output, EventEmitter, ViewChild} from '@angular/core';
   2 import {Location} from '@angular/common';
   3 import {Observable, Observer, of, from} from 'rxjs';
   4 import {concatMap} from 'rxjs/operators';
   5 import {IdlObject} from '@eg/core/idl.service';
   6 import {NetService} from '@eg/core/net.service';
   7 import {OrgService} from '@eg/core/org.service';
   8 import {AuthService} from '@eg/core/auth.service';
   9 import {Pager} from '@eg/share/util/pager';
  10 import {ServerStoreService} from '@eg/core/server-store.service';
  11 import {GridDataSource, GridColumn, GridCellTextGenerator} from '@eg/share/grid/grid';
  12 import {GridComponent} from '@eg/share/grid/grid.component';
  13 import {ProgressDialogComponent} from '@eg/share/dialog/progress.component';
  14 import {ConfirmDialogComponent} from '@eg/share/dialog/confirm.component';
  15 import {MarkDamagedDialogComponent
  16     } from '@eg/staff/share/holdings/mark-damaged-dialog.component';
  17 import {MarkMissingDialogComponent
  18     } from '@eg/staff/share/holdings/mark-missing-dialog.component';
  19 import {MarkDiscardDialogComponent
  20     } from '@eg/staff/share/holdings/mark-discard-dialog.component';
  21 import {HoldRetargetDialogComponent
  22     } from '@eg/staff/share/holds/retarget-dialog.component';
  23 import {HoldTransferDialogComponent} from './transfer-dialog.component';
  24 import {HoldCancelDialogComponent} from './cancel-dialog.component';
  25 import {HoldManageDialogComponent} from './manage-dialog.component';
  26 import {PrintService} from '@eg/share/print/print.service';
  27 import {HoldingsService} from '@eg/staff/share/holdings/holdings.service';
  28 import {OrgSelectComponent} from '@eg/share/org-select/org-select.component';
  29 import {ComboboxEntry} from '@eg/share/combobox/combobox.component';
  30 import {HoldCopyLocationsDialogComponent} from './copy-locations-dialog.component';
  31
  32 /** Holds grid with access to detail page and other actions */
  33
  34 @Component({
  35   selector: 'eg-holds-grid',
  36   templateUrl: 'grid.component.html',
  37   styles: ['.input-group > .form-control { width: auto; flex-grow: 0; }']
  38 })
  39 export class HoldsGridComponent implements OnInit {
  40
  41     // Hide the "Holds Count" header
  42     @Input() hideHoldsCount = false;
  43
  44     // If either are set/true, the pickup lib selector will display
  45     @Input() initialPickupLib: number | IdlObject;
  46     @Input() hidePickupLibFilter: boolean;
  47
  48     // Setting a value here puts us into "pull list" mode.
  49     @Input() pullListOrg: number;
  50
  51     // If true, only retrieve holds with a Hopeless Date
  52     // and enable related Actions
  53     @Input() hopeless: boolean;
  54
  55     // Grid persist key
  56     @Input() persistKey: string;
  57
  58     @Input() preFetchSetting: string;
  59
  60     @Input() printTemplate: string;
  61
  62     // Adds a Place Hold grid toolbar button that emits
  63     // placeHoldRequested on click.
  64     @Input() showPlaceHoldButton = false;
  65
  66     // If set, all holds are fetched on grid load and sorting/paging all
  67     // happens in the client.  If false, sorting and paging occur on
  68     // the server.
  69     @Input() enablePreFetch: boolean;
  70
  71     // How to sort when no sort parameters have been applied
  72     // via grid controls.  This uses the eg-grid sort format:
  73     // [{name: fname, dir: 'asc'}, {name: fname2, dir: 'desc'}]
  74     @Input() defaultSort: any[];
  75
  76     // To pass through to the underlying eg-grid
  77     @Input() showFields: string;
  78
  79     // Display bib record summary along the top of the detail page.
  80     @Input() showRecordSummary = false;
  81
  82     // If true, avoid popping up the progress dialog.  Note the grid
  83     // has it's own generic embedded 'loading' progress indicator.
  84     @Input() noLoadProgress = false;
  85
  86     // Some default columns and actions do or don't make sense when
  87     // displaying holds for a specific patron vs. e.g. a specific title.
  88     @Input() patronFocused = false;
  89
  90     mode: 'list' | 'detail' | 'manage' = 'list';
  91     initDone = false;
  92     holdsCount: number;
  93     pickupLib: IdlObject;
  94     plCompLoaded = false;
  95     gridDataSource: GridDataSource;
  96     detailHold: any;
  97     editHolds: number[];
  98     transferTarget: number;
  99     uncancelHoldCount: number;
 100     copyLocationClass?: string;
 101     copyLocationEntries: ComboboxEntry[] = [];
 102     copyLocationIds: number[] = [];
 103
 104     @ViewChild('holdsGrid', { static: false }) private holdsGrid: GridComponent;
 105     @ViewChild('progressDialog', { static: true })
 106         private progressDialog: ProgressDialogComponent;
 107     @ViewChild('transferDialog', { static: true })
 108         private transferDialog: HoldTransferDialogComponent;
 109     @ViewChild('markDamagedDialog', { static: true })
 110         private markDamagedDialog: MarkDamagedDialogComponent;
 111     @ViewChild('markMissingDialog', { static: true })
 112         private markMissingDialog: MarkMissingDialogComponent;
 113     @ViewChild('markDiscardDialog')
 114         private markDiscardDialog: MarkDiscardDialogComponent;
 115     @ViewChild('retargetDialog', { static: true })
 116         private retargetDialog: HoldRetargetDialogComponent;
 117     @ViewChild('cancelDialog', { static: true })
 118         private cancelDialog: HoldCancelDialogComponent;
 119     @ViewChild('manageDialog', { static: true })
 120         private manageDialog: HoldManageDialogComponent;
 121     @ViewChild('uncancelDialog') private uncancelDialog: ConfirmDialogComponent;
 122     @ViewChild('copyLocationsDialog')
 123         private copyLocationsDialog: HoldCopyLocationsDialogComponent;
 124     @ViewChild('clearCopyLocationsDialog')
 125         private clearCopyLocationsDialog: ConfirmDialogComponent;
 126     @ViewChild('pullPickupLibFilter')
 127         private pullPickupLibFilter: OrgSelectComponent;
 128
 129     // Bib record ID.
 130     _recordId: number;
 131     @Input() set recordId(id: number) {
 132         this._recordId = id;
 133         if (this.initDone) { // reload on update
 134             this.holdsGrid.reload();
 135         }
 136     }
 137
 138     get recordId(): number {
 139         return this._recordId;
 140     }
 141
 142     _patronId: number;
 143     @Input() set patronId(id: number) {
 144         this._patronId = id;
 145         if (this.initDone) {
 146             this.holdsGrid.reload();
 147         }
 148     }
 149     get patronId(): number {
 150         return this._patronId;
 151     }
 152
 153     // If true, show recently canceled holds only.
 154     @Input() showRecentlyCanceled = false;
 155
 156     // Include holds fulfilled on or after hte provided date.
 157     // If no value is passed, fulfilled holds are not displayed.
 158     _showFulfilledSince: Date;
 159     @Input() set showFulfilledSince(show: Date) {
 160         this._showFulfilledSince = show;
 161         if (this.initDone) { // reload on update
 162             this.holdsGrid.reload();
 163         }
 164     }
 165     get showFulfilledSince(): Date {
 166         return this._showFulfilledSince;
 167     }
 168
 169
 170     cellTextGenerator: GridCellTextGenerator;
 171
 172     // Include holds marked Hopeless on or after this date.
 173     _showHopelessAfter: Date;
 174     @Input() set showHopelessAfter(show: Date) {
 175         this._showHopelessAfter = show;
 176         if (this.initDone) { // reload on update
 177             this.holdsGrid.reload();
 178         }
 179     }
 180
 181     // Include holds marked Hopeless on or before this date.
 182     _showHopelessBefore: Date;
 183     @Input() set showHopelessBefore(show: Date) {
 184         this._showHopelessBefore = show;
 185         if (this.initDone) { // reload on update
 186             this.holdsGrid.reload();
 187         }
 188     }
 189
 190     // Notify the caller the place hold button was clicked.
 191     @Output() placeHoldRequested: EventEmitter<void> = new EventEmitter<void>();
 192
 193     constructor(
 194         private ngLocation: Location,
 195         private net: NetService,
 196         private org: OrgService,
 197         private store: ServerStoreService,
 198         private auth: AuthService,
 199         private printer: PrintService,
 200         private holdings: HoldingsService
 201     ) {
 202         this.gridDataSource = new GridDataSource();
 203         this.enablePreFetch = null;
 204     }
 205
 206     ngOnInit() {
 207         this.initDone = true;
 208         this.pickupLib = this.org.get(this.initialPickupLib);
 209
 210         if (this.preFetchSetting) {
 211             this.store.getItem(this.preFetchSetting).then(
 212                 applied => this.enablePreFetch = Boolean(applied)
 213             );
 214         } else {
 215             this.enablePreFetch = false;
 216         }
 217
 218         if (!this.defaultSort) {
 219             if (this.pullListOrg) {
 220
 221                 this.defaultSort = [
 222                     {name: 'copy_location_order_position', dir: 'asc'},
 223                     {name: 'acpl_name', dir: 'asc'},
 224                     {name: 'ancp_label', dir: 'asc'}, // NOTE: API typo "ancp"
 225                     {name: 'cn_label_sortkey', dir: 'asc'},
 226                     {name: 'ancs_label', dir: 'asc'} // NOTE: API typo "ancs"
 227                 ];
 228
 229             } else {
 230                 this.defaultSort = [{name: 'request_time', dir: 'asc'}];
 231             }
 232         }
 233
 234         this.gridDataSource.getRows = (pager: Pager, sort: any[]) => {
 235
 236             if (!this.hidePickupLibFilter || this.pullListOrg) {
 237                 // When the pickup lib selector is active, avoid any
 238                 // data fetches until it has settled on a default value.
 239                 // Once the final value is applied, its onchange will
 240                 // fire and we'll be back here with plCompLoaded=true.
 241                 if (!this.plCompLoaded) return of([]);
 242             }
 243
 244             sort = sort.length > 0 ? sort : this.defaultSort;
 245             return this.fetchHolds(pager, sort);
 246         };
 247
 248         // Text-ify function for cells that use display templates.
 249         this.cellTextGenerator = {
 250             title: row => row.title,
 251             cp_barcode: row => (row.cp_barcode == null) ? '' : row.cp_barcode,
 252             current_item: row => row.current_copy ? row.cp_barcode : '',
 253             requested_item: row => this.isCopyHold(row) ? row.cp_barcode : '',
 254             ucard_barcode: row => row.ucard_barcode,
 255             hold_status: row => row.hold_status // TODO labels
 256         };
 257
 258         if (this.pullListOrg) {
 259             this.store.getItem('eg.holds.pull_list_filters').then(data => {
 260                 if (data) {
 261                     this.copyLocationClass = data.copyLocationClass;
 262                     this.copyLocationEntries = data.copyLocationEntries;
 263                     this.copyLocationIds = data.copyLocationIds;
 264                     if (data.pickupLib) {
 265                         this.pickupLib = this.org.get(data.pickupLib);
 266                     }
 267                 } else {
 268                     this.copyLocationClass = 'acpl';
 269                 }
 270             });
 271         }
 272     }
 273
 274     // Returns true after all data/settings/etc required to render the
 275     // grid have been fetched.
 276     initComplete(): boolean {
 277         return this.enablePreFetch !== null;
 278     }
 279
 280     pickupLibChanged(org: IdlObject) {
 281         this.pickupLib = org;
 282         this.holdsGrid.reload();
 283     }
 284
 285     pullPickupLibLoaded(): void {
 286         this.plCompLoaded = true;
 287         this.holdsGrid.reload();
 288     }
 289
 290     resetPullPickupLibFilter(): void {
 291         if (this.pickupLib) {
 292             this.pullPickupLibFilter.reset();
 293         }
 294     }
 295
 296     pullPickupLibChanged(org: IdlObject): void {
 297         if (org?.id() !== this.pickupLib?.id()) {
 298             this.pickupLib = org;
 299             this.savePullFilterSettings();
 300             this.holdsGrid.reload();
 301         }
 302     }
 303
 304     openCopyLocationsDialog(): void {
 305         this.copyLocationsDialog.init();
 306         this.copyLocationsDialog.open({size: 'lg'}).subscribe(
 307             ([fmClass, entries, ids]) => {
 308                 this.copyLocationClass = fmClass;
 309                 this.copyLocationEntries = entries;
 310                 this.copyLocationIds = ids;
 311                 this.savePullFilterSettings();
 312                 this.holdsGrid.reload();
 313             }
 314         );
 315     }
 316
 317     clearCopyLocations(): void {
 318         if (!this.copyLocationEntries.length) return;
 319         this.clearCopyLocationsDialog.open().subscribe(data => {
 320             if (data) {
 321                 this.copyLocationClass = 'acpl';
 322                 this.copyLocationEntries = [];
 323                 this.copyLocationIds = [];
 324                 this.savePullFilterSettings();
 325                 this.holdsGrid.reload();
 326             }
 327         });
 328     }
 329
 330     pullListSettingsLoaded(): boolean {
 331         return !!this.copyLocationClass;
 332     }
 333
 334     savePullFilterSettings(): void {
 335         this.store.setItem('eg.holds.pull_list_filters', {
 336             copyLocationClass: this.copyLocationClass,
 337             copyLocationEntries: this.copyLocationEntries,
 338             copyLocationIds: this.copyLocationIds,
 339             pickupLib: this.pickupLib ? +this.pickupLib.id() : undefined
 340         });
 341     }
 342
 343     pullListOrgChanged(org: IdlObject): void {
 344         if (org && +org.id() !== +this.pullListOrg) {
 345             this.pullListOrg = org.id();
 346             this.holdsGrid.reload();
 347         }
 348     }
 349
 350     preFetchHolds(apply: boolean) {
 351         this.enablePreFetch = apply;
 352
 353         if (apply) {
 354             setTimeout(() => this.holdsGrid.reload());
 355         }
 356
 357         if (this.preFetchSetting) {
 358             // fire and forget
 359             this.store.setItem(this.preFetchSetting, apply);
 360         }
 361     }
 362
 363     applyFilters(): any {
 364
 365         const filters: any = {};
 366
 367         if (this.copyLocationIds.length) {
 368             filters['acpl.id'] = this.copyLocationIds;
 369         }
 370
 371         if (this.pickupLib) {
 372             filters.pickup_lib =
 373                 this.org.descendants(this.pickupLib, true);
 374         }
 375
 376         if (this.pullListOrg) {
 377             filters.cancel_time = null;
 378             filters.capture_time = null;
 379             filters.frozen = 'f';
 380
 381             // cp.* fields are set for copy-level holds even if they
 382             // have no current_copy.  Make sure current_copy is set.
 383             filters.current_copy = {'is not': null};
 384
 385             // There are aliases for these (cp_status, cp_circ_lib),
 386             // but the API complains when I use them.
 387             filters['cp.status'] = {"in":{"select":{"ccs":["id"]},"from":"ccs","where":{"holdable":'t',"is_available":'t'}}};
 388             filters['cp.circ_lib'] = this.pullListOrg;
 389             // Avoid deleted copies AND this uses a database index on copy circ_lib where deleted is false.
 390             filters['cp.deleted'] = 'f';
 391
 392             return filters;
 393         }
 394
 395         if (this._showFulfilledSince) {
 396             filters.fulfillment_time = this._showFulfilledSince.toISOString();
 397         } else {
 398             filters.fulfillment_time = null;
 399         }
 400
 401
 402         if (this.hopeless) {
 403           filters['hopeless_holds'] = {
 404             'start_date' : this._showHopelessAfter
 405               ? (
 406                   // FIXME -- consistency desired, string or object
 407                   typeof this._showHopelessAfter === 'object'
 408                   ? this._showHopelessAfter.toISOString()
 409                   : this._showHopelessAfter
 410                 )
 411               : '1970-01-01T00:00:00.000Z',
 412             'end_date' : this._showHopelessBefore
 413               ? (
 414                   // FIXME -- consistency desired, string or object
 415                   typeof this._showHopelessBefore === 'object'
 416                   ? this._showHopelessBefore.toISOString()
 417                   : this._showHopelessBefore
 418                 )
 419               : (new Date()).toISOString()
 420           };
 421         }
 422
 423         if (this.recordId) {
 424             filters.record_id = this.recordId;
 425         }
 426
 427         if (this.patronId) {
 428             filters.usr_id = this.patronId;
 429         }
 430
 431         return filters;
 432     }
 433
 434     fetchHolds(pager: Pager, sort: any[]): Observable<any> {
 435
 436         // We need at least one filter.
 437         if (!this.recordId && !this.pickupLib && !this.patronId && !this.pullListOrg) {
 438             return of([]);
 439         }
 440
 441         const filters = this.applyFilters();
 442
 443         const orderBy: any = [];
 444         if (sort.length > 0) {
 445             sort.forEach(obj => {
 446                 const subObj: any = {};
 447                 subObj[obj.name] = {dir: obj.dir, nulls: 'last'};
 448                 orderBy.push(subObj);
 449             });
 450         }
 451
 452         const limit = this.enablePreFetch ? null : pager.limit;
 453         const offset = this.enablePreFetch ? 0 : pager.offset;
 454         const options: any = {};
 455         if (this.showRecentlyCanceled) {
 456             options.recently_canceled = true;
 457         } else {
 458             filters.cancel_time = null;
 459         }
 460
 461         let observer: Observer<any>;
 462         const observable = new Observable(obs => observer = obs);
 463
 464         if (!this.noLoadProgress) {
 465             // Note remaining dialog actions have no impact
 466             this.progressDialog.open();
 467         }
 468
 469         this.progressDialog.update({value: 0, max: 1});
 470
 471         let first = true;
 472         let loadCount = 0;
 473         this.net.request(
 474             'open-ils.circ',
 475             'open-ils.circ.hold.wide_hash.stream',
 476             this.auth.token(), filters, orderBy, limit, offset, options
 477         ).subscribe(
 478             holdData => {
 479
 480                 if (first) { // First response is the hold count.
 481                     this.holdsCount = Number(holdData);
 482                     first = false;
 483
 484                 } else { // Subsequent responses are hold data blobs
 485
 486                     this.progressDialog.update(
 487                         {value: ++loadCount, max: this.holdsCount});
 488
 489                     observer.next(holdData);
 490                 }
 491             },
 492             err => {
 493                 this.progressDialog.close();
 494                 observer.error(err);
 495             },
 496             ()  => {
 497                 this.progressDialog.close();
 498                 observer.complete();
 499             }
 500         );
 501
 502         return observable;
 503     }
 504
 505     metaRecordHoldsSelected(rows: IdlObject[]) {
 506         let found = false;
 507         rows.forEach( row => {
 508            if (row.hold_type === 'M') {
 509              found = true;
 510            }
 511         });
 512         return found;
 513     }
 514
 515     nonTitleHoldsSelected(rows: IdlObject[]) {
 516         let found = false;
 517         rows.forEach( row => {
 518            if (row.hold_type !== 'T') {
 519              found = true;
 520            }
 521         });
 522         return found;
 523     }
 524
 525     showDetails(rows: any[]) {
 526         this.showDetail(rows[0]);
 527     }
 528
 529     showHoldsForTitle(rows: any[]) {
 530         if (rows.length === 0) { return; }
 531
 532         const url = this.ngLocation.prepareExternalUrl(
 533             `/staff/catalog/record/${rows[0].record_id}/holds`);
 534
 535         window.open(url, '_blank');
 536     }
 537
 538     showDetail(row: any) {
 539         if (row) {
 540             this.mode = 'detail';
 541             this.detailHold = row;
 542         }
 543     }
 544
 545     showManager(rows: any[]) {
 546         if (rows.length) {
 547             this.mode = 'manage';
 548             this.editHolds = rows.map(r => r.id);
 549         }
 550     }
 551
 552     handleModify(rowsModified: boolean) {
 553         this.mode = 'list';
 554
 555         if (rowsModified) {
 556             // give the grid a chance to render then ask it to reload
 557             setTimeout(() => this.holdsGrid.reload());
 558         }
 559     }
 560
 561
 562
 563     showRecentCircs(rows: any[]) {
 564         const copyIds = Array.from(new Set( rows.map(r => r.cp_id).filter( cp_id => Boolean(cp_id)) ));
 565         copyIds.forEach( copyId => {
 566             const url =
 567                 '/eg/staff/cat/item/' + copyId + '/circ_list';
 568             window.open(url, '_blank');
 569         });
 570     }
 571
 572     showPatron(rows: any[]) {
 573         const usrIds = Array.from(new Set( rows.map(r => r.usr_id).filter( usr_id => Boolean(usr_id)) ));
 574         usrIds.forEach( usrId => {
 575             const url =
 576                 '/eg/staff/circ/patron/' + usrId + '/checkout';
 577             window.open(url, '_blank');
 578         });
 579     }
 580
 581     showOrder(rows: any[]) {
 582         // Doesn't work in Typescript currently without compiler option:
 583         //   const bibIds = [...new Set( rows.map(r => r.record_id) )];
 584         const bibIds = Array.from(
 585           new Set( rows.filter(r => r.hold_type !== 'M').map(r => r.record_id) ));
 586         bibIds.forEach( bibId => {
 587           const url =
 588               '/eg/staff/acq/legacy/lineitem/related/' + bibId + '?target=bib';
 589           window.open(url, '_blank');
 590         });
 591     }
 592
 593     addVolume(rows: any[]) {
 594         const bibIds = Array.from(
 595           new Set( rows.filter(r => r.hold_type !== 'M').map(r => r.record_id) ));
 596         bibIds.forEach( bibId => {
 597           this.holdings.spawnAddHoldingsUi(bibId);
 598         });
 599     }
 600
 601     showTitle(rows: any[]) {
 602         const bibIds = Array.from(new Set( rows.map(r => r.record_id) ));
 603         bibIds.forEach( bibId => {
 604           // const url = '/eg/staff/cat/catalog/record/' + bibId;
 605           const url = '/eg2/staff/catalog/record/' + bibId;
 606           window.open(url, '_blank');
 607         });
 608     }
 609
 610     showManageDialog(rows: any[]) {
 611         const holdIds = rows.map(r => r.id).filter(id => Boolean(id));
 612         if (holdIds.length > 0) {
 613             this.manageDialog.holdIds = holdIds;
 614             this.manageDialog.open({size: 'lg'}).subscribe(
 615                 rowsModified => {
 616                     if (rowsModified) {
 617                         this.holdsGrid.reload();
 618                     }
 619                 }
 620             );
 621         }
 622     }
 623
 624     showTransferDialog(rows: any[]) {
 625         const holdIds = rows.filter(r => r.hold_type === 'T').map(r => r.id).filter(id => Boolean(id));
 626         if (holdIds.length > 0) {
 627             this.transferDialog.holdIds = holdIds;
 628             this.transferDialog.open({}).subscribe(
 629                 rowsModified => {
 630                     if (rowsModified) {
 631                         this.holdsGrid.reload();
 632                     }
 633                 }
 634             );
 635         }
 636     }
 637
 638     async showMarkDamagedDialog(rows: any[]) {
 639         const copyIds = rows.map(r => r.cp_id).filter(id => Boolean(id));
 640         if (copyIds.length === 0) { return; }
 641
 642         let rowsModified = false;
 643
 644         const markNext = async(ids: number[]) => {
 645             if (ids.length === 0) {
 646                 return Promise.resolve();
 647             }
 648
 649             this.markDamagedDialog.copyId = ids.pop();
 650             return this.markDamagedDialog.open({size: 'lg'}).subscribe(
 651                 ok => {
 652                     if (ok) { rowsModified = true; }
 653                     return markNext(ids);
 654                 },
 655                 dismiss => markNext(ids)
 656             );
 657         };
 658
 659         await markNext(copyIds);
 660         if (rowsModified) {
 661             this.holdsGrid.reload();
 662         }
 663     }
 664
 665     showMarkMissingDialog(rows: any[]) {
 666         const copyIds = rows.map(r => r.cp_id).filter(id => Boolean(id));
 667         if (copyIds.length > 0) {
 668             this.markMissingDialog.copyIds = copyIds;
 669             this.markMissingDialog.open({}).subscribe(
 670                 rowsModified => {
 671                     if (rowsModified) {
 672                         this.holdsGrid.reload();
 673                     }
 674                 }
 675             );
 676         }
 677     }
 678
 679     showMarkDiscardDialog(rows: any[]) {
 680         const copyIds = rows.map(r => r.cp_id).filter(id => Boolean(id));
 681         if (copyIds.length > 0) {
 682             this.markDiscardDialog.copyIds = copyIds;
 683             this.markDiscardDialog.open({}).subscribe(
 684                 rowsModified => {
 685                     if (rowsModified) {
 686                         this.holdsGrid.reload();
 687                     }
 688                 }
 689             );
 690         }
 691     }
 692
 693
 694     showRetargetDialog(rows: any[]) {
 695         const holdIds = rows.map(r => r.id).filter(id => Boolean(id));
 696         if (holdIds.length > 0) {
 697             this.retargetDialog.holdIds = holdIds;
 698             this.retargetDialog.open({}).subscribe(
 699                 rowsModified => {
 700                     if (rowsModified) {
 701                         this.holdsGrid.reload();
 702                     }
 703                 }
 704             );
 705         }
 706     }
 707
 708     showCancelDialog(rows: any[]) {
 709         const holdIds = rows.map(r => r.id).filter(id => Boolean(id));
 710         if (holdIds.length > 0) {
 711             this.cancelDialog.holdIds = holdIds;
 712             this.cancelDialog.open({}).subscribe(
 713                 rowsModified => {
 714                     if (rowsModified) {
 715                         this.holdsGrid.reload();
 716                     }
 717                 }
 718             );
 719         }
 720     }
 721
 722     showUncancelDialog(rows: any[]) {
 723         const holdIds = rows.map(r => r.id).filter(id => Boolean(id));
 724         if (holdIds.length === 0) { return; }
 725         this.uncancelHoldCount = holdIds.length;
 726
 727         this.uncancelDialog.open().subscribe(confirmed => {
 728             if (!confirmed) { return; }
 729             this.progressDialog.open();
 730
 731             from(holdIds).pipe(concatMap(holdId => {
 732                 return this.net.request(
 733                     'open-ils.circ',
 734                     'open-ils.circ.hold.uncancel',
 735                     this.auth.token(), holdId
 736                 );
 737             })).subscribe(
 738                 resp => {
 739                     if (Number(resp) !== 1) {
 740                         console.error('Failed uncanceling hold', resp);
 741                     }
 742                 },
 743                 null,
 744                 () => {
 745                     this.progressDialog.close();
 746                     this.holdsGrid.reload();
 747                 }
 748             );
 749         });
 750     }
 751
 752     printHolds() {
 753         // Request a page with no limit to get all of the wide holds for
 754         // printing.  Call requestPage() directly instead of grid.reload()
 755         // since we may already have the data.
 756
 757         const pager = new Pager();
 758         pager.offset = 0;
 759         pager.limit = null;
 760
 761         if (this.gridDataSource.sort.length === 0) {
 762             this.gridDataSource.sort = this.defaultSort;
 763         }
 764
 765         this.gridDataSource.requestPage(pager).then(() => {
 766             if (this.gridDataSource.data.length > 0) {
 767                 this.printer.print({
 768                     templateName: this.printTemplate || 'holds_for_bib',
 769                     contextData: this.gridDataSource.data,
 770                     printContext: 'default'
 771                 });
 772             }
 773         });
 774     }
 775
 776     isCopyHold(holdData: any): boolean {
 777         if (holdData && holdData.hold_type) {
 778             return holdData.hold_type.match(/C|R|F/) !== null;
 779         }
 780         return false;
 781     }
 782 }
 783
 784
 785
 786