ec8300579c55f4aa8c294d76cbe1aa2b5638cb40
[working/Evergreen.git] / Open-ILS / web / js / ui / default / staff / services / auth.js
1 /* Core Sevice - egAuth
2  *
3  * Manages login and auth session retrieval.
4  */
5
6 angular.module('egCoreMod')
7
8 .factory('egAuth', 
9        ['$q','$timeout','$rootScope','$window','$location','egNet','egHatch',
10 function($q , $timeout , $rootScope , $window , $location , egNet , egHatch) {
11
12     var service = {
13         // the currently active user (au) object
14         user : function(u) {
15             if (u) {
16                 this._user = u;
17             }
18             return this._user;
19         },
20
21         // the user hidden by an operator change
22         OCuser : function(u) {
23             if (u) {
24                 this._OCuser = u;
25             }
26             return this._OCuser;
27         },
28
29         // the Op Change hidden auth token string
30         OCtoken : function() {
31             return egHatch.getLoginSessionItem('eg.auth.token.oc');
32         },
33
34         // Op Change hidden authtime in seconds
35         OCauthtime : function() {
36             return egHatch.getLoginSessionItem('eg.auth.time.oc');
37         },
38
39         // the currently active auth token string
40         token : function() {
41             return egHatch.getLoginSessionItem('eg.auth.token');
42         },
43
44         // authtime in seconds
45         authtime : function() {
46             return egHatch.getLoginSessionItem('eg.auth.time');
47         },
48
49         // the currently active workstation name
50         // For ws_ou or wsid(), see egAuth.user().ws_ou(), etc.
51         workstation : function() {
52             return this.ws;
53         },
54
55         // Listen for logout events in other tabs
56         // Current version of phantomjs (unit tests, etc.) does not 
57         // support BroadcastChannel, so just dummy it up.
58         authChannel : (typeof BroadcastChannel == 'undefined') ? 
59             {} : new BroadcastChannel('eg.auth')
60     };
61
62     /* Returns a promise, which is resolved if valid
63      * authtoken is found, otherwise rejected */
64     service.testAuthToken = function() {
65         var deferred = $q.defer();
66         var token = service.token();
67
68         if (token) {
69
70             if (lf.isOffline && !$location.path().match(/\/session/) ) {
71                 // Just stop here if we're in the offline interface but not on the session tab
72                 $timeout(function(){deferred.resolve()});
73             } else if (lf.isOffline && $location.path().match(/\/session/) && !$window.navigator.onLine) {
74                 // Likewise, if we're in the offline interface on the session tab and the network is down.
75                 // The session tab itself will redirect appropriately due to no network.
76                 $timeout(function(){deferred.resolve()});
77             } else {
78                 // Otherwise, check the token.  This will freeze all other interfaces, which is what we want.
79                 egNet.request(
80                     'open-ils.auth',
81                     'open-ils.auth.session.retrieve', token)
82     
83                 .then(function(user) {
84                     if (user && user.classname) {
85                         // authtoken test succeeded
86                         service.user(user);
87                         service.poll();
88                         service.check_workstation(deferred);
89     
90                     } else {
91                         // authtoken test failed
92                         egHatch.clearLoginSessionItems();
93                         deferred.reject(); 
94                     }
95                 });
96             }
97
98         } else {
99             // no authtoken to test
100             deferred.reject('No authtoken found');
101         }
102
103         return deferred.promise;
104     };
105
106     service.check_workstation = function(deferred) {
107
108         var user = service.user();
109         var ws_path = '/admin/workstation/workstations';
110
111         return egHatch.getItem('eg.workstation.all')
112         .then(function(workstations) { 
113             if (!workstations) workstations = [];
114
115             // If the user is authenticated with a workstation, get the
116             // name from the locally registered version of the workstation.
117
118             if (user.wsid()) {
119
120                 var ws = workstations.filter(
121                     function(w) {return w.id == user.wsid()})[0];
122
123                 if (ws) { // success
124                     service.ws = ws.name;
125                     deferred.resolve();
126                     return;
127                 }
128             }
129
130             if ($location.path() == ws_path) {
131                 // User is on the workstation admin page.  No need
132                 // to redirect.
133                 deferred.resolve();
134                 return;
135             }
136
137             // At this point, the user is trying to access a page
138             // besides the workstation admin page without a valid
139             // registered workstation.  Send them back to the 
140             // workstation admin page.
141
142             // NOTE: egEnv also defines basePath, but we cannot import
143             // egEnv here becuase it creates a circular reference.
144             $window.location.href = '/eg/staff' + ws_path;
145             deferred.resolve();
146         });
147     }
148
149     /**
150      * Returns a promise, which is resolved on successful 
151      * login and rejected on failed login.
152      */
153     service.login = function(args, ops) {
154         // avoid modifying the caller's data structure.
155         args = angular.copy(args);
156
157         if (!ops) { // only set on redo attempts.
158             ops = {deferred : $q.defer()};
159
160             // Clear old LoginSession keys that were left in localStorage
161             // when the previous user closed the browser without logging
162             // out.  Under normal circumstance, LoginSession data would
163             // have been cleared by now, either during logout or cookie
164             // expiration.  But, if for some reason the user manually
165             // removed the auth token cookie w/o closing the browser
166             // (say, for testing), then this serves double duty to ensure
167             // LoginSession data cannot persist across logins.
168             egHatch.clearLoginSessionItems();
169         }
170
171         service.login_api(args).then(function(evt) {
172
173             if (evt.textcode == 'SUCCESS') {
174                 service.handle_login_ok(args, evt);
175                 ops.deferred.resolve({
176                     invalid_workstation : ops.invalid_workstation
177                 });
178
179             } else if (evt.textcode == 'WORKSTATION_NOT_FOUND') {
180                 ops.invalid_workstation = true;
181                 delete args.workstation;
182                 service.login(args, ops); // redo w/o workstation
183
184             } else {
185                 // note: the likely outcome here is a NO_SESION
186                 // server event, which results in broadcasting an 
187                 // egInvalidAuth by egNet. 
188                 console.error('login failed ' + js2JSON(evt));
189                 ops.deferred.reject();
190             }
191         });
192
193         return ops.deferred.promise;
194     }
195
196     /**
197      * Returns a promise, which is resolved on successful 
198      * login and rejected on failed login.
199      */
200     service.opChange = function(args) {
201         // avoid modifying the caller's data structure.
202         args = angular.copy(args);
203         args.workstation = service.workstation();
204
205         var deferred = $q.defer();
206
207         service.login_api(args).then(function(evt) {
208
209             if (evt.textcode == 'SUCCESS') {
210                 if (args.type != 'persist') {
211                     egHatch.setLoginSessionItem('eg.auth.token.oc', service.token());
212                     egHatch.setLoginSessionItem('eg.auth.time.oc', service.authtime());
213                     service.OCuser(service.user());
214                 }
215                 service.handle_login_ok(args, evt);
216                 service.testAuthToken().then(
217                     deferred.resolve,
218                     function () { service.opChangeUndo().then(deferred.reject)  }
219                 );
220             } else {
221                 // note: the likely outcome here is a NO_SESION
222                 // server event, which results in broadcasting an 
223                 // egInvalidAuth by egNet. 
224                 console.error('operator change failed ' + js2JSON(evt));
225                 deferred.reject();
226             }
227         });
228
229         return deferred.promise;
230     }
231
232     service.opChangeUndo = function() {
233         if (service.OCtoken()) {
234             service.user(service.OCuser());
235             egHatch.setLoginSessionItem('eg.auth.token', service.OCtoken());
236             egHatch.setLoginSessionItem('eg.auth.time', service.OCauthtime());
237             egHatch.removeLoginSessionItem('eg.auth.token.oc');
238             egHatch.removeLoginSessionItem('eg.auth.time.oc');
239         }
240         return service.testAuthToken();
241     }
242
243     service.login_api = function(args) {
244         return egNet.request(
245             'open-ils.auth',
246             'open-ils.auth.authenticate.init', args.username)
247         .then(function(seed) {
248                 // avoid clobbering the bare password in case
249                 // we need it for a login redo attempt.
250                 var login_args = angular.copy(args);
251                 login_args.password = hex_md5(seed + hex_md5(args.password));
252
253                 return egNet.request(
254                     'open-ils.auth',
255                     'open-ils.auth.authenticate.complete', login_args)
256             }
257         );
258     }
259
260     service.handle_login_ok = function(args, evt) {
261         service.ws = args.workstation; 
262         egHatch.setLoginSessionItem('eg.auth.token', evt.payload.authtoken);
263         egHatch.setLoginSessionItem('eg.auth.time', evt.payload.authtime);
264         service.poll();
265     }
266
267     /**
268      * Force-check the validity of the authtoken on occasion. 
269      * This allows us to redirect an idle staff client back to the login
270      * page after the session times out.  Otherwise, the UI would stay
271      * open with potentially sensitive data visible.
272      * TODO: What is the practical difference (for a browser) between 
273      * checking auth validity and the ui.general.idle_timeout setting?
274      * Does that setting serve a purpose in a browser environment?
275      */
276     service.poll = function() {
277
278         if (!service.authChannel.onmessage) {
279             // Now that we have an authtoken, listen for logout events 
280             // initiated by other tabs.
281             service.authChannel.onmessage = function(e) {
282                 if (e.data.action == 'logout') {
283                     $rootScope.$broadcast(
284                         'egAuthExpired', {startedElsewhere : true});
285                 }
286             }
287         }
288
289         $timeout(
290             function() {
291                 egNet.request(                                                     
292                     'open-ils.auth',                                               
293                     'open-ils.auth.session.retrieve', 
294                     service.token(),
295                     0, // return extra auth details, unneeded here.
296                     1  // avoid extending the auth timeout
297                 ).then(function(user) {
298                     if (user && user.classname) { // all good
299                         service.poll();
300                     } else {
301                         // NOTE: we should never get here, since egNet
302                         // filters responses for NO_SESSION events.
303                         $rootScope.$broadcast('egAuthExpired');
304                     }
305                 })
306             },
307             // add a 5 second delay to give the token plenty of time
308             // to expire on the server.
309             service.authtime() * 1000 + 5000
310         );
311     }
312
313     service.logout = function(broadcast) {
314
315         if (broadcast) {
316             // Tell the other tabs to shut it all down.
317             service.authChannel.postMessage({action : 'logout'});
318         }
319
320         if (service.token()) {
321             egNet.request(
322                 'open-ils.auth', 
323                 'open-ils.auth.session.delete', 
324                 service.token()); // fire and forget
325             egHatch.clearLoginSessionItems();
326         }
327         service._user = null;
328     };
329
330     return service;
331 }])
332
333
334 /**
335  * Service for testing user permissions.
336  * Note: this cannot live within egAuth, because it creates a circular
337  * dependency of egOrg -> egEnv -> egAuth -> egOrg
338  */
339 .factory('egPerm', 
340        ['$q','egNet','egAuth','egOrg',
341 function($q , egNet , egAuth , egOrg) {
342     var service = {};
343
344     /*
345      * Returns the full list of org unit objects at which the currently
346      * logged in user has the selected permissions.
347      * @permList - list or string.  If a list, the response object is a
348      * hash of perm => orgList maps.  If a string, the response is the
349      * org list for the requested perm.
350      */
351     service.hasPermAt = function(permList, asId) {
352         var deferred = $q.defer();
353         var isArray = true;
354         if (!angular.isArray(permList)) {
355             isArray = false;
356             permList = [permList];
357         }
358         // as called, this method will return the top-most org unit of the
359         // sub-tree at which this user has the selected permission.
360         // From there, flesh the descendant orgs locally.
361         egNet.request(
362             'open-ils.actor',
363             'open-ils.actor.user.has_work_perm_at.batch',
364             egAuth.token(), permList
365         ).then(function(resp) {
366             var answer = {};
367             angular.forEach(permList, function(perm) {
368                 var all = [];
369                 angular.forEach(resp[perm], function(oneOrg) {
370                     all = all.concat(egOrg.descendants(oneOrg, asId));
371                 });
372                 answer[perm] = all;
373             });
374             if (!isArray) answer = answer[permList[0]];
375             deferred.resolve(answer);
376         });
377        return deferred.promise;
378     };
379
380
381     /**
382      * Returns a hash of perm => hasPermBool for each requested permission.
383      * If the authenticated user has no workstation, no checks are made
384      * and all permissions return false.
385      */
386     service.hasPermHere = function(permList) {
387         var response = {};
388
389         var isArray = true;
390         if (!angular.isArray(permList)) {
391             isArray = false;
392             permList = [permList];
393         }
394
395         // no workstation, all are false
396         if (egAuth.user().wsid() === null) {
397             console.warn("egPerm.hasPermHere() called with no workstation");
398             if (isArray) {
399                 response = permList.map(function(perm) {
400                     return response[perm] = false;
401                 });
402             } else {
403                 response = false;
404             }
405             return $q.when(response);
406         }
407
408         ws_ou = Number(egAuth.user().ws_ou()); // from string
409
410         return service.hasPermAt(permList, true)
411         .then(function(orgMap) {
412             angular.forEach(orgMap, function(orgIds, perm) {
413                 // each permission is mapped to a flat list of org unit ids,
414                 // including descendants.  See if our workstation org unit
415                 // is in the list.
416                 response[perm] = orgIds.indexOf(ws_ou) > -1;
417             });
418             if (!isArray) response = response[permList[0]];
419             return response;
420         });
421     }
422
423     return service;
424 }])
425
426