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 = { record: args.record };
 285
 286                 if( ! args.record ) {
 287                         if( args.metarecord )
 288                                 params = { metarecord : args.metarecord };
 289                         else
 290                                 params = { metarecord : args.metarecordObject.doc_id() };
 291                 }
 292
 293                 var req = new Request(FETCH_MR_DESCRIPTORS, params );
 294                 req.callback(
 295                         function(r) {
 296                                 var data = r.getResultObject();
 297                                 args.recordDescriptors = data.descriptors;
 298                                 args.metarecord = data.metarecord;
 299                                 if( args.type == 'M' && ! args.metarecordObject)
 300                                         args.metarecordObject = findRecord(args.metarecord, 'M');
 301
 302                                 if(doneCallback) doneCallback(args);
 303                         }
 304                 );
 305                 req.send();
 306
 307         } else {
 308                 if(doneCallback) doneCallback(args);
 309         }
 310
 311         return args;
 312 }
 313
 314
 315
 316 function holdsDrawWindow() {
 317         swapCanvas($('holds_box'));
 318         $('holds_cancel').onclick = function(){ runEvt('common', 'holdUpdateCanceled'), showCanvas() };
 319         $('holds_submit').onclick = function(){holdsPlaceHold(holdsBuildHoldFromWindow())};
 320         $('holds_update').onclick = function(){holdsPlaceHold(holdsBuildHoldFromWindow())};
 321         holdFetchObjects(null,
 322                 function(){
 323                         __holdsDrawWindow();
 324
 325                         if(holdArgs.editHold) {
 326                                 hideMe($('holds_submit'));
 327                                 unHideMe($('holds_update'));
 328                                 var req = new Request(FETCH_HOLD_STATUS,
 329                                         G.user.session, holdArgs.editHold.id());
 330                                 req.send(true);
 331                                 holdArgs.status = req.result();
 332                                 _holdsUpdateEditHold();
 333                         }
 334                 }
 335         );
 336 }
 337
 338 function __holdsDrawWindow() {
 339
 340         var rec = holdArgs.recordObject;
 341         var vol = holdArgs.volumeObject;
 342         var copy = holdArgs.copyObject;
 343         var mr = holdArgs.metarecordObject;
 344
 345         rec = (rec) ? rec : mr;
 346
 347         if(!holdsOrgSelectorBuilt) {
 348                 holdsBuildOrgSelector(null,0);
 349                 holdsOrgSelectorBuilt = true;
 350                 var selector = $('holds_org_selector');
 351
 352                 /*
 353                 var o_loc = findOrgUnit(getOrigLocation());
 354                 var t = findOrgType(o_loc.ou_type());
 355                 if( t.can_have_users() )
 356                         setSelector(selector, o_loc.id());
 357                 else
 358                 */
 359
 360                 setSelector(selector, holdArgs.recipient.home_ou());
 361
 362         }
 363
 364         /*
 365         if(isXUL()) {
 366                 var dsel = $('holds_depth_selector');
 367                 unHideMe($('holds_depth_selector_row'));
 368                 if(dsel.getElementsByTagName('option').length == 0) {
 369                         var types = globalOrgTypes;
 370                         var depth = findOrgDepth(G.user.ws_ou());
 371                         iterate(types,
 372                                 function(t) {
 373                                         if(t.depth() > depth) return;
 374                                         insertSelectorVal(dsel, -1, t.opac_label(), t.depth());
 375                                 }
 376                         );
 377                 }
 378         }
 379         */
 380
 381         appendClear($('holds_recipient'), text(
 382                 holdArgs.recipient.family_name() + ', ' +
 383                         holdArgs.recipient.first_given_name()));
 384         appendClear($('holds_title'), text(rec.title()));
 385         appendClear($('holds_author'), text(rec.author()));
 386
 387         if( holdArgs.type == 'V' || holdArgs.type == 'C' ) {
 388
 389                 unHideMe($('holds_type_row'));
 390                 unHideMe($('holds_cn_row'));
 391                 appendClear($('holds_cn'), text(holdArgs.volumeObject.label()));
 392
 393                 if( holdArgs.type == 'V'  ) {
 394                         unHideMe($('holds_is_cn'));
 395                         hideMe($('holds_is_copy'));
 396
 397                 } else {
 398                         hideMe($('holds_is_cn'));
 399                         unHideMe($('holds_is_copy'));
 400                         unHideMe($('holds_copy_row'));
 401                         appendClear($('holds_copy'), text(holdArgs.copyObject.barcode()));
 402                 }
 403
 404         } else {
 405                 hideMe($('holds_type_row'));
 406                 hideMe($('holds_copy_row'));
 407                 hideMe($('holds_cn_row'));
 408         }
 409
 410         removeChildren($('holds_format'));
 411
 412         var mods_formats = rec.types_of_resource();
 413         var formats;
 414
 415         if(holdArgs.recordDescriptors)
 416                 formats = holdArgs.recordDescriptors[0].item_type();
 417
 418         if( holdArgs.type == 'T' ) {
 419                 var desc = grep( holdArgs.recordDescriptors,
 420                         function(i) {
 421                                 return (i.record() == holdArgs.record);
 422                         }
 423                 );
 424                 formats = desc[0].item_type();
 425         }
 426
 427         if( holdArgs.type == 'M' ) {
 428                 var data = holdsParseMRFormats(holdArgs.editHold.holdable_formats());
 429                 mods_formats = data.mods_formats;
 430                 formats = data.formats;
 431         }
 432
 433
 434         for( var i in mods_formats ) {
 435                 var res = mods_formats[i];
 436                 var img = elem("img");
 437                 setResourcePic(img, res);
 438                 $('holds_format').appendChild(img);
 439                 if(formats)
 440                         $('holds_format').appendChild(text(' '+ MARCTypeToFriendly(formats[i]) +' '));
 441                 else
 442                         $('holds_format').appendChild(text(' '+ mods_formats[i] +' '));
 443                 $('holds_format').appendChild(elem('br'));
 444         }
 445
 446
 447         $('holds_phone').value = holdArgs.recipient.day_phone();
 448         appendClear( $('holds_email'), text(holdArgs.recipient.email()));
 449
 450         var pref = holdArgs.recipient.prefs[PREF_HOLD_NOTIFY];
 451
 452         if(pref) {
 453                 if( ! pref.match(/email/i) ) {
 454                         $('holds_enable_email').checked = false;
 455                 } else {
 456                         $('holds_enable_email').checked = true;
 457                 }
 458
 459                 if( ! pref.match(/phone/i) ) {
 460                         $('holds_phone').disabled = true;
 461                         $('holds_enable_phone').checked = false;
 462                 } else {
 463                         $('holds_phone').disabled = false;
 464                         $('holds_enable_phone').checked = true;
 465                 }
 466         }
 467
 468     if(!holdArgs.recipient.email()) {
 469                 $('holds_enable_email').checked = false;
 470                 $('holds_enable_email').disabled = true;
 471         var message;
 472         if(isXUL()) {
 473             message = noEmailMessageXUL.cloneNode(true);
 474                 appendClear($('holds_email'), message);
 475         } else {
 476             message = noEmailMessage.cloneNode(true);
 477                 appendClear($('holds_email'), message);
 478             $('holds.no_email.my_account').setAttribute('href', buildOPACLink({page:MYOPAC},null,true));
 479         }
 480         unHideMe(message);
 481     }
 482
 483         if(!$('holds_phone').value)
 484                 $('holds_enable_phone').checked = false;
 485
 486         appendClear($('holds_physical_desc'), text(rec.physical_description()));
 487
 488         if(holdArgs.type == 'M') hideMe($('hold_physical_desc_row'));
 489
 490         holdsSetFormatSelector();
 491
 492     $('holds_frozen_chkbox').checked = false;
 493     hideMe($('hold_frozen_thaw_row'));
 494
 495     var interval = fetchOrgSettingDefault(holdArgs.recipient.home_ou(), 'circ.hold_expire_interval');
 496     var secs = 0;
 497     if(interval) {
 498         secs = interval_to_seconds(interval);
 499         var expire = new Date();
 500         expire.setTime(expire.getTime() + Number(secs + '000'));
 501         dijit.byId('holds_expire_time').setValue(expire);
 502     }
 503 }
 504
 505 function holdsParseMRFormats(str) {
 506         var data = str.split(/-/);
 507
 508         var formats = [];
 509         var mods_formats = [];
 510
 511         for( var i = 0; i < data[0].length; i++ ) {
 512                 formats.push( data[0].charAt(i) );
 513                 mods_formats.push( MARCFormatToMods( formats[i] ) );
 514         }
 515
 516         formats = uniquify(formats);
 517         mods_formats = uniquify(mods_formats);
 518
 519         return {
 520                 formats                 : formats,
 521                 mods_formats    : mods_formats,
 522                 lang                            : data[2],
 523                 largeprint              : data[1]
 524         };
 525 }
 526
 527
 528 function holdsSetFormatSelector() {
 529         var type = holdArgs.type;
 530         if( type == 'C' || type == 'V' || holdArgs.editHold ) return;
 531
 532         var data                                = holdsGetFormats();
 533         var avail_formats       = data.avail_formats;
 534         var sel_formats = data.sel_formats;
 535         holdArgs.language = data.lang;
 536
 537         unHideMe($('holds_alt_formats_row_extras'));
 538         var selector = $('hold_alt_form_selector');
 539
 540         for( var i = 0; i < avail_formats.length; i++ ) {
 541                 var form = avail_formats[i];
 542                 unHideMe(findSelectorOptByValue(selector, form));
 543         }
 544 }
 545
 546
 547 function holdsGetFormats() {
 548
 549         var lang;
 550         var formats = [];
 551         var sformats = []; // selected formats
 552
 553         var type = holdArgs.type;
 554         var desc = holdArgs.recordDescriptors;
 555         var rec = holdArgs.record;
 556         var mrec = holdArgs.metarecord;
 557
 558         if( type == 'T' ) {
 559
 560                 for( var i = 0; i < desc.length; i++ ) {
 561                         var d = desc[i];
 562                         if( d.record() == holdArgs.record ) {
 563                                 lang = d.item_lang();
 564                                 holdArgs.myFormat =  _t_f_2_format(d.item_type(), d.item_form());
 565                                 sformats.push(holdArgs.myFormat);
 566                                 break;
 567                         }
 568                 }
 569         }
 570
 571         for( var i = 0; i < desc.length; i++ ) {
 572                 var d = desc[i];
 573                 if( d.item_lang() != lang ) continue;
 574                 formats.push( _t_f_2_format(d.item_type(), d.item_form()));
 575         }
 576
 577         formats = uniquify(formats);
 578
 579         return {
 580                 lang : lang,
 581                 avail_formats : formats,
 582                 sel_formats : sformats
 583         };
 584 }
 585
 586
 587
 588 function _t_f_2_format(type, form) {
 589         if( form == 'd' ) return 'at-d';
 590         return (type == 'a' || type == 't') ? 'at' :
 591                 ( type == 'i' || type == 'g' || type == 'j' ) ? type : null;
 592 }
 593
 594 function holdsSetSelectedFormats() {
 595
 596         var cn = $('holds_alt_formats_row').className;
 597         if( cn && cn.match(/hide_me/) ) return;
 598
 599         var selector = $('hold_alt_form_selector');
 600         var vals = getSelectedList(selector);
 601
 602         if(vals.length == 0) return;
 603
 604         var fstring = "";
 605
 606         if( contains(vals, 'at-d') ) {
 607                 if( contains(vals, 'at') )
 608                         fstring = 'at';
 609                 else
 610                         fstring = 'at-d';
 611         } else {
 612                 if( contains(vals, 'at') )
 613                         fstring = 'at';
 614         }
 615
 616         for( var i = 0; i < vals.length; i++ ) {
 617                 var val = vals[i];
 618                 if( !val.match(/at/) ) fstring = val + fstring;
 619         }
 620
 621         if( holdArgs.language ) {
 622                 if( fstring.match(/-/) )
 623                         fstring = fstring + '-' + holdArgs.language;
 624                 else
 625                         fstring = fstring + '--' + holdArgs.language;
 626         }
 627
 628
 629         return fstring;
 630 }
 631
 632
 633 function holdsCheckPossibility(pickuplib, hold, recurse) {
 634
 635         var args = {
 636                 titleid : holdArgs.record,
 637                 volume_id : holdArgs.volume,
 638                 copy_id : holdArgs.copy,
 639                 hold_type : holdArgs.type,
 640                 patronid : holdArgs.recipient.id(),
 641                 depth : 0,
 642                 pickup_lib : pickuplib
 643         };
 644
 645         if(recurse) {
 646                 /* if we're calling create again (recursing),
 647                         we know that the hold possibility check already succeeded */
 648                 holdHandleCreateResponse({_recurse:true, _hold:hold}, true );
 649
 650         } else {
 651                 _debug("hold possible args = "+js2JSON(args));
 652
 653                 var req = new Request(CHECK_HOLD_POSSIBLE, G.user.session, args );
 654
 655                 req.request.alertEvent = false;
 656                 req.request._hold = hold;
 657                 req.request._recurse = recurse;
 658                 req.callback(holdHandleCreateResponse);
 659                 req.send();
 660         }
 661 }
 662
 663
 664 function holdsBuildOrgSelector(node) {
 665
 666         if(!node) node = globalOrgTree;
 667     if(!isTrue(node.opac_visible())) return;
 668
 669         var selector = $('holds_org_selector');
 670         var index = selector.options.length;
 671
 672         var type = findOrgType(node.ou_type());
 673         var indent = type.depth() - 1;
 674         var opt = setSelectorVal( selector, index, node.name(), node.id(), null, indent );
 675         if(!type.can_have_users()) {
 676                 opt.disabled = true;
 677                 addCSSClass(opt, 'disabled_option');
 678         }
 679
 680         for( var i in node.children() ) {
 681                 var child = node.children()[i];
 682                 if(child) holdsBuildOrgSelector(child);
 683         }
 684 }
 685
 686 function holdsBuildHoldFromWindow() {
 687
 688         var org = getSelectorVal($('holds_org_selector'));
 689         var node = findOrgUnit(org);
 690         var ntype = findOrgType(node.ou_type());
 691         if(!ntype.can_have_users()) {
 692                 alertId('holds_pick_good_org');
 693                 return;
 694         }
 695
 696         var hold = new ahr();
 697         if(holdArgs.editHold) {
 698                 hold = holdArgs.editHold;
 699                 holdArgs.editHold = null;
 700         }
 701
 702         if( $('holds_enable_phone').checked ) {
 703                 var phone = $('holds_phone').value;
 704                 if( !phone || !phone.match(REGEX_PHONE) ) {
 705                         alert($('holds_bad_phone').innerHTML);
 706                         return null;
 707                 }
 708                 hold.phone_notify(phone);
 709
 710         } else {
 711                 hold.phone_notify("");
 712         }
 713
 714         if( $('holds_enable_email').checked )
 715                 hold.email_notify(1);
 716         else
 717                 hold.email_notify(0);
 718
 719         var target;
 720
 721         switch(holdArgs.type) {
 722                 case 'M':
 723                         target = holdArgs.metarecord; break;
 724                 case 'T':
 725                         target = holdArgs.record; break;
 726                 case 'V':
 727                         target = holdArgs.volume; break;
 728                 case 'C':
 729                         target = holdArgs.copy; break;
 730         }
 731
 732
 733
 734         hold.pickup_lib(org);
 735         //hold.request_lib(org);
 736         hold.requestor(holdArgs.requestor.id());
 737         hold.usr(holdArgs.recipient.id());
 738         hold.target(target);
 739         hold.hold_type(holdArgs.type);
 740
 741     var expDate = dijit.byId('holds_expire_time').getValue();
 742     if(expDate) {
 743         var expireDate = dojo.date.stamp.toISOString(expDate);
 744         expireDate = holdsVerifyThawDate(expireDate);
 745         if(expireDate)
 746             hold.expire_time(expireDate);
 747         else
 748             return;
 749     }
 750
 751     // see if this hold should be frozen and for how long
 752     if($('holds_frozen_chkbox').checked) {
 753         hold.frozen('t');
 754         unHideMe($('hold_frozen_thaw_row'));
 755         thawDate = dojo.date.stamp.toISOString(dijit.byId('holds_frozen_thaw_input').getValue());
 756         if(thawDate) {
 757             thawDate = holdsVerifyThawDate(thawDate);
 758             if(thawDate)
 759                 hold.thaw_date(thawDate);
 760             else
 761                 return;
 762         } else {
 763             hold.thaw_date(null);
 764         }
 765     } else {
 766         hold.frozen('f');
 767         hold.thaw_date(null);
 768     }
 769
 770         //check for alternate hold formats
 771         var fstring = holdsSetSelectedFormats();
 772         if(fstring) {
 773                 hold.hold_type('M');
 774                 hold.holdable_formats(fstring);
 775                 hold.target(holdArgs.metarecord);
 776         }
 777         return hold;
 778 }
 779
 780 function holdsPlaceHold(hold, recurse) {
 781         if(!hold) return;
 782         swapCanvas($('check_holds_box'));
 783         holdsCheckPossibility(hold.pickup_lib(), hold, recurse);
 784 }
 785
 786
 787 function holdHandleCreateResponse(r, recurse) {
 788
 789         if(!recurse) {
 790                 var res = r.getResultObject();
 791                 if(checkILSEvent(res) || res.success != 1) {
 792                         if(res.success != 1) {
 793                                 alert($('hold_not_allowed').innerHTML);
 794                         } else {
 795                                 if( res.textcode == 'PATRON_BARRED' ) {
 796                                         alertId('hold_failed_patron_barred');
 797                         } else {
 798                                         alert($('hold_not_allowed').innerHTML);
 799                                 }
 800                         }
 801                         swapCanvas($('holds_box'));
 802                         return;
 803                 }
 804         r._hold.selection_depth(res.depth);
 805         }
 806
 807         holdCreateHold(r._recurse, r._hold);
 808 }
 809
 810
 811 function holdCreateHold( recurse, hold ) {
 812         var method = CREATE_HOLD;
 813         if(recurse) method = CREATE_HOLD_OVERRIDE;
 814         var req = new Request( method, holdArgs.requestor.session, hold );
 815         req.request.alertEvent = false;
 816         req.send(true);
 817         var res = req.result();
 818         holdProcessResult(hold, res, recurse);
 819
 820         showCanvas();
 821
 822         runEvt('common', 'holdUpdated');
 823 }
 824
 825
 826 function holdProcessResult( hold, res, recurse ) {
 827
 828         if( res && res > -1 ) {
 829                 alert($('holds_success').innerHTML);
 830                 holdArgs = null;
 831         if(isXUL() && typeof xulG.opac_hold_placed == 'function')
 832             xulG.opac_hold_placed(res);
 833
 834         } else {
 835
 836                 if( recurse ) {
 837                         alert($('holds_failure').innerHTML);
 838                         return;
 839                 }
 840
 841                 if( grep(res, function(e) { return (e.textcode == 'HOLD_EXISTS'); }) ) {
 842                         if( fetchPermOrgs('HOLD_EXISTS.override')[0] != -1 ) {
 843                                 if( confirm($('hold_dup_exists_override').innerHTML) ) {
 844                                         return holdsPlaceHold(hold, true);
 845                                 }
 846
 847                         } else {
 848                                 return alert($('hold_dup_exists').innerHTML);
 849                         }
 850                 }
 851
 852                 alert($('holds_failure').innerHTML);
 853         }
 854 }
 855
 856
 857 function holdsCancel(holdid, user) {
 858         if(!user) user = G.user;
 859         var req = new Request(CANCEL_HOLD, user.session, holdid, /* Patron via OPAC */ 6);
 860         req.send(true);
 861         return req.result();
 862         runEvt('common', 'holdUpdated');
 863 }
 864
 865 function holdsUpdate(hold, user) {
 866         if(!user) user = G.user;
 867         var req = new Request(UPDATE_HOLD, user.session, hold);
 868         req.send(true);
 869         var x = req.result(); // cause an exception if there is one
 870         runEvt('common', 'holdUpdated');
 871 }
 872
 873 /* verify that the thaw date is valid and after today */
 874 function holdsVerifyThawDate(dateString, isGreater) {
 875     thawDate = dojo.date.stamp.fromISOString(dateString);
 876     if(thawDate) {
 877         if(isGreater) {
 878             if(dojo.date.compare(thawDate) > 0) {
 879                 return dojo.date.stamp.toISOString(thawDate);
 880             }
 881         } else {
 882             return dojo.date.stamp.toISOString(thawDate);
 883         }
 884     }
 885     return null;
 886 }
 887
 888 function holdsVerifyThawDateUI(element) {
 889     value = dojo.date.stamp.toISOString(dijit.byId(element).getValue());
 890
 891     if(!value) {
 892         removeCSSClass($(element), 'invalid_field');
 893         return;
 894     }
 895
 896     if(!holdsVerifyThawDate(value, true)) {
 897         addCSSClass($(element), 'invalid_field');
 898     } else {
 899         removeCSSClass($(element), 'invalid_field');
 900     }
 901 }
 902