Open-ILS/web/js/ui/default/staff/cat/bucket/copy/app.js

   1 /**
   2  * Copy Buckets
   3  *
   4  * Known Issues
   5  *
   6  * add-all actions only add visible/fetched items.
   7  * remove all from bucket UI leaves busted pagination
   8  *   -- apply a refresh after item removal?
   9  * problems with bucket view fetching by record ID instead of bucket item:
  10  *   -- dupe bibs always sort to the bottom
  11  *   -- dupe bibs result in more records displayed per page than requested
  12  *   -- item 'pos' ordering is not honored on initial load.
  13  */
  14
  15 angular.module('egCatCopyBuckets',
  16     ['ngRoute', 'ui.bootstrap', 'egCoreMod', 'egUiMod', 'egGridMod', 'egUserMod'])
  17
  18 .config(function($routeProvider, $locationProvider, $compileProvider) {
  19     $locationProvider.html5Mode(true);
  20     $compileProvider.aHrefSanitizationWhitelist(/^\s*(https?|mailto|blob):/); // grid export
  21
  22     var resolver = {delay : function(egStartup) {return egStartup.go()}};
  23
  24     $routeProvider.when('/cat/bucket/copy/pending/:id', {
  25         templateUrl: './cat/bucket/copy/t_pending',
  26         controller: 'PendingCtrl',
  27         resolve : resolver
  28     });
  29
  30     $routeProvider.when('/cat/bucket/copy/pending', {
  31         templateUrl: './cat/bucket/copy/t_pending',
  32         controller: 'PendingCtrl',
  33         resolve : resolver
  34     });
  35
  36     $routeProvider.when('/cat/bucket/copy/view/:id', {
  37         templateUrl: './cat/bucket/copy/t_view',
  38         controller: 'ViewCtrl',
  39         resolve : resolver
  40     });
  41
  42     $routeProvider.when('/cat/bucket/copy/view', {
  43         templateUrl: './cat/bucket/copy/t_view',
  44         controller: 'ViewCtrl',
  45         resolve : resolver
  46     });
  47
  48     // default page / bucket view
  49     $routeProvider.otherwise({redirectTo : '/cat/bucket/copy/view'});
  50 })
  51
  52 /**
  53  * bucketSvc allows us to communicate between the pending
  54  * and view controllers.  It also allows us to cache
  55  * data for each so that data reloads are not needed on every
  56  * tab click (i.e. route persistence).
  57  */
  58 .factory('bucketSvc', ['$q','egCore', function($q,  egCore) {
  59
  60     var service = {
  61         allBuckets : [], // un-fleshed user buckets
  62         barcodeString : '', // last scanned barcode
  63         barcodeRecords : [], // last scanned barcode results
  64         currentBucket : null, // currently viewed bucket
  65
  66         // per-page list collections
  67         pendingList : [],
  68         viewList  : [],
  69
  70         // fetches all staff/copy buckets for the authenticated user
  71         // this function may only be called after startup.
  72         fetchUserBuckets : function(force) {
  73             if (this.allBuckets.length && !force) return;
  74             var self = this;
  75             return egCore.net.request(
  76                 'open-ils.actor',
  77                 'open-ils.actor.container.retrieve_by_class.authoritative',
  78                 egCore.auth.token(), egCore.auth.user().id(),
  79                 'copy', 'staff_client'
  80             ).then(function(buckets) { self.allBuckets = buckets });
  81         },
  82
  83         createBucket : function(name, desc) {
  84             var deferred = $q.defer();
  85             var bucket = new egCore.idl.ccb();
  86             bucket.owner(egCore.auth.user().id());
  87             bucket.name(name);
  88             bucket.description(desc || '');
  89             bucket.btype('staff_client');
  90
  91             egCore.net.request(
  92                 'open-ils.actor',
  93                 'open-ils.actor.container.create',
  94                 egCore.auth.token(), 'copy', bucket
  95             ).then(function(resp) {
  96                 if (resp) {
  97                     if (typeof resp == 'object') {
  98                         console.error('bucket create error: ' + js2JSON(resp));
  99                         deferred.reject();
 100                     } else {
 101                         deferred.resolve(resp);
 102                     }
 103                 }
 104             });
 105
 106             return deferred.promise;
 107         },
 108
 109         // edit the current bucket.  since we edit the
 110         // local object, there's no need to re-fetch.
 111         editBucket : function(args) {
 112             var bucket = service.currentBucket;
 113             bucket.name(args.name);
 114             bucket.description(args.desc);
 115             bucket.pub(args.pub);
 116             return egCore.net.request(
 117                 'open-ils.actor',
 118                 'open-ils.actor.container.update',
 119                 egCore.auth.token(), 'copy', bucket
 120             );
 121         }
 122     }
 123
 124     // returns 1 if full refresh is needed
 125     // returns 2 if list refresh only is needed
 126     service.bucketRefreshLevel = function(id) {
 127         if (!service.currentBucket) return 1;
 128         if (service.bucketNeedsRefresh) {
 129             service.bucketNeedsRefresh = false;
 130             service.currentBucket = null;
 131             return 1;
 132         }
 133         if (service.currentBucket.id() != id) return 1;
 134         return 2;
 135     }
 136
 137     // returns a promise, resolved with bucket, rejected if bucket is
 138     // not fetch-able
 139     service.fetchBucket = function(id) {
 140         var refresh = service.bucketRefreshLevel(id);
 141         if (refresh == 2) return $q.when(service.currentBucket);
 142
 143         var deferred = $q.defer();
 144
 145         egCore.net.request(
 146             'open-ils.actor',
 147             'open-ils.actor.container.flesh.authoritative',
 148             egCore.auth.token(), 'copy', id
 149         ).then(function(bucket) {
 150             var evt = egCore.evt.parse(bucket);
 151             if (evt) {
 152                 console.debug(evt);
 153                 deferred.reject(evt);
 154                 return;
 155             }
 156             egCore.pcrud.retrieve(
 157                 'au', bucket.owner(),
 158                 {flesh : 1, flesh_fields : {au : ["card"]}}
 159             ).then(function(patron) {
 160                 // On the off chance no barcode is present (it's not
 161                 // required) use the patron username as the identifier.
 162                 bucket._owner_ident = patron.card() ?
 163                     patron.card().barcode() : patron.usrname();
 164                 bucket._owner_name = patron.family_name();
 165                 bucket._owner_ou = egCore.org.get(patron.home_ou()).shortname();
 166             });
 167
 168             service.currentBucket = bucket;
 169             deferred.resolve(bucket);
 170         });
 171
 172         return deferred.promise;
 173     }
 174
 175     // deletes a single container item from a bucket by container item ID.
 176     // promise is rejected on failure
 177     service.detachCopy = function(itemId) {
 178         var deferred = $q.defer();
 179         egCore.net.request(
 180             'open-ils.actor',
 181             'open-ils.actor.container.item.delete',
 182             egCore.auth.token(), 'copy', itemId
 183         ).then(function(resp) {
 184             var evt = egCore.evt.parse(resp);
 185             if (evt) {
 186                 console.error(evt);
 187                 deferred.reject(evt);
 188                 return;
 189             }
 190             console.log('detached bucket item ' + itemId);
 191             deferred.resolve(resp);
 192         });
 193
 194         return deferred.promise;
 195     }
 196
 197     // delete bucket by ID.
 198     // resolved w/ response on successful delete,
 199     // rejected otherwise.
 200     service.deleteBucket = function(id) {
 201         var deferred = $q.defer();
 202         egCore.net.request(
 203             'open-ils.actor',
 204             'open-ils.actor.container.full_delete',
 205             egCore.auth.token(), 'copy', id
 206         ).then(function(resp) {
 207             var evt = egCore.evt.parse(resp);
 208             if (evt) {
 209                 console.error(evt);
 210                 deferred.reject(evt);
 211                 return;
 212             }
 213             deferred.resolve(resp);
 214         });
 215         return deferred.promise;
 216     }
 217
 218     // apply last inventory data to fetched bucket items
 219     service.fetchRecentInventoryData = function(copy) {
 220         return egCore.pcrud.search('alci',
 221             {copy: copy.id},
 222             {flesh: 2, flesh_fields: {alci: ['inventory_workstation']}}
 223         ).then(function(alci) {
 224             return alci;
 225         });
 226     }
 227
 228     return service;
 229 }])
 230
 231 /**
 232  * Top-level controller.
 233  * Hosts functions needed by all controllers.
 234  */
 235 .controller('CopyBucketCtrl',
 236        ['$scope','$location','$q','$timeout','$uibModal',
 237         '$window','egCore','bucketSvc',
 238 function($scope,  $location,  $q,  $timeout,  $uibModal,
 239          $window,  egCore,  bucketSvc) {
 240
 241     $scope.bucketSvc = bucketSvc;
 242     $scope.bucket = function() { return bucketSvc.currentBucket }
 243
 244     // tabs: search, pending, view
 245     $scope.setTab = function(tab) {
 246         $scope.tab = tab;
 247
 248         // for bucket selector; must be called after route resolve
 249         bucketSvc.fetchUserBuckets();
 250     };
 251
 252     $scope.loadBucketFromMenu = function(item, bucket) {
 253         if (bucket) return $scope.loadBucket(bucket.id());
 254     }
 255
 256     $scope.loadBucket = function(id) {
 257         $location.path(
 258             '/cat/bucket/copy/' +
 259                 $scope.tab + '/' + encodeURIComponent(id));
 260     }
 261
 262     $scope.addToBucket = function(recs) {
 263         if (recs.length == 0) return;
 264         bucketSvc.bucketNeedsRefresh = true;
 265
 266         angular.forEach(recs,
 267             function(rec) {
 268                 var item = new egCore.idl.ccbi();
 269                 item.bucket(bucketSvc.currentBucket.id());
 270                 item.target_copy(rec.id);
 271                 egCore.net.request(
 272                     'open-ils.actor',
 273                     'open-ils.actor.container.item.create',
 274                     egCore.auth.token(), 'copy', item
 275                 ).then(function(resp) {
 276
 277                     // HACK: add the IDs of the added items so that the size
 278                     // of the view list will grow (and update any UI looking at
 279                     // the list size).  The data stored is inconsistent, but since
 280                     // we are forcing a bucket refresh on the next rendering of
 281                     // the view pane, the list will be repaired.
 282                     bucketSvc.currentBucket.items().push(resp);
 283                 });
 284             }
 285         );
 286     }
 287
 288     $scope.openCreateBucketDialog = function() {
 289         $uibModal.open({
 290             templateUrl: './cat/bucket/share/t_bucket_create',
 291             backdrop: 'static',
 292             controller:
 293                 ['$scope', '$uibModalInstance', function($scope, $uibModalInstance) {
 294                 $scope.focusMe = true;
 295                 $scope.ok = function(args) { $uibModalInstance.close(args) }
 296                 $scope.cancel = function () { $uibModalInstance.dismiss() }
 297             }]
 298         }).result.then(function (args) {
 299             if (!args || !args.name) return;
 300             bucketSvc.createBucket(args.name, args.desc).then(
 301                 function(id) {
 302                     if (!id) return;
 303                     bucketSvc.viewList = [];
 304                     bucketSvc.allBuckets = []; // reset
 305                     bucketSvc.currentBucket = null;
 306                     $location.path(
 307                         '/cat/bucket/copy/' + $scope.tab + '/' + id);
 308                 }
 309             );
 310         });
 311     }
 312
 313     $scope.openEditBucketDialog = function() {
 314         $uibModal.open({
 315             templateUrl: './cat/bucket/share/t_bucket_edit',
 316             backdrop: 'static',
 317             controller:
 318                 ['$scope', '$uibModalInstance', function($scope, $uibModalInstance) {
 319                 $scope.focusMe = true;
 320                 $scope.args = {
 321                     name : bucketSvc.currentBucket.name(),
 322                     desc : bucketSvc.currentBucket.description(),
 323                     pub : bucketSvc.currentBucket.pub() == 't'
 324                 };
 325                 $scope.ok = function(args) {
 326                     if (!args) return;
 327                     $scope.actionPending = true;
 328                     args.pub = args.pub ? 't' : 'f';
 329                     // close the dialog after edit has completed
 330                     bucketSvc.editBucket(args).then(
 331                         function() { $uibModalInstance.close() });
 332                 }
 333                 $scope.cancel = function () { $uibModalInstance.dismiss() }
 334             }]
 335         })
 336     }
 337
 338     // opens the delete confirmation and deletes the current
 339     // bucket if the user confirms.
 340     $scope.openDeleteBucketDialog = function() {
 341         $uibModal.open({
 342             templateUrl: './cat/bucket/share/t_bucket_delete',
 343             backdrop: 'static',
 344             controller :
 345                 ['$scope', '$uibModalInstance', function($scope, $uibModalInstance) {
 346                 $scope.bucket = function() { return bucketSvc.currentBucket }
 347                 $scope.ok = function() { $uibModalInstance.close() }
 348                 $scope.cancel = function() { $uibModalInstance.dismiss() }
 349             }]
 350         }).result.then(function () {
 351             bucketSvc.deleteBucket(bucketSvc.currentBucket.id())
 352             .then(function() {
 353                 bucketSvc.allBuckets = [];
 354                 $location.path('/cat/bucket/copy/view');
 355             });
 356         });
 357     }
 358
 359     // retrieves the requested bucket by ID
 360     $scope.openSharedBucketDialog = function() {
 361         $uibModal.open({
 362             templateUrl: './cat/bucket/share/t_load_shared',
 363             backdrop: 'static',
 364             controller :
 365                 ['$scope', '$uibModalInstance', function($scope, $uibModalInstance) {
 366                 $scope.focusMe = true;
 367                 $scope.ok = function(args) {
 368                     if (args && args.id) {
 369                         $uibModalInstance.close(args.id)
 370                     }
 371                 }
 372                 $scope.cancel = function() { $uibModalInstance.dismiss() }
 373             }]
 374         }).result.then(function(id) {
 375             // RecordBucketCtrl $scope is not inherited by the
 376             // modal, so we need to call loadBucket from the
 377             // promise resolver.
 378             $scope.loadBucket(id);
 379         });
 380     }
 381
 382 }])
 383
 384 .controller('PendingCtrl',
 385        ['$scope','$routeParams','bucketSvc','egGridDataProvider', 'egCore',
 386 function($scope,  $routeParams,  bucketSvc , egGridDataProvider,   egCore) {
 387     $scope.setTab('pending');
 388
 389     $scope.context = {
 390         copyNotFound : false,
 391         selectPendingBC : true
 392     };
 393
 394     var query;
 395     $scope.gridControls = {
 396         setQuery : function(q) {
 397             if (bucketSvc.pendingList.length)
 398                 return {id : bucketSvc.pendingList};
 399             else
 400             return null;
 401         },
 402         allItemsRetrieved : function() {
 403             $scope.context.selectPendingBC = true;
 404         }
 405     }
 406
 407     $scope.handle_barcode_completion = function(barcode) {
 408         return egCore.net.request(
 409             'open-ils.actor',
 410             'open-ils.actor.get_barcodes',
 411             egCore.auth.token(), egCore.auth.user().ws_ou(),
 412             'asset', barcode)
 413
 414         .then(function(resp) {
 415             // TODO: handle event during barcode lookup
 416             if (evt = egCore.evt.parse(resp)) {
 417                 console.error(evt.toString());
 418                 return $q.reject();
 419             }
 420
 421             // no matching barcodes: return the barcode as entered
 422             // by the user (so that, e.g., checkout can fall back to
 423             // precat/noncat handling)
 424             if (!resp || !resp[0]) {
 425                 return barcode;
 426             }
 427
 428             // exactly one matching barcode: return it
 429             if (resp.length == 1) {
 430                 return resp[0].barcode;
 431             }
 432
 433             // multiple matching barcodes: let the user pick one
 434             console.debug('multiple matching barcodes');
 435             var matches = [];
 436             var promises = [];
 437             var final_barcode;
 438             angular.forEach(resp, function(cp) {
 439                 promises.push(
 440                     egCore.net.request(
 441                         'open-ils.circ',
 442                         'open-ils.circ.copy_details.retrieve',
 443                         egCore.auth.token(), cp.id
 444                     ).then(function(r) {
 445                         matches.push({
 446                             barcode: r.copy.barcode(),
 447                             title: r.mvr.title(),
 448                             org_name: egCore.org.get(r.copy.circ_lib()).name(),
 449                             org_shortname: egCore.org.get(r.copy.circ_lib()).shortname()
 450                         });
 451                     })
 452                 );
 453             });
 454             return $q.all(promises)
 455             .then(function() {
 456                 return $uibModal.open({
 457                     templateUrl: './circ/share/t_barcode_choice_dialog',
 458                     controller:
 459                         ['$scope', '$uibModalInstance',
 460                         function($scope, $uibModalInstance) {
 461                         $scope.matches = matches;
 462                         $scope.ok = function(barcode) {
 463                             $uibModalInstance.close();
 464                             final_barcode = barcode;
 465                         }
 466                         $scope.cancel = function() {$uibModalInstance.dismiss()}
 467                     }],
 468                 }).result.then(function() { return final_barcode });
 469             })
 470         });
 471     }
 472
 473     $scope.search = function() {
 474         bucketSvc.barcodeRecords = [];
 475         $scope.context.itemNotFound = false;
 476
 477         // clear selection so re-selecting can have an effect
 478         $scope.context.selectPendingBC = false;
 479
 480         return $scope.handle_barcode_completion(bucketSvc.barcodeString)
 481         .then(function(actual_barcode) {
 482             egCore.pcrud.search(
 483                 'acp',
 484                 {barcode : actual_barcode, deleted : 'f'},
 485                 {}
 486             ).then(function(copy) {
 487                 if (copy) {
 488                     bucketSvc.pendingList.push(copy.id());
 489                     $scope.gridControls.setQuery({id : bucketSvc.pendingList});
 490                     bucketSvc.barcodeString = ''; // clear form on valid copy
 491                 } else {
 492                     $scope.context.itemNotFound = true;
 493                     $scope.context.selectPendingBC = true;
 494                 }
 495             });
 496         });
 497     }
 498
 499     $scope.resetPendingList = function() {
 500         bucketSvc.pendingList = [];
 501         $scope.gridControls.setQuery({});
 502     }
 503
 504     if ($routeParams.id &&
 505         (!bucketSvc.currentBucket ||
 506             bucketSvc.currentBucket.id() != $routeParams.id)) {
 507         // user has accessed this page cold with a bucket ID.
 508         // fetch the bucket for display, then set the totalCount
 509         // (also for display), but avoid fully fetching the bucket,
 510         // since it's premature, in this UI.
 511         bucketSvc.fetchBucket($routeParams.id);
 512     }
 513     $scope.gridControls.setQuery();
 514 }])
 515
 516 .controller('ViewCtrl',
 517        ['$scope','$q','$routeParams','$timeout','$window','$uibModal','bucketSvc','egCore','egOrg','egUser',
 518         'ngToast','egConfirmDialog',
 519 function($scope,  $q , $routeParams , $timeout , $window , $uibModal , bucketSvc , egCore , egOrg , egUser ,
 520          ngToast , egConfirmDialog) {
 521
 522     $scope.setTab('view');
 523     $scope.bucketId = $routeParams.id;
 524
 525     var query;
 526     $scope.gridControls = {
 527         setQuery : function(q) {
 528             if (q) query = q;
 529             return query;
 530         }
 531     };
 532
 533     function drawBucket() {
 534         return bucketSvc.fetchBucket($scope.bucketId).then(
 535             function(bucket) {
 536                 var ids = bucket.items().map(
 537                     function(i){return i.target_copy()}
 538                 );
 539                 if (ids.length) {
 540                     $scope.gridControls.setQuery({id : ids});
 541                 } else {
 542                     $scope.gridControls.setQuery({});
 543                 }
 544             }
 545         );
 546     }
 547
 548     $scope.detachCopies = function(copies) {
 549         var promises = [];
 550         angular.forEach(copies, function(rec) {
 551             var item = bucketSvc.currentBucket.items().filter(
 552                 function(i) {
 553                     return (i.target_copy() == rec.id)
 554                 }
 555             );
 556             if (item.length)
 557                 promises.push(bucketSvc.detachCopy(item[0].id()));
 558         });
 559
 560         bucketSvc.bucketNeedsRefresh = true;
 561         return $q.all(promises).then(drawBucket);
 562     }
 563
 564     $scope.moveToPending = function(copies) {
 565         angular.forEach(copies, function(copy) {
 566             bucketSvc.pendingList.push(copy.id);
 567         });
 568         $scope.detachCopies(copies);
 569     }
 570
 571     $scope.spawnHoldingsEdit = function (copies) {
 572         var cp_list = []
 573         angular.forEach($scope.gridControls.selectedItems(), function (i) {
 574             cp_list.push(i.id);
 575         })
 576
 577         egCore.net.request(
 578             'open-ils.actor',
 579             'open-ils.actor.anon_cache.set_value',
 580             null, 'edit-these-copies', {
 581                 record_id: 0, // false-y value for record_id disables record summary
 582                 copies: cp_list,
 583                 hide_vols : true,
 584                 hide_copies : false
 585             }
 586         ).then(function(key) {
 587             if (key) {
 588                 var url = egCore.env.basePath + 'cat/volcopy/' + key;
 589                 $timeout(function() { $window.open(url, '_blank') });
 590             } else {
 591                 alert('Could not create anonymous cache key!');
 592             }
 593         });
 594     }
 595
 596     $scope.print_labels = function() {
 597         var cp_list = []
 598         angular.forEach($scope.gridControls.selectedItems(), function (i) {
 599             cp_list.push(i.id);
 600         })
 601
 602         egCore.net.request(
 603             'open-ils.actor',
 604             'open-ils.actor.anon_cache.set_value',
 605             null, 'print-labels-these-copies', {
 606                 copies : cp_list
 607             }
 608         ).then(function(key) {
 609             if (key) {
 610                 var url = egCore.env.basePath + 'cat/printlabels/' + key;
 611                 $timeout(function() { $window.open(url, '_blank') });
 612             } else {
 613                 alert('Could not create anonymous cache key!');
 614             }
 615         });
 616     }
 617
 618     $scope.showItems = function() {
 619         var cp_list = []
 620         angular.forEach($scope.gridControls.selectedItems(), function (i) {
 621             cp_list.push(i.id);
 622         })
 623         var url = egCore.env.basePath + '/cat/item/search/' + cp_list.join();
 624         $timeout(function() { $window.open(url, '_blank') });
 625     }
 626
 627     $scope.requestItems = function() {
 628         var copy_list = $scope.gridControls.selectedItems().map(
 629             function (i) {
 630                 return i.id;
 631             }
 632         );
 633         var record_list = $scope.gridControls.selectedItems().map(
 634             function (i) {
 635                 return i['call_number.record.id'];
 636             }
 637         ).filter(function(v,i,s){ // dedup
 638             return s.indexOf(v) == i;
 639         });
 640
 641         if (copy_list.length == 0) return;
 642
 643         return $uibModal.open({
 644             templateUrl: './cat/catalog/t_request_items',
 645             backdrop: 'static',
 646             animation: true,
 647             controller:
 648                    ['$scope','$uibModalInstance',
 649             function($scope , $uibModalInstance) {
 650                 $scope.user = null;
 651                 $scope.first_user_fetch = true;
 652
 653                 $scope.hold_data = {
 654                     hold_type : 'C',
 655                     copy_list : copy_list,
 656                     record_list : record_list,
 657                     pickup_lib: egCore.org.get(egCore.auth.user().ws_ou()),
 658                     user      : egCore.auth.user().id(),
 659                     honor_user_settings :
 660                         egCore.hatch.getLocalItem('eg.cat.request_items.honor_user_settings')
 661                 };
 662
 663                 egUser.get( $scope.hold_data.user ).then(function(u) {
 664                     $scope.user = u;
 665                     $scope.barcode = u.card().barcode();
 666                     $scope.user_name = egUser.format_name(u);
 667                     $scope.hold_data.user = u.id();
 668                 });
 669
 670                 $scope.user_name = '';
 671                 $scope.barcode = '';
 672                 function user_preferred_pickup_lib(u) {
 673                     var pickup_lib = u.home_ou();
 674                     angular.forEach(u.settings(), function (s) {
 675                         if (s.name() == "opac.default_pickup_location") {
 676                             pickup_lib = s.value();
 677                         }
 678                     });
 679                     return egOrg.get(pickup_lib);
 680                 }
 681                 $scope.$watch('barcode', function (n) {
 682                     if (!$scope.first_user_fetch) {
 683                         egUser.getByBarcode(n).then(function(u) {
 684                             $scope.user = u;
 685                             $scope.user_name = egUser.format_name(u);
 686                             $scope.hold_data.user = u.id();
 687                             if ($scope.hold_data.honor_user_settings) {
 688                                 $scope.hold_data.pickup_lib = user_preferred_pickup_lib(u);
 689                             }
 690                         }, function() {
 691                             $scope.user = null;
 692                             $scope.user_name = '';
 693                             delete $scope.hold_data.user;
 694                         });
 695                     }
 696                     $scope.first_user_fetch = false;
 697                 });
 698                 $scope.$watch('hold_data.honor_user_settings', function (n) {
 699                     if (n && $scope.user) {
 700                         $scope.hold_data.pickup_lib = user_preferred_pickup_lib($scope.user);
 701                     } else {
 702                         $scope.hold_data.pickup_lib = egCore.org.get(egCore.auth.user().ws_ou());
 703                     }
 704                     egCore.hatch.setLocalItem('eg.cat.request_items.honor_user_settings',n);
 705                 });
 706
 707                 $scope.ok = function(h) {
 708                     var args = {
 709                         patronid  : h.user,
 710                         hold_type : h.hold_type,
 711                         pickup_lib: h.pickup_lib.id(),
 712                         depth     : 0
 713                     };
 714
 715                     egCore.net.request(
 716                         'open-ils.circ',
 717                         'open-ils.circ.holds.test_and_create.batch.override',
 718                         egCore.auth.token(), args,
 719                         h.hold_type == 'T' ? h.record_list : h.copy_list,
 720                         { 'all' : 1, 'honor_user_settings' : h.honor_user_settings }
 721                     ).then(function(r) {
 722                         console.log('request result',r);
 723                         if (isNaN(r.result)) {
 724                             if (typeof r.result.desc != 'undefined') {
 725                                 ngToast.danger(r.result.desc);
 726                             } else {
 727                                 if (typeof r.result.last_event != 'undefined') {
 728                                     ngToast.danger(r.result.last_event.desc);
 729                                 } else {
 730                                     ngToast.danger(egCore.strings.FAILURE_HOLD_REQUEST);
 731                                 }
 732                             }
 733                         } else {
 734                             ngToast.success(egCore.strings.SUCCESS_HOLD_REQUEST);
 735                         }
 736                     });
 737
 738                     $uibModalInstance.close();
 739                 }
 740
 741                 $scope.cancel = function($event) {
 742                     $uibModalInstance.dismiss();
 743                     $event.preventDefault();
 744                 }
 745             }]
 746         });
 747     }
 748
 749     $scope.deleteCopiesFromCatalog = function(copies) {
 750         egConfirmDialog.open(
 751             egCore.strings.CONFIRM_DELETE_COPY_BUCKET_ITEMS_FROM_CATALOG,
 752             '', {}
 753         ).result.then(function() {
 754             var fleshed_copies = [];
 755             var promises = [];
 756             angular.forEach(copies, function(i) {
 757                 promises.push(
 758                     egCore.net.request(
 759                         'open-ils.search',
 760                         'open-ils.search.asset.copy.fleshed2.retrieve',
 761                         i.id
 762                     ).then(function(copy) {
 763                         copy.ischanged(1);
 764                         copy.isdeleted(1);
 765                         fleshed_copies.push(copy);
 766                     })
 767                 );
 768             });
 769             $q.all(promises).then(function() {
 770                 egCore.net.request(
 771                     'open-ils.cat',
 772                     'open-ils.cat.asset.copy.fleshed.batch.update',
 773                     egCore.auth.token(), fleshed_copies, true
 774                 ).then(function(resp) {
 775                     var evt = egCore.evt.parse(resp);
 776                     if (evt) {
 777                         egConfirmDialog.open(
 778                             egCore.strings.OVERRIDE_DELETE_COPY_BUCKET_ITEMS_FROM_CATALOG_TITLE,
 779                             egCore.strings.OVERRIDE_DELETE_COPY_BUCKET_ITEMS_FROM_CATALOG_BODY,
 780                             {'evt_desc': evt.desc}
 781                         ).result.then(function() {
 782                             egCore.net.request(
 783                                 'open-ils.cat',
 784                                 'open-ils.cat.asset.copy.fleshed.batch.update.override',
 785                                 egCore.auth.token(), fleshed_copies, true,
 786                                 { events: ['TITLE_LAST_COPY', 'COPY_DELETE_WARNING'] }
 787                             ).then(function(resp) {
 788                                 bucketSvc.bucketNeedsRefresh = true;
 789                                 drawBucket();
 790                             });
 791                         });
 792                     }
 793                     bucketSvc.bucketNeedsRefresh = true;
 794                     drawBucket();
 795                 });
 796             });
 797         });
 798     }
 799
 800     $scope.transferCopies = function(copies) {
 801         var xfer_target = egCore.hatch.getLocalItem('eg.cat.transfer_target_vol');
 802         var copy_ids = copies.map(
 803             function(curr,idx,arr) {
 804                 return curr.id;
 805             }
 806         );
 807         if (xfer_target) {
 808             egCore.net.request(
 809                 'open-ils.cat',
 810                 'open-ils.cat.transfer_copies_to_volume',
 811                 egCore.auth.token(),
 812                 xfer_target,
 813                 copy_ids
 814             ).then(
 815                 function(resp) { // oncomplete
 816                     var evt = egCore.evt.parse(resp);
 817                     if (evt) {
 818                         egConfirmDialog.open(
 819                             egCore.strings.OVERRIDE_TRANSFER_COPY_BUCKET_ITEMS_TO_MARKED_VOLUME_TITLE,
 820                             egCore.strings.OVERRIDE_TRANSFER_COPY_BUCKET_ITEMS_TO_MARKED_VOLUME_BODY,
 821                             {'evt_desc': evt.desc}
 822                         ).result.then(function() {
 823                             egCore.net.request(
 824                                 'open-ils.cat',
 825                                 'open-ils.cat.transfer_copies_to_volume.override',
 826                                 egCore.auth.token(),
 827                                 xfer_target,
 828                                 copy_ids,
 829                                 { events: ['TITLE_LAST_COPY', 'COPY_DELETE_WARNING'] }
 830                             ).then(function(resp) {
 831                                 bucketSvc.bucketNeedsRefresh = true;
 832                                 drawBucket();
 833                             });
 834                         });
 835                     } else {
 836                         bucketSvc.bucketNeedsRefresh = true;
 837                         drawBucket();
 838                     }
 839                 },
 840                 null, // onerror
 841                 null // onprogress
 842             )
 843         }
 844     }
 845
 846     $scope.applyTags = function(copies) {
 847         return $uibModal.open({
 848             templateUrl: './cat/bucket/copy/t_apply_tags',
 849             backdrop: 'static',
 850             animation: true,
 851             controller:
 852                    ['$scope','$uibModalInstance',
 853             function($scope , $uibModalInstance) {
 854
 855                 $scope.tag_map = [];
 856
 857                 egCore.pcrud.retrieveAll('cctt', {order_by : { cctt : 'label' }}, {atomic : true}).then(function(list) {
 858                     $scope.tag_types = list;
 859                     $scope.tag_type = $scope.tag_types[0].code(); // just pick a default
 860                 });
 861
 862                 $scope.getTags = function(val) {
 863                     return egCore.pcrud.search('acpt',
 864                         {
 865                             owner :  egCore.org.fullPath(egCore.auth.user().ws_ou(), true),
 866                             label : { 'startwith' : {
 867                                         transform: 'evergreen.lowercase',
 868                                         value : [ 'evergreen.lowercase', val ]
 869                                     }},
 870                             tag_type : $scope.tag_type
 871                         },
 872                         { order_by : { 'acpt' : ['label'] } }, { atomic: true }
 873                     ).then(function(list) {
 874                         return list.map(function(item) {
 875                             return { value: item.label(), display: item.label() + " (" + egCore.org.get(item.owner()).shortname() + ")" };
 876                         });
 877                     });
 878                 }
 879
 880                 $scope.addTag = function() {
 881                     var tagLabel = $scope.selectedLabel;
 882                     // clear the typeahead
 883                     $scope.selectedLabel = "";
 884
 885                     egCore.pcrud.search('acpt',
 886                         {
 887                             owner : egCore.org.fullPath(egCore.auth.user().ws_ou(), true),
 888                             label : tagLabel,
 889                             tag_type : $scope.tag_type
 890                         },
 891                         { order_by : { 'acpt' : ['label'] } }, { atomic: true }
 892                     ).then(function(list) {
 893                         if (list.length > 0) {
 894                             var newMap = new egCore.idl.acptcm();
 895                             newMap.isnew(1);
 896                             newMap.tag(egCore.idl.Clone(list[0]));
 897                             $scope.tag_map.push(newMap);
 898                         }
 899                     });
 900                 }
 901
 902                 $scope.ok = function() {
 903                     var promises = [];
 904                     angular.forEach($scope.tag_map, function(map) {
 905                         if (map.isdeleted()) return;
 906                         angular.forEach(copies, function (cp) {
 907                             var m = new egCore.idl.acptcm();
 908                             m.isnew(1);
 909                             m.copy(cp.id);
 910                             m.tag(map.tag().id());
 911                             promises.push(egCore.pcrud.create(m));
 912                         });
 913                     });
 914                     return $q.all(promises).then(function(){$uibModalInstance.close()});
 915                 }
 916
 917                 $scope.cancel = function($event) {
 918                     $uibModalInstance.dismiss();
 919                     $event.preventDefault();
 920                 }
 921             }]
 922         });
 923     }
 924
 925     // fetch the bucket;  on error show the not-allowed message
 926     if ($scope.bucketId)
 927         drawBucket()['catch'](function() { $scope.forbidden = true });
 928 }])