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