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

   1 import {Component, OnInit, Input, ViewChild} from '@angular/core';
   2 import {Observable, Observer, of} from 'rxjs';
   3 import {IdlObject} from '@eg/core/idl.service';
   4 import {NetService} from '@eg/core/net.service';
   5 import {OrgService} from '@eg/core/org.service';
   6 import {AuthService} from '@eg/core/auth.service';
   7 import {Pager} from '@eg/share/util/pager';
   8 import {ServerStoreService} from '@eg/core/server-store.service';
   9 import {GridDataSource, GridColumn, GridCellTextGenerator} from '@eg/share/grid/grid';
  10 import {GridComponent} from '@eg/share/grid/grid.component';
  11 import {ProgressDialogComponent} from '@eg/share/dialog/progress.component';
  12 import {MarkDamagedDialogComponent
  13     } from '@eg/staff/share/holdings/mark-damaged-dialog.component';
  14 import {MarkMissingDialogComponent
  15     } from '@eg/staff/share/holdings/mark-missing-dialog.component';
  16 import {HoldRetargetDialogComponent
  17     } from '@eg/staff/share/holds/retarget-dialog.component';
  18 import {HoldTransferDialogComponent} from './transfer-dialog.component';
  19 import {HoldCancelDialogComponent} from './cancel-dialog.component';
  20 import {HoldManageDialogComponent} from './manage-dialog.component';
  21 import {PrintService} from '@eg/share/print/print.service';
  22
  23 /** Holds grid with access to detail page and other actions */
  24
  25 @Component({
  26   selector: 'eg-holds-grid',
  27   templateUrl: 'grid.component.html'
  28 })
  29 export class HoldsGridComponent implements OnInit {
  30
  31     // If either are set/true, the pickup lib selector will display
  32     @Input() initialPickupLib: number | IdlObject;
  33     @Input() hidePickupLibFilter: boolean;
  34
  35     // Grid persist key
  36     @Input() persistKey: string;
  37
  38     @Input() preFetchSetting: string;
  39
  40     @Input() printTemplate: string;
  41
  42     // If set, all holds are fetched on grid load and sorting/paging all
  43     // happens in the client.  If false, sorting and paging occur on
  44     // the server.
  45     enablePreFetch: boolean;
  46
  47     // How to sort when no sort parameters have been applied
  48     // via grid controls.  This uses the eg-grid sort format:
  49     // [{name: fname, dir: 'asc'}, {name: fname2, dir: 'desc'}]
  50     @Input() defaultSort: any[];
  51
  52     mode: 'list' | 'detail' | 'manage' = 'list';
  53     initDone = false;
  54     holdsCount: number;
  55     pickupLib: IdlObject;
  56     plCompLoaded = false;
  57     gridDataSource: GridDataSource;
  58     detailHold: any;
  59     editHolds: number[];
  60     transferTarget: number;
  61
  62     @ViewChild('holdsGrid', { static: false }) private holdsGrid: GridComponent;
  63     @ViewChild('progressDialog', { static: true })
  64         private progressDialog: ProgressDialogComponent;
  65     @ViewChild('transferDialog', { static: true })
  66         private transferDialog: HoldTransferDialogComponent;
  67     @ViewChild('markDamagedDialog', { static: true })
  68         private markDamagedDialog: MarkDamagedDialogComponent;
  69     @ViewChild('markMissingDialog', { static: true })
  70         private markMissingDialog: MarkMissingDialogComponent;
  71     @ViewChild('retargetDialog', { static: true })
  72         private retargetDialog: HoldRetargetDialogComponent;
  73     @ViewChild('cancelDialog', { static: true })
  74         private cancelDialog: HoldCancelDialogComponent;
  75     @ViewChild('manageDialog', { static: true })
  76         private manageDialog: HoldManageDialogComponent;
  77
  78     // Bib record ID.
  79     _recordId: number;
  80     @Input() set recordId(id: number) {
  81         this._recordId = id;
  82         if (this.initDone) { // reload on update
  83             this.holdsGrid.reload();
  84         }
  85     }
  86
  87     _userId: number;
  88     @Input() set userId(id: number) {
  89         this._userId = id;
  90         if (this.initDone) {
  91             this.holdsGrid.reload();
  92         }
  93     }
  94
  95     // Include holds canceled on or after the provided date.
  96     // If no value is passed, canceled holds are not displayed.
  97     _showCanceledSince: Date;
  98     @Input() set showCanceledSince(show: Date) {
  99         this._showCanceledSince = show;
 100         if (this.initDone) { // reload on update
 101             this.holdsGrid.reload();
 102         }
 103     }
 104
 105     // Include holds fulfilled on or after hte provided date.
 106     // If no value is passed, fulfilled holds are not displayed.
 107     _showFulfilledSince: Date;
 108     @Input() set showFulfilledSince(show: Date) {
 109         this._showFulfilledSince = show;
 110         if (this.initDone) { // reload on update
 111             this.holdsGrid.reload();
 112         }
 113     }
 114
 115     cellTextGenerator: GridCellTextGenerator;
 116
 117     constructor(
 118         private net: NetService,
 119         private org: OrgService,
 120         private store: ServerStoreService,
 121         private auth: AuthService,
 122         private printer: PrintService
 123     ) {
 124         this.gridDataSource = new GridDataSource();
 125         this.enablePreFetch = null;
 126     }
 127
 128     ngOnInit() {
 129         this.initDone = true;
 130         this.pickupLib = this.org.get(this.initialPickupLib);
 131
 132         if (this.preFetchSetting) {
 133             this.store.getItem(this.preFetchSetting).then(
 134                 applied => this.enablePreFetch = Boolean(applied)
 135             );
 136         }
 137
 138         if (!this.defaultSort) {
 139             this.defaultSort = [{name: 'request_time', dir: 'asc'}];
 140         }
 141
 142         this.gridDataSource.getRows = (pager: Pager, sort: any[]) => {
 143
 144             if (!this.hidePickupLibFilter && !this.plCompLoaded) {
 145                 // When the pickup lib selector is active, avoid any
 146                 // data fetches until it has settled on a default value.
 147                 // Once the final value is applied, its onchange will
 148                 // fire and we'll be back here with plCompLoaded=true.
 149                 return of([]);
 150             }
 151
 152             sort = sort.length > 0 ? sort : this.defaultSort;
 153             return this.fetchHolds(pager, sort);
 154         };
 155
 156         // Text-ify function for cells that use display templates.
 157         this.cellTextGenerator = {
 158             title: row => row.title,
 159             cp_barcode: row => (row.cp_barcode == null) ? '' : row.cp_barcode,
 160             patron_barcode: row => row.ucard_barcode
 161         };
 162     }
 163
 164     // Returns true after all data/settings/etc required to render the
 165     // grid have been fetched.
 166     initComplete(): boolean {
 167         return this.enablePreFetch !== null;
 168     }
 169
 170     pickupLibChanged(org: IdlObject) {
 171         this.pickupLib = org;
 172         this.holdsGrid.reload();
 173     }
 174
 175     preFetchHolds(apply: boolean) {
 176         this.enablePreFetch = apply;
 177
 178         if (apply) {
 179             setTimeout(() => this.holdsGrid.reload());
 180         }
 181
 182         if (this.preFetchSetting) {
 183             // fire and forget
 184             this.store.setItem(this.preFetchSetting, apply);
 185         }
 186     }
 187
 188     applyFilters(): any {
 189         const filters: any = {
 190             is_staff_request: true,
 191             fulfillment_time: this._showFulfilledSince ?
 192                 this._showFulfilledSince.toISOString() : null,
 193             cancel_time: this._showCanceledSince ?
 194                 this._showCanceledSince.toISOString() : null,
 195         };
 196
 197         if (this.pickupLib) {
 198             filters.pickup_lib =
 199                 this.org.descendants(this.pickupLib, true);
 200         }
 201
 202         if (this._recordId) {
 203             filters.record_id = this._recordId;
 204         }
 205
 206         if (this._userId) {
 207             filters.usr_id = this._userId;
 208         }
 209
 210         return filters;
 211     }
 212
 213     fetchHolds(pager: Pager, sort: any[]): Observable<any> {
 214
 215         // We need at least one filter.
 216         if (!this._recordId && !this.pickupLib && !this._userId) {
 217             return of([]);
 218         }
 219
 220         const filters = this.applyFilters();
 221
 222         const orderBy: any = [];
 223         if (sort.length > 0) {
 224             sort.forEach(obj => {
 225                 const subObj: any = {};
 226                 subObj[obj.name] = {dir: obj.dir, nulls: 'last'};
 227                 orderBy.push(subObj);
 228             });
 229         }
 230
 231         const limit = this.enablePreFetch ? null : pager.limit;
 232         const offset = this.enablePreFetch ? 0 : pager.offset;
 233
 234         let observer: Observer<any>;
 235         const observable = new Observable(obs => observer = obs);
 236
 237         this.progressDialog.open();
 238         this.progressDialog.update({value: 0, max: 1});
 239         let first = true;
 240         let loadCount = 0;
 241         this.net.request(
 242             'open-ils.circ',
 243             'open-ils.circ.hold.wide_hash.stream',
 244             this.auth.token(), filters, orderBy, limit, offset
 245         ).subscribe(
 246             holdData => {
 247
 248                 if (first) { // First response is the hold count.
 249                     this.holdsCount = Number(holdData);
 250                     first = false;
 251
 252                 } else { // Subsequent responses are hold data blobs
 253
 254                     this.progressDialog.update(
 255                         {value: ++loadCount, max: this.holdsCount});
 256
 257                     observer.next(holdData);
 258                 }
 259             },
 260             err => {
 261                 this.progressDialog.close();
 262                 observer.error(err);
 263             },
 264             ()  => {
 265                 this.progressDialog.close();
 266                 observer.complete();
 267             }
 268         );
 269
 270         return observable;
 271     }
 272
 273     showDetails(rows: any[]) {
 274         this.showDetail(rows[0]);
 275     }
 276
 277     showDetail(row: any) {
 278         if (row) {
 279             this.mode = 'detail';
 280             this.detailHold = row;
 281         }
 282     }
 283
 284     showManager(rows: any[]) {
 285         if (rows.length) {
 286             this.mode = 'manage';
 287             this.editHolds = rows.map(r => r.id);
 288         }
 289     }
 290
 291     handleModify(rowsModified: boolean) {
 292         this.mode = 'list';
 293
 294         if (rowsModified) {
 295             // give the grid a chance to render then ask it to reload
 296             setTimeout(() => this.holdsGrid.reload());
 297         }
 298     }
 299
 300
 301
 302     showRecentCircs(rows: any[]) {
 303         if (rows.length) {
 304             const url =
 305                 '/eg/staff/cat/item/' + rows[0].cp_id + '/circ_list';
 306             window.open(url, '_blank');
 307         }
 308     }
 309
 310     showPatron(rows: any[]) {
 311         if (rows.length) {
 312             const url =
 313                 '/eg/staff/circ/patron/' + rows[0].usr_id + '/checkout';
 314             window.open(url, '_blank');
 315         }
 316     }
 317
 318     showManageDialog(rows: any[]) {
 319         const holdIds = rows.map(r => r.id).filter(id => Boolean(id));
 320         if (holdIds.length > 0) {
 321             this.manageDialog.holdIds = holdIds;
 322             this.manageDialog.open({size: 'lg'}).subscribe(
 323                 rowsModified => {
 324                     if (rowsModified) {
 325                         this.holdsGrid.reload();
 326                     }
 327                 }
 328             );
 329         }
 330     }
 331
 332     showTransferDialog(rows: any[]) {
 333         const holdIds = rows.map(r => r.id).filter(id => Boolean(id));
 334         if (holdIds.length > 0) {
 335             this.transferDialog.holdIds = holdIds;
 336             this.transferDialog.open({}).subscribe(
 337                 rowsModified => {
 338                     if (rowsModified) {
 339                         this.holdsGrid.reload();
 340                     }
 341                 }
 342             );
 343         }
 344     }
 345
 346     async showMarkDamagedDialog(rows: any[]) {
 347         const copyIds = rows.map(r => r.cp_id).filter(id => Boolean(id));
 348         if (copyIds.length === 0) { return; }
 349
 350         let rowsModified = false;
 351
 352         const markNext = async(ids: number[]) => {
 353             if (ids.length === 0) {
 354                 return Promise.resolve();
 355             }
 356
 357             this.markDamagedDialog.copyId = ids.pop();
 358             return this.markDamagedDialog.open({size: 'lg'}).subscribe(
 359                 ok => {
 360                     if (ok) { rowsModified = true; }
 361                     return markNext(ids);
 362                 },
 363                 dismiss => markNext(ids)
 364             );
 365         };
 366
 367         await markNext(copyIds);
 368         if (rowsModified) {
 369             this.holdsGrid.reload();
 370         }
 371     }
 372
 373     showMarkMissingDialog(rows: any[]) {
 374         const copyIds = rows.map(r => r.cp_id).filter(id => Boolean(id));
 375         if (copyIds.length > 0) {
 376             this.markMissingDialog.copyIds = copyIds;
 377             this.markMissingDialog.open({}).subscribe(
 378                 rowsModified => {
 379                     if (rowsModified) {
 380                         this.holdsGrid.reload();
 381                     }
 382                 }
 383             );
 384         }
 385     }
 386
 387     showRetargetDialog(rows: any[]) {
 388         const holdIds = rows.map(r => r.id).filter(id => Boolean(id));
 389         if (holdIds.length > 0) {
 390             this.retargetDialog.holdIds = holdIds;
 391             this.retargetDialog.open({}).subscribe(
 392                 rowsModified => {
 393                     if (rowsModified) {
 394                         this.holdsGrid.reload();
 395                     }
 396                 }
 397             );
 398         }
 399     }
 400
 401     showCancelDialog(rows: any[]) {
 402         const holdIds = rows.map(r => r.id).filter(id => Boolean(id));
 403         if (holdIds.length > 0) {
 404             this.cancelDialog.holdIds = holdIds;
 405             this.cancelDialog.open({}).subscribe(
 406                 rowsModified => {
 407                     if (rowsModified) {
 408                         this.holdsGrid.reload();
 409                     }
 410                 }
 411             );
 412         }
 413     }
 414
 415     printHolds() {
 416         // Request a page with no limit to get all of the wide holds for
 417         // printing.  Call requestPage() directly instead of grid.reload()
 418         // since we may already have the data.
 419
 420         const pager = new Pager();
 421         pager.offset = 0;
 422         pager.limit = null;
 423
 424         if (this.gridDataSource.sort.length === 0) {
 425             this.gridDataSource.sort = this.defaultSort;
 426         }
 427
 428         this.gridDataSource.requestPage(pager).then(() => {
 429             if (this.gridDataSource.data.length > 0) {
 430                 this.printer.print({
 431                     templateName: this.printTemplate || 'holds_for_bib',
 432                     contextData: this.gridDataSource.data,
 433                     printContext: 'default'
 434                 });
 435             }
 436         });
 437     }
 438 }
 439
 440
 441
 442