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