Open-ILS/web/opac/skin/default/js/holds.js

   1 var holdsOrgSelectorBuilt = false;
   2 var holdArgs;
   3
   4 /*
   5 note: metarecord holds have a holdable_formats field that contains
   6 item_type(s)-item_forms(s)-language
   7 item_form and language are optional - if language exist and no
   8 item_form is specified, use item_type(s)--language
   9 */
  10
  11 var noEmailMessage;
  12 var noEmailMessageXUL;
  13
  14 function holdsHandleStaff() {
  15
  16     // if we know the recipient's barcode, use it
  17     if(xulG.patron_barcode) return _holdsHandleStaff();
  18
  19         swapCanvas($('xulholds_box'));
  20         $('xul_recipient_barcode').focus();
  21         $('xul_recipient_barcode').onkeypress = function(evt)
  22                 {if(userPressedEnter(evt)) { _holdsHandleStaff(); } };
  23         $('xul_recipient_barcode_submit').onclick = _holdsHandleStaff;
  24         $('xul_recipient_me').onclick = _holdsHandleStaffMe;
  25
  26         $('xul_recipient_barcode').onkeyup = function(evt) {
  27         if($('xul_recipient_barcode').value == '')
  28             $('xul_recipient_me').disabled = false;
  29         else
  30             $('xul_recipient_me').disabled = true;
  31     };
  32 }
  33
  34 $('holds_frozen_thaw_input').onchange =
  35         function(){holdsVerifyThawDateUI('holds_frozen_thaw_input');}
  36 $('holds_frozen_thaw_input').onkeyup =
  37         function(){holdsVerifyThawDateUI('holds_frozen_thaw_input');}
  38
  39 function _holdsHandleStaffMe() {
  40         holdArgs.recipient = G.user;
  41         holdsDrawEditor();
  42 }
  43
  44 function _holdsHandleStaff() {
  45         var barcode = xulG.patron_barcode || $('xul_recipient_barcode').value;
  46         var user = grabUserByBarcode( G.user.session, barcode );
  47
  48         var evt;
  49         if(evt = checkILSEvent(user)) {
  50                 alertILSEvent(user);
  51                 return;
  52         }
  53
  54         if(!barcode || !user) {
  55                 alertId('holds_invalid_recipient', barcode);
  56                 return
  57         }
  58
  59         grabUserPrefs(user);
  60
  61         holdArgs.recipient = user;
  62         holdsDrawEditor();
  63 }
  64
  65
  66
  67 /** args:
  68   * record, volume, copy (ids)
  69   * request, recipient, editHold (objects)
  70   */
  71
  72 function holdsDrawEditor(args) {
  73
  74         holdArgs = (args) ? args : holdArgs;
  75
  76     if(!noEmailMessage)
  77         noEmailMessage = $('holds_email').removeChild($('holds.no_email'));
  78
  79     if(!noEmailMessageXUL)
  80         noEmailMessageXUL = $('holds_email').removeChild($('holds.no_email.xul'));
  81
  82         if(isXUL() && holdArgs.recipient == null
  83                         && holdArgs.editHold == null) {
  84                 holdsHandleStaff();
  85                 return;
  86         }
  87
  88         if(!holdArgs.recipient) holdArgs.recipient = G.user;
  89         if(!holdArgs.requestor) holdArgs.requestor = G.user;
  90
  91         if(!(holdArgs.requestor && holdArgs.requestor.session)) {
  92                 detachAllEvt('common','locationChanged');
  93                 attachEvt('common','loggedIn', holdsDrawEditor)
  94                 initLogin();
  95                 return;
  96         }
  97
  98         if(holdArgs.editHold) // flesh the args with the existing hold
  99                 holdArgsFromHold(holdArgs.editHold, holdArgs);
 100
 101         holdsDrawWindow();
 102 }
 103
 104
 105 // updates the edit window with the existing hold's data
 106 function _holdsUpdateEditHold() {
 107
 108         var hold = holdArgs.editHold;
 109         var qstats = holdArgs.status;
 110
 111         var orgsel = $('holds_org_selector');
 112     var frozenbox = $('holds_frozen_chkbox');
 113
 114         setSelector(orgsel, hold.pickup_lib());
 115
 116         if( hold.capture_time() || qstats.status > 2 ) {
 117         frozenbox.disabled = true;
 118         $('holds_frozen_thaw_input').disabled = true;
 119         if(qstats.status == 3) {
 120             // no pickup lib changes while in-transit
 121                     orgsel.disabled = true;
 122         } else {
 123             var orgs = fetchPermOrgs('UPDATE_PICKUP_LIB_FROM_HOLDS_SHELF');
 124             if(orgs[0] == -1)
 125                         orgsel.disabled = true;
 126         }
 127     } else {
 128                 orgsel.disabled = false;
 129         frozenbox.disabled = false;
 130     }
 131
 132
 133         $('holds_submit').onclick = holdsEditHold;
 134         $('holds_update').onclick = holdsEditHold;
 135
 136         if(hold.phone_notify()) {
 137                 $('holds_enable_phone').checked = true;
 138                 $('holds_phone').value = hold.phone_notify();
 139
 140         } else {
 141                 $('holds_phone').disabled = true;
 142                 $('holds_enable_phone').checked = false;
 143         }
 144
 145         if(isTrue(hold.email_notify())) {
 146                 $('holds_enable_email').checked = true;
 147
 148         } else {
 149                 $('holds_enable_email').checked = false;
 150         }
 151
 152     dijit.byId('holds_expire_time').setValue(dojo.date.stamp.fromISOString(hold.expire_time()));
 153
 154     /* populate the hold freezing info */
 155     if(!frozenbox.disabled && isTrue(hold.frozen())) {
 156         frozenbox.checked = true;
 157         unHideMe($('hold_frozen_thaw_row'));
 158         if(hold.thaw_date()) {
 159             dijit.byId('holds_frozen_thaw_input').setValue(dojo.date.stamp.fromISOString(hold.thaw_date()));
 160         } else {
 161             dijit.byId('holds_frozen_thaw_input').setValue('');
 162         }
 163     } else {
 164         frozenbox.checked = false;
 165         dijit.byId('holds_frozen_thaw_input').setValue('');
 166         hideMe($('hold_frozen_thaw_row'));
 167     }
 168 }
 169
 170 function holdsEditHold() {
 171         var hold = holdsBuildHoldFromWindow();
 172         if(!hold) return;
 173         holdsUpdate(hold);
 174         showCanvas();
 175         if(holdArgs.onComplete)
 176                 holdArgs.onComplete(hold);
 177 }
 178
 179 function holdArgsFromHold(hold, oargs) {
 180         var args = (oargs) ? oargs : {};
 181         args.type = hold.hold_type();
 182         var target = hold.target();
 183
 184         switch(args.type) {
 185                 case 'M':
 186                         args.metarecord = target;
 187                         break;
 188                 case 'T':
 189                         args.record = target;
 190                         break;
 191                 case 'V':
 192                         args.volume = target;
 193                         break;
 194                 case 'C':
 195                         args.copy = target;
 196                         break;
 197         }
 198         return args;
 199 }
 200
 201 function holdFetchObjects(hold, doneCallback) {
 202
 203         var args = (hold) ? holdArgsFromHold(hold) : holdArgs;
 204
 205         var type = args.type;
 206
 207         if( type == 'C' ) {
 208
 209                 if( args.copyObject ) {
 210
 211                         args.copy = args.copyObject.id();
 212                         args.volume = args.copyObject.call_number();
 213                         _h_set_vol(args, doneCallback);
 214
 215                 } else {
 216                         var creq = new Request(FETCH_COPY, args.copy);
 217
 218                         creq.callback(
 219                                 function(r) {
 220                                         var cp = r.getResultObject();
 221                                         args.copyObject = cp;
 222                                         args.volume = args.copyObject.call_number();
 223                                         _h_set_vol(args, doneCallback);
 224                                 }
 225                         );
 226                         creq.send();
 227                 }
 228         } else {
 229                 if( type == 'V' ) {
 230                         _h_set_vol(args, doneCallback);
 231
 232                 } else {
 233                         if( type == 'T' ) {
 234                                 _h_set_rec(args, doneCallback);
 235                         } else {
 236                                 _h_set_rec_descriptors(args, doneCallback);
 237                         }
 238                 }
 239         }
 240
 241         return args;
 242 }
 243
 244 function _h_set_vol(args, doneCallback) {
 245
 246         if( args.volumeObject ) {
 247                 args.volume = args.volumeObject.id();
 248                 args.record = args.volumeObject.record();
 249                 _h_set_rec(args, doneCallback);
 250
 251         } else {
 252
 253                 var vreq = new Request(FETCH_VOLUME, args.volume);
 254                 vreq.callback(
 255                         function(r) {
 256                                 var vol = r.getResultObject();
 257                                 args.volumeObject = vol;
 258                                 args.record = vol.record();
 259                                 _h_set_rec(args, doneCallback);
 260                         }
 261                 );
 262                 vreq.send();
 263         }
 264 }
 265
 266 function _h_set_rec(args, doneCallback) {
 267
 268         if(args.recordObject)
 269                 args.record = args.recordObject.doc_id();
 270         else
 271                 args.recordObject = findRecord( args.record, 'T' );
 272
 273         if( args.type == 'T' || args.type == 'M' )
 274                 _h_set_rec_descriptors(args, doneCallback);
 275         else
 276                 if(doneCallback) doneCallback(args);
 277 }
 278
 279
 280 function _h_set_rec_descriptors(args, doneCallback) {
 281
 282         // grab the list of record desciptors attached to this records metarecord
 283         if( ! args.recordDescriptors )  {
 284                 var params = {};
 285
 286         if (args.type == 'M') {
 287                 if( !args.metarecord && args.record) {
 288                 params.metarecord = args.metarecord = args.record;
 289                 delete(args.record);
 290                 } else {
 291                                 params = { metarecord : args.metarecordObject.doc_id() };
 292                 }
 293         } else {
 294                 params = { record: args.record };
 295         }
 296
 297                 if( ! args.record ) {
 298                         if( args.metarecord )
 299                                 params = { metarecord : args.metarecord };
 300                         else
 301                                 params = { metarecord : args.metarecordObject.doc_id() };
 302                 }
 303
 304                 var req = new Request(FETCH_MR_DESCRIPTORS, params );
 305                 req.callback(
 306                         function(r) {
 307                                 var data = r.getResultObject();
 308                                 holdArgs.recordDescriptors = args.recordDescriptors = data.descriptors;
 309                                 holdArgs.metarecord = args.metarecord = data.metarecord;
 310                                 if( args.type == 'M' && ! args.metarecordObject)
 311                                         holdArgs.metarecordObject = args.metarecordObject = findRecord(args.metarecord, 'M');
 312
 313                                 if(doneCallback) doneCallback(args);
 314                         }
 315                 );
 316                 req.send();
 317
 318         } else {
 319                 if(doneCallback) doneCallback(args);
 320         }
 321
 322         return args;
 323 }
 324
 325
 326
 327 function holdsDrawWindow() {
 328         swapCanvas($('holds_box'));
 329         $('holds_cancel').onclick = function(){ runEvt('common', 'holdUpdateCanceled'), showCanvas() };
 330         $('holds_submit').onclick = function(){holdsPlaceHold(holdsBuildHoldFromWindow())};
 331         $('holds_update').onclick = function(){holdsPlaceHold(holdsBuildHoldFromWindow())};
 332         holdFetchObjects(null,
 333                 function(){
 334                         __holdsDrawWindow();
 335
 336                         if(holdArgs.editHold) {
 337                                 hideMe($('holds_submit'));
 338                                 unHideMe($('holds_update'));
 339                                 var req = new Request(FETCH_HOLD_STATUS,
 340                                         G.user.session, holdArgs.editHold.id());
 341                                 req.send(true);
 342                                 holdArgs.status = req.result();
 343                                 _holdsUpdateEditHold();
 344                         }
 345                 }
 346         );
 347 }
 348
 349 function __holdsDrawWindow() {
 350
 351         var rec = holdArgs.recordObject;
 352         var vol = holdArgs.volumeObject;
 353         var copy = holdArgs.copyObject;
 354         var mr = holdArgs.metarecordObject;
 355
 356         rec = (rec) ? rec : mr;
 357
 358         if(!holdsOrgSelectorBuilt) {
 359                 holdsBuildOrgSelector(null,0);
 360                 holdsOrgSelectorBuilt = true;
 361                 var selector = $('holds_org_selector');
 362
 363                 /*
 364                 var o_loc = findOrgUnit(getOrigLocation());
 365                 var t = findOrgType(o_loc.ou_type());
 366                 if( t.can_have_users() )
 367                         setSelector(selector, o_loc.id());
 368                 else
 369                 */
 370
 371                 setSelector(selector, holdArgs.recipient.home_ou());
 372
 373         }
 374
 375         /*
 376         if(isXUL()) {
 377                 var dsel = $('holds_depth_selector');
 378                 unHideMe($('holds_depth_selector_row'));
 379                 if(dsel.getElementsByTagName('option').length == 0) {
 380                         var types = globalOrgTypes;
 381                         var depth = findOrgDepth(G.user.ws_ou());
 382                         iterate(types,
 383                                 function(t) {
 384                                         if(t.depth() > depth) return;
 385                                         insertSelectorVal(dsel, -1, t.opac_label(), t.depth());
 386                                 }
 387                         );
 388                 }
 389         }
 390         */
 391
 392         appendClear($('holds_recipient'), text(
 393                 holdArgs.recipient.family_name() + ', ' +
 394                         holdArgs.recipient.first_given_name()));
 395         appendClear($('holds_title'), text(rec.title()));
 396         appendClear($('holds_author'), text(rec.author()));
 397
 398         if( holdArgs.type == 'V' || holdArgs.type == 'C' ) {
 399
 400                 unHideMe($('holds_type_row'));
 401                 unHideMe($('holds_cn_row'));
 402                 appendClear($('holds_cn'), text(holdArgs.volumeObject.label()));
 403
 404                 if( holdArgs.type == 'V'  ) {
 405                         unHideMe($('holds_is_cn'));
 406                         hideMe($('holds_is_copy'));
 407
 408                 } else {
 409                         hideMe($('holds_is_cn'));
 410                         unHideMe($('holds_is_copy'));
 411                         unHideMe($('holds_copy_row'));
 412                         appendClear($('holds_copy'), text(holdArgs.copyObject.barcode()));
 413                 }
 414
 415         } else {
 416                 hideMe($('holds_type_row'));
 417                 hideMe($('holds_copy_row'));
 418                 hideMe($('holds_cn_row'));
 419         }
 420
 421         removeChildren($('holds_format'));
 422
 423         var mods_formats = rec.types_of_resource();
 424         var formats;
 425
 426         if(holdArgs.recordDescriptors)
 427                 formats = holdArgs.recordDescriptors[0].item_type();
 428
 429         if( holdArgs.type == 'T' ) {
 430                 var desc = grep( holdArgs.recordDescriptors,
 431                         function(i) {
 432                                 return (i.record() == holdArgs.record);
 433                         }
 434                 );
 435                 formats = desc[0].item_type();
 436         }
 437
 438         if( holdArgs.type == 'M' ) {
 439                 var mr_formats;
 440                 if(holdArgs.editHold){
 441                         mr_formats = holdArgs.editHold.holdable_formats();
 442                 }else{
 443                         mr_formats = ''; // collect the item_type()s from all holdArgs.recordDescriptors
 444                         for(var desc in holdArgs.recordDescriptors){
 445                 if (!holdArgs.recordDescriptors[desc].item_type()) continue;
 446                                 mr_formats += holdArgs.recordDescriptors[desc].item_type();
 447                         }
 448
 449             var first_form = 1;
 450                         for(var desc in holdArgs.recordDescriptors){
 451                 if (!holdArgs.recordDescriptors[desc].item_form()) continue;
 452                 if (first_form) {
 453                     mr_formats += '-';
 454                     first_form = 0;
 455                 }
 456                                 mr_formats += holdArgs.recordDescriptors[desc].item_form();
 457                         }
 458
 459
 460                 }
 461
 462                 var data = holdsParseMRFormats(mr_formats);
 463                 mods_formats = data.mods_formats;
 464                 formats = data.formats;
 465         }
 466
 467
 468         for( var i in mods_formats ) {
 469                 var res = mods_formats[i];
 470                 var img = elem("img");
 471                 setResourcePic(img, res);
 472                 $('holds_format').appendChild(img);
 473                 if(formats)
 474                         $('holds_format').appendChild(text(' '+ MARCTypeToFriendly(formats[i]) +' '));
 475                 else
 476                         $('holds_format').appendChild(text(' '+ mods_formats[i] +' '));
 477                 $('holds_format').appendChild(elem('br'));
 478         }
 479
 480
 481         $('holds_phone').value = holdArgs.recipient.day_phone();
 482         appendClear( $('holds_email'), text(holdArgs.recipient.email()));
 483
 484         var pref = holdArgs.recipient.prefs[PREF_HOLD_NOTIFY];
 485
 486         if(pref) {
 487                 if( ! pref.match(/email/i) ) {
 488                         $('holds_enable_email').checked = false;
 489                 } else {
 490                         $('holds_enable_email').checked = true;
 491                 }
 492
 493                 if( ! pref.match(/phone/i) ) {
 494                         $('holds_phone').disabled = true;
 495                         $('holds_enable_phone').checked = false;
 496                 } else {
 497                         $('holds_phone').disabled = false;
 498                         $('holds_enable_phone').checked = true;
 499                 }
 500         }
 501
 502     if(!holdArgs.recipient.email()) {
 503                 $('holds_enable_email').checked = false;
 504                 $('holds_enable_email').disabled = true;
 505         var message;
 506         if(isXUL()) {
 507             message = noEmailMessageXUL.cloneNode(true);
 508                 appendClear($('holds_email'), message);
 509         } else {
 510             message = noEmailMessage.cloneNode(true);
 511                 appendClear($('holds_email'), message);
 512             $('holds.no_email.my_account').setAttribute('href', buildOPACLink({page:MYOPAC},null,true));
 513         }
 514         unHideMe(message);
 515     }
 516
 517         if(!$('holds_phone').value)
 518                 $('holds_enable_phone').checked = false;
 519
 520         appendClear($('holds_physical_desc'), text(rec.physical_description()));
 521
 522         if(holdArgs.type == 'M') hideMe($('hold_physical_desc_row'));
 523
 524         holdsSetFormatSelector();
 525
 526     $('holds_frozen_chkbox').checked = false;
 527     hideMe($('hold_frozen_thaw_row'));
 528
 529     var interval = fetchOrgSettingDefault(holdArgs.recipient.home_ou(), 'circ.hold_expire_interval');
 530     var secs = 0;
 531     if(interval) {
 532         secs = interval_to_seconds(interval);
 533         var expire = new Date();
 534         expire.setTime(expire.getTime() + Number(secs + '000'));
 535         dijit.byId('holds_expire_time').setValue(expire);
 536     }
 537 }
 538
 539 function holdsParseMRFormats(str) {
 540         var data = str.split(/-/);
 541
 542         var formats = [];
 543         var mods_formats = [];
 544
 545         for( var i = 0; i < data[0].length; i++ ) {
 546                 formats.push( data[0].charAt(i) );
 547                 mods_formats.push( MARCFormatToMods( formats[i] ) );
 548         }
 549
 550         formats = uniquify(formats);
 551         mods_formats = uniquify(mods_formats);
 552
 553         return {
 554                 formats                 : formats,
 555                 mods_formats    : mods_formats,
 556                 lang                            : data[2],
 557                 largeprint              : data[1]
 558         };
 559 }
 560
 561
 562 function holdsSetFormatSelector() {
 563         var type = holdArgs.type;
 564         if( type == 'C' || type == 'V' || holdArgs.editHold ) return;
 565
 566         var data                                = holdsGetFormats();
 567         var avail_formats       = data.avail_formats;
 568         var sel_formats = data.sel_formats;
 569         holdArgs.language = data.lang;
 570         if( type=='M'){
 571                 hideMe($('holds_alt_formats_row_extras'));
 572                 unHideMe($('holds_alt_formats_row'));
 573         }else{
 574                 unHideMe($('holds_alt_formats_row_extras'));
 575         }
 576
 577         var selector = $('hold_alt_form_selector');
 578
 579         for( var i = 0; i < avail_formats.length; i++ ) {
 580                 var form = avail_formats[i];
 581                 var opt = findSelectorOptByValue(selector,form);
 582                 if(type=='M') opt.selected=true;
 583                 unHideMe(opt);
 584         }
 585 }
 586
 587
 588 function holdsGetFormats() {
 589
 590         var lang;
 591         var formats = [];
 592         var sformats = []; // selected formats
 593
 594         var type = holdArgs.type;
 595         var desc = holdArgs.recordDescriptors;
 596         var rec = holdArgs.record;
 597         var mrec = holdArgs.metarecord;
 598
 599         for( var i = 0; i < desc.length; i++ ) {
 600                 var d = desc[i];
 601                 if( type == 'T' && d.item_lang() != lang ) continue;
 602                 formats.push( _t_f_2_format(d.item_type(), d.item_form()));
 603         }
 604
 605         formats = uniquify(formats);
 606
 607         if( type == 'T') {
 608
 609                 for( var i = 0; i < desc.length; i++ ) {
 610                         var d = desc[i];
 611                         if( d.record() == holdArgs.record ) {
 612                                 lang = d.item_lang();
 613                                 holdArgs.myFormat =  _t_f_2_format(d.item_type(), d.item_form());
 614                                 sformats.push(holdArgs.myFormat);
 615                                 break;
 616                         }
 617                 }
 618         } else if( type =='M') {
 619
 620         // All available formats are selected by default in MR holds
 621                 for( var i = 0; i < formats.length; i++ ) {
 622                         sformats.push(formats[i]);
 623                 }
 624         }
 625
 626         return {
 627                 lang : lang,
 628                 avail_formats : formats,
 629                 sel_formats : sformats
 630         };
 631 }
 632
 633
 634
 635 function _t_f_2_format(type, form) {
 636         if( (type == 'a' || type == 't') && form == 's' ) return 'at-s';
 637         if( form == 'd' ) return 'at-d';
 638         return (type == 'a' || type == 't') ? 'at' :
 639                 ( type == 'i' || type == 'g' || type == 'j' ) ? type : null;
 640 }
 641
 642 function holdsSetSelectedFormats() {
 643
 644         var cn = $('holds_alt_formats_row').className;
 645         if( cn && cn.match(/hide_me/) ) return;
 646
 647         var selector = $('hold_alt_form_selector');
 648         var vals = getSelectedList(selector);
 649
 650         if(vals.length == 0) return;
 651
 652         var fstring = "";
 653
 654         if( contains(vals, 'at-d') || contains(vals, 'at-s')) {
 655                 if( contains(vals, 'at') ) {
 656                         fstring = 'at';
 657                 } else if (contains(vals, 'at-s') && contains(vals, 'at-d')) {
 658                         fstring = 'at-sd';
 659                 } else if (!contains(vals, 'at-s')) {
 660                         fstring = 'at-d';
 661         } else {
 662                         fstring = 'at-s';
 663                 }
 664         }
 665
 666         for( var i = 0; i < vals.length; i++ ) {
 667                 var val = vals[i];
 668                 if( !val.match(/at/) ) fstring = val + fstring;
 669         }
 670
 671         if( holdArgs.language ) {
 672                 if( fstring.match(/-/) )
 673                         fstring = fstring + '-' + holdArgs.language;
 674                 else
 675                         fstring = fstring + '--' + holdArgs.language;
 676         }
 677
 678
 679         return fstring;
 680 }
 681
 682
 683 function holdsCheckPossibility(pickuplib, hold, recurse) {
 684
 685         var args = {
 686                 titleid : holdArgs.record,
 687                 mrid : holdArgs.record,
 688                 volume_id : holdArgs.volume,
 689                 copy_id : holdArgs.copy,
 690                 hold_type : holdArgs.type,
 691                 patronid : holdArgs.recipient.id(),
 692                 depth : 0,
 693                 pickup_lib : pickuplib
 694         };
 695
 696         if(recurse) {
 697                 /* if we're calling create again (recursing),
 698                         we know that the hold possibility check already succeeded */
 699                 holdHandleCreateResponse({_recurse:true, _hold:hold}, true );
 700
 701         } else {
 702                 _debug("hold possible args = "+js2JSON(args));
 703
 704                 var req = new Request(CHECK_HOLD_POSSIBLE, G.user.session, args );
 705
 706                 req.request.alertEvent = false;
 707                 req.request._hold = hold;
 708                 req.request._recurse = recurse;
 709                 req.callback(holdHandleCreateResponse);
 710                 req.send();
 711         }
 712 }
 713
 714
 715 function holdsBuildOrgSelector(node) {
 716
 717         if(!node) node = globalOrgTree;
 718     if(!isTrue(node.opac_visible())) return;
 719
 720         var selector = $('holds_org_selector');
 721         var index = selector.options.length;
 722
 723         var type = findOrgType(node.ou_type());
 724         var indent = type.depth() - 1;
 725         var opt = setSelectorVal( selector, index, node.name(), node.id(), null, indent );
 726         if(!type.can_have_users()) {
 727                 opt.disabled = true;
 728                 addCSSClass(opt, 'disabled_option');
 729         }
 730
 731         for( var i in node.children() ) {
 732                 var child = node.children()[i];
 733                 if(child) holdsBuildOrgSelector(child);
 734         }
 735 }
 736
 737 function holdsBuildHoldFromWindow() {
 738
 739         var org = getSelectorVal($('holds_org_selector'));
 740         var node = findOrgUnit(org);
 741         var ntype = findOrgType(node.ou_type());
 742         if(!ntype.can_have_users()) {
 743                 alertId('holds_pick_good_org');
 744                 return;
 745         }
 746
 747         var hold = new ahr();
 748         if(holdArgs.editHold) {
 749                 hold = holdArgs.editHold;
 750                 holdArgs.editHold = null;
 751         }
 752
 753         if( $('holds_enable_phone').checked ) {
 754                 var phone = $('holds_phone').value;
 755                 if( !phone || !phone.match(REGEX_PHONE) ) {
 756                         alert($('holds_bad_phone').innerHTML);
 757                         return null;
 758                 }
 759                 hold.phone_notify(phone);
 760
 761         } else {
 762                 hold.phone_notify("");
 763         }
 764
 765         if( $('holds_enable_email').checked )
 766                 hold.email_notify(1);
 767         else
 768                 hold.email_notify(0);
 769
 770         var target;
 771
 772         switch(holdArgs.type) {
 773                 case 'M':
 774                         target = holdArgs.metarecord; break;
 775                 case 'T':
 776                         target = holdArgs.record; break;
 777                 case 'V':
 778                         target = holdArgs.volume; break;
 779                 case 'C':
 780                         target = holdArgs.copy; break;
 781         }
 782
 783
 784
 785         hold.pickup_lib(org);
 786         //hold.request_lib(org);
 787         hold.requestor(holdArgs.requestor.id());
 788         hold.usr(holdArgs.recipient.id());
 789         hold.target(target);
 790         hold.hold_type(holdArgs.type);
 791
 792     var expDate = dijit.byId('holds_expire_time').getValue();
 793     if(expDate) {
 794         var expireDate = dojo.date.stamp.toISOString(expDate);
 795         expireDate = holdsVerifyThawDate(expireDate);
 796         if(expireDate)
 797             hold.expire_time(expireDate);
 798         else
 799             return;
 800     }
 801
 802     // see if this hold should be frozen and for how long
 803     if($('holds_frozen_chkbox').checked) {
 804         hold.frozen('t');
 805         unHideMe($('hold_frozen_thaw_row'));
 806         thawDate = dojo.date.stamp.toISOString(dijit.byId('holds_frozen_thaw_input').getValue());
 807         if(thawDate) {
 808             thawDate = holdsVerifyThawDate(thawDate);
 809             if(thawDate)
 810                 hold.thaw_date(thawDate);
 811             else
 812                 return;
 813         } else {
 814             hold.thaw_date(null);
 815         }
 816     } else {
 817         hold.frozen('f');
 818         hold.thaw_date(null);
 819     }
 820
 821         //check for alternate hold formats
 822         var fstring = holdsSetSelectedFormats();
 823         if(fstring) {
 824                 hold.hold_type('M');
 825                 hold.holdable_formats(fstring);
 826                 hold.target(holdArgs.metarecord);
 827         }
 828         return hold;
 829 }
 830
 831 function holdsPlaceHold(hold, recurse) {
 832         if(!hold) return;
 833         swapCanvas($('check_holds_box'));
 834         holdsCheckPossibility(hold.pickup_lib(), hold, recurse);
 835 }
 836
 837
 838 function holdHandleCreateResponse(r, recurse) {
 839
 840         if(!recurse) {
 841                 var res = r.getResultObject();
 842                 if(checkILSEvent(res) || res.success != 1) {
 843                         if(res.success != 1) {
 844                                 alert($('hold_not_allowed').innerHTML);
 845                         } else {
 846                                 if( res.textcode == 'PATRON_BARRED' ) {
 847                                         alertId('hold_failed_patron_barred');
 848                         } else {
 849                                         alert($('hold_not_allowed').innerHTML);
 850                                 }
 851                         }
 852                         swapCanvas($('holds_box'));
 853                         return;
 854                 }
 855         r._hold.selection_depth(res.depth);
 856         }
 857
 858         holdCreateHold(r._recurse, r._hold);
 859 }
 860
 861
 862 function holdCreateHold( recurse, hold ) {
 863         var method = CREATE_HOLD;
 864         if(recurse) method = CREATE_HOLD_OVERRIDE;
 865         var req = new Request( method, holdArgs.requestor.session, hold );
 866         req.request.alertEvent = false;
 867         req.send(true);
 868         var res = req.result();
 869         holdProcessResult(hold, res, recurse);
 870
 871         showCanvas();
 872
 873         runEvt('common', 'holdUpdated');
 874 }
 875
 876
 877 function holdProcessResult( hold, res, recurse ) {
 878
 879         if( res && res > -1 ) {
 880                 alert($('holds_success').innerHTML);
 881                 holdArgs = null;
 882         if(isXUL() && typeof xulG.opac_hold_placed == 'function')
 883             xulG.opac_hold_placed(res);
 884
 885         } else {
 886
 887                 if( recurse ) {
 888                         alert($('holds_failure').innerHTML);
 889                         return;
 890                 }
 891
 892                 if( grep(res, function(e) { return (e.textcode == 'HOLD_EXISTS'); }) ) {
 893                         if( fetchPermOrgs('HOLD_EXISTS.override')[0] != -1 ) {
 894                                 if( confirm($('hold_dup_exists_override').innerHTML) ) {
 895                                         return holdsPlaceHold(hold, true);
 896                                 }
 897                 return;
 898
 899                         } else {
 900                                 return alert($('hold_dup_exists').innerHTML);
 901                         }
 902                 }
 903
 904                 if( grep(res, function(e) { return (e.textcode == 'HOLD_ITEM_CHECKED_OUT'); }) ) {
 905                         if( fetchPermOrgs('HOLD_ITEM_CHECKED_OUT.override')[0] != -1 ) {
 906                                 if( confirm($('hold_checked_out_override').innerHTML) ) {
 907                                         return holdsPlaceHold(hold, true);
 908                                 }
 909                 return;
 910
 911                         } else {
 912                                 return alert($('hold_checked_out').innerHTML);
 913                         }
 914                 }
 915
 916
 917                 alert($('holds_failure').innerHTML);
 918         }
 919 }
 920
 921
 922 function holdsCancel(holdid, user) {
 923         if(!user) user = G.user;
 924         var req = new Request(CANCEL_HOLD, user.session, holdid, /* Patron via OPAC */ 6);
 925         req.send(true);
 926         return req.result();
 927         runEvt('common', 'holdUpdated');
 928 }
 929
 930 function holdsUpdate(hold, user) {
 931         if(!user) user = G.user;
 932         var req = new Request(UPDATE_HOLD, user.session, hold);
 933         req.send(true);
 934         var x = req.result(); // cause an exception if there is one
 935         runEvt('common', 'holdUpdated');
 936 }
 937
 938 /* verify that the thaw date is valid and after today */
 939 function holdsVerifyThawDate(dateString, isGreater) {
 940     thawDate = dojo.date.stamp.fromISOString(dateString);
 941     if(thawDate) {
 942         if(isGreater) {
 943             if(dojo.date.compare(thawDate) > 0) {
 944                 return dojo.date.stamp.toISOString(thawDate);
 945             }
 946         } else {
 947             return dojo.date.stamp.toISOString(thawDate);
 948         }
 949     }
 950     return null;
 951 }
 952
 953 function holdsVerifyThawDateUI(element) {
 954     value = dojo.date.stamp.toISOString(dijit.byId(element).getValue());
 955
 956     if(!value) {
 957         removeCSSClass($(element), 'invalid_field');
 958         return;
 959     }
 960
 961     if(!holdsVerifyThawDate(value, true)) {
 962         addCSSClass($(element), 'invalid_field');
 963     } else {
 964         removeCSSClass($(element), 'invalid_field');
 965     }
 966 }
 967