Open-ILS/web/js/ui/default/vandelay/vandelay.js

   1 /* ---------------------------------------------------------------------------
   2 # Copyright (C) 2008  Georgia Public Library Service
   3 # Bill Erickson <erickson@esilibrary.com>
   4 #
   5 # This program is free software; you can redistribute it and/or
   6 # modify it under the terms of the GNU General Public License
   7 # as published by the Free Software Foundation; either version 2
   8 # of the License, or (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 # --------------------------------------------------------------------------- */
  15 dojo.require("dojo.parser");
  16 dojo.require("dojo.io.iframe");
  17 dojo.require("dijit.ProgressBar");
  18 dojo.require("dijit.form.FilteringSelect");
  19 dojo.require("dijit.layout.ContentPane");
  20 dojo.require("dijit.layout.TabContainer");
  21 dojo.require("dijit.layout.LayoutContainer");
  22 dojo.require('dijit.form.Button');
  23 dojo.require('dijit.form.CheckBox');
  24 dojo.require('dijit.Toolbar');
  25 dojo.require('dijit.Tooltip');
  26 dojo.require('dijit.Menu');
  27 dojo.require("dijit.Dialog");
  28 dojo.require("dojo.cookie");
  29 dojo.require('dojox.grid.DataGrid');
  30 dojo.require("dojo.data.ItemFileReadStore");
  31 dojo.require('dojo.date.locale');
  32 dojo.require('dojo.date.stamp');
  33 dojo.require("fieldmapper.Fieldmapper");
  34 dojo.require("fieldmapper.dojoData");
  35 dojo.require("fieldmapper.OrgUtils");
  36 dojo.require('openils.CGI');
  37 dojo.require('openils.User');
  38 dojo.require('openils.Event');
  39 dojo.require('openils.Util');
  40 dojo.require('openils.MarcXPathParser');
  41 dojo.require('openils.widget.GridColumnPicker');
  42 dojo.require('openils.PermaCrud');
  43 dojo.require('openils.widget.OrgUnitFilteringSelect');
  44 dojo.require('openils.widget.AutoGrid');
  45 dojo.require('openils.widget.AutoFieldWidget');
  46
  47
  48 var globalDivs = [
  49     'vl-generic-progress',
  50     'vl-generic-progress-with-total',
  51     'vl-marc-upload-div',
  52     'vl-queue-div',
  53     'vl-match-div',
  54     'vl-marc-html-div',
  55     'vl-queue-select-div',
  56     'vl-marc-upload-status-div',
  57     'vl-attr-editor-div',
  58     'vl-marc-export-div',
  59     'vl-profile-editor-div',
  60     'vl-item-attr-editor-div',
  61     'vl-import-error-div'
  62 ];
  63
  64 var authtoken;
  65 var VANDELAY_URL = '/vandelay-upload';
  66 var bibAttrDefs = [];
  67 var authAttrDefs = [];
  68 var queuedRecords = [];
  69 var queuedRecordsMap = {};
  70 var bibAttrsFetched = false;
  71 var authAttrsFetched = false;
  72 var attrDefMap = {}; // maps attr def code names to attr def ids
  73 var currentType;
  74 var currentQueueId = null;
  75 var userCache = {};
  76 var currentMatchedRecords; // set of loaded matched bib records
  77 var currentOverlayRecordsMap; // map of import record to overlay record
  78 var currentOverlayRecordsMapGid; // map of import record to overlay record grid id
  79 var currentImportRecId; // when analyzing matches, this is the current import record
  80 var userBibQueues = []; // only non-complete queues
  81 var userAuthQueues = []; // only non-complete queues
  82 var allUserBibQueues;
  83 var allUserAuthQueues;
  84 var selectableGridRecords;
  85 var cgi = new openils.CGI();
  86 var vlQueueGridColumePicker = {};
  87 var vlBibSources = [];
  88 var importItemDefs = [];
  89 var matchSets = {};
  90 var mergeProfiles = [];
  91
  92 /**
  93   * Grab initial data
  94   */
  95 function vlInit() {
  96     authtoken = openils.User.authtoken;
  97     var initNeeded = 7; // how many async responses do we need before we're init'd
  98     var initCount = 0; // how many async reponses we've received
  99
 100     openils.Util.registerEnterHandler(
 101         vlQueueDisplayPage.domNode, function(){retrieveQueuedRecords();});
 102     openils.Util.addCSSClass(dojo.byId('vl-menu-marc-upload'), 'toolbar_selected');
 103
 104     function checkInitDone() {
 105         initCount++;
 106         if(initCount == initNeeded)
 107             runStartupCommands();
 108     }
 109
 110     mergeProfiles = new openils.PermaCrud().retrieveAll('vmp');
 111     vlUploadMergeProfile.store = new dojo.data.ItemFileReadStore({data:fieldmapper.vmp.toStoreData(mergeProfiles)});
 112     vlUploadMergeProfile.labelAttr = 'name';
 113     vlUploadMergeProfile.searchAttr = 'name';
 114     vlUploadMergeProfile.startup();
 115
 116     vlUploadMergeProfile2.store = new dojo.data.ItemFileReadStore({data:fieldmapper.vmp.toStoreData(mergeProfiles)});
 117     vlUploadMergeProfile2.labelAttr = 'name';
 118     vlUploadMergeProfile2.searchAttr = 'name';
 119     vlUploadMergeProfile2.startup();
 120
 121
 122     // Fetch the bib and authority attribute definitions
 123     vlFetchBibAttrDefs(function () { checkInitDone(); });
 124     vlFetchAuthAttrDefs(function () { checkInitDone(); });
 125
 126     vlRetrieveQueueList('bib', null,
 127         function(list) {
 128             allUserBibQueues = list;
 129             for(var i = 0; i < allUserBibQueues.length; i++) {
 130                 if(allUserBibQueues[i].complete() == 'f')
 131                     userBibQueues.push(allUserBibQueues[i]);
 132             }
 133             checkInitDone();
 134         }
 135     );
 136
 137     vlRetrieveQueueList('auth', null,
 138         function(list) {
 139             allUserAuthQueues = list;
 140             for(var i = 0; i < allUserAuthQueues.length; i++) {
 141                 if(allUserAuthQueues[i].complete() == 'f')
 142                     userAuthQueues.push(allUserAuthQueues[i]);
 143             }
 144             checkInitDone();
 145         }
 146     );
 147
 148     fieldmapper.standardRequest(
 149         ['open-ils.permacrud', 'open-ils.permacrud.search.cbs.atomic'],
 150         {   async: true,
 151             params: [authtoken, {id:{"!=":null}}, {order_by:{cbs:'id'}}],
 152             oncomplete : function(r) {
 153                 vlBibSources = openils.Util.readResponse(r, false, true);
 154                 checkInitDone();
 155             }
 156         }
 157     );
 158
 159     var owner = fieldmapper.aou.orgNodeTrail(fieldmapper.aou.findOrgUnit(new openils.User().user.ws_ou()));
 160     new openils.PermaCrud().search('viiad',
 161         {owner: owner.map(function(org) { return org.id(); })},
 162         {   async: true,
 163             oncomplete: function(r) {
 164                 importItemDefs = openils.Util.readResponse(r);
 165                 checkInitDone();
 166             }
 167         }
 168     );
 169
 170     new openils.PermaCrud().search('vms',
 171         {owner: owner.map(function(org) { return org.id(); })},
 172         {   async: true,
 173             oncomplete: function(r) {
 174                 var sets = openils.Util.readResponse(r);
 175                 dojo.forEach(sets,
 176                     function(set) {
 177                         if(!matchSets[set.mtype()])
 178                             matchSets[set.mtype()] = [];
 179                         matchSets[set.mtype()].push(set);
 180                     }
 181                 );
 182                 checkInitDone();
 183             }
 184         }
 185     );
 186
 187     vlAttrEditorInit();
 188     vlExportInit();
 189 }
 190
 191
 192 openils.Util.addOnLoad(vlInit);
 193
 194
 195 // fetch the bib and authority attribute definitions
 196
 197 function vlFetchBibAttrDefs(postcomplete) {
 198     bibAttrDefs = [];
 199     fieldmapper.standardRequest(
 200         ['open-ils.permacrud', 'open-ils.permacrud.search.vqbrad'],
 201         {   async: true,
 202             params: [authtoken, {id:{'!=':null}}],
 203             onresponse: function(r) {
 204                 var def = r.recv().content();
 205                 if(e = openils.Event.parse(def[0]))
 206                     return alert(e);
 207                 bibAttrDefs.push(def);
 208             },
 209             oncomplete: function() {
 210                 bibAttrDefs = bibAttrDefs.sort(
 211                     function(a, b) {
 212                         if(a.id() > b.id()) return 1;
 213                         if(a.id() < b.id()) return -1;
 214                         return 0;
 215                     }
 216                 );
 217                 postcomplete();
 218             }
 219         }
 220     );
 221 }
 222
 223 function vlFetchAuthAttrDefs(postcomplete) {
 224     authAttrDefs = [];
 225     fieldmapper.standardRequest(
 226         ['open-ils.permacrud', 'open-ils.permacrud.search.vqarad'],
 227         {   async: true,
 228             params: [authtoken, {id:{'!=':null}}],
 229             onresponse: function(r) {
 230                 var def = r.recv().content();
 231                 if(e = openils.Event.parse(def[0]))
 232                     return alert(e);
 233                 authAttrDefs.push(def);
 234             },
 235             oncomplete: function() {
 236                 authAttrDefs = authAttrDefs.sort(
 237                     function(a, b) {
 238                         if(a.id() > b.id()) return 1;
 239                         if(a.id() < b.id()) return -1;
 240                         return 0;
 241                     }
 242                 );
 243                 postcomplete();
 244             }
 245         }
 246     );
 247 }
 248
 249 function vlRetrieveQueueList(type, filter, onload) {
 250     type = (type == 'bib') ? type : 'authority';
 251     fieldmapper.standardRequest(
 252         ['open-ils.vandelay', 'open-ils.vandelay.'+type+'_queue.owner.retrieve.atomic'],
 253         {   async: true,
 254             params: [authtoken, null, filter],
 255             oncomplete: function(r) {
 256                 var list = r.recv().content();
 257                 if(e = openils.Event.parse(list[0]))
 258                     return alert(e);
 259                 onload(list);
 260             }
 261         }
 262     );
 263
 264 }
 265
 266 function displayGlobalDiv(id) {
 267     for(var i = 0; i < globalDivs.length; i++) {
 268         try {
 269             dojo.style(dojo.byId(globalDivs[i]), 'display', 'none');
 270         } catch(e) {
 271             alert('please define div ' + globalDivs[i]);
 272         }
 273     }
 274     dojo.style(dojo.byId(id),'display','block');
 275
 276     openils.Util.removeCSSClass(dojo.byId('vl-menu-marc-export'), 'toolbar_selected');
 277     openils.Util.removeCSSClass(dojo.byId('vl-menu-marc-upload'), 'toolbar_selected');
 278     openils.Util.removeCSSClass(dojo.byId('vl-menu-queue-select'), 'toolbar_selected');
 279     openils.Util.removeCSSClass(dojo.byId('vl-menu-attr-editor'), 'toolbar_selected');
 280     openils.Util.removeCSSClass(dojo.byId('vl-menu-profile-editor'), 'toolbar_selected');
 281     openils.Util.removeCSSClass(dojo.byId('vl-menu-match-set-editor'), 'toolbar_selected');
 282
 283     if(dojo.byId('vl-match-set-iframe'))
 284         dojo.byId('vl-match-set-editor-div').removeChild(dojo.byId('vl-match-set-iframe'));
 285
 286     switch(id) {
 287         case 'vl-marc-export-div':
 288             openils.Util.addCSSClass(dojo.byId('vl-menu-marc-export'), 'toolbar_selected');
 289             break;
 290         case 'vl-marc-upload-div':
 291             openils.Util.addCSSClass(dojo.byId('vl-menu-marc-upload'), 'toolbar_selected');
 292             break;
 293         case 'vl-queue-select-div':
 294             openils.Util.addCSSClass(dojo.byId('vl-menu-queue-select'), 'toolbar_selected');
 295             break;
 296         case 'vl-attr-editor-div':
 297             openils.Util.addCSSClass(dojo.byId('vl-menu-attr-editor'), 'toolbar_selected');
 298             break;
 299         case 'vl-profile-editor-div':
 300             openils.Util.addCSSClass(dojo.byId('vl-menu-profile-editor'), 'toolbar_selected');
 301             break;
 302         case 'vl-item-attr-editor-div':
 303             openils.Util.addCSSClass(dojo.byId('vl-menu-import-item-attr-editor'), 'toolbar_selected');
 304             break;
 305         case 'vl-match-set-editor-div':
 306             openils.Util.addCSSClass(dojo.byId('vl-menu-match-set-editor'), 'toolbar_selected');
 307             break;
 308     }
 309 }
 310
 311 function runStartupCommands() {
 312     currentQueueId = cgi.param('qid');
 313     currentType = cgi.param('qtype');
 314     dojo.style('vl-nav-bar', 'visibility', 'visible');
 315     if(currentQueueId)
 316         return retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
 317     vlShowUploadForm();
 318 }
 319
 320 /**
 321   * asynchronously upload a file of MARC records
 322   */
 323 function uploadMARC(onload){
 324     dojo.byId('vl-upload-status-count').innerHTML = '0';
 325     dojo.byId('vl-ses-input').value = authtoken;
 326     displayGlobalDiv('vl-marc-upload-status-div');
 327     dojo.io.iframe.send({
 328         url: VANDELAY_URL,
 329         method: "post",
 330         handleAs: "html",
 331         form: dojo.byId('vl-marc-upload-form'),
 332         handle: function(data,ioArgs){
 333             var content = data.documentElement.textContent;
 334             onload(content);
 335         }
 336     });
 337 }
 338
 339 /**
 340   * Creates a new vandelay queue
 341   */
 342 function createQueue(queueName, type, onload, importDefId, matchSet) {
 343     var name = (type=='bib') ? 'bib' : 'authority';
 344     var method = 'open-ils.vandelay.'+ name +'_queue.create'
 345     fieldmapper.standardRequest(
 346         ['open-ils.vandelay', method],
 347         {   async: true,
 348             params: [authtoken, queueName, null, name, matchSet, importDefId],
 349             oncomplete : function(r) {
 350                 var queue = r.recv().content();
 351                 if(e = openils.Event.parse(queue))
 352                     return alert(e);
 353                 onload(queue);
 354             }
 355         }
 356     );
 357 }
 358
 359 /**
 360   * Tells vandelay to pull a batch of records from the cache and explode them
 361   * out into the vandelay tables
 362   */
 363 function processSpool(key, queueId, type, onload) {
 364     fieldmapper.standardRequest(
 365         ['open-ils.vandelay', 'open-ils.vandelay.'+type+'.process_spool'],
 366         {   async: true,
 367             params: [authtoken, key, queueId],
 368             onresponse : function(r) {
 369                 var resp = r.recv().content();
 370                 if(e = openils.Event.parse(resp))
 371                     return alert(e);
 372                 dojo.byId('vl-upload-status-count').innerHTML = resp;
 373             },
 374             oncomplete : function(r) {onload();}
 375         }
 376     );
 377 }
 378
 379 function vlExportInit() {
 380     var qsel = dojo.byId('vl-queue-export-options');
 381     qsel.onchange = function(newVal) {
 382         var value = qsel.options[qsel.selectedIndex].value;
 383         qsel.selectedIndex = 0;
 384         if(!value) return;
 385         if(!confirm('Export as "' + value + '"?')) return; // TODO: i18n
 386         retrieveQueuedRecords(
 387             currentType,
 388             currentQueueId,
 389             function(r) { exportHandler(value, r) },
 390             value
 391         );
 392     }
 393 }
 394
 395 function exportHandler(type, response) {
 396     var content = openils.Util.readResponse(response);
 397     if(type == 'print') {
 398         // TODO print the content
 399     }
 400     alert('response = ' + response);
 401 }
 402
 403 function retrieveQueuedRecords(type, queueId, onload, doExport) {
 404     displayGlobalDiv('vl-generic-progress');
 405     queuedRecords = [];
 406     queuedRecordsMap = {};
 407     currentOverlayRecordsMap = {};
 408     currentOverlayRecordsMapGid = {};
 409     selectableGridRecords = {};
 410
 411     if(!type) type = currentType;
 412     if(!queueId) queueId = currentQueueId;
 413     if(!onload) onload = handleRetrieveRecords;
 414
 415     var method = 'open-ils.vandelay.'+type+'_queue.records.retrieve.atomic';
 416
 417     if(doExport) method += '.export.' + doExport;
 418     if(vlQueueGridShowMatches.checked)
 419         method = method.replace('records', 'records.matches');
 420
 421     var sel = dojo.byId('vl-queue-display-limit-selector');
 422     var limit = parseInt(sel.options[sel.selectedIndex].value);
 423     var offset = limit * parseInt(vlQueueDisplayPage.attr('value')-1);
 424
 425     var params =  [authtoken, queueId, {clear_marc: 1, offset: offset, limit: limit, flesh_import_items:1}];
 426     if(vlQueueGridShowNonImport.checked)
 427         params[2].non_imported = 1;
 428
 429     if(vlQueueGridShowImportErrors.checked)
 430         params[2].with_import_error = 1;
 431
 432     fieldmapper.standardRequest(
 433         ['open-ils.vandelay', method],
 434         {   async: true,
 435             params: params,
 436             oncomplete: function(r){
 437                 if(doExport) return onload();
 438                 var recs = r.recv().content();
 439                 if(e = openils.Event.parse(recs[0]))
 440                     return alert(e);
 441                 for(var i = 0; i < recs.length; i++) {
 442                     var rec = recs[i];
 443                     queuedRecords.push(rec);
 444                     queuedRecordsMap[rec.id()] = rec;
 445                 }
 446                 onload();
 447             }
 448         }
 449     );
 450 }
 451
 452 function vlLoadMatchUI(recId) {
 453     displayGlobalDiv('vl-generic-progress');
 454     var queuedRec = queuedRecordsMap[recId];
 455     var matches = queuedRec.matches();
 456     var records = [];
 457     currentImportRecId = recId;
 458     for(var i = 0; i < matches.length; i++)
 459         records.push(matches[i].eg_record());
 460
 461     var retrieve = ['open-ils.search', 'open-ils.search.biblio.record_entry.slim.retrieve'];
 462     var params = [records];
 463     if(currentType == 'auth') {
 464         retrieve = ['open-ils.cat', 'open-ils.cat.authority.record.retrieve'];
 465         params = [authtoken, records, {clear_marc:1}];
 466     }
 467
 468     fieldmapper.standardRequest(
 469         retrieve,
 470         {   async: true,
 471             params:params,
 472             oncomplete: function(r) {
 473                 var recs = r.recv().content();
 474                 if(e = openils.Event.parse(recs))
 475                     return alert(e);
 476
 477                 /* ui mangling */
 478                 displayGlobalDiv('vl-match-div');
 479                 resetVlMatchGridLayout();
 480                 currentMatchedRecords = recs;
 481                 vlMatchGrid.setStructure(vlMatchGridLayout);
 482
 483                 // build the data store of records with match information
 484                 var dataStore = bre.toStoreData(recs, null,
 485                     {virtualFields:['_id', 'match_score', 'match_quality', 'rec_quality']});
 486                 dataStore.identifier = '_id';
 487
 488                 var matchSeenMap = {};
 489
 490                 for(var i = 0; i < dataStore.items.length; i++) {
 491                     var item = dataStore.items[i];
 492                     item._id = i; // just need something unique
 493                     for(var j = 0; j < matches.length; j++) {
 494                         var match = matches[j];
 495                         if(match.eg_record() == item.id && !matchSeenMap[match.id()]) {
 496                             if(match.match_score)
 497                                 item.match_score = match.match_score();
 498                             item.match_quality = match.quality();
 499                             item.rec_quality = queuedRec.quality();
 500                             matchSeenMap[match.id()] = 1;
 501                             break;
 502                         }
 503                     }
 504                 }
 505
 506                 // now populate the grid
 507                 vlPopulateMatchGrid(vlMatchGrid, dataStore);
 508             }
 509         }
 510     );
 511 }
 512
 513 function vlPopulateMatchGrid(grid, data) {
 514     var store = new dojo.data.ItemFileReadStore({data:data});
 515     grid.setStore(store);
 516     grid.update();
 517 }
 518
 519 function showMe(id) {
 520     dojo.style(dojo.byId(id), 'display', 'block');
 521 }
 522 function hideMe(id) {
 523     dojo.style(dojo.byId(id), 'display', 'none');
 524 }
 525
 526
 527 function vlLoadMARCHtml(recId, inCat, oncomplete) {
 528     dijit.byId('vl-marc-html-done-button').onClick = oncomplete;
 529     displayGlobalDiv('vl-generic-progress');
 530     var api;
 531     var params = [recId, 1];
 532
 533     if(inCat) {
 534         hideMe('vl-marc-html-edit-button'); // don't show marc editor button
 535         dijit.byId('vl-marc-html-edit-button').onClick = function(){}
 536         api = ['open-ils.search', 'open-ils.search.biblio.record.html'];
 537         if(currentType == 'auth')
 538             api = ['open-ils.search', 'open-ils.search.authority.to_html'];
 539     } else {
 540         showMe('vl-marc-html-edit-button'); // plug in the marc editor button
 541         dijit.byId('vl-marc-html-edit-button').onClick =
 542             function() {vlLoadMarcEditor(currentType, recId, oncomplete);};
 543         params = [authtoken, recId];
 544         api = ['open-ils.vandelay', 'open-ils.vandelay.queued_bib_record.html'];
 545         if(currentType == 'auth')
 546             api = ['open-ils.vandelay', 'open-ils.vandelay.queued_authority_record.html'];
 547     }
 548
 549     fieldmapper.standardRequest(
 550         api,
 551         {   async: true,
 552             params: params,
 553             oncomplete: function(r) {
 554             displayGlobalDiv('vl-marc-html-div');
 555                 var html = r.recv().content();
 556                 dojo.byId('vl-marc-record-html').innerHTML = html;
 557             }
 558         }
 559     );
 560 }
 561
 562
 563 /*
 564 function getRecMatchesFromAttrCode(rec, attrCode) {
 565     var matches = [];
 566     var attr = getRecAttrFromCode(rec, attrCode);
 567     for(var j = 0; j < rec.matches().length; j++) {
 568         var match = rec.matches()[j];
 569         if(match.matched_attr() == attr.id())
 570             matches.push(match);
 571     }
 572     return matches;
 573 }
 574 */
 575
 576 /*
 577 function getRecAttrFromMatch(rec, match) {
 578     for(var i = 0; i < rec.attributes().length; i++) {
 579         var attr = rec.attributes()[i];
 580         if(attr.id() == match.matched_attr())
 581             return attr;
 582     }
 583 }
 584 */
 585
 586 function getRecAttrDefFromAttr(attr, type) {
 587     var defs = (type == 'bib') ? bibAttrDefs : authAttrDefs;
 588     for(var i = 0; i < defs.length; i++) {
 589         var def = defs[i];
 590         if(def.id() == attr.field())
 591             return def;
 592     }
 593 }
 594
 595 function getRecAttrFromCode(rec, attrCode) {
 596     var defId = attrDefMap[currentType][attrCode];
 597     var attrs = rec.attributes();
 598     for(var i = 0; i < attrs.length; i++) {
 599         var attr = attrs[i];
 600         if(attr.field() == defId)
 601             return attr;
 602     }
 603     return null;
 604 }
 605
 606 function vlGetViewMatches(rowIdx, item) {
 607     if(item) {
 608         var id = this.grid.store.getValue(item, 'id');
 609         var rec = queuedRecordsMap[id];
 610         if(rec.matches().length > 0)
 611             return id;
 612     }
 613     return -1
 614 }
 615
 616 function vlFormatViewMatches(id) {
 617     if(id == -1) return '';
 618     return '<a href="javascript:void(0);" onclick="vlLoadMatchUI(' + id + ');">' + this.name + '</a>';
 619 }
 620
 621 function vlGetViewErrors(rowIdx, item) {
 622     if(item) {
 623         var id = this.grid.store.getValue(item, 'id');
 624         var rec = queuedRecordsMap[id];
 625         // id:rec_error:item_import_error_count
 626         return id + ':' +
 627             (rec.import_error() ? 1 : '') + ':' +
 628             rec.import_items().filter(function(i) {return i.import_error()}).length;
 629     }
 630     return -1
 631 }
 632
 633 function vlFormatViewErrors(chunk) {
 634     if(chunk == -1) return '';
 635     var id = chunk.split(':')[0];
 636     var rec = chunk.split(':')[1];
 637     var count = chunk.split(':')[2];
 638     var links = '';
 639     if(rec)
 640         links += '<a href="javascript:void(0);" onclick="vlLoadErrorUI(' + id + ');">Record</a><br/>'; // TODO I18N
 641     if(Number(count))
 642         links += '<a href="javascript:void(0);" onclick="vlLoadErrorUI(' + id + ');">Items ('+count+')</a>'; // TODO I18N
 643     return links;
 644 }
 645
 646 //var vlItemErrorColumnPicker;
 647 function vlLoadErrorUI(id) {
 648
 649     displayGlobalDiv('vl-import-error-div');
 650     openils.Util.hide('vl-import-error-grid-all');
 651     openils.Util.show('vl-import-error-record');
 652
 653     var rec = queuedRecordsMap[id];
 654
 655     dojo.byId('vl-error-id').innerHTML = rec.id();
 656     dojo.forEach( // TODO sane authority rec. fields
 657         ['title', 'author', 'isbn', 'issn', 'upc'],
 658         function(field) {
 659             var attr =  getRecAttrFromCode(rec, field);
 660             var eid = 'vl-error-' + field;
 661             if(attr) {
 662                 openils.Util.show(dojo.byId(eid).parentNode, 'table-row');
 663                 dojo.byId(eid).innerHTML = attr.attr_value();
 664             } else {
 665                 openils.Util.hide(dojo.byId(eid).parentNode);
 666             }
 667         }
 668     );
 669     var iediv = dojo.byId('vl-error-import-error');
 670     var eddiv = dojo.byId('vl-error-error-detail');
 671     if(rec.import_error()) {
 672         openils.Util.show(iediv.parentNode, 'table-row');
 673         openils.Util.show(eddiv.parentNode, 'table-row');
 674         iediv.innerHTML = rec.import_error();
 675         eddiv.innerHTML = rec.error_detail();
 676     } else {
 677         openils.Util.hide(iediv.parentNode);
 678         openils.Util.hide(eddiv.parentNode);
 679     }
 680
 681     var errorItems = rec.import_items().filter(function(i) {return i.import_error()});
 682     if(errorItems.length) {
 683         openils.Util.show('vl-import-error-grid-some');
 684         storeData = vqbr.toStoreData(errorItems);
 685         var store = new dojo.data.ItemFileReadStore({data:storeData});
 686         vlImportErrorGrid.setStore(store);
 687         vlImportErrorGrid.update();
 688     } else {
 689         openils.Util.hide('vl-import-error-grid-some');
 690     }
 691 }
 692
 693 function vlLoadErrorUIAll() {
 694
 695     displayGlobalDiv('vl-import-error-div');
 696     openils.Util.hide('vl-import-error-grid-some');
 697     openils.Util.hide('vl-import-error-record');
 698     openils.Util.show('vl-import-error-grid-all');
 699     vlAllImportErrorGrid.resetStore();
 700
 701     vlImportErrorGrid.displayOffset = 0;
 702
 703     vlAllImportErrorGrid.dataLoader = function() {
 704
 705         vlAllImportErrorGrid.showLoadProgressIndicator();
 706
 707         fieldmapper.standardRequest(
 708             ['open-ils.vandelay', 'open-ils.vandelay.import_item.queue.retrieve'],
 709             {
 710                 async : true,
 711                 params : [
 712                     authtoken, currentQueueId, {
 713                         with_import_error: (vlImportItemsShowErrors.checked) ? 1 : null,
 714                         offset : vlAllImportErrorGrid.displayOffset,
 715                         limit : vlAllImportErrorGrid.displayLimit
 716                     }
 717                 ],
 718                 onresponse : function(r) {
 719                     var item = openils.Util.readResponse(r);
 720                     if(!item) return;
 721                     vlAllImportErrorGrid.store.newItem(vii.toStoreItem(item));
 722                 },
 723                 oncomplete : function() {
 724                     vlAllImportErrorGrid.hideLoadProgressIndicator();
 725                 }
 726             }
 727         );
 728     };
 729
 730     vlAllImportErrorGrid.dataLoader();
 731 }
 732
 733 function vlGetOrg(rowIdx, item) {
 734     if(!item) return '';
 735     var value = this.grid.store.getValue(item, this.field);
 736     if(value) return fieldmapper.aou.findOrgUnit(value).shortname();
 737     return '';
 738 }
 739
 740 function vlFormatViewMatchMARC(id) {
 741     return '<a href="javascript:void(0);" onclick="vlLoadMARCHtml(' + id + ', true, '+
 742         'function(){displayGlobalDiv(\'vl-match-div\');});">' + this.name + '</a>';
 743 }
 744
 745 function getAttrValue(rowIdx, item) {
 746     if(!item) return '';
 747     var attrCode = this.field.split('.')[1];
 748     var rec = queuedRecordsMap[this.grid.store.getValue(item, 'id')];
 749     var attr = getRecAttrFromCode(rec, attrCode);
 750     return (attr) ? attr.attr_value() : '';
 751 }
 752
 753 function vlGetDateTimeField(rowIdx, item) {
 754     if(!item) return '';
 755     var value = this.grid.store.getValue(item, this.field);
 756     if(!value) return '';
 757     var date = dojo.date.stamp.fromISOString(value);
 758     return dojo.date.locale.format(date, {selector:'date'});
 759 }
 760
 761 function vlGetCreator(rowIdx, item) {
 762     if(!item) return '';
 763     var id = this.grid.store.getValue(item, 'creator');
 764     if(userCache[id])
 765         return userCache[id].usrname();
 766     var user = fieldmapper.standardRequest(
 767         ['open-ils.actor', 'open-ils.actor.user.retrieve'], [authtoken, id]);
 768     if(e = openils.Event.parse(user))
 769         return alert(e);
 770     userCache[id] = user;
 771     return user.usrname();
 772 }
 773
 774 function vlGetViewMARC(rowIdx, item) {
 775     return item && this.grid.store.getValue(item, 'id');
 776 }
 777
 778 function vlFormatViewMARC(id) {
 779     return '<a href="javascript:void(0);" onclick="vlLoadMARCHtml(' + id + ', false, '+
 780         'function(){displayGlobalDiv(\'vl-queue-div\');});">' + this.name + '</a>';
 781 }
 782
 783 function vlGetOverlayTargetSelector(rowIdx, item) {
 784     if(!item) return;
 785     return this.grid.store.getValue(item, '_id') + ':' + this.grid.store.getValue(item, 'id');
 786 }
 787
 788 function vlFormatOverlayTargetSelector(val) {
 789     if(!val) return '';
 790     var parts = val.split(':');
 791     var _id = parts[0];
 792     var id = parts[1];
 793     var value = '<input type="checkbox" name="vl-overlay-target-RECID" '+
 794         'onclick="vlHandleOverlayTargetSelected(ID, GRIDID);" gridid="GRIDID" match="ID"/>';
 795     value = value.replace(/GRIDID/g, _id);
 796     value = value.replace(/RECID/g, currentImportRecId);
 797     value = value.replace(/ID/g, id);
 798     if(_id == currentOverlayRecordsMapGid[currentImportRecId])
 799         return value.replace('/>', 'checked="checked"/>');
 800     return value;
 801 }
 802
 803
 804 /**
 805   * see if the user has enabled overlays for the current match set and,
 806   * if so, map the current import record to the overlay target.
 807   */
 808 function vlHandleOverlayTargetSelected(recId, gridId) {
 809     var noneSelected = true;
 810     var checkboxes = dojo.query('[name=vl-overlay-target-'+currentImportRecId+']');
 811     for(var i = 0; i < checkboxes.length; i++) {
 812         var checkbox = checkboxes[i];
 813         var matchRecId = checkbox.getAttribute('match');
 814         var gid = checkbox.getAttribute('gridid');
 815         if(checkbox.checked) {
 816             if(matchRecId == recId && gid == gridId) {
 817                 noneSelected = false;
 818                 currentOverlayRecordsMap[currentImportRecId] = matchRecId;
 819                 currentOverlayRecordsMapGid[currentImportRecId] = gid;
 820                 dojo.byId('vl-record-list-selected-' + currentImportRecId).checked = true;
 821                 dojo.byId('vl-record-list-selected-' + currentImportRecId).parentNode.className = 'overlay_selected';
 822             } else {
 823                 checkbox.checked = false;
 824             }
 825         }
 826     }
 827
 828     if(noneSelected) {
 829         delete currentOverlayRecordsMap[currentImportRecId];
 830         delete currentOverlayRecordsMapGid[currentImportRecId];
 831         dojo.byId('vl-record-list-selected-' + currentImportRecId).checked = false;
 832         dojo.byId('vl-record-list-selected-' + currentImportRecId).parentNode.className = '';
 833     }
 834 }
 835
 836 var valLastQueueType = null;
 837 var vlQueueGridLayout = null;
 838 function buildRecordGrid(type) {
 839     displayGlobalDiv('vl-queue-div');
 840
 841     if(type == 'bib') {
 842         openils.Util.show('vl-bib-queue-grid-wrapper');
 843         openils.Util.hide('vl-auth-queue-grid-wrapper');
 844         vlQueueGrid = vlBibQueueGrid;
 845     } else {
 846         openils.Util.show('vl-auth-queue-grid-wrapper');
 847         openils.Util.hide('vl-bib-queue-grid-wrapper');
 848         vlQueueGrid = vlAuthQueueGrid;
 849     }
 850
 851
 852     if(valLastQueueType != type) {
 853         valLastQueueType = type;
 854         vlQueueGridLayout = vlQueueGrid.attr('structure');
 855         var defs = (type == 'bib') ? bibAttrDefs : authAttrDefs;
 856         attrDefMap[type] = {};
 857         for(var i = 0; i < defs.length; i++) {
 858             var def = defs[i]
 859             attrDefMap[type][def.code()] = def.id();
 860             var col = {
 861                 name:def.description(),
 862                 field:'attr.' + def.code(),
 863                 get: getAttrValue,
 864                 selectableColumn:true
 865             };
 866             vlQueueGridLayout[0].cells[0].push(col);
 867         }
 868     }
 869
 870     dojo.forEach(vlQueueGridLayout[0].cells[0],
 871         function(cell) {
 872             if(cell.field.match(/^\+/))
 873                 cell.nonSelectable=true;
 874         }
 875     );
 876
 877     var storeData;
 878     if(type == 'bib')
 879         storeData = vqbr.toStoreData(queuedRecords);
 880     else
 881         storeData = vqar.toStoreData(queuedRecords);
 882
 883     var store = new dojo.data.ItemFileReadStore({data:storeData});
 884     vlQueueGrid.setStore(store);
 885
 886     if(vlQueueGridColumePicker[type]) {
 887         vlQueueGrid.update();
 888     } else {
 889
 890         vlQueueGridColumePicker[type] =
 891             new openils.widget.GridColumnPicker(
 892                 authtoken, 'vandelay.queue.'+type, vlQueueGrid, vlQueueGridLayout);
 893         vlQueueGridColumePicker[type].load();
 894     }
 895 }
 896
 897 function vlQueueGridPrevPage() {
 898     var page = parseInt(vlQueueDisplayPage.getValue());
 899     if(page < 2) return;
 900     vlQueueDisplayPage.setValue(page - 1);
 901     retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
 902 }
 903
 904 function vlQueueGridNextPage() {
 905     vlQueueDisplayPage.setValue(parseInt(vlQueueDisplayPage.getValue())+1);
 906     retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
 907 }
 908
 909 function vlDeleteQueue(type, queueId, onload) {
 910     fieldmapper.standardRequest(
 911         ['open-ils.vandelay', 'open-ils.vandelay.'+type+'_queue.delete'],
 912         {   async: true,
 913             params: [authtoken, queueId],
 914             oncomplete: function(r) {
 915                 var resp = r.recv().content();
 916                 if(e = openils.Event.parse(resp))
 917                     return alert(e);
 918                 onload();
 919             }
 920         }
 921     );
 922 }
 923
 924
 925 function vlQueueGridDrawSelectBox(rowIdx, item) {
 926     return item &&  this.grid.store.getValue(item, 'id');
 927 }
 928
 929 function vlQueueGridFormatSelectBox(id) {
 930     var domId = 'vl-record-list-selected-' + id;
 931     if (id) { selectableGridRecords[domId] = id; }
 932     return "<div><input type='checkbox' id='"+domId+"'/></div>";
 933 }
 934
 935 function vlSelectAllQueueGridRecords() {
 936     for(var id in selectableGridRecords)
 937         dojo.byId(id).checked = true;
 938 }
 939 function vlSelectNoQueueGridRecords() {
 940     for(var id in selectableGridRecords)
 941         dojo.byId(id).checked = false;
 942 }
 943 function vlToggleQueueGridSelect() {
 944     if(dojo.byId('vl-queue-grid-row-selector').checked)
 945         vlSelectAllQueueGridRecords();
 946     else
 947         vlSelectNoQueueGridRecords();
 948 }
 949
 950 var handleRetrieveRecords = function() {
 951     buildRecordGrid(currentType);
 952     vlFetchQueueSummary(currentQueueId, currentType,
 953         function(summary) {
 954             dojo.byId('vl-queue-summary-name').innerHTML = summary.queue.name();
 955             dojo.byId('vl-queue-summary-total-count').innerHTML = summary.total +'';
 956             dojo.byId('vl-queue-summary-import-count').innerHTML = summary.imported + '';
 957             dojo.byId('vl-queue-summary-import-item-count').innerHTML = summary.total_items + '';
 958             dojo.byId('vl-queue-summary-rec-error-count').innerHTML = summary.rec_import_errors + '';
 959             dojo.byId('vl-queue-summary-item-error-count').innerHTML = summary.item_import_errors + '';
 960         }
 961     );
 962 }
 963
 964 function vlFetchQueueSummary(qId, type, onload) {
 965     fieldmapper.standardRequest(
 966         ['open-ils.vandelay', 'open-ils.vandelay.'+type+'_queue.summary.retrieve'],
 967         {   async: true,
 968             params: [authtoken, qId],
 969             oncomplete : function(r) {
 970                 var summary = r.recv().content();
 971                 if(e = openils.Event.parse(summary))
 972                     return alert(e);
 973                 return onload(summary);
 974             }
 975         }
 976     );
 977 }
 978
 979 function vlHandleQueueItemsAction(action) {
 980
 981     dojo.connect(
 982         queueItemsImportCancelButton,
 983         'onClick',
 984         function() {
 985             queueItemsImportDialog.hide();
 986         }
 987     );
 988
 989     dojo.connect(
 990         queueItemsImportGoButton,
 991         'onClick',
 992         function() {
 993             queueItemsImportDialog.hide();
 994
 995             // hack to set the widgets the import funcs will be looking at.  Reset them below.
 996             vlUploadQueueImportNoMatch.attr('value',  vlUploadQueueImportNoMatch2.attr('value'));
 997             vlUploadQueueAutoOverlayExact.attr('value',  vlUploadQueueAutoOverlayExact2.attr('value'));
 998             vlUploadQueueAutoOverlay1Match.attr('value',  vlUploadQueueAutoOverlay1Match2.attr('value'));
 999             vlUploadMergeProfile.attr('value',  vlUploadMergeProfile2.attr('value'));
1000             vlUploadQueueAutoOverlayBestMatch.attr('value',  vlUploadQueueAutoOverlayBestMatch2.attr('value'));
1001             vlUploadQueueAutoOverlayBestMatchRatio.attr('value',  vlUploadQueueAutoOverlayBestMatchRatio2.attr('value'));
1002
1003             if(action == 'import') {
1004                 vlImportSelectedRecords();
1005             } else if(action == 'import_all') {
1006                 vlImportAllRecords();
1007             }
1008
1009             // reset the widgets to prevent accidental future actions
1010             vlUploadQueueImportNoMatch.attr('value',  false);
1011             vlUploadQueueImportNoMatch2.attr('value', false);
1012             vlUploadQueueAutoOverlayExact.attr('value', false);
1013             vlUploadQueueAutoOverlayExact2.attr('value', false);
1014             vlUploadQueueAutoOverlay1Match.attr('value', false);
1015             vlUploadQueueAutoOverlay1Match2.attr('value', false);
1016             vlUploadMergeProfile.attr('value', '');
1017             vlUploadMergeProfile2.attr('value', '');
1018             vlUploadQueueAutoOverlayBestMatch.attr('value', false);
1019             vlUploadQueueAutoOverlayBestMatch2.attr('value', false);
1020             vlUploadQueueAutoOverlayBestMatchRatio.attr('value', '0.0');
1021             vlUploadQueueAutoOverlayBestMatchRatio2.attr('value', '0.0');
1022         }
1023     );
1024
1025     queueItemsImportDialog.show();
1026 }
1027
1028
1029 /* import user-selected records */
1030 function vlImportSelectedRecords() {
1031     var records = [];
1032
1033     for(var id in selectableGridRecords) {
1034         if(dojo.byId(id).checked) {
1035             var recId = selectableGridRecords[id];
1036             var rec = queuedRecordsMap[recId];
1037             if(!rec.import_time())
1038                 records.push(recId);
1039         }
1040     }
1041
1042     vlImportRecordQueue(
1043         currentType,
1044         currentQueueId,
1045         records,
1046         function(){
1047             retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
1048         }
1049     );
1050 }
1051
1052 /* import all (non-imported) queue records */
1053 function vlImportAllRecords() {
1054     vlImportRecordQueue(
1055         currentType,
1056         currentQueueId,
1057         null,
1058         function(){
1059             retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
1060         }
1061     );
1062 }
1063
1064 /* if recList has values, import only those records */
1065 function vlImportRecordQueue(type, queueId, recList, onload) {
1066     displayGlobalDiv('vl-generic-progress-with-total');
1067
1068     /* set up options */
1069     var mergeOpt = false;
1070     var options = {overlay_map : currentOverlayRecordsMap};
1071
1072     if(vlUploadQueueImportNoMatch.checked) {
1073         options.import_no_match = true;
1074         vlUploadQueueImportNoMatch.checked = false;
1075     }
1076
1077     if(vlUploadQueueAutoOverlayExact.checked) {
1078         options.auto_overlay_exact = true;
1079         vlUploadQueueAutoOverlayExact.checked = false;
1080         mergeOpt = true;
1081     }
1082
1083     if(vlUploadQueueAutoOverlayBestMatch.checked) {
1084         options.auto_overlay_best_match = true;
1085         vlUploadQueueAutoOverlayBestMatch.checked = false;
1086         options.match_quality_ratio = vlUploadQueueAutoOverlayBestMatchRatio.attr('value');
1087         mergeOpt = true;
1088     }
1089
1090     if(vlUploadQueueAutoOverlay1Match.checked) {
1091         options.auto_overlay_1match = true;
1092         vlUploadQueueAutoOverlay1Match.checked = false;
1093         mergeOpt = true;
1094     }
1095
1096     var profile = vlUploadMergeProfile.attr('value');
1097     if(profile != null && profile != '') {
1098         options.merge_profile = profile;
1099     }
1100
1101     /* determine which method we're calling */
1102
1103     var method = 'open-ils.vandelay.bib_queue.import';
1104     if(type == 'auth')
1105         method = method.replace('bib', 'auth');
1106
1107     if(!mergeOpt) {
1108         // in the interest of speed, if no merge options are
1109         // chosen, tell the back-end code to only process records
1110         // that have no matches
1111         method = method.replace(/\.import/, '.nomatch.import');
1112     }
1113
1114     var params = [authtoken, queueId, options];
1115     if(recList) {
1116         method = 'open-ils.vandelay.'+currentType+'_record.list.import';
1117         params[1] = recList;
1118     }
1119
1120     fieldmapper.standardRequest(
1121         ['open-ils.vandelay', method],
1122         {   async: true,
1123             params: params,
1124             onresponse: function(r) {
1125                 var resp = r.recv().content();
1126                 if(e = openils.Event.parse(resp))
1127                     return alert(e);
1128                 vlControlledProgressBar.update({maximum:resp.total, progress:resp.progress});
1129             },
1130             oncomplete: function() {onload();}
1131         }
1132     );
1133 }
1134
1135
1136 /**
1137   * Create queue, upload MARC, process spool, load the newly created queue
1138   */
1139 function batchUpload() {
1140     var queueName = dijit.byId('vl-queue-name').getValue();
1141     currentType = dijit.byId('vl-record-type').getValue();
1142
1143     var handleProcessSpool = function() {
1144         if(
1145             vlUploadQueueImportNoMatch.checked ||
1146             vlUploadQueueAutoOverlayExact.checked ||
1147             vlUploadQueueAutoOverlay1Match.checked ||
1148             vlUploadQueueAutoOverlayBestMatch.checked ) {
1149
1150                 vlImportRecordQueue(
1151                     currentType,
1152                     currentQueueId,
1153                     null,
1154                     function() {
1155                         retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
1156                     }
1157                 );
1158         } else {
1159             retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
1160         }
1161     }
1162
1163     var handleUploadMARC = function(key) {
1164         dojo.style(dojo.byId('vl-upload-status-processing'), 'display', 'block');
1165         processSpool(key, currentQueueId, currentType, handleProcessSpool);
1166     };
1167
1168     var handleCreateQueue = function(queue) {
1169         currentQueueId = queue.id();
1170         uploadMARC(handleUploadMARC);
1171     };
1172
1173     if(vlUploadQueueSelector.getValue() && !queueName) {
1174         currentQueueId = vlUploadQueueSelector.getValue();
1175         uploadMARC(handleUploadMARC);
1176     } else {
1177         createQueue(queueName, currentType, handleCreateQueue,
1178             vlUploadQueueHoldingsImportProfile.attr('value'),
1179             vlUploadQueueMatchSet.attr('value')
1180         );
1181     }
1182 }
1183
1184
1185 function vlFleshQueueSelect(selector, type) {
1186     var data = (type == 'bib') ? vbq.toStoreData(allUserBibQueues) : vaq.toStoreData(allUserAuthQueues);
1187     selector.store = new dojo.data.ItemFileReadStore({data:data});
1188     selector.setValue(null);
1189     selector.setDisplayedValue('');
1190     if(data[0])
1191         selector.setValue(data[0].id());
1192
1193     var qInput = dijit.byId('vl-queue-name');
1194
1195     var selChange = function(val) {
1196         console.log('selector onchange');
1197         // user selected a queue from the selector;  clear the input and
1198         // set the item import profile already defined for the queue
1199         var queue = allUserBibQueues.filter(function(q) { return (q.id() == val) })[0];
1200         if(val) {
1201             vlUploadQueueHoldingsImportProfile.attr('value', queue.item_attr_def() || '');
1202             vlUploadQueueHoldingsImportProfile.attr('disabled', true);
1203             vlUploadQueueMatchSet.attr('value', queue.match_set() || '');
1204             vlUploadQueueMatchSet.attr('disabled', true);
1205         } else {
1206             vlUploadQueueHoldingsImportProfile.attr('value', '');
1207             vlUploadQueueHoldingsImportProfile.attr('disabled', false);
1208             vlUploadQueueMatchSet.attr('value', '');
1209             vlUploadQueueMatchSet.attr('disabled', false);
1210         }
1211         dojo.disconnect(qInput._onchange);
1212         qInput.attr('value', '');
1213         qInput._onchange = dojo.connect(qInput, 'onChange', inputChange);
1214     }
1215
1216     var inputChange = function(val) {
1217         console.log('qinput onchange');
1218         // user entered a new queue name. clear the selector
1219         vlUploadQueueHoldingsImportProfile.attr('value', '');
1220         vlUploadQueueHoldingsImportProfile.attr('disabled', false);
1221         vlUploadQueueMatchSet.attr('value', '');
1222         vlUploadQueueMatchSet.attr('disabled', false);
1223         dojo.disconnect(selector._onchange);
1224         selector.attr('value', '');
1225         selector._onchange = dojo.connect(selector, 'onChange', selChange);
1226     }
1227
1228     selector._onchange = dojo.connect(selector, 'onChange', selChange);
1229     qInput._onchange = dojo.connect(qInput, 'onChange', inputChange);
1230 }
1231
1232 function vlUpdateMatchSetSelector(type) {
1233     type = (type.match(/bib/)) ? 'biblio' : 'authority';
1234     vlUploadQueueMatchSet.store =
1235         new dojo.data.ItemFileReadStore({data:vms.toStoreData(matchSets[type])});
1236 }
1237
1238 function vlShowUploadForm() {
1239     displayGlobalDiv('vl-marc-upload-div');
1240     vlFleshQueueSelect(vlUploadQueueSelector, vlUploadRecordType.getValue());
1241     vlUploadSourceSelector.store =
1242         new dojo.data.ItemFileReadStore({data:cbs.toStoreData(vlBibSources, 'source')});
1243     vlUploadSourceSelector.setValue(vlBibSources[0].id());
1244     vlUploadQueueHoldingsImportProfile.store =
1245         new dojo.data.ItemFileReadStore({data:viiad.toStoreData(importItemDefs)});
1246     vlUpdateMatchSetSelector(vlUploadRecordType.getValue());
1247
1248     // use ratio from the merge profile if it's set
1249     dojo.connect(
1250         vlUploadMergeProfile,
1251         'onChange',
1252         function(val) {
1253             if(!val) return;
1254             var profile = mergeProfiles.filter(function(p) { return (p.id() == val); })[0];
1255             if(profile.lwm_ratio() != null)
1256                vlUploadQueueAutoOverlayBestMatchRatio.attr('value', profile.lwm_ratio()+'');
1257         }
1258     );
1259     dojo.connect(
1260         vlUploadMergeProfile2,
1261         'onChange',
1262         function(val) {
1263             if(!val) return;
1264             var profile = mergeProfiles.filter(function(p) { return (p.id() == val); })[0];
1265             if(profile.lwm_ratio() != null)
1266                vlUploadQueueAutoOverlayBestMatchRatio2.attr('value', profile.lwm_ratio()+'');
1267         }
1268     );
1269
1270 }
1271
1272 function vlShowQueueSelect() {
1273     displayGlobalDiv('vl-queue-select-div');
1274     vlFleshQueueSelect(vlQueueSelectQueueList, vlQueueSelectType.getValue());
1275 }
1276
1277 function vlShowMatchSetEditor() {
1278     displayGlobalDiv('vl-match-set-editor-div');
1279     dojo.byId('vl-match-set-editor-div').appendChild(
1280         dojo.create('iframe', {
1281             id : 'vl-match-set-iframe',
1282             src : oilsBasePath + '/eg/conify/global/vandelay/match_set',
1283             style : 'width:100%; height:500px; border:none; margin:0px;'
1284         })
1285     );
1286 }
1287
1288 function vlFetchQueueFromForm() {
1289     currentType = vlQueueSelectType.getValue();
1290     currentQueueId = vlQueueSelectQueueList.getValue();
1291     retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
1292 }
1293
1294 function vlOpenMarcEditWindow(rec, postReloadHTMLHandler) {
1295     /*
1296         To run in Firefox directly, must set signed.applets.codebase_principal_support
1297         to true in about:config
1298     */
1299     netscape.security.PrivilegeManager.enablePrivilege('UniversalXPConnect');
1300     win = window.open('/xul/server/cat/marcedit.xul'); // XXX version?
1301
1302     var type;
1303     if (currentType == 'bib') {
1304         type = 'bre';
1305     } else {
1306         type = 'are';
1307     }
1308
1309     function onsave(r) {
1310         // after the record is saved, reload the HTML display
1311         var stat = r.recv().content();
1312         if(e = openils.Event.parse(stat))
1313             return alert(e);
1314         alert(dojo.byId('vl-marc-edit-complete-label').innerHTML);
1315         win.close();
1316         vlLoadMARCHtml(rec.id(), false, postReloadHTMLHandler);
1317     }
1318
1319     win.xulG = {
1320         record : {marc : rec.marc(), "rtype": type},
1321         save : {
1322             label: dojo.byId('vl-marc-edit-save-label').innerHTML,
1323             func: function(xmlString) {
1324                 var method = 'open-ils.permacrud.update.' + rec.classname;
1325                 rec.marc(xmlString);
1326                 fieldmapper.standardRequest(
1327                     ['open-ils.permacrud', method],
1328                     {   async: true,
1329                         params: [authtoken, rec],
1330                         oncomplete: onsave
1331                     }
1332                 );
1333             },
1334         },
1335         'lock_tab' : typeof xulG != 'undefined' ? (typeof xulG['lock_tab'] != 'undefined' ? xulG.lock_tab : undefined) : undefined,
1336         'unlock_tab' : typeof xulG != 'undefined' ? (typeof xulG['unlock_tab'] != 'undefined' ? xulG.unlock_tab : undefined) : undefined
1337     };
1338 }
1339
1340 function vlLoadMarcEditor(type, recId, postReloadHTMLHandler) {
1341     var method = 'open-ils.permacrud.search.vqbr';
1342     if(currentType != 'bib')
1343         method = method.replace(/vqbr/,'vqar');
1344
1345     fieldmapper.standardRequest(
1346         ['open-ils.permacrud', method],
1347         {   async: true,
1348             params: [authtoken, {id : recId}],
1349             oncomplete: function(r) {
1350                 var rec = r.recv().content();
1351                 if(e = openils.Event.parse(rec))
1352                     return alert(e);
1353                 vlOpenMarcEditWindow(rec, postReloadHTMLHandler);
1354             }
1355         }
1356     );
1357 }
1358
1359
1360
1361 //------------------------------------------------------------
1362 // attribute editors
1363
1364 // attribute-editor global variables
1365
1366 var ATTR_EDITOR_IN_UPDATE_MODE = false; // true on 'edit', false on 'create'
1367 var ATTR_EDIT_ID = null;                // id of current 'edit' attribute
1368 var ATTR_EDIT_GROUP = 'bib';            // bib-attrs or auth-attrs
1369
1370 function vlAttrEditorInit() {
1371     // set up tooltips on the edit form
1372     connectTooltip('attr-editor-tags');
1373     connectTooltip('attr-editor-subfields');
1374 }
1375
1376 function vlShowAttrEditor() {
1377     displayGlobalDiv('vl-attr-editor-div');
1378     loadAttrEditorGrid();
1379     idHide('vl-generic-progress');
1380 }
1381
1382 function setAttrEditorGroup(groupName) {
1383     // put us into 'bib'-attr or 'auth'-attr mode.
1384     if (ATTR_EDIT_GROUP != groupName) {
1385         ATTR_EDIT_GROUP = groupName;
1386         loadAttrEditorGrid();
1387     }
1388 }
1389
1390 function onAttrEditorOpen() {
1391     // the "bars" have the create/update/cancel/etc. buttons.
1392     var create_bar = document.getElementById('attr-editor-create-bar');
1393     var update_bar = document.getElementById('attr-editor-update-bar');
1394     if (ATTR_EDITOR_IN_UPDATE_MODE) {
1395         update_bar.style.display='table-row';
1396         create_bar.style.display='none';
1397         // hide the dropdown-button
1398         idStyle('vl-create-attr-editor-button', 'visibility', 'hidden');
1399     } else {
1400         dijit.byId('attr-editor-dialog').reset();
1401         create_bar.style.display='table-row';
1402         update_bar.style.display='none';
1403     }
1404 }
1405
1406 function onAttrEditorClose() {
1407     // reset the form to a "create" form. (We may have borrowed it for editing.)
1408     ATTR_EDITOR_IN_UPDATE_MODE = false;
1409     // show the dropdown-button
1410     idStyle('vl-create-attr-editor-button', 'visibility', 'visible');
1411 }
1412
1413 function loadAttrEditorGrid() {
1414     var _data = (ATTR_EDIT_GROUP == 'auth') ?
1415         vqarad.toStoreData(authAttrDefs) : vqbrad.toStoreData(bibAttrDefs) ;
1416
1417     var store = new dojo.data.ItemFileReadStore({data:_data});
1418     attrEditorGrid.setStore(store);
1419     attrEditorGrid.onRowDblClick = onAttrEditorClick;
1420     attrEditorGrid.update();
1421 }
1422
1423 function attrGridGetTag(n, item) {
1424     // grid helper: return the tags from the row's xpath column.
1425     return item && xpathParser.parse(this.grid.store.getValue(item, 'xpath')).tags;
1426 }
1427
1428 function attrGridGetSubfield(n, item) {
1429     // grid helper: return the subfields from the row's xpath column.
1430     return item && xpathParser.parse(this.grid.store.getValue(item, 'xpath')).subfields;
1431 }
1432
1433 function onAttrEditorClick() {
1434     var row = this.getItem(this.focus.rowIndex);
1435     ATTR_EDIT_ID = this.store.getValue(row, 'id');
1436     ATTR_EDITOR_IN_UPDATE_MODE = true;
1437
1438     // populate the popup editor.
1439     dijit.byId('attr-editor-code').attr('value', this.store.getValue(row, 'code'));
1440     dijit.byId('attr-editor-description').attr('value', this.store.getValue(row, 'description'));
1441     var parsed_xpath = xpathParser.parse(this.store.getValue(row, 'xpath'));
1442     dijit.byId('attr-editor-tags').attr('value', parsed_xpath.tags);
1443     dijit.byId('attr-editor-subfields').attr('value', parsed_xpath.subfields);
1444     dijit.byId('attr-editor-xpath').attr('value', this.store.getValue(row, 'xpath'));
1445     dijit.byId('attr-editor-remove').attr('value', this.store.getValue(row, 'remove'));
1446
1447     // set up UI for editing
1448     dojo.byId('vl-create-attr-editor-button').click();
1449 }
1450
1451 function vlSaveAttrDefinition(data) {
1452     idHide('vl-attr-editor-div');
1453     idShow('vl-generic-progress');
1454
1455     data.id = ATTR_EDIT_ID;
1456
1457     // this ought to honour custom xpaths, but overwrite xpaths
1458     // derived from tags/subfields.
1459     if (data.xpath == '' || looksLikeDerivedXpath(data.xpath)) {
1460         var _xpath = tagAndSubFieldsToXpath(data.tag, data.subfield);
1461         data.xpath = _xpath;
1462     }
1463
1464     // build up our permacrud params. Key variables here are
1465     // "create or update" and "bib or auth".
1466
1467     var isAuth   = (ATTR_EDIT_GROUP == 'auth');
1468     var isCreate = (ATTR_EDIT_ID == null);
1469     var rad      = isAuth ? new vqarad() : new vqbrad() ;
1470     var method   = 'open-ils.permacrud' + (isCreate ? '.create.' : '.update.')
1471         + (isAuth ? 'vqarad' : 'vqbrad');
1472     var _data    = rad.fromStoreItem(data);
1473
1474     _data.ischanged(1);
1475
1476     fieldmapper.standardRequest(
1477         ['open-ils.permacrud', method],
1478         {   async: true,
1479             params: [authtoken, _data ],
1480             onresponse: function(r) { },
1481             oncomplete: function(r) {
1482                 attrEditorFetchAttrDefs(vlShowAttrEditor);
1483                 ATTR_EDIT_ID = null;
1484             },
1485             onerror: function(r) {
1486                 alert('vlSaveAttrDefinition comms error: ' + r);
1487             }
1488         }
1489     );
1490 }
1491
1492 function attrEditorFetchAttrDefs(callback) {
1493     var fn = (ATTR_EDIT_GROUP == 'auth') ? vlFetchAuthAttrDefs : vlFetchBibAttrDefs;
1494     return fn(callback);
1495 }
1496
1497 function vlAttrDelete() {
1498     idHide('vl-attr-editor-div');
1499     idShow('vl-generic-progress');
1500
1501     var isAuth = (ATTR_EDIT_GROUP == 'auth');
1502     var method = 'open-ils.permacrud.delete.' + (isAuth ? 'vqarad' : 'vqbrad');
1503     var rad    = isAuth ? new vqarad() : new vqbrad() ;
1504     fieldmapper.standardRequest(
1505         ['open-ils.permacrud', method],
1506         {   async: true,
1507             params: [authtoken, rad.fromHash({ id : ATTR_EDIT_ID }), ],
1508             oncomplete: function() {
1509                 dijit.byId('attr-editor-dialog').onCancel(); // close the dialog
1510                 attrEditorFetchAttrDefs(vlShowAttrEditor);
1511                 ATTR_EDIT_ID = null;
1512             },
1513             onerror: function(r) {
1514                 alert('vlAttrDelete comms error: ' + r);
1515             }
1516         }
1517     );
1518 }
1519
1520 // ------------------------------------------------------------
1521 // utilities for attribute editors
1522
1523 // dom utilities (maybe dojo does these, and these should be replaced)
1524
1525 function idStyle(obId, k, v)    { document.getElementById(obId).style[k] = v;   }
1526 function idShow(obId)           { idStyle(obId, 'display', 'block');            }
1527 function idHide(obId)           { idStyle(obId, 'display' , 'none');            }
1528
1529 function connectTooltip(fieldId) {
1530     // Given an element id, look up a tooltip element in the doc (same
1531     // id with a '-tip' suffix) and associate the two. Maybe dojo has
1532     // a better way to do this?
1533     var fld = dojo.byId(fieldId);
1534     var tip = dojo.byId(fieldId + '-tip');
1535     dojo.connect(fld, 'onfocus', function(evt) {
1536                      dijit.showTooltip(tip.innerHTML, fld, ['below', 'after']); });
1537     dojo.connect(fld, 'onblur', function(evt) { dijit.hideTooltip(fld); });
1538 }
1539
1540 // xpath utilities
1541
1542 var xpathParser = new openils.MarcXPathParser();
1543
1544 function tagAndSubFieldsToXpath(tags, subfields) {
1545     // given tags, and subfields, build up an XPath.
1546     try {
1547         var parts = {
1548             'tags':tags.match(/[\d]+/g),
1549             'subfields':subfields.match(/[a-zA-z]/g) };
1550         return xpathParser.compile(parts);
1551     } catch (err) {
1552         return {'parts':null, 'tags':null, 'error':err};
1553     }
1554 }
1555
1556 function looksLikeDerivedXpath(path) {
1557     // Does this path look like it was derived from tags and subfields?
1558     var parsed = xpathParser.parse(path);
1559     if (parsed.tags == null)
1560         return false;
1561     var compiled = xpathParser.compile(parsed);
1562     return (path == compiled);
1563 }
1564
1565 // amazing xpath-util unit-tests
1566 if (!looksLikeDerivedXpath('//*[@tag="901"]/*[@code="c"]'))     alert('vandelay xpath-utility error');
1567 if ( looksLikeDerivedXpath('ba-boo-ba-boo!'))                   alert('vandelay xpath-utility error');
1568
1569
1570
1571 var profileContextOrg
1572 function vlShowProfileEditor() {
1573     displayGlobalDiv('vl-profile-editor-div');
1574     buildProfileGrid();
1575
1576     var connect = function() {
1577         dojo.connect(profileContextOrgSelector, 'onChange',
1578             function() {
1579                 profileContextOrg = this.attr('value');
1580                 pGrid.resetStore();
1581                 buildProfileGrid();
1582             }
1583         );
1584     };
1585
1586     new openils.User().buildPermOrgSelector(
1587         'ADMIN_MERGE_PROFILE', profileContextOrgSelector, null, connect);
1588 }
1589
1590 function buildProfileGrid() {
1591
1592     if(profileContextOrg == null)
1593         profileContextOrg = openils.User.user.ws_ou();
1594
1595     pGrid.loadAll(
1596         {order_by : {vmp : 'name'}},
1597         {owner : fieldmapper.aou.fullPath(profileContextOrg, true)}
1598     );
1599 }
1600
1601 /* --- Import Item Attr Grid --------------- */
1602
1603 var itemAttrContextOrg;
1604 function vlShowImportItemAttrEditor() {
1605     displayGlobalDiv('vl-item-attr-editor-div');
1606     buildImportItemAttrGrid();
1607
1608     var connect = function() {
1609         dojo.connect(itemAttrContextOrgSelector, 'onChange',
1610             function() {
1611                 itemAttrContextOrg = this.attr('value');
1612                 itemAttrGrid.resetStore();
1613                 vlShowImportItemAttrEditor();
1614             }
1615         );
1616     };
1617
1618     new openils.User().buildPermOrgSelector(
1619         'ADMIN_IMPORT_ITEM_ATTR_DEF',
1620             itemAttrContextOrgSelector, null, connect);
1621 }
1622
1623 function buildImportItemAttrGrid() {
1624
1625     if(itemAttrContextOrg == null)
1626         itemAttrContextOrg = openils.User.user.ws_ou();
1627
1628     itemAttrGrid.loadAll(
1629         {order_by : {viiad : 'name'}},
1630         {owner : fieldmapper.aou.fullPath(itemAttrContextOrg, true)}
1631     );
1632 }
1633