webstaff: sound for batch hold edit
[working/Evergreen.git] / Open-ILS / web / js / ui / default / staff / circ / services / holds.js
1 /**
2  * Holds, yo
3  */
4
5 angular.module('egCoreMod')
6
7 .factory('egHolds',
8
9        ['$uibModal','$q','egCore','egConfirmDialog','egAlertDialog',
10 function($uibModal , $q , egCore , egConfirmDialog , egAlertDialog) {
11
12     var service = {};
13
14     service.fetch_holds = function(hold_ids) {
15         var deferred = $q.defer();
16
17         // FIXME: large batches using .authoritative result in many 
18         // stranded cstore backends on the server.  Needs investigation.
19         // For now, collect holds in a series of small batches.
20         // Fetch them serially both to avoid the above problem and
21         // to maintain order.
22         var batch_size = 5;
23         var index = 0;
24
25         function one_batch() {
26             var ids = hold_ids.slice(index, index + batch_size)
27                 .filter(function(id) {return Boolean(id)}) // avoid nulls
28
29             console.debug('egHolds.fetch_holds => ' + ids);
30             index += batch_size;
31
32             if (!ids.length) {
33                 deferred.resolve();
34                 return;
35             }
36
37             egCore.net.request(
38                 'open-ils.circ',
39                 'open-ils.circ.hold.details.batch.retrieve.authoritative',
40                 egCore.auth.token(), ids
41
42             ).then(
43                 one_batch,  // kick off the next batch
44                 null, 
45                 function(hold_data) {
46                     var hold = hold_data.hold;
47                     hold_data.id = hold.id();
48                     service.local_flesh(hold_data);
49                     deferred.notify(hold_data);
50                 }
51             );
52         }
53
54         one_batch(); // kick it off
55         return deferred.promise;
56     }
57
58
59     service.cancel_holds = function(hold_ids) {
60        
61         return $uibModal.open({
62             templateUrl : './circ/share/t_cancel_hold_dialog',
63             controller : 
64                 ['$scope', '$uibModalInstance', 'cancel_reasons',
65                 function($scope, $uibModalInstance, cancel_reasons) {
66                     $scope.args = {
67                         cancel_reason : 5,
68                         cancel_reasons : cancel_reasons,
69                         num_holds : hold_ids.length
70                     };
71                     
72                     $scope.cancel = function($event) {
73                         $uibModalInstance.dismiss();
74                         $event.preventDefault();
75                     }
76
77                     $scope.ok = function() {
78
79                         function cancel_one() {
80                             var hold_id = hold_ids.pop();
81                             if (!hold_id) {
82                                 $uibModalInstance.close();
83                                 return;
84                             }
85                             egCore.net.request(
86                                 'open-ils.circ', 'open-ils.circ.hold.cancel',
87                                 egCore.auth.token(), hold_id,
88                                 $scope.args.cancel_reason,
89                                 $scope.args.note
90                             ).then(function(resp) {
91                                 if (evt = egCore.evt.parse(resp)) {
92                                     egCore.audio.play(
93                                         'warning.hold.cancel_failed');
94                                     console.error('unable to cancel hold: ' 
95                                         + evt.toString());
96                                 }
97                                 cancel_one();
98                             });
99                         }
100
101                         cancel_one();
102                     }
103                 }
104             ],
105             resolve : {
106                 cancel_reasons : function() {
107                     return service.get_cancel_reasons();
108                 }
109             }
110         }).result;
111     }
112
113     service.uncancel_holds = function(hold_ids) {
114        
115         return $uibModal.open({
116             templateUrl : './circ/share/t_uncancel_hold_dialog',
117             controller : 
118                 ['$scope', '$uibModalInstance',
119                 function($scope, $uibModalInstance) {
120                     $scope.args = {
121                         num_holds : hold_ids.length
122                     };
123                     
124                     $scope.cancel = function($event) {
125                         $uibModalInstance.dismiss();
126                         $event.preventDefault();
127                     }
128
129                     $scope.ok = function() {
130
131                         function uncancel_one() {
132                             var hold_id = hold_ids.pop();
133                             if (!hold_id) {
134                                 $uibModalInstance.close();
135                                 return;
136                             }
137                             egCore.net.request(
138                                 'open-ils.circ', 'open-ils.circ.hold.uncancel',
139                                 egCore.auth.token(), hold_id
140                             ).then(function(resp) {
141                                 if (evt = egCore.evt.parse(resp)) {
142                                     egCore.audio.play(
143                                         'warning.hold.uncancel_failed');
144                                     console.error('unable to uncancel hold: ' 
145                                         + evt.toString());
146                                 }
147                                 uncancel_one();
148                             });
149                         }
150
151                         uncancel_one();
152                     }
153                 }
154             ]
155         }).result;
156     }
157
158     service.get_cancel_reasons = function() {
159         if (egCore.env.ahrcc) return $q.when(egCore.env.ahrcc.list);
160         return egCore.pcrud.retrieveAll('ahrcc', {}, {atomic : true})
161         .then(function(list) { return egCore.env.absorbList(list, 'ahrcc').list });
162     }
163
164     // Updates a batch of holds, notifies on each response.
165     // new_values = array of hashes describing values to change,
166     // including the id of the hold to change.
167     // e.g. {id : 1, mint_condition : true}
168     service.update_holds = function(new_values) {
169         return egCore.net.request(
170             'open-ils.circ',
171             'open-ils.circ.hold.update.batch',
172             egCore.auth.token(), null, new_values).then(
173             function(resp) {
174                 if (evt = egCore.evt.parse(resp)) {
175                     egCore.audio.play(
176                         'warning.hold.batch_update');
177                     console.error('unable to batch update holds: '
178                         + evt.toString());
179                 } else {
180                     egCore.audio.play(
181                         'success.hold.batch_update');
182                 }
183             }
184         );
185     }
186
187     service.set_copy_quality = function(hold_ids) {
188         if (!hold_ids.length) return $q.when();
189         return $uibModal.open({
190             templateUrl : './circ/share/t_hold_copy_quality_dialog',
191             controller : 
192                 ['$scope', '$uibModalInstance',
193                 function($scope, $uibModalInstance) {
194
195                     function update(val) {
196                         var vals = hold_ids.map(function(hold_id) {
197                             return {id : hold_id, mint_condition : val}})
198                         service.update_holds(vals).finally(function() {
199                             $uibModalInstance.close();
200                         });
201                     }
202                     $scope.good = function() { update(true) }
203                     $scope.any = function() { update(false) }
204                     $scope.cancel = function() { $uibModalInstance.dismiss() }
205                 }
206             ]
207         }).result;
208     }
209
210     service.edit_pickup_lib = function(hold_ids) {
211         if (!hold_ids.length) return $q.when();
212         return $uibModal.open({
213             templateUrl : './circ/share/t_hold_edit_pickup_lib',
214             controller : 
215                 ['$scope', '$uibModalInstance',
216                 function($scope, $uibModalInstance) {
217                     $scope.cant_be_pickup = function (id) { return !egCore.org.CanHaveUsers(id); };
218                     $scope.args = {};
219                     $scope.ok = function() { 
220                         var vals = hold_ids.map(function(hold_id) {
221                             return {
222                                 id : hold_id, 
223                                 pickup_lib : $scope.args.org_unit.id()
224                             }
225                         });
226                         service.update_holds(vals).finally(function() {
227                             $uibModalInstance.close();
228                         });
229                     }
230                     $scope.cancel = function() { $uibModalInstance.dismiss() }
231                 }
232             ]
233         }).result;
234     }
235
236     service.get_sms_carriers = function() {
237         if (egCore.env.csc) return $q.when(egCore.env.csc.list);
238         return egCore.pcrud.retrieveAll('csc', {}, {atomic : true})
239         .then(function(list) { return egCore.env.absorbList(list, 'csc').list });
240     }
241
242     service.edit_notify_prefs = function(hold_ids) {
243         if (!hold_ids.length) return $q.when();
244         return $uibModal.open({
245             templateUrl : './circ/share/t_hold_notification_prefs',
246             controller : 
247                 ['$scope', '$uibModalInstance', 'sms_carriers',
248                 function($scope, $uibModalInstance, sms_carriers) {
249                     $scope.args = {}
250                     $scope.sms_carriers = sms_carriers;
251                     $scope.num_holds = hold_ids.length;
252                     $scope.ok = function() { 
253
254                         var vals = hold_ids.map(function(hold_id) {
255                             var val = {id : hold_id};
256                             angular.forEach(
257                                 ['email', 'phone', 'sms'],
258                                 function(type) {
259                                     var key = type + '_notify';
260                                     if ($scope.args['update_' + key]) 
261                                         val[key] = $scope.args[key];
262                                 }
263                             );
264                             if ($scope.args.update_sms_carrier)
265                                 val.sms_carrier = $scope.args.sms_carrier.id();
266                             return val;
267                         });
268
269                         service.update_holds(vals).finally(function() {
270                             $uibModalInstance.close();
271                         });
272                     }
273                     $scope.cancel = function() { $uibModalInstance.dismiss() }
274                 }
275             ],
276             resolve : {
277                 sms_carriers : service.get_sms_carriers
278             }
279         }).result;
280     }
281
282     service.edit_dates = function(hold_ids) {
283         if (!hold_ids.length) return $q.when();
284
285         // collects the fields from the dialog the user wishes to modify
286         function relay_to_update(modal_scope) {
287             var vals = hold_ids.map(function(hold_id) {
288                 var val = {id : hold_id};
289                 angular.forEach(
290                     ['thaw_date', 'request_time', 'expire_time', 'shelf_expire_time'], 
291                     function(field) {
292                         if (modal_scope.args['modify_' + field]) 
293                             val[field] = modal_scope.args[field].toISOString();
294                     }
295                 );
296
297                 return val;
298             });
299
300             console.log(JSON.stringify(vals,null,2));
301             return service.update_holds(vals);
302         }
303
304         return $uibModal.open({
305             templateUrl : './circ/share/t_hold_dates',
306             controller : 
307                 ['$scope', '$uibModalInstance',
308                 function($scope, $uibModalInstance) {
309                     var today = new Date();
310                     $scope.args = {
311                         thaw_date : today,
312                         request_time : today,
313                         expire_time : today,
314                         shelf_expire_time : today
315                     }
316                     $scope.num_holds = hold_ids.length;
317                     $scope.ok = function() { 
318                         relay_to_update($scope).then($uibModalInstance.close);
319                     }
320                     $scope.cancel = function() { $uibModalInstance.dismiss() }
321                 }
322             ],
323         }).result;
324     }
325
326     service.update_field_with_confirm = function(hold_ids, msg_key, field, value) {
327         if (!hold_ids.length) return $q.when();
328
329         return egConfirmDialog.open(
330             egCore.strings[msg_key], '', {num_holds : hold_ids.length})
331         .result.then(function() {
332
333             var vals = hold_ids.map(function(hold_id) {
334                 val = {id : hold_id};
335                 val[field] = value;
336                 return val;
337             });
338             return service.update_holds(vals);
339         });
340     }
341
342     service.suspend_holds = function(hold_ids) {
343         return service.update_field_with_confirm(
344             hold_ids, 'SUSPEND_HOLDS', 'frozen', true);
345     }
346
347     service.activate_holds = function(hold_ids) {
348         return service.update_field_with_confirm(
349             hold_ids, 'ACTIVATE_HOLDS', 'frozen', false);
350     }
351
352     service.set_top_of_queue = function(hold_ids) {
353         return service.update_field_with_confirm(
354             hold_ids, 'SET_TOP_OF_QUEUE', 'cut_in_line', true);
355     }
356
357     service.clear_top_of_queue = function(hold_ids) {
358         return service.update_field_with_confirm(
359             hold_ids, 'CLEAR_TOP_OF_QUEUE', 'cut_in_line', null);
360     }
361
362     service.transfer_to_marked_title = function(hold_ids) {
363         if (!hold_ids.length) return $q.when();
364
365         var bib_id = egCore.hatch.getLocalItem(
366             'eg.circ.hold.title_transfer_target');
367
368         if (!bib_id) {
369             // no target marked
370             return egAlertDialog.open(
371                 egCore.strings.NO_HOLD_TRANSFER_TITLE_MARKED).result;
372         }
373
374         return egConfirmDialog.open(
375             egCore.strings.TRANSFER_HOLD_TO_TITLE, '', {
376                 num_holds : hold_ids.length,
377                 bib_id : bib_id
378             }
379         ).result.then(function() {
380             return egCore.net.request(
381                 'open-ils.circ',
382                 'open-ils.circ.hold.change_title.specific_holds',
383                 egCore.auth.token(), bib_id, hold_ids);
384         });
385     }
386
387     service.transfer_all_bib_holds_to_marked_title = function(bib_ids) {
388         if (!bib_ids.length) return $q.when();
389
390         var target_bib_id = egCore.hatch.getLocalItem(
391             'eg.circ.hold.title_transfer_target');
392
393         if (!target_bib_id) {
394             // no target marked
395             return egAlertDialog.open(
396                 egCore.strings.NO_HOLD_TRANSFER_TITLE_MARKED).result;
397         }
398
399         return egConfirmDialog.open(
400             egCore.strings.TRANSFER_ALL_BIB_HOLDS_TO_TITLE, '', {
401                 num_bibs : bib_ids.length,
402                 bib_id : target_bib_id
403             }
404         ).result.then(function() {
405             return egCore.net.request(
406                 'open-ils.circ',
407                 'open-ils.circ.hold.change_title',
408                 egCore.auth.token(), target_bib_id, bib_ids);
409         });
410     }
411
412     // serially retargets each hold
413     service.retarget = function(hold_ids) {
414         if (!hold_ids.length) return $q.when();
415         var deferred = $q.defer();
416
417         egConfirmDialog.open(
418             egCore.strings.RETARGET_HOLDS, '', 
419             {hold_ids : hold_ids.join(',')}
420
421         ).result.then(function() {
422
423             function do_one() {
424                 var hold_id = hold_ids.pop();
425                 if (!hold_id) {
426                     deferred.resolve();
427                     return;
428                 }
429
430                 egCore.net.request(
431                     'open-ils.circ',
432                     'open-ils.circ.hold.reset',
433                     egCore.auth.token(), hold_id).finally(do_one);
434             }
435
436             do_one(); // kick it off
437         });
438
439         return deferred.promise;
440     }
441
442     // fleshes orgs, etc. for hold data blobs retrieved from
443     // open-ils.circ.hold.details[.batch].retrieve
444     service.local_flesh = function(hold_data) {
445
446         hold_data.status_string = 
447             egCore.strings['HOLD_STATUS_' + hold_data.status] 
448             || hold_data.status;
449
450         var hold = hold_data.hold;
451         hold.pickup_lib(egCore.org.get(hold.pickup_lib()));
452         hold.current_shelf_lib(egCore.org.get(hold.current_shelf_lib()));
453         hold_data.id = hold.id();
454
455         if (hold.requestor() && typeof hold.requestor() != 'object')
456             egCore.pcrud.retrieve('au',hold.requestor()).then(function(u) { hold.requestor(u) });
457
458         if (hold.cancel_cause() && typeof hold.cancel_cause() != 'object')
459             egCore.pcrud.retrieve('ahrcc',hold.cancel_cause()).then(function(c) { hold.cancel_cause(c) });
460
461         if (hold.usr() && typeof hold.usr() != 'object')
462             egCore.pcrud.retrieve('au',hold.usr()).then(function(u) { hold.usr(u) });
463
464         // current_copy is not always fleshed in the API
465         if (hold.current_copy() && typeof hold.current_copy() != 'object')
466             hold.current_copy(hold_data.copy);
467     }
468
469     return service;
470 }])
471
472 /**  
473  * Action handlers for the common Hold grid UI.
474  * These generally scrub the data for valid input then pass the
475  * holds / copies / etc. off to the relevant action in egHolds or egCirc.
476  *
477  * Caller must apply a reset_page function, which is called after 
478  * most actionis are performed.
479  */
480 .factory('egHoldGridActions', 
481        ['$window','$location','$timeout','egCore','egHolds','egCirc',
482 function($window , $location , $timeout , egCore , egHolds , egCirc) {
483     
484     var service = {};
485
486     service.refresh = function() {
487         console.error('egHoldGridActions.refresh not defined!');
488     }
489
490     service.cancel_hold = function(items) {
491         var hold_ids = items.filter(function(item) {
492             return !item.hold.cancel_time();
493         }).map(function(item) {return item.hold.id()});
494
495         return egHolds.cancel_holds(hold_ids).then(service.refresh);
496     }
497
498     service.uncancel_hold = function(items) {
499         var hold_ids = items.filter(function(item) {
500             return item.hold.cancel_time();
501         }).map(function(item) {return item.hold.id()});
502
503         return egHolds.uncancel_holds(hold_ids).then(service.refresh);
504     }
505
506     // jump to circ list for either 1) the targeted copy or
507     // 2) the hold target copy for copy-level holds
508     service.show_recent_circs = function(items) {
509         var focus = items.length == 1;
510         angular.forEach(items, function(item) {
511             if (item.copy) {
512                 var url = egCore.env.basePath +
513                           '/cat/item/' +
514                           item.copy.id() +
515                           '/circ_list';
516                 $timeout(function() { var x = $window.open(url, '_blank'); if (focus) x.focus() });
517             }
518         });
519     }
520
521     service.show_patrons = function(items) {
522         var focus = items.length == 1;
523         angular.forEach(items, function(item) {
524             var url = egCore.env.basePath +
525                       'circ/patron/' +
526                       item.hold.usr().id() +
527                       '/holds';
528             $timeout(function() { var x = $window.open(url, '_blank'); if (focus) x.focus() });
529         });
530     }
531
532     service.show_holds_for_title = function(items) {
533         var focus = items.length == 1;
534         angular.forEach(items, function(item) {
535             var url = egCore.env.basePath +
536                       'cat/catalog/record/' +
537                       item.mvr.doc_id() +
538                       '/holds';
539             $timeout(function() { var x = $window.open(url, '_blank'); if (focus) x.focus() });
540         });
541     }
542
543
544     function generic_update(items, action) {
545         if (!items.length) return $q.when();
546         var hold_ids = items.map(function(item) {return item.hold.id()});
547         return egHolds[action](hold_ids).then(service.refresh);
548     }
549
550     service.set_copy_quality = function(items) {
551         generic_update(items, 'set_copy_quality'); }
552     service.edit_pickup_lib = function(items) {
553         generic_update(items, 'edit_pickup_lib'); }
554     service.edit_notify_prefs = function(items) {
555         generic_update(items, 'edit_notify_prefs'); }
556     service.edit_dates = function(items) {
557         generic_update(items, 'edit_dates'); }
558     service.suspend = function(items) {
559         generic_update(items, 'suspend_holds'); }
560     service.activate = function(items) {
561         generic_update(items, 'activate_holds'); }
562     service.set_top_of_queue = function(items) {
563         generic_update(items, 'set_top_of_queue'); }
564     service.clear_top_of_queue = function(items) {
565         generic_update(items, 'clear_top_of_queue'); }
566     service.transfer_to_marked_title = function(items) {
567         generic_update(items, 'transfer_to_marked_title'); }
568
569     service.mark_damaged = function(items) {
570         var copy_ids = items
571             .filter(function(item) { return Boolean(item.copy) })
572             .map(function(item) { return item.copy.id() });
573         if (copy_ids.length) 
574             egCirc.mark_damaged(copy_ids).then(service.refresh);
575     }
576
577     service.mark_missing = function(items) {
578         var copy_ids = items
579             .filter(function(item) { return Boolean(item.copy) })
580             .map(function(item) { return item.copy.id() });
581         if (copy_ids.length) 
582             egCirc.mark_missing(copy_ids).then(service.refresh);
583     }
584
585     service.retarget = function(items) {
586         var hold_ids = items.map(function(item) { return item.hold.id() });
587         egHolds.retarget(hold_ids).then(service.refresh);
588     }
589
590     return service;
591 }])
592
593 /**
594  * Hold details interface 
595  */
596 .directive('egHoldDetails', function() {
597     return {
598         restrict : 'AE',
599         templateUrl : './circ/share/t_hold_details',
600         scope : {
601             holdId : '=',
602             // if set, called whenever hold details are retrieved.  The
603             // argument is the hold blob returned from hold.details.retrieve
604             holdRetrieved : '=',
605             showPatron : '='
606         },
607         controller : [
608                     '$scope','$uibModal','egCore','egHolds','egCirc',
609             function($scope , $uibModal , egCore , egHolds , egCirc) {
610
611                 function draw() {
612                     if (!$scope.holdId) return;
613
614                     egCore.net.request(
615                         'open-ils.circ',
616                         'open-ils.circ.hold.details.retrieve.authoritative',
617                         egCore.auth.token(), $scope.holdId
618
619                     ).then(function(hold_data) { 
620                         egHolds.local_flesh(hold_data);
621     
622                         angular.forEach(hold_data, 
623                             function(val, key) { $scope[key] = val });
624
625                         // fetch + flesh the cancel_cause if needed
626                         if ($scope.hold.cancel_time()) {
627                             egHolds.get_cancel_reasons().then(function() {
628                                 // egHolds caches the causes in egEnv
629                                 $scope.hold.cancel_cause(
630                                     egCore.env.ahrcc.map[$scope.hold.cancel_cause()]);
631                             })
632                         }
633
634                         if ($scope.hold.current_copy()) {
635                             egCirc.flesh_copy_location($scope.hold.current_copy());
636                         }
637
638                         if ($scope.holdRetrieved)
639                             $scope.holdRetrieved(hold_data);
640
641                     });
642                 }
643
644                 $scope.show_notify_tab = function() {
645                     $scope.detail_tab = 'notify';
646                     egCore.pcrud.search('ahn',
647                         {hold : $scope.hold.id()}, 
648                         {flesh : 1, flesh_fields : {ahn : ['notify_staff']}}, 
649                         {atomic : true}
650                     ).then(function(nots) {
651                         $scope.hold.notifications(nots);
652                     });
653                 }
654
655                 $scope.delete_note = function(note) {
656                     egCore.pcrud.remove(note).then(function() {
657                         // remove the deleted note from the locally fleshed notes
658                         $scope.hold.notes(
659                             $scope.hold.notes().filter(function(n) {
660                                 return n.id() != note.id()
661                             })
662                         );
663                     });
664                 }
665
666                 $scope.new_note = function() {
667                     return $uibModal.open({
668                         templateUrl : './circ/share/t_hold_note_dialog',
669                         controller : 
670                             ['$scope', '$uibModalInstance',
671                             function($scope, $uibModalInstance) {
672                                 $scope.args = {};
673                                 $scope.ok = function() {
674                                     $uibModalInstance.close($scope.args)
675                                 },
676                                 $scope.cancel = function($event) {
677                                     $uibModalInstance.dismiss();
678                                     $event.preventDefault();
679                                 }
680                             }
681                         ]
682                     }).result.then(function(args) {
683                         var note = new egCore.idl.ahrn();
684                         note.hold($scope.hold.id());
685                         note.staff(true);
686                         note.slip(args.slip);
687                         note.pub(args.pub); 
688                         note.title(args.title);
689                         note.body(args.body);
690                         return egCore.pcrud.create(note).then(function(n) {
691                             $scope.hold.notes().push(n);
692                         });
693                     });
694                 }
695
696                 $scope.new_notification = function() {
697                     return $uibModal.open({
698                         templateUrl : './circ/share/t_hold_notification_dialog',
699                         controller : 
700                             ['$scope', '$uibModalInstance',
701                             function($scope, $uibModalInstance) {
702                                 $scope.args = {};
703                                 $scope.ok = function() {
704                                     $uibModalInstance.close($scope.args)
705                                 },
706                                 $scope.cancel = function($event) {
707                                     $uibModalInstance.dismiss();
708                                     $event.preventDefault();
709                                 }
710                             }
711                         ]
712                     }).result.then(function(args) {
713                         var note = new egCore.idl.ahn();
714                         note.hold($scope.hold.id());
715                         note.method(args.method);
716                         note.note(args.note);
717                         note.notify_staff(egCore.auth.user().id());
718                         note.notify_time('now');
719                         return egCore.pcrud.create(note).then(function(n) {
720                             n.notify_staff(egCore.auth.user());
721                             $scope.hold.notifications().push(n);
722                         });
723                     });
724                 }
725
726                 $scope.$watch('holdId', function(newVal, oldVal) {
727                     if (newVal != oldVal) draw();
728                 });
729
730                 draw();
731             }
732         ]
733     }
734 })
735
736