bc9a15370d9d33a7835e5d36651de6760914614f
[Evergreen.git] / 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
381     // queue export
382     var qsel = dojo.byId('vl-queue-export-options');
383     qsel.onchange = function(newVal) {
384         var value = qsel.options[qsel.selectedIndex].value;
385         qsel.selectedIndex = 0;
386         if(!value) return;
387         if(!confirm('Export as "' + value + '"?')) return; // TODO: i18n
388         retrieveQueuedRecords(
389             currentType, 
390             currentQueueId, 
391             function(r) { 
392                 exportHandler(value, r);
393                 displayGlobalDiv('vl-queue-div');
394             },
395             value
396         );
397     }
398
399     // item export
400     var isel = dojo.byId('vl-item-export-options');
401     isel.onchange = function(newVal) {
402         var value = isel.options[isel.selectedIndex].value;
403         isel.selectedIndex = 0;
404         if(!value) return;
405         if(!confirm('Export as "' + value + '"?')) return; // TODO: i18n
406
407         var method = 'open-ils.vandelay.import_item.queue.export.' + value;
408
409         fieldmapper.standardRequest(
410             ['open-ils.vandelay', method],
411             {
412                 params : [
413                     authtoken, 
414                     currentQueueId, 
415                     {with_import_error: (vlImportItemsShowErrors.checked) ? 1 : null}
416                 ],
417                 async : true,
418                 oncomplete : function(r) {exportHandler(type, r)}
419             }
420         );
421     }
422 }
423
424 function exportHandler(type, response) {
425     var content = openils.Util.readResponse(response);
426     if(type == 'print') {
427         // TODO print the content
428     }
429     alert('response = ' + response);
430 }
431
432 function retrieveQueuedRecords(type, queueId, onload, doExport) {
433     displayGlobalDiv('vl-generic-progress');
434     queuedRecords = [];
435     queuedRecordsMap = {};
436     currentOverlayRecordsMap = {};
437     currentOverlayRecordsMapGid = {};
438     selectableGridRecords = {};
439
440     if(!type) type = currentType;
441     if(!queueId) queueId = currentQueueId;
442     if(!onload) onload = handleRetrieveRecords;
443
444     var method = 'open-ils.vandelay.'+type+'_queue.records.retrieve';
445
446     if(doExport) method += '.export.' + doExport;
447     if(vlQueueGridShowMatches.checked)
448         method = method.replace('records', 'records.matches');
449
450     method += '.atomic';
451
452     var sel = dojo.byId('vl-queue-display-limit-selector');
453     var limit = parseInt(sel.options[sel.selectedIndex].value);
454     var offset = limit * parseInt(vlQueueDisplayPage.attr('value')-1);
455
456     var params =  [authtoken, queueId, {clear_marc: 1, offset: offset, limit: limit, flesh_import_items:1}];
457     if(vlQueueGridShowNonImport.checked)
458         params[2].non_imported = 1;
459
460     if(vlQueueGridShowImportErrors.checked)
461         params[2].with_import_error = 1;
462
463     fieldmapper.standardRequest(
464         ['open-ils.vandelay', method],
465         {   async: true,
466             params: params,
467             oncomplete: function(r){
468                 if(doExport) return onload();
469                 var recs = r.recv().content();
470                 if(e = openils.Event.parse(recs[0]))
471                     return alert(e);
472                 for(var i = 0; i < recs.length; i++) {
473                     var rec = recs[i];
474                     queuedRecords.push(rec);
475                     queuedRecordsMap[rec.id()] = rec;
476                 }
477                 onload();
478             }
479         }
480     );
481 }
482
483 function vlLoadMatchUI(recId) {
484     displayGlobalDiv('vl-generic-progress');
485     var queuedRec = queuedRecordsMap[recId];
486     var matches = queuedRec.matches();
487     var records = [];
488     currentImportRecId = recId;
489     for(var i = 0; i < matches.length; i++)
490         records.push(matches[i].eg_record());
491
492     var retrieve = ['open-ils.search', 'open-ils.search.biblio.record_entry.slim.retrieve'];
493     var params = [records];
494     if(currentType == 'auth') {
495         retrieve = ['open-ils.cat', 'open-ils.cat.authority.record.retrieve'];
496         params = [authtoken, records, {clear_marc:1}];
497     }
498
499     fieldmapper.standardRequest(
500         retrieve,
501         {   async: true,
502             params:params,
503             oncomplete: function(r) {
504                 var recs = r.recv().content();
505                 if(e = openils.Event.parse(recs))
506                     return alert(e);
507
508                 /* ui mangling */
509                 displayGlobalDiv('vl-match-div');
510                 resetVlMatchGridLayout();
511                 currentMatchedRecords = recs;
512                 vlMatchGrid.setStructure(vlMatchGridLayout);
513
514                 // build the data store of records with match information
515                 var dataStore = bre.toStoreData(recs, null, 
516                     {virtualFields:['_id', 'match_score', 'match_quality', 'rec_quality']});
517                 dataStore.identifier = '_id';
518
519                 var matchSeenMap = {};
520
521                 for(var i = 0; i < dataStore.items.length; i++) {
522                     var item = dataStore.items[i];
523                     item._id = i; // just need something unique
524                     for(var j = 0; j < matches.length; j++) {
525                         var match = matches[j];
526                         if(match.eg_record() == item.id && !matchSeenMap[match.id()]) {
527                             if(match.match_score)
528                                 item.match_score = match.match_score();
529                             item.match_quality = match.quality();
530                             item.rec_quality = queuedRec.quality();
531                             matchSeenMap[match.id()] = 1;
532                             break;
533                         }
534                     }
535                 }
536
537                 // now populate the grid
538                 vlPopulateMatchGrid(vlMatchGrid, dataStore);
539             }
540         }
541     );
542 }
543
544 function vlPopulateMatchGrid(grid, data) {
545     var store = new dojo.data.ItemFileReadStore({data:data});
546     grid.setStore(store);
547     grid.update();
548 }
549
550 function showMe(id) {
551     dojo.style(dojo.byId(id), 'display', 'block');
552 }
553 function hideMe(id) {
554     dojo.style(dojo.byId(id), 'display', 'none');
555 }
556
557
558 function vlLoadMARCHtml(recId, inCat, oncomplete) {
559     dijit.byId('vl-marc-html-done-button').onClick = oncomplete;
560     displayGlobalDiv('vl-generic-progress');
561     var api;
562     var params = [recId, 1];
563
564     if(inCat) {
565         hideMe('vl-marc-html-edit-button'); // don't show marc editor button
566         dijit.byId('vl-marc-html-edit-button').onClick = function(){}
567         api = ['open-ils.search', 'open-ils.search.biblio.record.html'];
568         if(currentType == 'auth')
569             api = ['open-ils.search', 'open-ils.search.authority.to_html'];
570     } else {
571         showMe('vl-marc-html-edit-button'); // plug in the marc editor button
572         dijit.byId('vl-marc-html-edit-button').onClick = 
573             function() {vlLoadMarcEditor(currentType, recId, oncomplete);};
574         params = [authtoken, recId];
575         api = ['open-ils.vandelay', 'open-ils.vandelay.queued_bib_record.html'];
576         if(currentType == 'auth')
577             api = ['open-ils.vandelay', 'open-ils.vandelay.queued_authority_record.html'];
578     }
579
580     fieldmapper.standardRequest(
581         api, 
582         {   async: true,
583             params: params,
584             oncomplete: function(r) {
585             displayGlobalDiv('vl-marc-html-div');
586                 var html = r.recv().content();
587                 dojo.byId('vl-marc-record-html').innerHTML = html;
588             }
589         }
590     );
591 }
592
593
594 /*
595 function getRecMatchesFromAttrCode(rec, attrCode) {
596     var matches = [];
597     var attr = getRecAttrFromCode(rec, attrCode);
598     for(var j = 0; j < rec.matches().length; j++) {
599         var match = rec.matches()[j];
600         if(match.matched_attr() == attr.id()) 
601             matches.push(match);
602     }
603     return matches;
604 }
605 */
606
607 /*
608 function getRecAttrFromMatch(rec, match) {
609     for(var i = 0; i < rec.attributes().length; i++) {
610         var attr = rec.attributes()[i];
611         if(attr.id() == match.matched_attr())
612             return attr;
613     }
614 }
615 */
616
617 function getRecAttrDefFromAttr(attr, type) {
618     var defs = (type == 'bib') ? bibAttrDefs : authAttrDefs;
619     for(var i = 0; i < defs.length; i++) {
620         var def = defs[i];
621         if(def.id() == attr.field())
622             return def;
623     }
624 }
625
626 function getRecAttrFromCode(rec, attrCode) {
627     var defId = attrDefMap[currentType][attrCode];
628     var attrs = rec.attributes();
629     for(var i = 0; i < attrs.length; i++) {
630         var attr = attrs[i];
631         if(attr.field() == defId) 
632             return attr;
633     }
634     return null;
635 }
636
637 function vlGetViewMatches(rowIdx, item) {
638     if(item) {
639         var id = this.grid.store.getValue(item, 'id');
640         var rec = queuedRecordsMap[id];
641         if(rec.matches().length > 0)
642             return id;
643     }
644     return -1
645 }
646
647 function vlFormatViewMatches(id) {
648     if(id == -1) return '';
649     return '<a href="javascript:void(0);" onclick="vlLoadMatchUI(' + id + ');">' + this.name + '</a>';
650 }
651
652 function vlGetViewErrors(rowIdx, item) {
653     if(item) {
654         var id = this.grid.store.getValue(item, 'id');
655         var rec = queuedRecordsMap[id];
656         // id:rec_error:item_import_error_count
657         return id + ':' + 
658             (rec.import_error() ? 1 : '') + ':' + 
659             rec.import_items().filter(function(i) {return i.import_error()}).length;
660     }
661     return -1
662 }
663
664 function vlFormatViewErrors(chunk) {
665     if(chunk == -1) return '';
666     var id = chunk.split(':')[0];
667     var rec = chunk.split(':')[1];
668     var count = chunk.split(':')[2];
669     var links = '';
670     if(rec) 
671         links += '<a href="javascript:void(0);" onclick="vlLoadErrorUI(' + id + ');">Record</a><br/>'; // TODO I18N
672     if(Number(count))
673         links += '<a href="javascript:void(0);" onclick="vlLoadErrorUI(' + id + ');">Items ('+count+')</a>'; // TODO I18N
674     return links;
675 }
676
677 //var vlItemErrorColumnPicker;
678 function vlLoadErrorUI(id) {
679
680     displayGlobalDiv('vl-import-error-div');
681     openils.Util.hide('vl-import-error-grid-all');
682     openils.Util.show('vl-import-error-record');
683
684     var rec = queuedRecordsMap[id];
685
686     dojo.byId('vl-error-id').innerHTML = rec.id();
687     dojo.forEach( // TODO sane authority rec. fields
688         ['title', 'author', 'isbn', 'issn', 'upc'],
689         function(field) {
690             var attr =  getRecAttrFromCode(rec, field);
691             var eid = 'vl-error-' + field;
692             if(attr) {
693                 openils.Util.show(dojo.byId(eid).parentNode, 'table-row');
694                 dojo.byId(eid).innerHTML = attr.attr_value();
695             } else {
696                 openils.Util.hide(dojo.byId(eid).parentNode);
697             }
698         }
699     );
700     var iediv = dojo.byId('vl-error-import-error');
701     var eddiv = dojo.byId('vl-error-error-detail');
702     if(rec.import_error()) {
703         openils.Util.show(iediv.parentNode, 'table-row');
704         openils.Util.show(eddiv.parentNode, 'table-row');
705         iediv.innerHTML = rec.import_error();
706         eddiv.innerHTML = rec.error_detail();
707     } else {
708         openils.Util.hide(iediv.parentNode);
709         openils.Util.hide(eddiv.parentNode);
710     }
711
712     var errorItems = rec.import_items().filter(function(i) {return i.import_error()});
713     if(errorItems.length) {
714         openils.Util.show('vl-import-error-grid-some');
715         storeData = vqbr.toStoreData(errorItems);
716         var store = new dojo.data.ItemFileReadStore({data:storeData});
717         vlImportErrorGrid.setStore(store);
718         vlImportErrorGrid.update();
719     } else {
720         openils.Util.hide('vl-import-error-grid-some');
721     }
722 }
723
724 function vlLoadErrorUIAll() {
725
726     displayGlobalDiv('vl-import-error-div');
727     openils.Util.hide('vl-import-error-grid-some');
728     openils.Util.hide('vl-import-error-record');
729     openils.Util.show('vl-import-error-grid-all');
730     vlAllImportErrorGrid.resetStore();
731
732     vlImportErrorGrid.displayOffset = 0;
733
734     vlAllImportErrorGrid.dataLoader = function() {
735
736         vlAllImportErrorGrid.showLoadProgressIndicator();
737
738         fieldmapper.standardRequest(
739             ['open-ils.vandelay', 'open-ils.vandelay.import_item.queue.retrieve'],
740             {
741                 async : true,
742                 params : [
743                     authtoken, currentQueueId, {   
744                         with_import_error: (vlImportItemsShowErrors.checked) ? 1 : null,
745                         offset : vlAllImportErrorGrid.displayOffset,
746                         limit : vlAllImportErrorGrid.displayLimit
747                     }
748                 ],
749                 onresponse : function(r) {
750                     var item = openils.Util.readResponse(r);
751                     if(!item) return;
752                     vlAllImportErrorGrid.store.newItem(vii.toStoreItem(item));
753                 },
754                 oncomplete : function() {
755                     vlAllImportErrorGrid.hideLoadProgressIndicator();
756                 }
757             }
758         );
759     };
760
761     vlAllImportErrorGrid.dataLoader();
762 }
763
764 function vlGetOrg(rowIdx, item) {
765     if(!item) return '';
766     var value = this.grid.store.getValue(item, this.field);
767     if(value) return fieldmapper.aou.findOrgUnit(value).shortname();
768     return '';
769 }
770
771 function vlFormatViewMatchMARC(id) {
772     return '<a href="javascript:void(0);" onclick="vlLoadMARCHtml(' + id + ', true, '+
773         'function(){displayGlobalDiv(\'vl-match-div\');});">' + this.name + '</a>';
774 }
775
776 function getAttrValue(rowIdx, item) {
777     if(!item) return '';
778     var attrCode = this.field.split('.')[1];
779     var rec = queuedRecordsMap[this.grid.store.getValue(item, 'id')];
780     var attr = getRecAttrFromCode(rec, attrCode);
781     return (attr) ? attr.attr_value() : '';
782 }
783
784 function vlGetDateTimeField(rowIdx, item) {
785     if(!item) return '';
786     var value = this.grid.store.getValue(item, this.field);
787     if(!value) return '';
788     var date = dojo.date.stamp.fromISOString(value);
789     return dojo.date.locale.format(date, {selector:'date'});
790 }
791
792 function vlGetCreator(rowIdx, item) {
793     if(!item) return '';
794     var id = this.grid.store.getValue(item, 'creator');
795     if(userCache[id])
796         return userCache[id].usrname();
797     var user = fieldmapper.standardRequest(
798         ['open-ils.actor', 'open-ils.actor.user.retrieve'], [authtoken, id]);
799     if(e = openils.Event.parse(user))
800         return alert(e);
801     userCache[id] = user;
802     return user.usrname();
803 }
804
805 function vlGetViewMARC(rowIdx, item) {
806     return item && this.grid.store.getValue(item, 'id');
807 }
808
809 function vlFormatViewMARC(id) {
810     return '<a href="javascript:void(0);" onclick="vlLoadMARCHtml(' + id + ', false, '+
811         'function(){displayGlobalDiv(\'vl-queue-div\');});">' + this.name + '</a>';
812 }
813
814 function vlGetOverlayTargetSelector(rowIdx, item) {
815     if(!item) return;
816     return this.grid.store.getValue(item, '_id') + ':' + this.grid.store.getValue(item, 'id');
817 }
818
819 function vlFormatOverlayTargetSelector(val) {
820     if(!val) return '';
821     var parts = val.split(':');
822     var _id = parts[0];
823     var id = parts[1];
824     var value = '<input type="checkbox" name="vl-overlay-target-RECID" '+
825         'onclick="vlHandleOverlayTargetSelected(ID, GRIDID);" gridid="GRIDID" match="ID"/>';
826     value = value.replace(/GRIDID/g, _id);
827     value = value.replace(/RECID/g, currentImportRecId);
828     value = value.replace(/ID/g, id);
829     if(_id == currentOverlayRecordsMapGid[currentImportRecId])
830         return value.replace('/>', 'checked="checked"/>');
831     return value;
832 }
833
834
835 /**
836   * see if the user has enabled overlays for the current match set and, 
837   * if so, map the current import record to the overlay target.
838   */
839 function vlHandleOverlayTargetSelected(recId, gridId) {
840     var noneSelected = true;
841     var checkboxes = dojo.query('[name=vl-overlay-target-'+currentImportRecId+']');
842     for(var i = 0; i < checkboxes.length; i++) {
843         var checkbox = checkboxes[i];
844         var matchRecId = checkbox.getAttribute('match');
845         var gid = checkbox.getAttribute('gridid');
846         if(checkbox.checked) {
847             if(matchRecId == recId && gid == gridId) {
848                 noneSelected = false;
849                 currentOverlayRecordsMap[currentImportRecId] = matchRecId;
850                 currentOverlayRecordsMapGid[currentImportRecId] = gid;
851                 dojo.byId('vl-record-list-selected-' + currentImportRecId).checked = true;
852                 dojo.byId('vl-record-list-selected-' + currentImportRecId).parentNode.className = 'overlay_selected';
853             } else {
854                 checkbox.checked = false;
855             }
856         }
857     }
858
859     if(noneSelected) {
860         delete currentOverlayRecordsMap[currentImportRecId];
861         delete currentOverlayRecordsMapGid[currentImportRecId];
862         dojo.byId('vl-record-list-selected-' + currentImportRecId).checked = false;
863         dojo.byId('vl-record-list-selected-' + currentImportRecId).parentNode.className = '';
864     }
865 }
866
867 var valLastQueueType = null;
868 var vlQueueGridLayout = null;
869 function buildRecordGrid(type) {
870     displayGlobalDiv('vl-queue-div');
871
872     if(type == 'bib') {
873         openils.Util.show('vl-bib-queue-grid-wrapper');
874         openils.Util.hide('vl-auth-queue-grid-wrapper');
875         vlQueueGrid = vlBibQueueGrid;
876     } else {
877         openils.Util.show('vl-auth-queue-grid-wrapper');
878         openils.Util.hide('vl-bib-queue-grid-wrapper');
879         vlQueueGrid = vlAuthQueueGrid;
880     }
881
882
883     if(valLastQueueType != type) {
884         valLastQueueType = type;
885         vlQueueGridLayout = vlQueueGrid.attr('structure');
886         var defs = (type == 'bib') ? bibAttrDefs : authAttrDefs;
887         attrDefMap[type] = {};
888         for(var i = 0; i < defs.length; i++) {
889             var def = defs[i]
890             attrDefMap[type][def.code()] = def.id();
891             var col = {
892                 name:def.description(), 
893                 field:'attr.' + def.code(),
894                 get: getAttrValue,
895                 selectableColumn:true
896             };
897             vlQueueGridLayout[0].cells[0].push(col);
898         }
899     }
900
901     dojo.forEach(vlQueueGridLayout[0].cells[0], 
902         function(cell) { 
903             if(cell.field.match(/^\+/)) 
904                 cell.nonSelectable=true;
905         }
906     );
907
908     var storeData;
909     if(type == 'bib')
910         storeData = vqbr.toStoreData(queuedRecords);
911     else
912         storeData = vqar.toStoreData(queuedRecords);
913
914     var store = new dojo.data.ItemFileReadStore({data:storeData});
915     vlQueueGrid.setStore(store);
916
917     if(vlQueueGridColumePicker[type]) {
918         vlQueueGrid.update();
919     } else {
920
921         vlQueueGridColumePicker[type] =
922             new openils.widget.GridColumnPicker(
923                 authtoken, 'vandelay.queue.'+type, vlQueueGrid, vlQueueGridLayout);
924         vlQueueGridColumePicker[type].load();
925     }
926 }
927
928 function vlQueueGridPrevPage() {
929     var page = parseInt(vlQueueDisplayPage.getValue());
930     if(page < 2) return;
931     vlQueueDisplayPage.setValue(page - 1);
932     retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
933 }
934
935 function vlQueueGridNextPage() {
936     vlQueueDisplayPage.setValue(parseInt(vlQueueDisplayPage.getValue())+1);
937     retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
938 }
939
940 function vlDeleteQueue(type, queueId, onload) {
941     fieldmapper.standardRequest(
942         ['open-ils.vandelay', 'open-ils.vandelay.'+type+'_queue.delete'],
943         {   async: true,
944             params: [authtoken, queueId],
945             oncomplete: function(r) {
946                 var resp = r.recv().content();
947                 if(e = openils.Event.parse(resp))
948                     return alert(e);
949                 onload();
950             }
951         }
952     );
953 }
954
955
956 function vlQueueGridDrawSelectBox(rowIdx, item) {
957     return item &&  this.grid.store.getValue(item, 'id');
958 }
959
960 function vlQueueGridFormatSelectBox(id) {
961     var domId = 'vl-record-list-selected-' + id;
962     if (id) { selectableGridRecords[domId] = id; }
963     return "<div><input type='checkbox' id='"+domId+"'/></div>";
964 }
965
966 function vlSelectAllQueueGridRecords() {
967     for(var id in selectableGridRecords) 
968         dojo.byId(id).checked = true;
969 }
970 function vlSelectNoQueueGridRecords() {
971     for(var id in selectableGridRecords) 
972         dojo.byId(id).checked = false;
973 }
974 function vlToggleQueueGridSelect() {
975     if(dojo.byId('vl-queue-grid-row-selector').checked)
976         vlSelectAllQueueGridRecords();
977     else
978         vlSelectNoQueueGridRecords();
979 }
980
981 var handleRetrieveRecords = function() {
982     buildRecordGrid(currentType);
983     vlFetchQueueSummary(currentQueueId, currentType, 
984         function(summary) {
985             dojo.byId('vl-queue-summary-name').innerHTML = summary.queue.name();
986             dojo.byId('vl-queue-summary-total-count').innerHTML = summary.total +'';
987             dojo.byId('vl-queue-summary-import-count').innerHTML = summary.imported + '';
988             dojo.byId('vl-queue-summary-import-item-count').innerHTML = summary.total_items + '';
989             dojo.byId('vl-queue-summary-rec-error-count').innerHTML = summary.rec_import_errors + '';
990             dojo.byId('vl-queue-summary-item-error-count').innerHTML = summary.item_import_errors + '';
991         }
992     );
993 }
994
995 function vlFetchQueueSummary(qId, type, onload) {
996     fieldmapper.standardRequest(
997         ['open-ils.vandelay', 'open-ils.vandelay.'+type+'_queue.summary.retrieve'],
998         {   async: true,
999             params: [authtoken, qId],
1000             oncomplete : function(r) {
1001                 var summary = r.recv().content();
1002                 if(e = openils.Event.parse(summary))
1003                     return alert(e);
1004                 return onload(summary);
1005             }
1006         }
1007     );
1008 }
1009
1010 function vlHandleQueueItemsAction(action) {
1011
1012     dojo.connect(
1013         queueItemsImportCancelButton, 
1014         'onClick', 
1015         function() {
1016             queueItemsImportDialog.hide();
1017         }
1018     );
1019
1020     dojo.connect(
1021         queueItemsImportGoButton,
1022         'onClick', 
1023         function() {
1024             queueItemsImportDialog.hide();
1025
1026             // hack to set the widgets the import funcs will be looking at.  Reset them below.
1027             vlUploadQueueImportNoMatch.attr('value',  vlUploadQueueImportNoMatch2.attr('value'));
1028             vlUploadQueueAutoOverlayExact.attr('value',  vlUploadQueueAutoOverlayExact2.attr('value'));
1029             vlUploadQueueAutoOverlay1Match.attr('value',  vlUploadQueueAutoOverlay1Match2.attr('value'));
1030             vlUploadMergeProfile.attr('value',  vlUploadMergeProfile2.attr('value'));
1031             vlUploadQueueAutoOverlayBestMatch.attr('value',  vlUploadQueueAutoOverlayBestMatch2.attr('value'));
1032             vlUploadQueueAutoOverlayBestMatchRatio.attr('value',  vlUploadQueueAutoOverlayBestMatchRatio2.attr('value'));
1033
1034             if(action == 'import') {
1035                 vlImportSelectedRecords();
1036             } else if(action == 'import_all') {
1037                 vlImportAllRecords();
1038             }
1039             
1040             // reset the widgets to prevent accidental future actions
1041             vlUploadQueueImportNoMatch.attr('value',  false);
1042             vlUploadQueueImportNoMatch2.attr('value', false);
1043             vlUploadQueueAutoOverlayExact.attr('value', false);
1044             vlUploadQueueAutoOverlayExact2.attr('value', false);
1045             vlUploadQueueAutoOverlay1Match.attr('value', false);
1046             vlUploadQueueAutoOverlay1Match2.attr('value', false);
1047             vlUploadMergeProfile.attr('value', '');
1048             vlUploadMergeProfile2.attr('value', '');
1049             vlUploadQueueAutoOverlayBestMatch.attr('value', false);
1050             vlUploadQueueAutoOverlayBestMatch2.attr('value', false);
1051             vlUploadQueueAutoOverlayBestMatchRatio.attr('value', '0.0');
1052             vlUploadQueueAutoOverlayBestMatchRatio2.attr('value', '0.0');
1053         }
1054     );
1055
1056     queueItemsImportDialog.show();
1057 }
1058     
1059
1060 /* import user-selected records */
1061 function vlImportSelectedRecords() {
1062     var records = [];
1063
1064     for(var id in selectableGridRecords) {
1065         if(dojo.byId(id).checked) {
1066             var recId = selectableGridRecords[id];
1067             var rec = queuedRecordsMap[recId];
1068             if(!rec.import_time()) 
1069                 records.push(recId);
1070         }
1071     }
1072
1073     vlImportRecordQueue(
1074         currentType, 
1075         currentQueueId, 
1076         records,
1077         function(){
1078             retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
1079         }
1080     );
1081 }
1082
1083 /* import all (non-imported) queue records */
1084 function vlImportAllRecords() {
1085     vlImportRecordQueue(
1086         currentType, 
1087         currentQueueId, 
1088         null,
1089         function(){
1090             retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
1091         }
1092     );
1093 }
1094
1095 /* if recList has values, import only those records */
1096 function vlImportRecordQueue(type, queueId, recList, onload) {
1097     displayGlobalDiv('vl-generic-progress-with-total');
1098
1099     /* set up options */
1100     var mergeOpt = false;
1101     var options = {overlay_map : currentOverlayRecordsMap};
1102
1103     if(vlUploadQueueImportNoMatch.checked) {
1104         options.import_no_match = true;
1105         vlUploadQueueImportNoMatch.checked = false;
1106     }
1107
1108     if(vlUploadQueueAutoOverlayExact.checked) {
1109         options.auto_overlay_exact = true;
1110         vlUploadQueueAutoOverlayExact.checked = false;
1111         mergeOpt = true;
1112     }
1113
1114     if(vlUploadQueueAutoOverlayBestMatch.checked) {
1115         options.auto_overlay_best_match = true;
1116         vlUploadQueueAutoOverlayBestMatch.checked = false;
1117         options.match_quality_ratio = vlUploadQueueAutoOverlayBestMatchRatio.attr('value');
1118         mergeOpt = true;
1119     }
1120
1121     if(vlUploadQueueAutoOverlay1Match.checked) {
1122         options.auto_overlay_1match = true;
1123         vlUploadQueueAutoOverlay1Match.checked = false;
1124         mergeOpt = true;
1125     }
1126
1127     var profile = vlUploadMergeProfile.attr('value');
1128     if(profile != null && profile != '') {
1129         options.merge_profile = profile;
1130     }
1131
1132     /* determine which method we're calling */
1133
1134     var method = 'open-ils.vandelay.bib_queue.import';
1135     if(type == 'auth')
1136         method = method.replace('bib', 'auth');
1137
1138     if(!mergeOpt) {
1139         // in the interest of speed, if no merge options are 
1140         // chosen, tell the back-end code to only process records
1141         // that have no matches
1142         method = method.replace(/\.import/, '.nomatch.import');
1143     }
1144
1145     var params = [authtoken, queueId, options];
1146     if(recList) {
1147         method = 'open-ils.vandelay.'+currentType+'_record.list.import';
1148         params[1] = recList;
1149     }
1150
1151     fieldmapper.standardRequest(
1152         ['open-ils.vandelay', method],
1153         {   async: true,
1154             params: params,
1155             onresponse: function(r) {
1156                 var resp = r.recv().content();
1157                 if(e = openils.Event.parse(resp))
1158                     return alert(e);
1159                 vlControlledProgressBar.update({maximum:resp.total, progress:resp.progress});
1160             },
1161             oncomplete: function() {onload();}
1162         }
1163     );
1164 }
1165
1166
1167 /**
1168   * Create queue, upload MARC, process spool, load the newly created queue 
1169   */
1170 function batchUpload() {
1171     var queueName = dijit.byId('vl-queue-name').getValue();
1172     currentType = dijit.byId('vl-record-type').getValue();
1173
1174     var handleProcessSpool = function() {
1175         if( 
1176             vlUploadQueueImportNoMatch.checked || 
1177             vlUploadQueueAutoOverlayExact.checked || 
1178             vlUploadQueueAutoOverlay1Match.checked ||
1179             vlUploadQueueAutoOverlayBestMatch.checked ) {
1180
1181                 vlImportRecordQueue(
1182                     currentType, 
1183                     currentQueueId, 
1184                     null,
1185                     function() {
1186                         retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
1187                     }
1188                 );
1189         } else {
1190             retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
1191         }
1192     }
1193
1194     var handleUploadMARC = function(key) {
1195         dojo.style(dojo.byId('vl-upload-status-processing'), 'display', 'block');
1196         processSpool(key, currentQueueId, currentType, handleProcessSpool);
1197     };
1198
1199     var handleCreateQueue = function(queue) {
1200         currentQueueId = queue.id();
1201         uploadMARC(handleUploadMARC);
1202     };
1203     
1204     if(vlUploadQueueSelector.getValue() && !queueName) {
1205         currentQueueId = vlUploadQueueSelector.getValue();
1206         uploadMARC(handleUploadMARC);
1207     } else {
1208         createQueue(queueName, currentType, handleCreateQueue, 
1209             vlUploadQueueHoldingsImportProfile.attr('value'),
1210             vlUploadQueueMatchSet.attr('value')
1211         );
1212     }
1213 }
1214
1215
1216 function vlFleshQueueSelect(selector, type) {
1217     var data = (type == 'bib') ? vbq.toStoreData(allUserBibQueues) : vaq.toStoreData(allUserAuthQueues);
1218     selector.store = new dojo.data.ItemFileReadStore({data:data});
1219     selector.setValue(null);
1220     selector.setDisplayedValue('');
1221     if(data[0])
1222         selector.setValue(data[0].id());
1223
1224     var qInput = dijit.byId('vl-queue-name');
1225
1226     var selChange = function(val) {
1227         console.log('selector onchange');
1228         // user selected a queue from the selector;  clear the input and 
1229         // set the item import profile already defined for the queue
1230         var queue = allUserBibQueues.filter(function(q) { return (q.id() == val) })[0];
1231         if(val) {
1232             vlUploadQueueHoldingsImportProfile.attr('value', queue.item_attr_def() || '');
1233             vlUploadQueueHoldingsImportProfile.attr('disabled', true);
1234             vlUploadQueueMatchSet.attr('value', queue.match_set() || '');
1235             vlUploadQueueMatchSet.attr('disabled', true);
1236         } else {
1237             vlUploadQueueHoldingsImportProfile.attr('value', '');
1238             vlUploadQueueHoldingsImportProfile.attr('disabled', false);
1239             vlUploadQueueMatchSet.attr('value', '');
1240             vlUploadQueueMatchSet.attr('disabled', false);
1241         }
1242         dojo.disconnect(qInput._onchange);
1243         qInput.attr('value', '');
1244         qInput._onchange = dojo.connect(qInput, 'onChange', inputChange);
1245     }
1246     
1247     var inputChange = function(val) {
1248         console.log('qinput onchange');
1249         // user entered a new queue name. clear the selector 
1250         vlUploadQueueHoldingsImportProfile.attr('value', '');
1251         vlUploadQueueHoldingsImportProfile.attr('disabled', false);
1252         vlUploadQueueMatchSet.attr('value', '');
1253         vlUploadQueueMatchSet.attr('disabled', false);
1254         dojo.disconnect(selector._onchange);
1255         selector.attr('value', '');
1256         selector._onchange = dojo.connect(selector, 'onChange', selChange);
1257     }
1258
1259     selector._onchange = dojo.connect(selector, 'onChange', selChange);
1260     qInput._onchange = dojo.connect(qInput, 'onChange', inputChange);
1261 }
1262
1263 function vlUpdateMatchSetSelector(type) {
1264     type = (type.match(/bib/)) ? 'biblio' : 'authority';
1265     vlUploadQueueMatchSet.store = 
1266         new dojo.data.ItemFileReadStore({data:vms.toStoreData(matchSets[type])});
1267 }
1268
1269 function vlShowUploadForm() {
1270     displayGlobalDiv('vl-marc-upload-div');
1271     vlFleshQueueSelect(vlUploadQueueSelector, vlUploadRecordType.getValue());
1272     vlUploadSourceSelector.store = 
1273         new dojo.data.ItemFileReadStore({data:cbs.toStoreData(vlBibSources, 'source')});
1274     vlUploadSourceSelector.setValue(vlBibSources[0].id());
1275     vlUploadQueueHoldingsImportProfile.store = 
1276         new dojo.data.ItemFileReadStore({data:viiad.toStoreData(importItemDefs)});
1277     vlUpdateMatchSetSelector(vlUploadRecordType.getValue());
1278
1279     // use ratio from the merge profile if it's set
1280     dojo.connect(
1281         vlUploadMergeProfile, 
1282         'onChange',
1283         function(val) {
1284             if(!val) return;
1285             var profile = mergeProfiles.filter(function(p) { return (p.id() == val); })[0];
1286             if(profile.lwm_ratio() != null)
1287                vlUploadQueueAutoOverlayBestMatchRatio.attr('value', profile.lwm_ratio()+''); 
1288         }
1289     );
1290     dojo.connect(
1291         vlUploadMergeProfile2, 
1292         'onChange',
1293         function(val) {
1294             if(!val) return;
1295             var profile = mergeProfiles.filter(function(p) { return (p.id() == val); })[0];
1296             if(profile.lwm_ratio() != null)
1297                vlUploadQueueAutoOverlayBestMatchRatio2.attr('value', profile.lwm_ratio()+''); 
1298         }
1299     );
1300
1301 }
1302
1303 function vlShowQueueSelect() {
1304     displayGlobalDiv('vl-queue-select-div');
1305     vlFleshQueueSelect(vlQueueSelectQueueList, vlQueueSelectType.getValue());
1306 }
1307
1308 function vlShowMatchSetEditor() {
1309     displayGlobalDiv('vl-match-set-editor-div');
1310     dojo.byId('vl-match-set-editor-div').appendChild(
1311         dojo.create('iframe', {
1312             id : 'vl-match-set-iframe',
1313             src : oilsBasePath + '/eg/conify/global/vandelay/match_set',
1314             style : 'width:100%; height:500px; border:none; margin:0px;'
1315         })
1316     );
1317 }
1318
1319 function vlFetchQueueFromForm() {
1320     currentType = vlQueueSelectType.getValue();
1321     currentQueueId = vlQueueSelectQueueList.getValue();
1322     retrieveQueuedRecords(currentType, currentQueueId, handleRetrieveRecords);
1323 }
1324
1325 function vlOpenMarcEditWindow(rec, postReloadHTMLHandler) {
1326     /*
1327         To run in Firefox directly, must set signed.applets.codebase_principal_support
1328         to true in about:config
1329     */
1330     netscape.security.PrivilegeManager.enablePrivilege('UniversalXPConnect');
1331     win = window.open('/xul/server/cat/marcedit.xul'); // XXX version?
1332
1333     var type;
1334     if (currentType == 'bib') {
1335         type = 'bre';
1336     } else {
1337         type = 'are';
1338     }
1339
1340     function onsave(r) {
1341         // after the record is saved, reload the HTML display
1342         var stat = r.recv().content();
1343         if(e = openils.Event.parse(stat))
1344             return alert(e);
1345         alert(dojo.byId('vl-marc-edit-complete-label').innerHTML);
1346         win.close();
1347         vlLoadMARCHtml(rec.id(), false, postReloadHTMLHandler);
1348     }
1349
1350     win.xulG = {
1351         record : {marc : rec.marc(), "rtype": type},
1352         save : {
1353             label: dojo.byId('vl-marc-edit-save-label').innerHTML,
1354             func: function(xmlString) {
1355                 var method = 'open-ils.permacrud.update.' + rec.classname;
1356                 rec.marc(xmlString);
1357                 fieldmapper.standardRequest(
1358                     ['open-ils.permacrud', method],
1359                     {   async: true,
1360                         params: [authtoken, rec],
1361                         oncomplete: onsave
1362                     }
1363                 );
1364             },
1365         },
1366         'lock_tab' : typeof xulG != 'undefined' ? (typeof xulG['lock_tab'] != 'undefined' ? xulG.lock_tab : undefined) : undefined,
1367         'unlock_tab' : typeof xulG != 'undefined' ? (typeof xulG['unlock_tab'] != 'undefined' ? xulG.unlock_tab : undefined) : undefined
1368     };
1369 }
1370
1371 function vlLoadMarcEditor(type, recId, postReloadHTMLHandler) {
1372     var method = 'open-ils.permacrud.search.vqbr';
1373     if(currentType != 'bib')
1374         method = method.replace(/vqbr/,'vqar');
1375
1376     fieldmapper.standardRequest(
1377         ['open-ils.permacrud', method],
1378         {   async: true, 
1379             params: [authtoken, {id : recId}],
1380             oncomplete: function(r) {
1381                 var rec = r.recv().content();
1382                 if(e = openils.Event.parse(rec))
1383                     return alert(e);
1384                 vlOpenMarcEditWindow(rec, postReloadHTMLHandler);
1385             }
1386         }
1387     );
1388 }
1389
1390
1391
1392 //------------------------------------------------------------
1393 // attribute editors
1394
1395 // attribute-editor global variables
1396
1397 var ATTR_EDITOR_IN_UPDATE_MODE = false; // true on 'edit', false on 'create'
1398 var ATTR_EDIT_ID = null;                // id of current 'edit' attribute
1399 var ATTR_EDIT_GROUP = 'bib';            // bib-attrs or auth-attrs
1400
1401 function vlAttrEditorInit() {
1402     // set up tooltips on the edit form
1403     connectTooltip('attr-editor-tags'); 
1404     connectTooltip('attr-editor-subfields'); 
1405 }
1406
1407 function vlShowAttrEditor() {
1408     displayGlobalDiv('vl-attr-editor-div');
1409     loadAttrEditorGrid();
1410     idHide('vl-generic-progress');
1411 }
1412
1413 function setAttrEditorGroup(groupName) {
1414     // put us into 'bib'-attr or 'auth'-attr mode.
1415     if (ATTR_EDIT_GROUP != groupName) {
1416         ATTR_EDIT_GROUP = groupName;
1417         loadAttrEditorGrid();
1418     }
1419 }
1420
1421 function onAttrEditorOpen() {
1422     // the "bars" have the create/update/cancel/etc. buttons.
1423     var create_bar = document.getElementById('attr-editor-create-bar');
1424     var update_bar = document.getElementById('attr-editor-update-bar');
1425     if (ATTR_EDITOR_IN_UPDATE_MODE) {
1426         update_bar.style.display='table-row';
1427         create_bar.style.display='none';
1428         // hide the dropdown-button
1429         idStyle('vl-create-attr-editor-button', 'visibility', 'hidden');
1430     } else {
1431         dijit.byId('attr-editor-dialog').reset();
1432         create_bar.style.display='table-row';
1433         update_bar.style.display='none';
1434     }
1435 }
1436
1437 function onAttrEditorClose() {
1438     // reset the form to a "create" form. (We may have borrowed it for editing.)
1439     ATTR_EDITOR_IN_UPDATE_MODE = false;
1440     // show the dropdown-button
1441     idStyle('vl-create-attr-editor-button', 'visibility', 'visible');
1442 }
1443
1444 function loadAttrEditorGrid() {
1445     var _data = (ATTR_EDIT_GROUP == 'auth') ? 
1446         vqarad.toStoreData(authAttrDefs) : vqbrad.toStoreData(bibAttrDefs) ;
1447
1448     var store = new dojo.data.ItemFileReadStore({data:_data});
1449     attrEditorGrid.setStore(store);
1450     attrEditorGrid.onRowDblClick = onAttrEditorClick;
1451     attrEditorGrid.update();
1452 }
1453
1454 function attrGridGetTag(n, item) {
1455     // grid helper: return the tags from the row's xpath column.
1456     return item && xpathParser.parse(this.grid.store.getValue(item, 'xpath')).tags;
1457 }
1458
1459 function attrGridGetSubfield(n, item) {
1460     // grid helper: return the subfields from the row's xpath column.
1461     return item && xpathParser.parse(this.grid.store.getValue(item, 'xpath')).subfields;
1462 }
1463
1464 function onAttrEditorClick() {
1465     var row = this.getItem(this.focus.rowIndex);
1466     ATTR_EDIT_ID = this.store.getValue(row, 'id');
1467     ATTR_EDITOR_IN_UPDATE_MODE = true;
1468
1469     // populate the popup editor.
1470     dijit.byId('attr-editor-code').attr('value', this.store.getValue(row, 'code'));
1471     dijit.byId('attr-editor-description').attr('value', this.store.getValue(row, 'description'));
1472     var parsed_xpath = xpathParser.parse(this.store.getValue(row, 'xpath'));
1473     dijit.byId('attr-editor-tags').attr('value', parsed_xpath.tags);
1474     dijit.byId('attr-editor-subfields').attr('value', parsed_xpath.subfields);
1475     dijit.byId('attr-editor-xpath').attr('value', this.store.getValue(row, 'xpath'));
1476     dijit.byId('attr-editor-remove').attr('value', this.store.getValue(row, 'remove'));
1477
1478     // set up UI for editing
1479     dojo.byId('vl-create-attr-editor-button').click();
1480 }
1481
1482 function vlSaveAttrDefinition(data) {
1483     idHide('vl-attr-editor-div');
1484     idShow('vl-generic-progress');
1485
1486     data.id = ATTR_EDIT_ID;
1487
1488     // this ought to honour custom xpaths, but overwrite xpaths
1489     // derived from tags/subfields.
1490     if (data.xpath == '' || looksLikeDerivedXpath(data.xpath)) {
1491         var _xpath = tagAndSubFieldsToXpath(data.tag, data.subfield);
1492         data.xpath = _xpath;
1493     }
1494
1495     // build up our permacrud params. Key variables here are
1496     // "create or update" and "bib or auth".
1497
1498     var isAuth   = (ATTR_EDIT_GROUP == 'auth');
1499     var isCreate = (ATTR_EDIT_ID == null);
1500     var rad      = isAuth ? new vqarad() : new vqbrad() ;
1501     var method   = 'open-ils.permacrud' + (isCreate ? '.create.' : '.update.') 
1502         + (isAuth ? 'vqarad' : 'vqbrad');
1503     var _data    = rad.fromStoreItem(data);
1504
1505     _data.ischanged(1);
1506
1507     fieldmapper.standardRequest(
1508         ['open-ils.permacrud', method],
1509         {   async: true,
1510             params: [authtoken, _data ],
1511             onresponse: function(r) { },
1512             oncomplete: function(r) {
1513                 attrEditorFetchAttrDefs(vlShowAttrEditor);
1514                 ATTR_EDIT_ID = null;
1515             },
1516             onerror: function(r) {
1517                 alert('vlSaveAttrDefinition comms error: ' + r);
1518             }
1519         }
1520     );
1521 }
1522
1523 function attrEditorFetchAttrDefs(callback) {
1524     var fn = (ATTR_EDIT_GROUP == 'auth') ? vlFetchAuthAttrDefs : vlFetchBibAttrDefs;
1525     return fn(callback);
1526 }
1527
1528 function vlAttrDelete() {
1529     idHide('vl-attr-editor-div');
1530     idShow('vl-generic-progress');
1531
1532     var isAuth = (ATTR_EDIT_GROUP == 'auth');
1533     var method = 'open-ils.permacrud.delete.' + (isAuth ? 'vqarad' : 'vqbrad');
1534     var rad    = isAuth ? new vqarad() : new vqbrad() ;
1535     fieldmapper.standardRequest(
1536         ['open-ils.permacrud', method],
1537         {   async: true,
1538             params: [authtoken, rad.fromHash({ id : ATTR_EDIT_ID }), ],
1539             oncomplete: function() {
1540                 dijit.byId('attr-editor-dialog').onCancel(); // close the dialog
1541                 attrEditorFetchAttrDefs(vlShowAttrEditor);
1542                 ATTR_EDIT_ID = null;
1543             },
1544             onerror: function(r) {
1545                 alert('vlAttrDelete comms error: ' + r);
1546             }
1547         }
1548     );
1549 }
1550
1551 // ------------------------------------------------------------
1552 // utilities for attribute editors
1553
1554 // dom utilities (maybe dojo does these, and these should be replaced)
1555
1556 function idStyle(obId, k, v)    { document.getElementById(obId).style[k] = v;   }
1557 function idShow(obId)           { idStyle(obId, 'display', 'block');            }
1558 function idHide(obId)           { idStyle(obId, 'display' , 'none');            }
1559
1560 function connectTooltip(fieldId) {
1561     // Given an element id, look up a tooltip element in the doc (same
1562     // id with a '-tip' suffix) and associate the two. Maybe dojo has
1563     // a better way to do this?
1564     var fld = dojo.byId(fieldId);
1565     var tip = dojo.byId(fieldId + '-tip');
1566     dojo.connect(fld, 'onfocus', function(evt) {
1567                      dijit.showTooltip(tip.innerHTML, fld, ['below', 'after']); });
1568     dojo.connect(fld, 'onblur', function(evt) { dijit.hideTooltip(fld); });
1569 }
1570
1571 // xpath utilities
1572
1573 var xpathParser = new openils.MarcXPathParser();
1574
1575 function tagAndSubFieldsToXpath(tags, subfields) {
1576     // given tags, and subfields, build up an XPath.
1577     try {
1578         var parts = {
1579             'tags':tags.match(/[\d]+/g), 
1580             'subfields':subfields.match(/[a-zA-z]/g) };
1581         return xpathParser.compile(parts);
1582     } catch (err) {
1583         return {'parts':null, 'tags':null, 'error':err};
1584     }
1585 }
1586
1587 function looksLikeDerivedXpath(path) {
1588     // Does this path look like it was derived from tags and subfields?
1589     var parsed = xpathParser.parse(path);
1590     if (parsed.tags == null) 
1591         return false;
1592     var compiled = xpathParser.compile(parsed);
1593     return (path == compiled);
1594 }
1595
1596 // amazing xpath-util unit-tests
1597 if (!looksLikeDerivedXpath('//*[@tag="901"]/*[@code="c"]'))     alert('vandelay xpath-utility error');
1598 if ( looksLikeDerivedXpath('ba-boo-ba-boo!'))                   alert('vandelay xpath-utility error');
1599
1600
1601
1602 var profileContextOrg
1603 function vlShowProfileEditor() {
1604     displayGlobalDiv('vl-profile-editor-div');
1605     buildProfileGrid();
1606
1607     var connect = function() {
1608         dojo.connect(profileContextOrgSelector, 'onChange',
1609             function() {
1610                 profileContextOrg = this.attr('value');
1611                 pGrid.resetStore();
1612                 buildProfileGrid();
1613             }
1614         );
1615     };
1616
1617     new openils.User().buildPermOrgSelector(
1618         'ADMIN_MERGE_PROFILE', profileContextOrgSelector, null, connect);
1619 }
1620
1621 function buildProfileGrid() {
1622
1623     if(profileContextOrg == null)
1624         profileContextOrg = openils.User.user.ws_ou();
1625
1626     pGrid.loadAll( 
1627         {order_by : {vmp : 'name'}}, 
1628         {owner : fieldmapper.aou.fullPath(profileContextOrg, true)}
1629     );
1630 }
1631
1632 /* --- Import Item Attr Grid --------------- */
1633
1634 var itemAttrContextOrg;
1635 function vlShowImportItemAttrEditor() {
1636     displayGlobalDiv('vl-item-attr-editor-div');
1637     buildImportItemAttrGrid();
1638
1639     var connect = function() {
1640         dojo.connect(itemAttrContextOrgSelector, 'onChange',
1641             function() {
1642                 itemAttrContextOrg = this.attr('value');
1643                 itemAttrGrid.resetStore();
1644                 vlShowImportItemAttrEditor();
1645             }
1646         );
1647     };
1648
1649     new openils.User().buildPermOrgSelector(
1650         'ADMIN_IMPORT_ITEM_ATTR_DEF', 
1651             itemAttrContextOrgSelector, null, connect);
1652 }
1653
1654 function buildImportItemAttrGrid() {
1655
1656     if(itemAttrContextOrg == null)
1657         itemAttrContextOrg = openils.User.user.ws_ou();
1658
1659     itemAttrGrid.loadAll( 
1660         {order_by : {viiad : 'name'}}, 
1661         {owner : fieldmapper.aou.fullPath(itemAttrContextOrg, true)}
1662     );
1663 }
1664