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','egUser',
 518         'egConfirmDialog',
 519 function($scope,  $q , $routeParams , $timeout , $window , $uibModal , bucketSvc , egCore , egUser ,
 520          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.requestItems = function() {
 619         var copy_list = $scope.gridControls.selectedItems().map(
 620             function (i) {
 621                 return i.id;
 622             }
 623         );
 624
 625         if (copy_list.length == 0) return;
 626
 627         return $uibModal.open({
 628             templateUrl: './cat/catalog/t_request_items',
 629             backdrop: 'static',
 630             animation: true,
 631             controller:
 632                    ['$scope','$uibModalInstance',
 633             function($scope , $uibModalInstance) {
 634                 $scope.user = null;
 635                 $scope.first_user_fetch = true;
 636
 637                 $scope.hold_data = {
 638                     hold_type : 'C',
 639                     copy_list : copy_list,
 640                     pickup_lib: egCore.org.get(egCore.auth.user().ws_ou()),
 641                     user      : egCore.auth.user().id()
 642                 };
 643
 644                 egUser.get( $scope.hold_data.user ).then(function(u) {
 645                     $scope.user = u;
 646                     $scope.barcode = u.card().barcode();
 647                     $scope.user_name = egUser.format_name(u);
 648                     $scope.hold_data.user = u.id();
 649                 });
 650
 651                 $scope.user_name = '';
 652                 $scope.barcode = '';
 653                 $scope.$watch('barcode', function (n) {
 654                     if (!$scope.first_user_fetch) {
 655                         egUser.getByBarcode(n).then(function(u) {
 656                             $scope.user = u;
 657                             $scope.user_name = egUser.format_name(u);
 658                             $scope.hold_data.user = u.id();
 659                         }, function() {
 660                             $scope.user = null;
 661                             $scope.user_name = '';
 662                             delete $scope.hold_data.user;
 663                         });
 664                     }
 665                     $scope.first_user_fetch = false;
 666                 });
 667
 668                 $scope.ok = function(h) {
 669                     var args = {
 670                         patronid  : h.user,
 671                         hold_type : h.hold_type,
 672                         pickup_lib: h.pickup_lib.id(),
 673                         depth     : 0
 674                     };
 675
 676                     egCore.net.request(
 677                         'open-ils.circ',
 678                         'open-ils.circ.holds.test_and_create.batch.override',
 679                         egCore.auth.token(), args, h.copy_list
 680                     );
 681
 682                     $uibModalInstance.close();
 683                 }
 684
 685                 $scope.cancel = function($event) {
 686                     $uibModalInstance.dismiss();
 687                     $event.preventDefault();
 688                 }
 689             }]
 690         });
 691     }
 692
 693     $scope.deleteCopiesFromCatalog = function(copies) {
 694         egConfirmDialog.open(
 695             egCore.strings.CONFIRM_DELETE_COPY_BUCKET_ITEMS_FROM_CATALOG,
 696             '', {}
 697         ).result.then(function() {
 698             var fleshed_copies = [];
 699             var promises = [];
 700             angular.forEach(copies, function(i) {
 701                 promises.push(
 702                     egCore.net.request(
 703                         'open-ils.search',
 704                         'open-ils.search.asset.copy.fleshed2.retrieve',
 705                         i.id
 706                     ).then(function(copy) {
 707                         copy.ischanged(1);
 708                         copy.isdeleted(1);
 709                         fleshed_copies.push(copy);
 710                     })
 711                 );
 712             });
 713             $q.all(promises).then(function() {
 714                 egCore.net.request(
 715                     'open-ils.cat',
 716                     'open-ils.cat.asset.copy.fleshed.batch.update',
 717                     egCore.auth.token(), fleshed_copies, true
 718                 ).then(function(resp) {
 719                     var evt = egCore.evt.parse(resp);
 720                     if (evt) {
 721                         egConfirmDialog.open(
 722                             egCore.strings.OVERRIDE_DELETE_COPY_BUCKET_ITEMS_FROM_CATALOG_TITLE,
 723                             egCore.strings.OVERRIDE_DELETE_COPY_BUCKET_ITEMS_FROM_CATALOG_BODY,
 724                             {'evt_desc': evt.desc}
 725                         ).result.then(function() {
 726                             egCore.net.request(
 727                                 'open-ils.cat',
 728                                 'open-ils.cat.asset.copy.fleshed.batch.update.override',
 729                                 egCore.auth.token(), fleshed_copies, true,
 730                                 { events: ['TITLE_LAST_COPY', 'COPY_DELETE_WARNING'] }
 731                             ).then(function(resp) {
 732                                 bucketSvc.bucketNeedsRefresh = true;
 733                                 drawBucket();
 734                             });
 735                         });
 736                     }
 737                     bucketSvc.bucketNeedsRefresh = true;
 738                     drawBucket();
 739                 });
 740             });
 741         });
 742     }
 743
 744     $scope.transferCopies = function(copies) {
 745         var xfer_target = egCore.hatch.getLocalItem('eg.cat.transfer_target_vol');
 746         var copy_ids = copies.map(
 747             function(curr,idx,arr) {
 748                 return curr.id;
 749             }
 750         );
 751         if (xfer_target) {
 752             egCore.net.request(
 753                 'open-ils.cat',
 754                 'open-ils.cat.transfer_copies_to_volume',
 755                 egCore.auth.token(),
 756                 xfer_target,
 757                 copy_ids
 758             ).then(
 759                 function(resp) { // oncomplete
 760                     var evt = egCore.evt.parse(resp);
 761                     if (evt) {
 762                         egConfirmDialog.open(
 763                             egCore.strings.OVERRIDE_TRANSFER_COPY_BUCKET_ITEMS_TO_MARKED_VOLUME_TITLE,
 764                             egCore.strings.OVERRIDE_TRANSFER_COPY_BUCKET_ITEMS_TO_MARKED_VOLUME_BODY,
 765                             {'evt_desc': evt.desc}
 766                         ).result.then(function() {
 767                             egCore.net.request(
 768                                 'open-ils.cat',
 769                                 'open-ils.cat.transfer_copies_to_volume.override',
 770                                 egCore.auth.token(),
 771                                 xfer_target,
 772                                 copy_ids,
 773                                 { events: ['TITLE_LAST_COPY', 'COPY_DELETE_WARNING'] }
 774                             ).then(function(resp) {
 775                                 bucketSvc.bucketNeedsRefresh = true;
 776                                 drawBucket();
 777                             });
 778                         });
 779                     } else {
 780                         bucketSvc.bucketNeedsRefresh = true;
 781                         drawBucket();
 782                     }
 783                 },
 784                 null, // onerror
 785                 null // onprogress
 786             )
 787         }
 788     }
 789
 790     $scope.applyTags = function(copies) {
 791         return $uibModal.open({
 792             templateUrl: './cat/bucket/copy/t_apply_tags',
 793             backdrop: 'static',
 794             animation: true,
 795             controller:
 796                    ['$scope','$uibModalInstance',
 797             function($scope , $uibModalInstance) {
 798
 799                 $scope.tag_map = [];
 800
 801                 egCore.pcrud.retrieveAll('cctt', {order_by : { cctt : 'label' }}, {atomic : true}).then(function(list) {
 802                     $scope.tag_types = list;
 803                     $scope.tag_type = $scope.tag_types[0].code(); // just pick a default
 804                 });
 805
 806                 $scope.getTags = function(val) {
 807                     return egCore.pcrud.search('acpt',
 808                         {
 809                             owner :  egCore.org.fullPath(egCore.auth.user().ws_ou(), true),
 810                             label : { 'startwith' : {
 811                                         transform: 'evergreen.lowercase',
 812                                         value : [ 'evergreen.lowercase', val ]
 813                                     }},
 814                             tag_type : $scope.tag_type
 815                         },
 816                         { order_by : { 'acpt' : ['label'] } }, { atomic: true }
 817                     ).then(function(list) {
 818                         return list.map(function(item) {
 819                             return item.label();
 820                         });
 821                     });
 822                 }
 823
 824                 $scope.addTag = function() {
 825                     var tagLabel = $scope.selectedLabel;
 826                     // clear the typeahead
 827                     $scope.selectedLabel = "";
 828
 829                     egCore.pcrud.search('acpt',
 830                         {
 831                             owner : egCore.org.fullPath(egCore.auth.user().ws_ou(), true),
 832                             label : tagLabel,
 833                             tag_type : $scope.tag_type
 834                         },
 835                         { order_by : { 'acpt' : ['label'] } }, { atomic: true }
 836                     ).then(function(list) {
 837                         if (list.length > 0) {
 838                             var newMap = new egCore.idl.acptcm();
 839                             newMap.isnew(1);
 840                             newMap.tag(egCore.idl.Clone(list[0]));
 841                             $scope.tag_map.push(newMap);
 842                         }
 843                     });
 844                 }
 845
 846                 $scope.ok = function() {
 847                     var promises = [];
 848                     angular.forEach($scope.tag_map, function(map) {
 849                         if (map.isdeleted()) return;
 850                         angular.forEach(copies, function (cp) {
 851                             var m = new egCore.idl.acptcm();
 852                             m.isnew(1);
 853                             m.copy(cp.id);
 854                             m.tag(map.tag().id());
 855                             promises.push(egCore.pcrud.create(m));
 856                         });
 857                     });
 858                     return $q.all(promises).then(function(){$uibModalInstance.close()});
 859                 }
 860
 861                 $scope.cancel = function($event) {
 862                     $uibModalInstance.dismiss();
 863                     $event.preventDefault();
 864                 }
 865             }]
 866         });
 867     }
 868
 869     // fetch the bucket;  on error show the not-allowed message
 870     if ($scope.bucketId)
 871         drawBucket()['catch'](function() { $scope.forbidden = true });
 872 }])