Open-ILS/web/js/ui/default/acq/common/vlagent.js

   1 dojo.require('openils.widget.AutoFieldWidget');
   2 dojo.require('openils.PermaCrud');
   3 dojo.require('openils.XUL');
   4 dojo.require('dojox.form.CheckedMultiSelect');
   5
   6 var xulStorage;
   7 var storekey = 'eg.acq.upload.';
   8 var osetkey = 'acq.upload.default.';
   9 var persistOrgSettings;
  10
  11 // map local dijit keys/names to their org setting counterparts
  12 var setNameMap = {
  13     match_set : 'vandelay.match_set',
  14     merge_profile : 'vandelay.merge_profile',
  15     create_assets : 'vandelay.load_item_for_imported',
  16     match_quality_ratio : 'vandelay.quality_ratio',
  17     auto_overlay_1match : 'vandelay.merge_on_single',
  18     import_no_match : 'vandelay.import_non_matching',
  19     fall_through_merge_profile : 'vandelay.low_quality_fall_thru_profile',
  20     auto_overlay_exact : 'vandelay.merge_on_exact',
  21     auto_overlay_best_match : 'vandelay.merge_on_best'
  22 }
  23
  24 // per-UI setting to change this?
  25 // if true, set default widget values from org settings
  26 // (when defined) regardless of any locally persisted value
  27 var ouSettingTrumpsPersist = true;
  28
  29 function VLAgent(args) {
  30     args = args || {};
  31     for (var key in args) {
  32         this[key] = args[key];
  33     }
  34
  35     this.widgets = [
  36         {key : 'import_no_match'},
  37         {key : 'auto_overlay_exact'},
  38         {key : 'auto_overlay_1match'},
  39         {key : 'auto_overlay_best_match'},
  40         {key : 'match_quality_ratio'},
  41         {key : 'queue_name'},
  42         {key : 'create_assets'},
  43         {key : 'match_set', cls : 'vms'},
  44         {key : 'bib_source', cls : 'cbs'},
  45         {key : 'merge_profile', cls : 'vmp'},
  46         {key : 'fall_through_merge_profile', cls : 'vmp'},
  47         {key : 'existing_queue', cls : 'vbq'},
  48         {key : 'strip_field_groups', cls : 'vibtg'}
  49     ];
  50
  51     this.loaded = false;
  52
  53     this.init = function(oncomplete) {
  54         var self = this;
  55
  56         xulStorage = openils.XUL.localStorage();
  57
  58         // load org unit persist setting values
  59         fieldmapper.standardRequest(
  60             ['open-ils.actor','open-ils.actor.ou_setting.ancestor_default.batch'],
  61             {   async : true,
  62                 params : [
  63                     new openils.User().user.ws_ou(),
  64                     [   osetkey + 'create_po',
  65                         osetkey + 'activate_po',
  66                         osetkey + 'provider',
  67                         osetkey + 'vandelay.match_set',
  68                         osetkey + 'vandelay.merge_profile',
  69                         osetkey + 'vandelay.import_non_matching',
  70                         osetkey + 'vandelay.merge_on_exact',
  71                         osetkey + 'vandelay.merge_on_best',
  72                         osetkey + 'vandelay.merge_on_single',
  73                         osetkey + 'vandelay.quality_ratio',
  74                         osetkey + 'vandelay.low_quality_fall_thru_profile',
  75                         osetkey + 'vandelay.load_item_for_imported'
  76                     ]
  77                 ],
  78                 oncomplete : function(r) {
  79                     persistOrgSettings = openils.Util.readResponse(r);
  80                     self.init2();
  81                     if (oncomplete)
  82                         oncomplete();
  83                 }
  84             }
  85         );
  86     };
  87
  88     this.init2 = function() {
  89         var self = this;
  90         // fetch the strip field groups, then continue init-ing
  91
  92         var owner = fieldmapper.aou.orgNodeTrail(
  93             fieldmapper.aou.findOrgUnit(new openils.User().user.ws_ou()));
  94
  95         new openils.PermaCrud().search('vibtg',
  96             {   always_apply : 'f',
  97                 owner: owner.map(function(org) { return org.id(); })
  98             },
  99             {   order_by : {vibtg : ['label']},
 100                 async: true,
 101                 oncomplete: function(r) {
 102                     var trashGroups = openils.Util.readResponse(r);
 103                     var sel = dijit.byId('acq_vl:strip_field_groups');
 104
 105                     var widg = self.widgets.filter(function(w) {
 106                         return w.key == 'strip_field_groups'})[0];
 107                     widg.dijit = sel;
 108
 109                     if (trashGroups.length == 0) {
 110                         openils.Util.hide('vl-trash-groups-row');
 111
 112                     } else {
 113
 114                         dojo.forEach(trashGroups, function(grp) {
 115                             var sn = fieldmapper.aou.findOrgUnit(
 116                                 grp.owner()).shortname();
 117                             var opt = {
 118                                 label : grp.label() + '&nbsp;(' + sn + ')',
 119                                 value : grp.id()
 120                             };
 121                             sel.addOption(opt);
 122                         });
 123
 124                         self.readCachedValue(sel, 'strip_field_groups');
 125                     }
 126
 127                     self.init3();
 128                 }
 129             }
 130         );
 131
 132     },
 133
 134     this.init3 = function() {
 135         var self = this;
 136
 137         dojo.forEach(this.widgets,
 138             function(widg) {
 139                 var key = widg.key;
 140
 141                 // strip-fields widget built above
 142                 if (key == 'strip_field_groups') return;
 143
 144                 if (widg.cls) { // selectors
 145
 146                     new openils.widget.AutoFieldWidget({
 147                         fmClass : widg.cls,
 148                         selfReference : true,
 149                         orgLimitPerms : [self.limitPerm || 'CREATE_PURCHASE_ORDER'],
 150                         parentNode : dojo.byId('acq_vl:' + key),
 151                         searchFilter : (widg.cls == 'vbq') ? {queue_type : 'acq'} : null,
 152                         useWriteStore :  (widg.cls == 'vbq')
 153                     }).build(function(dij) {
 154                         widg.dijit = dij;
 155                         if (!key.match(/queue/))
 156                             self.readCachedValue(dij, key);
 157                         self.attachOnChange(widg);
 158                     });
 159
 160                 } else { // bools
 161                     widg.dijit = dijit.byId('acq_vl:' + key);
 162                     if (!widg.dijit) return; // some fields optional
 163                     if (!key.match(/queue/))
 164                         self.readCachedValue(widg.dijit, key);
 165                     self.attachOnChange(widg);
 166                 }
 167             }
 168         );
 169
 170         // loaded != all widgets are done rendering,
 171         // only that init() has been called.
 172         this.loaded = true;
 173     }
 174
 175     this.attachOnChange = function(widg) {
 176         var self = this;
 177         var qInputChange;
 178
 179         var qSelChange = function(val) {
 180             // user selected a queue from the selector;  clear the text input
 181             // and set the item import profile already defined for the queue
 182
 183             var qInput = self.getDijit('queue_name');
 184             var matchSetSelector = self.getDijit('match_set');
 185             var qSelector = self.getDijit('existing_queue');
 186
 187             if(val) {
 188                 qSelector.store.fetch({
 189                     query : {id : val+''},
 190                     onComplete : function(items) {
 191                         matchSetSelector.attr('value', items[0].match_set[0] || '');
 192                         matchSetSelector.attr('disabled', true);
 193                     }
 194                 });
 195             } else {
 196                 matchSetSelector.attr('value', '');
 197                 matchSetSelector.attr('disabled', false);
 198             }
 199
 200             // detach and reattach to avoid onchange firing while when we clear
 201             dojo.disconnect(qInput._onchange);
 202             qInput.attr('value', '');
 203             qInput._onchange = dojo.connect(qInput, 'onChange', qInputChange);
 204         }
 205
 206         qInputChange = function(val) {
 207
 208             var qSelector = self.getDijit('existing_queue');
 209             var matchSetSelector = self.getDijit('match_set');
 210             var foundMatch = false;
 211
 212             if (val) {
 213
 214                 // if the user entered the name of an existing queue, update the
 215                 // queue selector to match the value (and clear the text input
 216                 // via qselector onchange)
 217                 qSelector.store.fetch({
 218                     query:{name:val},
 219                     onComplete:function(items) {
 220                         if(items.length == 0) return;
 221                         var item = items[0];
 222                         qSelector.attr('value', item.id);
 223                         foundMatch = true;
 224                     }
 225                 });
 226             }
 227
 228             if (!foundMatch) {
 229                 self.getDijit('match_set').attr('disabled', false);
 230                 dojo.disconnect(qSelector._onchange);
 231                 qSelector.attr('value', '');
 232                 qSelector._onchange = dojo.connect(qSelector, 'onChange', qSelChange);
 233             }
 234         }
 235
 236         if (widg.key == 'existing_queue') {
 237             var qSelector = self.getDijit('existing_queue');
 238             qSelector._onchange = dojo.connect(qSelector, 'onChange', qSelChange);
 239         } else if(widg.key == 'queue_name') {
 240             var qInput = self.getDijit('queue_name');
 241             qInput._onchange = dojo.connect(qInput, 'onChange', qInputChange);
 242         }
 243     }
 244
 245     this.getDijit = function(key) {
 246         return this.widgets.filter(function(w) {return (w.key == key)})[0].dijit;
 247     }
 248
 249     this.values = function() {
 250         var self = this;
 251         var values = {};
 252         dojo.forEach(this.widgets,
 253             function(widg) {
 254                 if (widg.dijit) {
 255                     values[widg.key] = widg.dijit.attr('value');
 256                     if (!widg.key.match(/queue/))
 257                         self.writeCachedValue(widg.dijit, widg.key);
 258                 }
 259             }
 260         );
 261         return values;
 262     }
 263
 264     this.handleResponse = function(resp, oncomplete) {
 265         if(!resp) return;
 266         var res = {}
 267
 268         console.log('vandelay import returned : ' + js2JSON(resp));
 269
 270         // update the display counts
 271         dojo.byId('acq_vl:li-processed').innerHTML = resp.li;
 272         dojo.byId('acq_vl:vqbr-processed').innerHTML = resp.vqbr;
 273         dojo.byId('acq_vl:bibs-processed').innerHTML = resp.bibs;
 274         dojo.byId('acq_vl:lid-processed').innerHTML = resp.lid;
 275         dojo.byId('acq_vl:debits-processed').innerHTML = resp.debits_accrued;
 276         dojo.byId('acq_vl:copies-processed').innerHTML = resp.copies;
 277
 278         if (resp.complete) {
 279
 280             if(resp.picklist) {
 281                 res.picklist_url = oilsBasePath + '/acq/picklist/view/' + resp.picklist.id();
 282             }
 283
 284             if(resp.purchase_order) {
 285                 res.po_url = oilsBasePath + '/acq/po/view/' + resp.purchase_order.id();
 286             }
 287
 288             if (resp.queue) {
 289                 var newQid = resp.queue.id();
 290                 res.queue_url = oilsBasePath + '/vandelay/vandelay?qtype=bib&qid=' + newQid;
 291
 292                 var qInput = this.getDijit('queue_name');
 293
 294                 if (newQName = qInput.attr('value')) {
 295                     // user created a new queue.  Fetch the new queue object,
 296                     // replace the ReadStore with a WriteStore and insert.
 297                     qInput.attr('value', '');
 298                     var qSelector = this.getDijit('existing_queue');
 299                     var newQ = new openils.PermaCrud().retrieve('vbq', newQid);
 300                     qSelector.store.newItem(newQ.toStoreItem());
 301                     qSelector.attr('value', newQid);
 302                 }
 303             }
 304
 305             if (oncomplete)
 306                 oncomplete(resp, res);
 307
 308             return res;
 309         }
 310
 311         return false; // not yet complete
 312     };
 313
 314     this.readCachedValue = function(dij, key, ousOnly) {
 315         var val;
 316         var setname = osetkey + (setNameMap[key] ? setNameMap[key] : key);
 317
 318         if (ouSettingTrumpsPersist && persistOrgSettings[setname]) {
 319             val = persistOrgSettings[setname].value;
 320         } else {
 321             if (!ousOnly)
 322                 val = xulStorage.getItem(storekey + key);
 323             if (!val && persistOrgSettings[setname])
 324                 val = persistOrgSettings[setname].value;
 325         }
 326
 327         if (val) dij.attr('value', val);
 328         return val;
 329     };
 330
 331     this.writeCachedValue = function(dij, key) {
 332         var setname = osetkey + (setNameMap[key] ? setNameMap[key] : key);
 333
 334         if (ouSettingTrumpsPersist && persistOrgSettings[setname]) {
 335             // don't muck up localStorage if we're using org settings
 336             xulStorage.removeItem(storekey + key);
 337
 338         } else {
 339             var val = dij.attr('value');
 340
 341             if (val === null || val === false || val == '') {
 342                 xulStorage.removeItem(storekey + key);
 343             } else {
 344                 xulStorage.setItem(storekey + key, val);
 345             }
 346         }
 347     };
 348 }