Open-ILS/web/js/ui/default/circ/selfcheck/selfcheck.js

   1 dojo.require('dojo.date.locale');
   2 dojo.require('dojo.cookie');
   3 dojo.require('dojo.date.stamp');
   4 dojo.require('dijit.form.CheckBox');
   5 dojo.require('dijit.form.NumberSpinner');
   6 dojo.require('openils.CGI');
   7 dojo.require('openils.Util');
   8 dojo.require('openils.User');
   9 dojo.require('openils.Event');
  10 dojo.require('openils.widget.ProgressDialog');
  11 dojo.require('openils.widget.OrgUnitFilteringSelect');
  12
  13
  14 dojo.requireLocalization('openils.circ', 'selfcheck');
  15 var localeStrings = dojo.i18n.getLocalization('openils.circ', 'selfcheck');
  16
  17 // set patron timeout default
  18 var patronTimeout = 180000; /* 3 minutes */
  19 var timerId = null;
  20
  21 const SET_BARCODE_REGEX = 'opac.barcode_regex';
  22 const SET_PATRON_TIMEOUT = 'circ.selfcheck.patron_login_timeout';
  23 const SET_AUTO_OVERRIDE_EVENTS = 'circ.selfcheck.auto_override_checkout_events';
  24 const SET_PATRON_PASSWORD_REQUIRED = 'circ.selfcheck.patron_password_required';
  25 const SET_AUTO_RENEW_INTERVAL = 'circ.checkout_auto_renew_age';
  26 const SET_WORKSTATION_REQUIRED = 'circ.selfcheck.workstation_required';
  27 const SET_ALERT_POPUP = 'circ.selfcheck.alert.popup';
  28 const SET_ALERT_SOUND = 'circ.selfcheck.alert.sound';
  29 const SET_CC_PAYMENT_ALLOWED = 'credit.payments.allow';
  30 // This setting only comes into play if COPY_NOT_AVAILABLE is in the SET_AUTO_OVERRIDE_EVENTS list
  31 const SET_BLOCK_CHECKOUT_ON_COPY_STATUS = 'circ.selfcheck.block_checkout_on_copy_status';
  32
  33 // set before the login dialog is rendered
  34 openils.User.default_login_agent = 'selfcheck';
  35
  36 // start the logout timer
  37 function selfckStartTimer() {
  38     timerId = setTimeout(
  39         function() {
  40             SelfCheckManager.prototype.logoutPatron();
  41         },
  42         patronTimeout
  43     );
  44 }
  45
  46 // reset the logout timer
  47 function selfckResetTimer() {
  48     clearTimeout(timerId);
  49     selfckStartTimer();
  50 }
  51
  52 function SelfCheckManager() {
  53
  54     this.cgi = new openils.CGI();
  55     this.staff = null;
  56     this.workstation = null;
  57     this.authtoken = null;
  58
  59     this.patron = null;
  60     this.patronBarcodeRegex = null;
  61
  62     this.checkouts = [];
  63     this.itemsOut = [];
  64
  65     // During renewals, keep track of the ID of the previous circulation.
  66     // Previous circ is used for tracking failed renewals (for receipts).
  67     this.prevCirc = null;
  68
  69     // current item barcode
  70     this.itemBarcode = null;
  71
  72     // are we currently performing a renewal?
  73     this.isRenewal = false;
  74
  75     // dict of org unit settings for "here"
  76     this.orgSettings = {};
  77
  78     // Construct a mock checkout for debugging purposes
  79     if(this.mockCheckouts = this.cgi.param('mock-circ')) {
  80
  81         this.mockCheckout = {
  82             payload : {
  83                 record : new fieldmapper.mvr(),
  84                 copy : new fieldmapper.acp(),
  85                 circ : new fieldmapper.circ()
  86             }
  87         };
  88
  89         this.mockCheckout.payload.record.title('Jazz improvisation for guitar');
  90         this.mockCheckout.payload.record.author('Wise, Les');
  91         this.mockCheckout.payload.record.isbn('0634033565');
  92         this.mockCheckout.payload.copy.barcode('123456789');
  93         this.mockCheckout.payload.circ.renewal_remaining(1);
  94         this.mockCheckout.payload.circ.parent_circ(1);
  95         this.mockCheckout.payload.circ.due_date('2012-12-21');
  96     }
  97
  98     this.initPrinter();
  99 }
 100
 101 SelfCheckManager.prototype.setupStaffLogin = function(verify) {
 102
 103     if(verify) oilsSetupUser();
 104     this.staff = openils.User.user;
 105     this.workstation = openils.User.workstation;
 106     this.authtoken = openils.User.authtoken;
 107 }
 108
 109
 110
 111 /**
 112  * Fetch the org-unit settings, initialize the display, etc.
 113  */
 114 SelfCheckManager.prototype.init = function() {
 115
 116     this.setupStaffLogin();
 117     this.loadOrgSettings();
 118
 119     this.circTbody = dojo.byId('oils-selfck-circ-tbody');
 120     this.itemsOutTbody = dojo.byId('oils-selfck-circ-out-tbody');
 121
 122     // workstation is required but none provided
 123     if(this.orgSettings[SET_WORKSTATION_REQUIRED] && !this.workstation) {
 124         if(confirm(dojo.string.substitute(localeStrings.WORKSTATION_REQUIRED))) {
 125             this.registerWorkstation();
 126         }
 127         return;
 128     }
 129
 130     var self = this;
 131     // connect onclick handlers to the various navigation links
 132     var linkHandlers = {
 133         'oils-selfck-hold-details-link' : function() { self.drawHoldsPage(); },
 134         'oils-selfck-view-fines-link' : function() { self.drawFinesPage(); },
 135         'oils-selfck-pay-fines-link' : function() {
 136             self.goToTab("payment");
 137             self.drawPayFinesPage(
 138                 self.patron,
 139                 self.getSelectedFinesTotal(),
 140                 self.getSelectedFineTransactions(),
 141                 function(resp) {
 142                     var evt = openils.Event.parse(resp);
 143                     if(evt) {
 144                         var message = evt + '';
 145                         if(evt.textcode == 'CREDIT_PROCESSOR_DECLINED_TRANSACTION' && evt.payload)
 146                             message += '\n' + evt.payload.error_message;
 147                         if(evt.textcode == 'INVALID_USER_XACT_ID')
 148                             message += '\n' + localeStrings.PAYMENT_INVALID_USER_XACT_ID;
 149                         self.handleAlert(message, true, 'payment-failure');
 150                         return;
 151                     }
 152
 153                     self.patron.last_xact_id(resp.last_xact_id); // update to match latest from server
 154                     self.printPaymentReceipt(
 155                         resp,
 156                         function() {
 157                             self.updateFinesSummary();
 158                             self.drawFinesPage();
 159                         }
 160                     );
 161                 }
 162             );
 163         },
 164         'oils-selfck-nav-home' : function() { self.drawCircPage(); },
 165         'oils-selfck-nav-logout' : function() { self.logoutPatron(); },
 166         'oils-selfck-nav-logout-print' : function() { self.logoutPatron(true); },
 167         'oils-selfck-items-out-details-link' : function() { self.drawItemsOutPage(); },
 168         'oils-selfck-print-list-link' : function() { self.printList(); }
 169     }
 170
 171     for(var id in linkHandlers)
 172         dojo.connect(dojo.byId(id), 'onclick', linkHandlers[id]);
 173
 174
 175     if(this.cgi.param('patron')) {
 176
 177         // Patron barcode via cgi param.  Mainly used for debugging and
 178         // only works if password is not required by policy
 179         this.loginPatron(this.cgi.param('patron'));
 180
 181     } else {
 182         this.drawLoginPage();
 183     }
 184
 185     /**
 186      * To test printing, pass a URL param of 'testprint'.  The value for the param
 187      * should be a JSON string like so:  [{circ:<circ_id>}, ...]
 188      */
 189     var testPrint = this.cgi.param('testprint');
 190     if(testPrint) {
 191         this.checkouts = JSON2js(testPrint);
 192         this.printSessionReceipt();
 193         this.checkouts = [];
 194     }
 195 }
 196
 197
 198 SelfCheckManager.prototype.getSelectedFinesTotal = function() {
 199     var total = 0;
 200     dojo.forEach(
 201         dojo.query("[name=selector]", this.finesTbody),
 202         function(input) {
 203             if(input.checked)
 204                 total += Number(input.getAttribute("balance_owed"));
 205         }
 206     );
 207     return total.toFixed(2);
 208 };
 209
 210 SelfCheckManager.prototype.getSelectedFineTransactions = function() {
 211     return dojo.query("[name=selector]", this.finesTbody).
 212         filter(function (o) { return o.checked }).
 213         map(
 214             function (o) {
 215                 return [
 216                     o.getAttribute("xact"),
 217                     Number(o.getAttribute("balance_owed")).toFixed(2)
 218                 ];
 219             }
 220         );
 221 };
 222
 223 /**
 224  * Registers a new workstion
 225  */
 226 SelfCheckManager.prototype.registerWorkstation = function() {
 227
 228     oilsSelfckWsDialog.show();
 229
 230     new openils.User().buildPermOrgSelector(
 231         'REGISTER_WORKSTATION',
 232         oilsSelfckWsLocSelector,
 233         this.staff.home_ou()
 234     );
 235
 236
 237     var self = this;
 238     dojo.connect(oilsSelfckWsSubmit, 'onClick',
 239
 240         function() {
 241             oilsSelfckWsDialog.hide();
 242             var name = oilsSelfckWsLocSelector.attr('displayedValue') + '-' + oilsSelfckWsName.attr('value');
 243
 244             var res = fieldmapper.standardRequest(
 245                 ['open-ils.actor', 'open-ils.actor.workstation.register'],
 246                 { params : [
 247                         self.authtoken, name, oilsSelfckWsLocSelector.attr('value')
 248                     ]
 249                 }
 250             );
 251
 252             if(evt = openils.Event.parse(res)) {
 253                 if(evt.textcode == 'WORKSTATION_NAME_EXISTS') {
 254                     if(confirm(localeStrings.WORKSTATION_EXISTS)) {
 255                         location.href = location.href.replace(/\?.*/, '') + '?ws=' + name;
 256                     } else {
 257                         self.registerWorkstation();
 258                     }
 259                     return;
 260                 } else {
 261                     alert(evt);
 262                 }
 263             } else {
 264                 location.href = location.href.replace(/\?.*/, '') + '?ws=' + name;
 265             }
 266         }
 267     );
 268 }
 269
 270 /**
 271  * Loads the org unit settings
 272  */
 273 SelfCheckManager.prototype.loadOrgSettings = function() {
 274
 275     var settings = fieldmapper.aou.fetchOrgSettingBatch(
 276         this.staff.ws_ou(), [
 277             SET_BARCODE_REGEX,
 278             SET_PATRON_TIMEOUT,
 279             SET_ALERT_POPUP,
 280             SET_ALERT_SOUND,
 281             SET_AUTO_OVERRIDE_EVENTS,
 282             SET_BLOCK_CHECKOUT_ON_COPY_STATUS,
 283             SET_PATRON_PASSWORD_REQUIRED,
 284             SET_AUTO_RENEW_INTERVAL,
 285             SET_WORKSTATION_REQUIRED,
 286             SET_CC_PAYMENT_ALLOWED
 287         ]
 288     );
 289
 290     for(k in settings) {
 291         if(settings[k])
 292             this.orgSettings[k] = settings[k].value;
 293     }
 294
 295     if(settings[SET_BARCODE_REGEX])
 296         this.patronBarcodeRegex = new RegExp(settings[SET_BARCODE_REGEX].value);
 297
 298     if(settings[SET_PATRON_TIMEOUT])
 299         patronTimeout = parseInt(settings[SET_PATRON_TIMEOUT].value) * 1000;
 300 }
 301
 302 SelfCheckManager.prototype.drawLoginPage = function() {
 303     var self = this;
 304
 305     var bcHandler = function(barcode_or_usrname) {
 306         // handle patron barcode/usrname entry
 307
 308         if(self.orgSettings[SET_PATRON_PASSWORD_REQUIRED]) {
 309
 310             // password is required.  wire up the scan box to read it
 311             self.updateScanBox({
 312                 msg : localeStrings.ENTER_PASSWORD,
 313                 handler : function(pw) { self.loginPatron(barcode_or_usrname, pw); },
 314                 password : true
 315             });
 316
 317         } else {
 318             // password is not required, go ahead and login
 319             self.loginPatron(barcode_or_usrname);
 320         }
 321     };
 322
 323     this.updateScanBox({
 324         msg : localeStrings.PLEASE_LOGIN,
 325         handler : bcHandler
 326     });
 327 }
 328
 329 /**
 330  * Login the patron.
 331  */
 332 SelfCheckManager.prototype.loginPatron = function(barcode_or_usrname, passwd) {
 333
 334     // reset timeout
 335     selfckResetTimer();
 336
 337     this.setupStaffLogin(true); // verify still valid
 338
 339     var barcode = null;
 340     var usrname = null;
 341     console.log('testing ' + barcode_or_usrname);
 342     if (barcode_or_usrname.match(this.patronBarcodeRegex)) {
 343         console.log('barcode');
 344         barcode = barcode_or_usrname;
 345     } else {
 346         console.log('usrname');
 347         usrname = barcode_or_usrname;
 348     }
 349
 350     if(this.orgSettings[SET_PATRON_PASSWORD_REQUIRED]) {
 351
 352         if(!passwd) {
 353             // would only happen in dev/debug mode when using the patron= param
 354             alert('password required by org setting.  remove patron= from URL');
 355             return;
 356         }
 357
 358         // patron password is required.  Verify it.
 359
 360         var self = this;
 361         new openils.User().auth_verify(
 362             {   username : usrname, barcode : barcode,
 363                 type : 'opac', passwd : passwd, agent : 'selfcheck' },
 364             function(OK) {
 365                 if (OK) {
 366                     self.fetchPatron(barcode, usrname);
 367
 368                 } else {
 369                     // auth verify failed
 370                     self.handleAlert(
 371                         dojo.string.substitute(localeStrings.LOGIN_FAILED, [barcode_or_usrname]),
 372                         false, 'login-failure'
 373                     );
 374                     self.drawLoginPage();
 375                 }
 376             }
 377         );
 378
 379     } else {
 380         this.fetchPatron(barcode, usrname);
 381     }
 382 };
 383
 384 SelfCheckManager.prototype.fetchPatron = function(barcode, usrname) {
 385
 386     var patron_id = fieldmapper.standardRequest(
 387         ['open-ils.actor', 'open-ils.actor.user.retrieve_id_by_barcode_or_username'],
 388         {params : [this.authtoken, barcode, usrname]}
 389     );
 390
 391     // retrieve the fleshed user by id
 392     this.patron = fieldmapper.standardRequest(
 393         ['open-ils.actor', 'open-ils.actor.user.fleshed.retrieve.authoritative'],
 394         {params : [this.authtoken, patron_id]}
 395     );
 396
 397     var evt = openils.Event.parse(this.patron);
 398
 399     // verify validity of the card used to log in
 400     var inactiveCard = false;
 401     if(!evt) {
 402         var card;
 403         if (barcode) {
 404             card = this.patron.cards().filter(
 405                 function(c) { return (c.barcode() == barcode); })[0];
 406         } else {
 407             card = this.patron.card();
 408         }
 409         inactiveCard = !openils.Util.isTrue(card.active());
 410     }
 411
 412     if(evt || inactiveCard) {
 413         this.handleAlert(
 414             dojo.string.substitute(localeStrings.LOGIN_FAILED, [barcode || usrname]),
 415             false, 'login-failure'
 416         );
 417         this.drawLoginPage();
 418
 419     } else {
 420
 421         this.handleAlert('', false, 'login-success');
 422         dojo.byId('oils-selfck-user-banner').innerHTML =
 423             dojo.string.substitute(localeStrings.WELCOME_BANNER, [this.patron.first_given_name()]);
 424         this.drawCircPage();
 425     }
 426 }
 427
 428
 429 SelfCheckManager.prototype.handleAlert = function(message, shouldPopup, sound) {
 430
 431     console.log("Handling alert " + message);
 432
 433     dojo.byId('oils-selfck-status-div').innerHTML = message;
 434
 435     if(shouldPopup)
 436         openils.Util.addCSSClass( dojo.byId('oils-selfck-status-div'), 'checkout_failure' );
 437     else
 438         openils.Util.removeCSSClass( dojo.byId('oils-selfck-status-div'), 'checkout_failure' );
 439
 440     if(shouldPopup && this.orgSettings[SET_ALERT_POPUP])
 441         alert(message);
 442
 443     if(sound && this.orgSettings[SET_ALERT_SOUND])
 444         openils.Util.playAudioUrl(SelfCheckManager.audioConfig[sound]);
 445 }
 446
 447
 448 /**
 449  * Manages the main input box
 450  * @param msg The context message to display with the box
 451  * @param clearOnly Don't update the context message, just clear the value and re-focus
 452  * @param handler Optional "on-enter" handler.
 453  */
 454 SelfCheckManager.prototype.updateScanBox = function(args) {
 455     args = args || {};
 456
 457     if(args.select) {
 458         selfckScanBox.domNode.select();
 459     } else {
 460         selfckScanBox.attr('value', '');
 461     }
 462
 463     if(args.password) {
 464         selfckScanBox.domNode.setAttribute('type', 'password');
 465     } else {
 466         selfckScanBox.domNode.setAttribute('type', '');
 467     }
 468
 469     if(args.value)
 470         selfckScanBox.attr('value', args.value);
 471
 472     if(args.msg)
 473         dojo.byId('oils-selfck-scan-text').innerHTML = args.msg;
 474
 475     if(selfckScanBox._lastHandler && (args.handler || args.clearHandler)) {
 476         dojo.disconnect(selfckScanBox._lastHandler);
 477     }
 478
 479     if(args.handler) {
 480         selfckScanBox._lastHandler = dojo.connect(
 481             selfckScanBox,
 482             'onKeyDown',
 483             function(e) {
 484                 if(e.keyCode != dojo.keys.ENTER)
 485                     return;
 486                 args.handler(selfckScanBox.attr('value'));
 487             }
 488         );
 489     }
 490
 491     selfckScanBox.focus();
 492 }
 493
 494 /**
 495  *  Sets up the checkout/renewal interface
 496  */
 497 SelfCheckManager.prototype.drawCircPage = function() {
 498
 499     openils.Util.show('oils-selfck-circ-tbody', 'table-row-group');
 500     this.goToTab('checkout');
 501
 502     while(this.itemsOutTbody.childNodes[0])
 503         this.itemsOutTbody.removeChild(this.itemsOutTbody.childNodes[0]);
 504
 505     var self = this;
 506     this.updateScanBox({
 507         msg : localeStrings.ENTER_BARCODE,
 508         handler : function(barcode) { self.checkout(barcode); }
 509     });
 510
 511     if(!this.circTemplate)
 512         this.circTemplate = this.circTbody.removeChild(dojo.byId('oils-selfck-circ-row'));
 513
 514     // fines summary
 515     this.updateFinesSummary();
 516
 517     // holds summary
 518     this.updateHoldsSummary();
 519
 520     // items out summary
 521     this.updateCircSummary();
 522
 523     // render mock checkouts for debugging?
 524     if(this.mockCheckouts) {
 525         for(var i in [1,2,3])
 526             this.displayCheckout(this.mockCheckout, 'checkout');
 527     }
 528 }
 529
 530
 531 SelfCheckManager.prototype.updateFinesSummary = function() {
 532     var self = this;
 533
 534     // fines summary
 535     fieldmapper.standardRequest(
 536         ['open-ils.actor', 'open-ils.actor.user.fines.summary'],
 537         {   async : true,
 538             params : [this.authtoken, this.patron.id()],
 539             oncomplete : function(r) {
 540
 541                 var summary = openils.Util.readResponse(r);
 542
 543                 dojo.byId('oils-selfck-fines-total').innerHTML =
 544                     dojo.string.substitute(
 545                         localeStrings.TOTAL_FINES_ACCOUNT,
 546                         ['<b>' + summary.balance_owed() + '</b>']
 547                     );
 548
 549                 self.creditPayableBalance = summary.balance_owed();
 550             }
 551         }
 552     );
 553 }
 554
 555
 556 SelfCheckManager.prototype.drawItemsOutPage = function() {
 557     openils.Util.hide('oils-selfck-circ-tbody');
 558
 559     this.goToTab('items_out');
 560
 561     while(this.itemsOutTbody.childNodes[0])
 562         this.itemsOutTbody.removeChild(this.itemsOutTbody.childNodes[0]);
 563
 564     progressDialog.show(true);
 565
 566     var self = this;
 567     fieldmapper.standardRequest(
 568         ['open-ils.circ', 'open-ils.circ.actor.user.checked_out.atomic'],
 569         {
 570             async : true,
 571             params : [this.authtoken, this.patron.id()],
 572             oncomplete : function(r) {
 573
 574                 var resp = openils.Util.readResponse(r);
 575
 576                 var circs = resp.sort(
 577                     function(a, b) {
 578                         if(a.circ.due_date() > b.circ.due_date())
 579                             return -1;
 580                         return 1;
 581                     }
 582                 );
 583
 584                 progressDialog.hide();
 585
 586                 self.itemsOut = [];
 587                 dojo.forEach(circs,
 588                     function(circ) {
 589                         self.itemsOut.push(circ.circ.id());
 590                         self.displayCheckout(
 591                             {payload : circ},
 592                             (circ.circ.parent_circ()) ? 'renew' : 'checkout',
 593                             true
 594                         );
 595                     }
 596                 );
 597             }
 598         }
 599     );
 600 }
 601
 602
 603 SelfCheckManager.prototype.goToTab = function(name) {
 604     this.tabName = name;
 605
 606     openils.Util.hide('oils-selfck-fines-page');
 607     openils.Util.hide('oils-selfck-payment-page');
 608     openils.Util.hide('oils-selfck-holds-page');
 609     openils.Util.hide('oils-selfck-circ-page');
 610     openils.Util.hide('oils-selfck-pay-fines-link');
 611
 612     // reset timeout
 613     selfckResetTimer()
 614
 615     switch(name) {
 616         case 'checkout':
 617             openils.Util.show('oils-selfck-circ-page');
 618             break;
 619         case 'items_out':
 620             openils.Util.show('oils-selfck-circ-page');
 621             break;
 622         case 'holds':
 623             openils.Util.show('oils-selfck-holds-page');
 624             break;
 625         case 'fines':
 626             openils.Util.show('oils-selfck-fines-page');
 627             break;
 628         case 'payment':
 629             openils.Util.show('oils-selfck-payment-page');
 630             break;
 631     }
 632 }
 633
 634
 635 SelfCheckManager.prototype.printList = function() {
 636     // reset timeout
 637     selfckResetTimer()
 638
 639     switch(this.tabName) {
 640         case 'checkout':
 641             this.printSessionReceipt();
 642             break;
 643         case 'items_out':
 644             this.printItemsOutReceipt();
 645             break;
 646         case 'holds':
 647             this.printHoldsReceipt();
 648             break;
 649         case 'fines':
 650             this.printFinesReceipt();
 651             break;
 652     }
 653 }
 654
 655 SelfCheckManager.prototype.updateHoldsSummary = function() {
 656
 657     if(!this.holdsSummary) {
 658         var summary = fieldmapper.standardRequest(
 659             ['open-ils.circ', 'open-ils.circ.holds.user_summary'],
 660             {params : [this.authtoken, this.patron.id()]}
 661         );
 662
 663         this.holdsSummary = {};
 664         this.holdsSummary.ready = Number(summary['4']);
 665         this.holdsSummary.total = 0;
 666
 667         for(var i in summary)
 668             this.holdsSummary.total += Number(summary[i]);
 669     }
 670
 671     dojo.byId('oils-selfck-holds-total').innerHTML =
 672         dojo.string.substitute(
 673             localeStrings.TOTAL_HOLDS,
 674             ['<b>' + this.holdsSummary.total + '</b>']
 675         );
 676
 677     dojo.byId('oils-selfck-holds-ready').innerHTML =
 678         dojo.string.substitute(
 679             localeStrings.HOLDS_READY_FOR_PICKUP,
 680             ['<b>' + this.holdsSummary.ready + '</b>']
 681         );
 682 }
 683
 684
 685 SelfCheckManager.prototype.updateCircSummary = function(increment) {
 686
 687     if(!this.circSummary) {
 688
 689         var summary = fieldmapper.standardRequest(
 690             ['open-ils.actor', 'open-ils.actor.user.checked_out.count'],
 691             {params : [this.authtoken, this.patron.id()]}
 692         );
 693
 694         this.circSummary = {
 695             total : Number(summary.out) + Number(summary.overdue),
 696             overdue : Number(summary.overdue),
 697             session : 0
 698         };
 699     }
 700
 701     if(increment) {
 702         // local checkout occurred.  Add to the total and the session.
 703         this.circSummary.total += 1;
 704         this.circSummary.session += 1;
 705     }
 706
 707     dojo.byId('oils-selfck-circ-account-total').innerHTML =
 708         dojo.string.substitute(
 709             localeStrings.TOTAL_ITEMS_ACCOUNT,
 710             ['<b>' + this.circSummary.total + '</b>']
 711         );
 712
 713     dojo.byId('oils-selfck-circ-session-total').innerHTML =
 714         dojo.string.substitute(
 715             localeStrings.TOTAL_ITEMS_SESSION,
 716             ['<b>' + this.circSummary.session + '</b>']
 717         );
 718 }
 719
 720
 721 SelfCheckManager.prototype.drawHoldsPage = function() {
 722
 723     // TODO add option to hid scanBox
 724     // this.updateScanBox(...)
 725
 726     this.goToTab('holds');
 727
 728     this.holdTbody = dojo.byId('oils-selfck-hold-tbody');
 729     if(!this.holdTemplate)
 730         this.holdTemplate = this.holdTbody.removeChild(dojo.byId('oils-selfck-hold-row'));
 731     while(this.holdTbody.childNodes[0])
 732         this.holdTbody.removeChild(this.holdTbody.childNodes[0]);
 733
 734     progressDialog.show(true);
 735
 736     var self = this;
 737     fieldmapper.standardRequest( // fetch the hold IDs
 738
 739         ['open-ils.circ', 'open-ils.circ.holds.id_list.retrieve'],
 740         {   async : true,
 741             params : [this.authtoken, this.patron.id()],
 742
 743             oncomplete : function(r) {
 744                 var ids = openils.Util.readResponse(r);
 745                 if(!ids || ids.length == 0) {
 746                     progressDialog.hide();
 747                     return;
 748                 }
 749
 750                 fieldmapper.standardRequest( // fetch the hold objects with fleshed details
 751                     ['open-ils.circ', 'open-ils.circ.hold.details.batch.retrieve'],
 752                     {   async : true,
 753                         params : [self.authtoken, ids],
 754                         onresponse : function(rr) {
 755                             progressDialog.hide();
 756                             self.insertHold(openils.Util.readResponse(rr));
 757                         }
 758                     }
 759                 );
 760             }
 761         }
 762     );
 763 }
 764
 765 SelfCheckManager.prototype.insertHold = function(data) {
 766     var row = this.holdTemplate.cloneNode(true);
 767
 768     if(data.mvr.isbn()) {
 769         this.byName(row, 'jacket').setAttribute('src', '/opac/extras/ac/jacket/small/r/' + data.mvr.doc_id());
 770     }
 771
 772     this.byName(row, 'title').innerHTML = data.mvr.title();
 773     this.byName(row, 'author').innerHTML = data.mvr.author();
 774
 775     if(data.status == 4) {
 776
 777         // hold is ready for pickup
 778         this.byName(row, 'status').innerHTML = localeStrings.HOLD_STATUS_READY;
 779
 780     } else {
 781
 782         // hold is still pending
 783         this.byName(row, 'status').innerHTML =
 784             dojo.string.substitute(
 785                 localeStrings.HOLD_STATUS_WAITING,
 786                 [data.queue_position, data.potential_copies]
 787             );
 788     }
 789
 790     // find the correct place the table to slot in the hold based on queue position
 791
 792     var position = (data.status == 4) ? 0 : data.queue_position;
 793     row.setAttribute('position', position);
 794
 795     for(var i = 0; i < this.holdTbody.childNodes.length; i++) {
 796         var node = this.holdTbody.childNodes[i];
 797         if(Number(node.getAttribute('position')) >= position) {
 798             this.holdTbody.insertBefore(row, node);
 799             return;
 800         }
 801     }
 802
 803     this.holdTbody.appendChild(row);
 804 }
 805
 806
 807 SelfCheckManager.prototype.drawFinesPage = function() {
 808
 809     // TODO add option to hid scanBox
 810     // this.updateScanBox(...)
 811
 812     this.goToTab('fines');
 813     progressDialog.show(true);
 814
 815     if(this.creditPayableBalance > 0 && this.orgSettings[SET_CC_PAYMENT_ALLOWED]) {
 816         openils.Util.show('oils-selfck-pay-fines-link', 'inline');
 817     }
 818
 819     this.finesTbody = dojo.byId('oils-selfck-fines-tbody');
 820     if(!this.finesTemplate)
 821         this.finesTemplate = this.finesTbody.removeChild(dojo.byId('oils-selfck-fines-row'));
 822     while(this.finesTbody.childNodes[0])
 823         this.finesTbody.removeChild(this.finesTbody.childNodes[0]);
 824
 825     // when user clicks on a selector checkbox, update the total owed
 826     var updateSelected = function() {
 827         var total = 0;
 828         dojo.forEach(
 829             dojo.query('[name=selector]', this.finesTbody),
 830             function(input) {
 831                 if(input.checked)
 832                     total += Number(input.getAttribute('balance_owed'));
 833             }
 834         );
 835
 836         total = total.toFixed(2);
 837         dojo.byId('oils-selfck-selected-total').innerHTML =
 838             dojo.string.substitute(localeStrings.TOTAL_FINES_SELECTED, [total]);
 839     }
 840
 841     // wire up the batch on/off selector
 842     var sel = dojo.byId('oils-selfck-fines-selector');
 843     sel.onchange = function() {
 844         dojo.forEach(
 845             dojo.query('[name=selector]', this.finesTbody),
 846             function(input) {
 847                 input.checked = sel.checked;
 848             }
 849         );
 850     };
 851
 852     var self = this;
 853     var handler = function(dataList) {
 854
 855         self.finesCount = dataList.length;
 856         self.finesData = dataList;
 857
 858         for(var i in dataList) {
 859
 860             var data = dataList[i];
 861             var row = self.finesTemplate.cloneNode(true);
 862             var type = data.transaction.xact_type();
 863
 864             if(type == 'circulation') {
 865                 self.byName(row, 'type').innerHTML = type;
 866                 self.byName(row, 'details').innerHTML = data.record.title();
 867
 868             } else if(type == 'grocery') {
 869                 self.byName(row, 'type').innerHTML = localeStrings.MISCELLANEOUS; // Go ahead and head off any confusion around "grocery".
 870                 self.byName(row, 'details').innerHTML = data.transaction.last_billing_type();
 871             }
 872
 873             self.byName(row, 'total_owed').innerHTML = data.transaction.total_owed();
 874             self.byName(row, 'total_paid').innerHTML = data.transaction.total_paid();
 875             self.byName(row, 'balance').innerHTML = data.transaction.balance_owed();
 876
 877             // row selector
 878             var selector = self.byName(row, 'selector')
 879             selector.onchange = updateSelected;
 880             selector.setAttribute('xact', data.transaction.id());
 881             selector.setAttribute('balance_owed', data.transaction.balance_owed());
 882             selector.checked = true;
 883
 884             self.finesTbody.appendChild(row);
 885         }
 886
 887         updateSelected();
 888     }
 889
 890
 891     fieldmapper.standardRequest(
 892         ['open-ils.actor', 'open-ils.actor.user.transactions.have_balance.fleshed'],
 893         {   async : true,
 894             params : [this.authtoken, this.patron.id()],
 895             oncomplete : function(r) {
 896                 progressDialog.hide();
 897                 handler(openils.Util.readResponse(r));
 898             }
 899         }
 900     );
 901 }
 902
 903 SelfCheckManager.prototype.checkin = function(barcode, abortTransit) {
 904
 905     var resp = fieldmapper.standardRequest(
 906         ['open-ils.circ', 'open-ils.circ.transit.abort'],
 907         {params : [this.authtoken, {barcode : barcode}]}
 908     );
 909
 910     // resp == 1 on success
 911     if(openils.Event.parse(resp))
 912         return false;
 913
 914     var resp = fieldmapper.standardRequest(
 915         ['open-ils.circ', 'open-ils.circ.checkin.override'],
 916         {params : [
 917             this.authtoken, {
 918                 patron_id : this.patron.id(),
 919                 copy_barcode : barcode,
 920                 noop : true
 921             }
 922         ]}
 923     );
 924
 925     if(!resp.length) resp = [resp];
 926     for(var i = 0; i < resp.length; i++) {
 927         var tc = openils.Event.parse(resp[i]).textcode;
 928         if(tc == 'SUCCESS' || tc == 'NO_CHANGE') {
 929             continue;
 930         } else {
 931             return false;
 932         }
 933     }
 934
 935     return true;
 936 }
 937
 938 /**
 939  * Check out a single item.  If the item is already checked
 940  * out to the patron, redirect to renew()
 941  */
 942 SelfCheckManager.prototype.checkout = function(barcode, override) {
 943
 944     this.prevCirc = null;
 945
 946     if(!barcode) {
 947         this.updateScanbox(null, true);
 948         return;
 949     }
 950
 951     if(this.mockCheckouts) {
 952         // if we're in mock-checkout mode, just insert another
 953         // fake circ into the table and get out of here.
 954         this.displayCheckout(this.mockCheckout, 'checkout');
 955         return;
 956     }
 957
 958     // TODO see if it's a patron barcode
 959     // TODO see if this item has already been checked out in this session
 960
 961     var method = 'open-ils.circ.checkout.full';
 962     if(override) method += '.override';
 963
 964     console.log("Checkout out item " + barcode + " with method " + method);
 965
 966     var result = fieldmapper.standardRequest(
 967         ['open-ils.circ', method],
 968         {params: [
 969             this.authtoken, {
 970                 patron_id : this.patron.id(),
 971                 copy_barcode : barcode
 972             }
 973         ]}
 974     );
 975
 976     var stat = this.handleXactResult('checkout', barcode, result);
 977
 978     if(stat.override) {
 979         this.checkout(barcode, true);
 980     } else if(stat.doOver) {
 981         this.checkout(barcode);
 982     } else if(stat.renew) {
 983         this.renew(barcode);
 984     }
 985 }
 986
 987 SelfCheckManager.prototype.failPartMessage = function(result) {
 988     if (result.payload && result.payload.fail_part) {
 989         var stringKey = "FAIL_PART_" +
 990             result.payload.fail_part.replace(/\./g, "_");
 991         return localeStrings[stringKey];
 992     } else {
 993         return null;
 994     }
 995 }
 996
 997 SelfCheckManager.prototype.handleXactResult = function(action, item, result) {
 998
 999     var displayText = '';
1000
1001     // If true, the display message is important enough to pop up.  Whether or not
1002     // an alert() actually occurs, depends on org unit settings
1003     var popup = false;
1004     var sound = ''; // sound file reference
1005     var payload = result.payload || {};
1006     var overrideEvents = this.orgSettings[SET_AUTO_OVERRIDE_EVENTS];
1007     var blockStatuses = this.orgSettings[SET_BLOCK_CHECKOUT_ON_COPY_STATUS];
1008
1009     if(result.textcode == 'NO_SESSION') {
1010
1011         return this.logoutStaff();
1012
1013     } else if(result.textcode == 'SUCCESS') {
1014
1015         if(action == 'checkout') {
1016
1017             displayText = dojo.string.substitute(localeStrings.CHECKOUT_SUCCESS, [item]);
1018             this.displayCheckout(result, 'checkout');
1019
1020             if(payload.holds_fulfilled && payload.holds_fulfilled.length) {
1021                 // A hold was fulfilled, update the hold numbers in the circ summary
1022                 console.log("fulfilled hold " + payload.holds_fulfilled + " during checkout");
1023                 this.holdsSummary = null;
1024                 this.updateHoldsSummary();
1025             }
1026
1027             this.updateCircSummary(true);
1028
1029         } else if(action == 'renew') {
1030
1031             displayText = dojo.string.substitute(localeStrings.RENEW_SUCCESS, [item]);
1032             this.displayCheckout(result, 'renew');
1033         }
1034
1035         this.checkouts.push({circ : result.payload.circ.id()});
1036         sound = 'checkout-success';
1037         this.updateScanBox();
1038
1039     } else if(result.textcode == 'OPEN_CIRCULATION_EXISTS' && action == 'checkout') {
1040
1041         // Server says the item is already checked out.  If it's checked out to the
1042         // current user, we may need to renew it.
1043
1044         if(payload.old_circ) {
1045
1046             /*
1047             old_circ refers to the previous checkout IFF it's for the same user.
1048             If no auto-renew interval is not defined, assume we should renew it
1049             If an auto-renew interval is defined and the payload comes back with
1050             auto_renew set to true, do the renewal.  Otherwise, let the patron know
1051             the item is already checked out to them.  */
1052
1053             if( !this.orgSettings[SET_AUTO_RENEW_INTERVAL] ||
1054                 (this.orgSettings[SET_AUTO_RENEW_INTERVAL] && payload.auto_renew) ) {
1055                 this.prevCirc = payload.old_circ.id();
1056                 return { renew : true };
1057             }
1058
1059             popup = true;
1060             sound = 'checkout-failure';
1061             displayText = dojo.string.substitute(localeStrings.ALREADY_OUT, [item]);
1062
1063         } else {
1064
1065             if( // copy is marked lost.  if configured to do so, check it in and try again.
1066                 result.payload.copy &&
1067                 result.payload.copy.status() == /* LOST */ 3 &&
1068                 overrideEvents && overrideEvents.length &&
1069                 overrideEvents.indexOf('COPY_STATUS_LOST') != -1) {
1070
1071                     if(this.checkin(item)) {
1072                         return { doOver : true };
1073                     }
1074             }
1075
1076
1077             // item is checked out to some other user
1078             popup = true;
1079             sound = 'checkout-failure';
1080             displayText = dojo.string.substitute(localeStrings.OPEN_CIRCULATION_EXISTS, [item]);
1081         }
1082
1083         this.updateScanBox({select:true});
1084
1085     } else {
1086
1087
1088         if(overrideEvents && overrideEvents.length) {
1089
1090             // see if the events we received are all in the list of
1091             // events to override
1092
1093             if(!result.length) result = [result];
1094
1095             var override = true;
1096             for(var i = 0; i < result.length; i++) {
1097
1098                 var match = overrideEvents.filter(function(e) { return (e == result[i].textcode); })[0];
1099
1100                 if(!match) {
1101                     override = false;
1102                     break;
1103                 }
1104
1105                 if(result[i].textcode == 'COPY_NOT_AVAILABLE' && blockStatuses && blockStatuses.length) {
1106
1107                     var stat = result[i].payload.status(); // copy status
1108                     if(typeof stat == 'object') stat = stat.id();
1109
1110                     var match2 = blockStatuses.filter(function(e) { return (e == stat); })[0];
1111
1112                     if(match2) { // copy is in a blocked status
1113                         override = false;
1114                         break;
1115                     }
1116                 }
1117
1118                 if(result[i].textcode == 'COPY_IN_TRANSIT') {
1119                     // to override a transit, we have to abort the transit and check it in first
1120                     if(this.checkin(item, true)) {
1121                         return { doOver : true };
1122                     } else {
1123                         override = false;
1124                     }
1125                 }
1126             }
1127
1128             if(override)
1129                 return { override : true };
1130         }
1131
1132         this.updateScanBox({select : true});
1133         popup = true;
1134         sound = 'checkout-failure';
1135
1136         if(action == 'renew')
1137             this.checkouts.push({circ : this.prevCirc, renewal_failure : true});
1138
1139         if(result.length)
1140             result = result[0];
1141
1142         switch(result.textcode) {
1143
1144             // TODO custom handler for blocking penalties
1145
1146             case 'MAX_RENEWALS_REACHED' :
1147                 displayText = dojo.string.substitute(
1148                     localeStrings.MAX_RENEWALS, [item]);
1149                 break;
1150
1151             case 'ITEM_NOT_CATALOGED' :
1152                 displayText = dojo.string.substitute(
1153                     localeStrings.ITEM_NOT_CATALOGED, [item]);
1154                 break;
1155
1156             case 'OPEN_CIRCULATION_EXISTS' :
1157                 displayText = dojo.string.substitute(
1158                     localeStrings.OPEN_CIRCULATION_EXISTS, [item]);
1159
1160                 break;
1161
1162             default:
1163                 console.error('Unhandled event ' + result.textcode);
1164
1165                 if (!(displayText = this.failPartMessage(result))) {
1166                     if (action == 'checkout' || action == 'renew') {
1167                         displayText = dojo.string.substitute(
1168                             localeStrings.GENERIC_CIRC_FAILURE, [item]);
1169                     } else {
1170                         displayText = dojo.string.substitute(
1171                             localeStrings.UNKNOWN_ERROR, [result.textcode]);
1172                     }
1173                 }
1174         }
1175     }
1176
1177     this.handleAlert(displayText, popup, sound);
1178     return {};
1179 }
1180
1181
1182 /**
1183  * Renew an item
1184  */
1185 SelfCheckManager.prototype.renew = function(barcode, override) {
1186
1187     var method = 'open-ils.circ.renew';
1188     if(override) method += '.override';
1189
1190     console.log("Renewing item " + barcode + " with method " + method);
1191
1192     var result = fieldmapper.standardRequest(
1193         ['open-ils.circ', method],
1194         {params: [
1195             this.authtoken, {
1196                 patron_id : this.patron.id(),
1197                 copy_barcode : barcode
1198             }
1199         ]}
1200     );
1201
1202     console.log(js2JSON(result));
1203
1204     var stat = this.handleXactResult('renew', barcode, result);
1205
1206     if(stat.override)
1207         this.renew(barcode, true);
1208 }
1209
1210 /**
1211  * Display the result of a checkout or renewal in the items out table
1212  */
1213 SelfCheckManager.prototype.displayCheckout = function(evt, type, itemsOut) {
1214
1215     var copy = evt.payload.copy;
1216     var record = evt.payload.record;
1217     var circ = evt.payload.circ;
1218     var row = this.circTemplate.cloneNode(true);
1219
1220     if(record.doc_id()) {
1221         this.byName(row, 'jacket').setAttribute('src', '/opac/extras/ac/jacket/small/r/' + record.doc_id());
1222     }
1223
1224     this.byName(row, 'barcode').innerHTML = copy.barcode();
1225     this.byName(row, 'title').innerHTML = record.title();
1226     this.byName(row, 'author').innerHTML = record.author();
1227     this.byName(row, 'remaining').innerHTML = circ.renewal_remaining();
1228     openils.Util.show(this.byName(row, type));
1229
1230     var date = dojo.date.stamp.fromISOString(circ.due_date());
1231     this.byName(row, 'due_date').innerHTML =
1232         dojo.date.locale.format(date, {selector : 'date'});
1233
1234     // put new circs at the top of the list
1235     var tbody = this.circTbody;
1236     if(itemsOut) tbody = this.itemsOutTbody;
1237     tbody.insertBefore(row, tbody.getElementsByTagName('tr')[0]);
1238 }
1239
1240
1241 SelfCheckManager.prototype.byName = function(node, name) {
1242     return dojo.query('[name=' + name+']', node)[0];
1243 }
1244
1245
1246 SelfCheckManager.prototype.initPrinter = function() {
1247     try { // Mozilla only
1248                 netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
1249         netscape.security.PrivilegeManager.enablePrivilege('UniversalXPConnect');
1250         netscape.security.PrivilegeManager.enablePrivilege('UniversalPreferencesRead');
1251         netscape.security.PrivilegeManager.enablePrivilege('UniversalPreferencesWrite');
1252         var pref = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
1253         if (pref)
1254             pref.setBoolPref('print.always_print_silent', true);
1255     } catch(E) {
1256         console.log("Unable to initialize auto-printing");
1257     }
1258 }
1259
1260 /**
1261  * Print a receipt for this session's checkouts
1262  */
1263 SelfCheckManager.prototype.printSessionReceipt = function(callback) {
1264
1265     var circIds = [];
1266     var circCtx = []; // circ context data.  in this case, renewal_failure info
1267
1268     // collect the circs and failure info
1269     dojo.forEach(
1270         this.checkouts,
1271         function(blob) {
1272             circIds.push(blob.circ);
1273             circCtx.push({renewal_failure:blob.renewal_failure});
1274         }
1275     );
1276
1277     var params = [
1278         this.authtoken,
1279         this.staff.ws_ou(),
1280         null,
1281         'format.selfcheck.checkout',
1282         'print-on-demand',
1283         circIds,
1284         circCtx
1285     ];
1286
1287     var self = this;
1288     fieldmapper.standardRequest(
1289         ['open-ils.circ', 'open-ils.circ.fire_circ_trigger_events'],
1290         {
1291             async : true,
1292             params : params,
1293             oncomplete : function(r) {
1294                 var resp = openils.Util.readResponse(r);
1295                 var output = resp.template_output();
1296                 if(output) {
1297                     self.printData(output.data(), self.checkouts.length, callback);
1298                 } else {
1299                     var error = resp.error_output();
1300                     if(error) {
1301                         throw new Error("Error creating receipt: " + error.data());
1302                     } else {
1303                         throw new Error("No receipt data returned from server");
1304                     }
1305                 }
1306             }
1307         }
1308     );
1309 }
1310
1311 SelfCheckManager.prototype.printData = function(data, numItems, callback) {
1312
1313     var win = window.open('', '', 'resizable,width=700,height=500,scrollbars=1,chrome');
1314     win.document.body.innerHTML = data;
1315     win.print();
1316
1317     /*
1318      * There is no way to know when the browser is done printing.
1319      * Make a best guess at when to close the print window by basing
1320      * the setTimeout wait on the number of items to be printed plus
1321      * a small buffer
1322      */
1323     var sleepTime = 1000;
1324     if(numItems > 0)
1325         sleepTime += (numItems / 2) * 1000;
1326
1327     setTimeout(
1328         function() {
1329             win.close(); // close the print window
1330             if(callback)
1331                 callback(); // fire optional post-print callback
1332         },
1333         sleepTime
1334     );
1335 }
1336
1337
1338 /**
1339  * Print a receipt for this user's items out
1340  */
1341 SelfCheckManager.prototype.printItemsOutReceipt = function(callback) {
1342
1343     if(!this.itemsOut.length) return;
1344
1345     progressDialog.show(true);
1346
1347     var params = [
1348         this.authtoken,
1349         this.staff.ws_ou(),
1350         null,
1351         'format.selfcheck.items_out',
1352         'print-on-demand',
1353         this.itemsOut
1354     ];
1355
1356     var self = this;
1357     fieldmapper.standardRequest(
1358         ['open-ils.circ', 'open-ils.circ.fire_circ_trigger_events'],
1359         {
1360             async : true,
1361             params : params,
1362             oncomplete : function(r) {
1363                 progressDialog.hide();
1364                 var resp = openils.Util.readResponse(r);
1365                 var output = resp.template_output();
1366                 if(output) {
1367                     self.printData(output.data(), self.itemsOut.length, callback);
1368                 } else {
1369                     var error = resp.error_output();
1370                     if(error) {
1371                         throw new Error("Error creating receipt: " + error.data());
1372                     } else {
1373                         throw new Error("No receipt data returned from server");
1374                     }
1375                 }
1376             }
1377         }
1378     );
1379 }
1380
1381 /**
1382  * Print a receipt for this user's items out
1383  */
1384 SelfCheckManager.prototype.printHoldsReceipt = function(callback) {
1385
1386     if(!this.holds.length) return;
1387
1388     progressDialog.show(true);
1389
1390     var holdIds = [];
1391     var holdData = [];
1392
1393     dojo.forEach(this.holds,
1394         function(data) {
1395             holdIds.push(data.hold.id());
1396             if(data.status == 4) {
1397                 holdData.push({ready : true});
1398             } else {
1399                 holdData.push({
1400                     queue_position : data.queue_position,
1401                     potential_copies : data.potential_copies
1402                 });
1403             }
1404         }
1405     );
1406
1407     var params = [
1408         this.authtoken,
1409         this.staff.ws_ou(),
1410         null,
1411         'format.selfcheck.holds',
1412         'print-on-demand',
1413         holdIds,
1414         holdData
1415     ];
1416
1417     var self = this;
1418     fieldmapper.standardRequest(
1419         ['open-ils.circ', 'open-ils.circ.fire_hold_trigger_events'],
1420         {
1421             async : true,
1422             params : params,
1423             oncomplete : function(r) {
1424                 progressDialog.hide();
1425                 var resp = openils.Util.readResponse(r);
1426                 var output = resp.template_output();
1427                 if(output) {
1428                     self.printData(output.data(), self.holds.length, callback);
1429                 } else {
1430                     var error = resp.error_output();
1431                     if(error) {
1432                         throw new Error("Error creating receipt: " + error.data());
1433                     } else {
1434                         throw new Error("No receipt data returned from server");
1435                     }
1436                 }
1437             }
1438         }
1439     );
1440 }
1441
1442
1443 SelfCheckManager.prototype.printPaymentReceipt = function(response, callback) {
1444
1445     var self = this;
1446     progressDialog.show(true);
1447
1448     fieldmapper.standardRequest(
1449         ['open-ils.circ', 'open-ils.circ.money.payment_receipt.print'],
1450         {
1451             async : true,
1452             params : [this.authtoken, response.payments],
1453             oncomplete : function(r) {
1454                 var resp = openils.Util.readResponse(r);
1455                 var output = resp.template_output();
1456                 progressDialog.hide();
1457                 if(output) {
1458                     self.printData(output.data(), 1, callback);
1459                 } else {
1460                     var error = resp.error_output();
1461                     if(error) {
1462                         throw new Error("Error creating receipt: " + error.data());
1463                     } else {
1464                         throw new Error("No receipt data returned from server");
1465                     }
1466                 }
1467             }
1468         }
1469     );
1470 }
1471
1472 /**
1473  * Print a receipt for this user's items out
1474  */
1475 SelfCheckManager.prototype.printFinesReceipt = function(callback) {
1476
1477     progressDialog.show(true);
1478
1479     var params = [
1480         this.authtoken,
1481         this.staff.ws_ou(),
1482         null,
1483         'format.selfcheck.fines',
1484         'print-on-demand',
1485         [this.patron.id()]
1486     ];
1487
1488     var self = this;
1489     fieldmapper.standardRequest(
1490         ['open-ils.circ', 'open-ils.circ.fire_user_trigger_events'],
1491         {
1492             async : true,
1493             params : params,
1494             oncomplete : function(r) {
1495                 progressDialog.hide();
1496                 var resp = openils.Util.readResponse(r);
1497                 var output = resp.template_output();
1498                 if(output) {
1499                     self.printData(output.data(), self.finesCount, callback);
1500                 } else {
1501                     var error = resp.error_output();
1502                     if(error) {
1503                         throw new Error("Error creating receipt: " + error.data());
1504                     } else {
1505                         throw new Error("No receipt data returned from server");
1506                     }
1507                 }
1508             }
1509         }
1510     );
1511 }
1512
1513
1514
1515
1516 /**
1517  * Logout the patron and return to the login page
1518  */
1519 SelfCheckManager.prototype.logoutPatron = function(print) {
1520     progressDialog.show(true); // prevent patron from clicking logout link twice
1521     if(print && this.checkouts.length) {
1522         this.printSessionReceipt(
1523             function() {
1524                 location.href = location.href;
1525             }
1526         );
1527     } else {
1528         location.href = location.href;
1529     }
1530 }
1531
1532
1533 /**
1534  * Fire up the manager on page load
1535  */
1536 openils.Util.addOnLoad(
1537     function() {
1538         new SelfCheckManager().init();
1539     }
1540 );