Open-ILS/web/js/ui/default/staff/acq/services/requests.js

   1 /**
   2  * AcqRequests, yo
   3  */
   4
   5 angular.module('egCoreMod')
   6
   7 .factory('egAcqRequests',
   8
   9        ['$uibModal','$q','egCore','egOrg','ngToast',
  10 function($uibModal , $q , egCore , egOrg , ngToast) {
  11
  12     var service = {};
  13
  14     var aur_fleshing = {
  15
  16         flesh : 2,
  17         // aur   ->  cancel_reason
  18         // aur   ->  lineitem
  19         // aur   ->  pickup_lib
  20         // aur   ->  request_type
  21         // aur   ->  usr
  22         // aur   ->  usr            -> card
  23
  24         flesh_fields : {
  25              'aur' : [
  26                  'cancel_reason'
  27                 ,'lineitem'
  28                 ,'pickup_lib'
  29                 ,'request_type'
  30                 ,'usr'
  31             ]
  32             ,'au'  : [
  33                  'card'
  34                 ,'home_ou'
  35                 ,'mailing_address'
  36                 ,'billing_address'
  37                 ,'settings'
  38             ]
  39         }
  40     };
  41
  42     var aurs_fleshing = {
  43
  44         flesh : 2,
  45         // aurs   ->  cancel_reason
  46         // aurs   ->  lineitem
  47         // aurs   ->  pickup_lib
  48         // aurs   ->  request_type
  49         // aurs   ->  request_status
  50         // aurs   ->  usr
  51         // aurs   ->  usr            -> card
  52
  53         flesh_fields : {
  54              'aurs' : [
  55                  'cancel_reason'
  56                 ,'lineitem'
  57                 ,'pickup_lib'
  58                 ,'request_type'
  59                 ,'request_status'
  60                 ,'usr'
  61             ]
  62             ,'au'  : [
  63                  'card'
  64                 ,'home_ou'
  65                 ,'mailing_address'
  66                 ,'billing_address'
  67                 ,'settings'
  68             ]
  69         }
  70     };
  71
  72     service.aur_fleshing = function(newvalue) {
  73         if (newvalue) {
  74             aur_fleshing = newvalue;
  75         }
  76         return angular.copy(aur_fleshing);
  77     }
  78
  79     service.aurs_fleshing = function(newvalue) {
  80         if (newvalue) {
  81             aurs_fleshing = newvalue;
  82         }
  83         return angular.copy(aurs_fleshing);
  84     }
  85
  86     service.fetch_request = function(aur_id) {
  87         var deferred = $q.defer();
  88         egCore.pcrud.search(
  89             'aur', { id : aur_id }, aur_fleshing, { atomic : true, authoritative : true }
  90         ).then(function(requests) {
  91             deferred.resolve(requests[0]);
  92         });
  93         return deferred.promise;
  94     }
  95
  96     service.fetch_request_with_status = function(aur_id) {
  97         var deferred = $q.defer();
  98         egCore.pcrud.search(
  99             'aurs', { id : aur_id }, aurs_fleshing, { atomic : true, authoritative : true }
 100         ).then(function(requests) {
 101             deferred.resolve(requests[0]);
 102         });
 103         return deferred.promise;
 104     }
 105
 106     service.fetch_cancel_reasons = function() {
 107         var deferred = $q.defer();
 108         egCore.pcrud.retrieveAll(
 109             'acqcr', {}, {atomic : true, authoritative : true}
 110         ).then(function(cancel_reasons) {
 111             deferred.resolve(cancel_reasons);
 112         });
 113         return deferred.promise;
 114     }
 115
 116     service.fetch_request_types = function() {
 117         var deferred = $q.defer();
 118         egCore.pcrud.retrieveAll(
 119             'aurt', {}, {atomic : true, authoritative : true}
 120         ).then(function(request_types) {
 121             deferred.resolve(request_types);
 122         });
 123         return deferred.promise;
 124     }
 125
 126     service.fetch_request_status_types = function() {
 127         var deferred = $q.defer();
 128         egCore.pcrud.retrieveAll(
 129             'aurst', {}, {atomic : true, authoritative : true}
 130         ).then(function(request_status_types) {
 131             deferred.resolve(request_status_types);
 132         });
 133         return deferred.promise;
 134     }
 135
 136     service.add_request_to_picklist = function (row) {
 137         egCore.pcrud.search('aurs', {
 138                 id : row['id']
 139             }, aurs_fleshing, {
 140                 atomic : true
 141             }
 142         ).then(function(requests) {
 143             var aur_obj = requests[0];
 144             var prepop = { // based on acq.lineitem_marc_attr_definition
 145                 "1": [aur_obj.title(), aur_obj.article_title(), aur_obj.volume()].join(' '),
 146                 "2": aur_obj.author(),
 147                 "4": aur_obj.article_pages(),
 148                 "7": aur_obj.upc(),
 149                 "10": aur_obj.publisher(),
 150                 "11": aur_obj.pubdate()
 151             }
 152             if (aur_obj.request_type().id() == "2") { /* Articles */
 153                 prepop["6"] = aur_obj.isxn();
 154             } else {
 155                 prepop["5"] = aur_obj.isxn();
 156             }
 157             location.href = "/eg/staff/acq/legacy/picklist/brief_record?ur="
 158                 + aur_obj.id() + "&prepop=" + encodeURIComponent(js2JSON(prepop));
 159         });
 160     }
 161
 162     service.view_picklist = function (row) {
 163         location.href = "/eg/staff/acq/legacy/picklist/view/" + row['lineitem.picklist'];
 164     }
 165
 166     service.handle_request = function(row,mode,context_ou,callback) {
 167         if (mode!='create' && !row) { return; }
 168         return $uibModal.open({
 169             templateUrl: './acq/requests/t_edit',
 170             backdrop: 'static',
 171             controller: ['$scope',  '$uibModalInstance','egCore',
 172                          'request_and_extra','request_types','request_status_types',
 173                  function($m_scope , $uibModalInstance , egCore ,
 174                           request_and_extra , request_types , request_status_types ) {
 175                     var request = request_and_extra.request;
 176                     var extra = request_and_extra.extra || {};
 177                     var today = new Date();
 178                     today.setHours(0);
 179                     today.setMinutes(0);
 180                     today.setSeconds(0);
 181                     today.setMilliseconds(0);
 182                     $m_scope.minDate = today;
 183                     $m_scope.mode = mode;
 184                     $m_scope.request = request;
 185                     $m_scope.request_types = request_types;
 186                     $m_scope.extra = extra;
 187                     $m_scope.extra.user_obj = request.usr;
 188                     angular.forEach(['hold', 'email_notify'], function(field) {
 189                         if (request[field] == 't') {
 190                             request[field] = true;
 191                         } else if (request[field] == 'f' || typeof request[field] == 'undefined') {
 192                             request[field] = false;
 193                         }
 194                     });
 195                     if (request.request_type) {
 196                         if (typeof request.request_type.id != 'undefined') {
 197                             request.request_type = request.request_type.id;
 198                         }
 199                         angular.forEach(request_types,function(v,k) {
 200                             if (v.id() == request.request_type) {
 201                                 $m_scope.extra.selected_request_type = v;
 202                             }
 203                         });
 204                     }
 205                     if (request.need_before) {
 206                         request.need_before = new Date(request.need_before);
 207                     }
 208                     if (request.pickup_lib) {
 209                         $m_scope.request.pickup_lib =
 210                             egCore.idl.fromHash('aou',request.pickup_lib);
 211                     } else {
 212                         $m_scope.request.pickup_lib =
 213                             egOrg.CanHaveVolumes(context_ou)
 214                             ? context_ou
 215                             : egOrg.get( egCore.auth.user().ws_ou() );
 216                     }
 217                     if (request.cancel_reason) {
 218                         $m_scope.request.cancel_reason =
 219                             egCore.idl.fromHash('acqcr',request.cancel_reason);
 220                         $m_scope.mode = 'view'; // TODO: want explicit uncancel?
 221                     }
 222                     if (request.request_status && request.request_status.id != 1) { // New
 223                         $m_scope.mode = 'view';
 224                     }
 225                     if (request.usr) {
 226                         if (typeof request.usr.id != 'undefined') {
 227                             $m_scope.extra.barcode = request.usr.card.barcode;
 228                             request.usr = request.usr.id;
 229                         }
 230                     }
 231                     $m_scope.cancel = function () {
 232                         $uibModalInstance.dismiss('canceled');
 233                     }
 234                     $m_scope.ok = function(request2,extra2) {
 235                         $uibModalInstance.close({
 236                              'request':request2
 237                             ,'extra':extra2
 238                         });
 239                     }
 240                     $m_scope.model_has_changed = false;
 241                     $m_scope.cant_have_vols = function (id) {
 242                         return !egCore.org.CanHaveVolumes(id);
 243                     }
 244                     $m_scope.find_user = function () {
 245
 246                         $m_scope.request.usr = null;
 247                         $m_scope.extra.user_obj = null;
 248                         if (!$m_scope.extra.barcode) return;
 249
 250                         egCore.net.request(
 251                             'open-ils.actor',
 252                             'open-ils.actor.get_barcodes',
 253                             egCore.auth.token(), egCore.auth.user().ws_ou(),
 254                             'actor', $m_scope.extra.barcode)
 255
 256                         .then(function(resp) { // get_barcodes
 257
 258                             if (evt = egCore.evt.parse(resp)) {
 259                                 console.error(evt.toString());
 260                                 return;
 261                             }
 262
 263                             if (!resp || !resp[0]) {
 264                                 $m_scope.request.usr = null;
 265                                 return;
 266                             }
 267
 268                             egCore.pcrud.search('au', {
 269                                     id : resp[0].id
 270                                 }, {
 271                                     flesh : 1,
 272                                     flesh_fields : {
 273                                         'au'  : [
 274                                              'card'
 275                                             ,'home_ou'
 276                                             ,'mailing_address'
 277                                             ,'billing_address'
 278                                             ,'settings'
 279                                         ]
 280                                     }
 281                                 },
 282                                 { atomic : true }
 283                             ).then(function(users) {
 284                                 var usr = egCore.idl.toHash(users[0]);
 285                                 $m_scope.extra.user_obj = usr;
 286                                 $m_scope.request.usr = usr.id;
 287                                 $m_scope.request.pickup_lib = egOrg.get(usr.home_ou.id);
 288                                 $m_scope.request.phone_notify = usr.day_phone;
 289                                 angular.forEach(usr.settings, function(s) {
 290                                     if (s.name == 'opac.hold_notify') {
 291                                         if (s.value.match('phone')) {
 292                                             $m_scope.extra.phone_notify = true;
 293                                         }
 294                                         if (s.value.match('email')) {
 295                                             $m_scope.request.email_notify = true;
 296                                         }
 297                                     }
 298                                     if (s.name == 'opac.default_phone') {
 299                                         $m_scope.request.phone_notify = s.value.replace(/^"/,'').replace(/"$/,'');
 300                                     }
 301                                     if (s.name == 'opac.default_pickup_location') {
 302                                         $m_scope.request.pickup_lib =
 303                                             egOrg.get(s.value);
 304                                     }
 305                                 });
 306                                 return $m_scope.request;
 307                             });
 308                         });
 309                     }
 310                     $m_scope.$watch("extra.barcode", function(newVal, oldVal) {
 311                         if (newVal && newVal != oldVal) {
 312                             $m_scope.find_user();
 313                         }
 314                     });
 315                     $m_scope.$watch("extra.selected_request_type",
 316                         function(newVal, oldVal) {
 317                             if (newVal && newVal != oldVal) {
 318                                 $m_scope.request.request_type = newVal.id();
 319                             }
 320                         }
 321                     );
 322             }],
 323             resolve : {
 324                  request_and_extra : function() {
 325                     if (mode=='create') {
 326                         var aur_obj = egCore.idl.toHash(new egCore.idl.aurs());
 327                         var extra = {};
 328                         if (row['usr']) {
 329                             return egCore.pcrud.search('au', {
 330                                     id : row['usr']
 331                                 }, {
 332                                     flesh : 1,
 333                                     flesh_fields : {
 334                                         'au'  : [
 335                                              'card'
 336                                             ,'home_ou'
 337                                             ,'mailing_address'
 338                                             ,'billing_address'
 339                                             ,'settings'
 340                                         ]
 341                                     }
 342                                 },
 343                                 { atomic : true }
 344                             ).then(function(users) {
 345                                 if (users.length > 0) {
 346                                     var usr = egCore.idl.toHash(users[0]);
 347                                     aur_obj.usr = usr.id;
 348                                     aur_obj.pickup_lib = egCore.idl.toHash(
 349                                         egOrg.get(usr.home_ou.id)
 350                                     );
 351                                     aur_obj.phone_notify = usr.day_phone;
 352                                     angular.forEach(usr.settings, function(s) {
 353                                         if (s.name == 'opac.hold_notify') {
 354                                             if (s.value.match('phone')) {
 355                                                 extra.phone_notify = true;
 356                                             }
 357                                             if (s.value.match('email')) {
 358                                                 aur_obj.email_notify = true;
 359                                             }
 360                                         }
 361                                         if (s.name == 'opac.default_phone') {
 362                                             aur_obj.phone_notify = s.value.replace(/^"/,'').replace(/"$/,'');
 363                                         }
 364                                         if (s.name == 'opac.default_pickup_location') {
 365                                             aur_obj.pickup_lib = egCore.idl.toHash(
 366                                                 egOrg.get(s.value)
 367                                             );
 368                                         }
 369                                     });
 370                                 }
 371                                 return { 'request' : aur_obj, 'extra' : extra };
 372                             });
 373                         } else {
 374                             console.log('here');
 375                             return { 'request' : aur_obj, 'extra': extra };
 376                         }
 377                     } else {
 378                         return egCore.pcrud.search('aurs', {
 379                                 id : row['id']
 380                             }, aurs_fleshing, {
 381                                 atomic : true
 382                             }
 383                         ).then(function(requests) {
 384                             var aur_obj = egCore.idl.toHash(requests[0]);
 385                             var extra = {};
 386                             if (aur_obj.phone_notify) {
 387                                 extra.phone_notify = true;
 388                             }
 389                             return { 'request' : aur_obj, 'extra' : extra };
 390                         });
 391                     }
 392                 }
 393                 ,request_types : function() {
 394                     return service.fetch_request_types();
 395                 }
 396                 ,request_status_types : function() {
 397                     return service.fetch_request_status_types();
 398                 }
 399             }
 400         }).result.then(function(data) {
 401             delete data.request.request_status;
 402             delete data.request.home_ou;
 403             var aur_obj = new egCore.idl.fromHash('aur',data.request);
 404             if (aur_obj.need_before() && typeof aur_obj.need_before() == 'object') {
 405                 aur_obj.need_before( aur_obj.need_before().toISOString() );
 406             }
 407             if (!data.extra.phone_notify) {
 408                 aur_obj.phone_notify(null);
 409             }
 410             if (mode=='create') {
 411                 aur_obj.isnew('t');
 412                 aur_obj.pickup_lib( aur_obj.pickup_lib().id() );
 413                 return egCore.net.request(
 414                     'open-ils.acq',
 415                     'open-ils.acq.user_request.create',
 416                     egCore.auth.token(), egCore.idl.toHash(aur_obj)
 417                 ).then(function(resp) {
 418                     var evt = egCore.evt.parse(resp);
 419                     if (evt) {
 420                         ngToast.danger(egCore.strings.CREATE_USER_REQUEST_FAIL + ' : ' + evt.desc);
 421                     } else {
 422                         ngToast.success(egCore.strings.CREATE_USER_REQUEST_SUCCESS);
 423                     }
 424                     callback(resp);
 425                 });
 426             } else {
 427                 aur_obj.ischanged('t');
 428                 return egCore.pcrud.apply(aur_obj).then(function(resp) {
 429                     var evt = egCore.evt.parse(resp);
 430                     if (evt) {
 431                         ngToast.danger(egCore.strings.EDIT_USER_REQUEST_FAIL + ' : ' + evt.desc);
 432                     } else {
 433                         ngToast.success(egCore.strings.EDIT_USER_REQUEST_SUCCESS);
 434                     }
 435                     callback(resp);
 436                 });
 437             }
 438         }).catch(function(e) {
 439             console.log('caught',e);
 440         });
 441     }
 442
 443     service.set_no_hold_requests = function(rows,callback) {
 444         var ids = rows.map(function(v,i,a) {
 445             return v.id;
 446         });
 447         return $uibModal.open({
 448             templateUrl: './acq/requests/t_set_no_hold',
 449             backdrop: 'static',
 450             controller: ['$scope',  '$uibModalInstance','egCore',
 451                  function($m_scope , $uibModalInstance , egCore ) {
 452                     $m_scope.ids = ids;
 453                     $m_scope.cancel = function () {
 454                         $uibModalInstance.dismiss('canceled');
 455                     }
 456                     $m_scope.ok = function(doit) {
 457                         $uibModalInstance.close(doit);
 458                     }
 459             }],
 460             resolve : {}
 461         }).result.then(function(cancel_reason) {
 462             return egCore.net.request(
 463                 'open-ils.acq',
 464                 'open-ils.acq.user_request.set_no_hold.batch',
 465                 egCore.auth.token(), ids
 466             ).then(function(obj) {
 467                 if (callback) {
 468                     callback(obj);
 469                 }
 470             });
 471         }).catch(function(e) {
 472             console.log('caught',e);
 473         });
 474     }
 475
 476     service.set_yes_hold_requests = function(rows,callback) {
 477         var ids = rows.map(function(v,i,a) {
 478             return v.id;
 479         });
 480         return $uibModal.open({
 481             templateUrl: './acq/requests/t_set_yes_hold',
 482             backdrop: 'static',
 483             controller: ['$scope',  '$uibModalInstance','egCore',
 484                  function($m_scope , $uibModalInstance , egCore ) {
 485                     $m_scope.ids = ids;
 486                     $m_scope.cancel = function () {
 487                         $uibModalInstance.dismiss('canceled');
 488                     }
 489                     $m_scope.ok = function(doit) {
 490                         $uibModalInstance.close(doit);
 491                     }
 492             }],
 493             resolve : {}
 494         }).result.then(function(cancel_reason) {
 495             return egCore.net.request(
 496                 'open-ils.acq',
 497                 'open-ils.acq.user_request.set_yes_hold.batch',
 498                 egCore.auth.token(), ids
 499             ).then(function(obj) {
 500                 if (callback) {
 501                     callback(obj);
 502                 }
 503             });
 504         }).catch(function(e) {
 505             console.log('caught',e);
 506         });
 507     }
 508
 509     service.cancel_requests = function(rows,callback) {
 510         var ids = rows.map(function(v,i,a) {
 511             return v.id;
 512         });
 513         return $uibModal.open({
 514             templateUrl: './acq/requests/t_cancel',
 515             backdrop: 'static',
 516             controller: ['$scope',  '$uibModalInstance','egCore','cancel_reasons',
 517                  function($m_scope , $uibModalInstance , egCore , cancel_reasons ) {
 518                     $m_scope.ids = ids;
 519                     $m_scope.cancel_reasons = cancel_reasons;
 520                     $m_scope.cancel = function () {
 521                         $uibModalInstance.dismiss('canceled');
 522                     }
 523                     $m_scope.ok = function(cancel_reason) {
 524                         $uibModalInstance.close(cancel_reason);
 525                     }
 526             }],
 527             resolve : {
 528                 cancel_reasons : function() {
 529                     return service.fetch_cancel_reasons();
 530                 }
 531             }
 532         }).result.then(function(cancel_reason) {
 533             return egCore.net.request(
 534                 'open-ils.acq',
 535                 'open-ils.acq.user_request.cancel.batch.atomic',
 536                 egCore.auth.token(), ids, cancel_reason.id()
 537             ).then(function(obj) {
 538                 if (callback) {
 539                     callback(obj);
 540                 }
 541             });
 542         }).catch(function(e) {
 543             console.log('caught',e);
 544         });
 545     }
 546
 547     service.clear_requests = function(rows,callback) {
 548         var ids = rows.map(function(v,i,a) {
 549             return v.id;
 550         });
 551         return $uibModal.open({
 552             templateUrl: './acq/requests/t_clear',
 553             backdrop: 'static',
 554             controller: ['$scope',  '$uibModalInstance','egCore',
 555                  function($m_scope , $uibModalInstance , egCore) {
 556                     $m_scope.ids = ids;
 557                     $m_scope.cancel = function () {
 558                         $uibModalInstance.dismiss('canceled');
 559                     }
 560                     $m_scope.ok = function(cancel_reason) {
 561                         $uibModalInstance.close(true);
 562                     }
 563             }],
 564             resolve : {}
 565         }).result.then(function(doit) {
 566             return egCore.net.request(
 567                 'open-ils.acq',
 568                 'open-ils.acq.clear_completed_user_requests',
 569                 egCore.auth.token(), ids
 570             ).then(function(obj) {
 571                 if (callback) {
 572                     callback(obj);
 573                 }
 574             });
 575         }).catch(function(e) {
 576             console.log('caught',e);
 577         });
 578     }
 579
 580     return service;
 581 }])
 582 ;