cleanup, fixes. very basic checkout works
[Evergreen.git] / Open-ILS / web / js / ui / default / circ / selfcheck / selfcheck.js
1 dojo.require('openils.CGI');
2 dojo.require('openils.Util');
3 dojo.require('openils.User');
4 dojo.require('openils.Event');
5
6 const SET_BARCODE_REGEX = 'opac.barcode_regex';
7 const SET_PATRON_TIMEOUT = 'circ.selfcheck.patron_login_timeout';
8 const SET_ALERT_ON_CHECKOUT_EVENT = 'circ.selfcheck.alert_on_checkout_event';
9 const SET_AUTO_OVERRIDE_EVENTS = 'circ.selfcheck.auto_override_checkout_events';
10 const SET_PATRON_PASSWORD_REQUIRED = 'circ.selfcheck.patron_password_required';
11
12 function SelfCheckManager() {
13
14     this.cgi = new openils.CGI();
15     this.staff = null; 
16     this.workstation = null;
17     this.authtoken = null;
18
19     this.patron = null; 
20     this.patronBarcodeRegex = null;
21
22     // current item barcode
23     this.itemBarcode = null; 
24
25     // are we currently performing a renewal?
26     this.isRenewal = false; 
27
28     // is a transaction pending?
29     this.pendingXact = false; 
30
31     // dict of org unit settings for "here"
32     this.orgSettings = {};
33 }
34
35 /**
36  * Fetch the org-unit settings, initialize the display, etc.
37  */
38 SelfCheckManager.prototype.init = function() {
39
40     this.staff = openils.User.user;
41     this.workstation = openils.User.workstation;
42     this.authtoken = openils.User.authtoken;
43     this.loadOrgSettings();
44
45     if(this.cgi.param('patron')) {
46         // Patron barcode via cgi param.  Mainly used for debugging.
47         this.loginPatron(this.cgi.param('patron'));
48     } else {
49         this.drawLoginPage();
50     }
51 }
52
53 /**
54  * Loads the org unit settings
55  */
56 SelfCheckManager.prototype.loadOrgSettings = function() {
57
58     var settings = fieldmapper.aou.fetchOrgSettingBatch(
59         this.staff.ws_ou(), [
60             SET_BARCODE_REGEX,
61             SET_PATRON_TIMEOUT,
62             SET_ALERT_ON_CHECKOUT_EVENT,
63             SET_AUTO_OVERRIDE_EVENTS,
64         ]
65     );
66
67     for(k in settings) {
68         if(settings[k])
69             this.orgSettings[k] = settings[k].value;
70     }
71
72     if(settings[SET_BARCODE_REGEX]) 
73         this.patronBarcodeRegex = new RegExp(settings[SET_BARCODE_REGEX].value);
74 }
75
76 SelfCheckManager.prototype.drawLoginPage = function() {
77     var self = this;
78
79     var bcHandler = function(barcode) {
80         // handle patron barcode entry
81
82         if(self.orgSettings[SET_PATRON_PASSWORD_REQUIRED]) {
83             
84             // password is required.  wire up the scan box to read it
85             self.updateScanBox({
86                 msg : 'Please enter your password', // TODO i18n 
87                 handler : function(pw) { self.loginPatron(barcode, ps); }
88             });
89
90             dojo.connect(selfckScanBox, 'onKeyDown', pwHandler);
91
92         } else {
93             // password is not required, go ahead and login
94             self.loginPatron(barcode);
95         }
96     };
97
98     this.updateScanBox({
99         msg : 'Please log in with your library barcode.', // TODO
100         handler : bcHandler
101     });
102 }
103
104 /**
105  * Login the patron.  
106  */
107 SelfCheckManager.prototype.loginPatron = function(barcode, passwd) {
108     console.log('loginPatron: ' + barcode);
109
110     if(this.orgSettings[SET_PATRON_PASSWORD_REQUIRED]) {
111
112         // patron password is required.  Verify it.
113
114         var res = fieldmapper.standardRequest(
115             ['open-ils.actor', 'open-ils.actor.verify_user_password'],
116             {params : [this.authtoken, barcode, null, hex_md5(passwd)]}
117         );
118
119         if(res == 0) {
120             return alert('login failed'); // TODO
121         }
122     } 
123
124     // retrieve the fleshed user by barcode
125     this.patron = fieldmapper.standardRequest(
126         ['open-ils.actor', 'open-ils.actor.user.fleshed.retrieve_by_barcode'],
127         {params : [this.authtoken, barcode]}
128     );
129
130     var evt = openils.Event.parse(this.patron);
131     if(evt) {
132
133         // User login failed, why?
134         
135         switch(evt.textcode) {
136
137             case 'ACTOR_USER_NOT_FOUND':
138                 return alert('user not found'); // TODO
139
140             case 'NO_SESSION':
141                 return alert('staff login timed out'); // TODO
142
143             default:
144                 return alert('unexpected patron login error occured: ' + evt.textcode); // TODO
145         }
146     }
147
148     // patron login succeeded
149     dojo.byId('oils-selfck-user-banner').innerHTML = 'Welcome, ' + this.patron.usrname(); // TODO i18n
150     this.drawCircPage();
151 }
152
153
154 /**
155  * Manages the main input box
156  * @param msg The context message to display with the box
157  * @param clearOnly Don't update the context message, just clear the value and re-focus
158  * @param handler Optional "on-enter" handler.  
159  */
160 SelfCheckManager.prototype.updateScanBox = function(args) {
161
162     selfckScanBox.attr('value', '');
163
164     if(args.value)
165         selfckScanBox.attr('value', args.value);
166
167     if(args.msg) 
168         dojo.byId('oils-selfck-scan-text').innerHTML = args.msg;
169
170     if(selfckScanBox._lastHandler && (args.handler || args.clearHandler)) {
171         console.log('disconnecting ' + selfckScanBox._lastHandler);
172         dojo.disconnect(selfckScanBox._lastHandler);
173     }
174
175     if(args.handler) {
176         console.log('updating scan box with ['+args.msg+'] and handler ' + args.handler);
177
178         selfckScanBox._lastHandler = dojo.connect(
179             selfckScanBox, 
180             'onKeyDown', 
181             function(e) {
182                 if(e.keyCode != dojo.keys.ENTER) 
183                     return;
184                 args.handler(selfckScanBox.attr('value'));
185             }
186         );
187     }
188
189     selfckScanBox.focus();
190 }
191
192 /**
193  *  Sets up the checkout/renewal interface
194  */
195 SelfCheckManager.prototype.drawCircPage = function() {
196
197     var self = this;
198     this.updateScanBox({
199         msg : 'Please enter an item barcode', // TODO i18n
200         handler : function(barcode) { self.checkout(barcode); }
201     });
202
203     openils.Util.show('oils-selfck-circ-page');
204
205     this.circTbody = dojo.byId('oils-selfck-circ-tbody');
206     if(!this.circTemplate)
207         this.circTemplate = this.circTbody.removeChild(dojo.byId('oils-selfck-circ-row'));
208 }
209
210
211
212 /**
213  * Check out a single item.  If the item is already checked 
214  * out to the patron, redirect to renew()
215  */
216 SelfCheckManager.prototype.checkout = function(barcode, override) {
217
218     if(!barcode) {
219         this.updateScanbox(null, true);
220         return;
221     }
222
223     // TODO see if it's a patron barcode
224     // TODO see if this item has already been checked out in this session
225
226     var method = 'open-ils.circ.checkout.full';
227     if(override) method += '.override';
228
229     var result = fieldmapper.standardRequest(
230         ['open-ils.circ', 'open-ils.circ.checkout.full'],
231         {params: [
232             this.authtoken, {
233                 patron_id : this.patron.id(),
234                 copy_barcode : barcode
235             }
236         ]}
237     );
238
239
240     if(dojo.isArray(result)) {
241         // list of results.  See if we can override all of them.
242
243     } else {
244         var evt = openils.Event.parse(result);
245
246         switch(evt.textcode) {
247             // standard result events
248             
249             case 'SUCCESS':
250                 this.displayCheckout(evt);
251                 break;
252
253             case 'OPEN_CIRCULATION_EXISTS':
254                 // TODO renewal
255                 break;
256
257             case 'NO_SESSION':
258                 // TODO logout staff
259                 break;
260         }
261     }
262
263     console.log("Circ resulted in " + js2JSON(result));
264 }
265
266 /**
267  * Renew an item
268  */
269 SelfCheckManager.prototype.renew = function() {
270 }
271
272 /**
273  * Display the result of a checkout or renewal in the items out table
274  */
275 SelfCheckManager.prototype.displayCheckout = function(evt) {
276
277     var copy = evt.payload.copy;
278     var record = evt.payload.record;
279     var circ = evt.payload.circ;
280     var row = this.circTemplate.cloneNode(true);
281
282     /*
283     if(record.isbn()) {
284             var pic = $n(template, 'jacket');
285             pic.setAttribute('src', '/opac/ac/jacket/small/' + cleanISBN(record.isbn()));
286     }
287     */
288
289     this.byName(row, 'barcode').innerHTML = copy.barcode();
290     this.byName(row, 'title').innerHTML = record.title();
291     this.byName(row, 'author').innerHTML = record.author();
292     this.circTbody.appendChild(row);
293 }
294
295
296 SelfCheckManager.prototype.byName = function(node, name) {
297     return dojo.query('[name=' + name+']', node)[0];
298 }
299
300 /**
301  * Print a receipt
302  */
303 SelfCheckManager.prototype.printReceipt = function() {
304 }
305
306 /**
307  * Build the patron holds table
308  */
309 SelfCheckManager.prototype.displayHolds = function() {
310 }
311
312
313 /**
314  * Logout the patron and return to the login page
315  */
316 SelfCheckManager.prototype.logoutPatron = function() {
317 }
318
319
320 /**
321  * Fire up the manager on page load
322  */
323 openils.Util.addOnLoad(
324     function() {
325         new SelfCheckManager().init();
326     }
327 );