js/ui/default/acq/picklist/view_list.js

   1 //dojo.require('dojox.grid.DataGrid');
   2 dojo.require('openils.widget.AutoGrid');
   3 dojo.require('dojo.data.ItemFileWriteStore');
   4 dojo.require('dijit.Dialog');
   5 dojo.require('dijit.form.Button');
   6 dojo.require('dijit.form.TextBox');
   7 dojo.require('dijit.form.FilteringSelect');
   8 dojo.require('dijit.form.Button');
   9 dojo.require('dojox.grid.cells.dijit');
  10 dojo.require('openils.acq.Picklist');
  11 dojo.require('openils.Util');
  12 dojo.require('openils.widget.ProgressDialog');
  13
  14 var listAll = false;
  15 var plCache = {};
  16
  17 function loadGrid() {
  18     dojo.connect(plMergeDialog, 'onOpen', function(){loadLeadPlSelector();});
  19     plListGrid.dataLoader = gridDataLoader;
  20     gridDataLoader();
  21 }
  22
  23 function gridDataLoader() {
  24
  25     var method = 'open-ils.acq.picklist.user.retrieve';
  26     if(listAll)
  27         method = method.replace(/user/, 'user.all');
  28
  29     plListGrid.showLoadProgressIndicator();
  30
  31     fieldmapper.standardRequest(
  32         ['open-ils.acq', method],
  33         {   async: true,
  34             params: [
  35                 openils.User.authtoken,
  36                 {
  37                     flesh_lineitem_count:1,
  38                     flesh_owner:1,
  39                     offset : plListGrid.displayOffset,
  40                     limit : plListGrid.displayLimit,
  41                 }
  42             ],
  43             onresponse : function(r) {
  44                 var pl = openils.Util.readResponse(r);
  45                 if(pl) {
  46                     plCache[pl.id()] = pl;
  47                     plListGrid.store.newItem(acqpl.toStoreItem(pl));
  48                 }
  49             },
  50             oncomplete : function() {
  51                 plListGrid.hideLoadProgressIndicator();
  52             }
  53         }
  54     );
  55 }
  56 function getOwnerName(rowIndex, item) {
  57     if(!item) return '';
  58     var id= this.grid.store.getValue(item, 'id');
  59     var pl = plCache[id];
  60     return pl.owner().usrname();
  61 }
  62
  63 function createPL(fields) {
  64     if(fields.name == '') return;
  65
  66     openils.acq.Picklist.create(fields,
  67
  68         function(plId) {
  69             fieldmapper.standardRequest(
  70
  71                 ['open-ils.acq', 'open-ils.acq.picklist.retrieve.authoritative'],
  72                 {   async: true,
  73                     params: [openils.User.authtoken, plId,
  74                         {flesh_lineitem_count:1, flesh_owner:1}],
  75
  76                     oncomplete: function(r) {
  77                         if(pl = openils.Util.readResponse(r)) {
  78                            plCache[pl.id()] = pl;
  79                            plListGrid.store.newItem(acqpl.toStoreData([pl]).items[0]);
  80                         }
  81                     }
  82                 }
  83             );
  84         }
  85     );
  86 }
  87
  88 function getDateTimeField(rowIndex, item) {
  89     if(!item) return '';
  90     var data = this.grid.store.getValue(item, this.field);
  91     var date = dojo.date.stamp.fromISOString(data);
  92     return dojo.date.locale.format(date, {formatLength:'short'});
  93 }
  94 function deleteFromGrid() {
  95     progressDialog.show(true);
  96     var list = [];
  97     dojo.forEach(
  98         plListGrid.getSelectedItems(),
  99         function(item) {
 100             list.push(plListGrid.store.getValue(item, 'id'));
 101             plListGrid.store.deleteItem(item);
 102         }
 103     );
 104     openils.acq.Picklist.deleteList(list, function(){progressDialog.hide();});
 105 }
 106
 107 function cloneSelectedPl(fields) {
 108
 109     var item = plListGrid.getSelectedItems()[0];
 110     if(!item) return;
 111
 112     var plId = plListGrid.store.getValue(item, 'id');
 113     var entryCount = Number(plListGrid.store.getValue(item, 'entry_count'));
 114
 115     progressDialog.show();
 116     progressDialog.update({maximum:entryCount, progress:0});
 117
 118     fieldmapper.standardRequest(
 119         ['open-ils.acq', 'open-ils.acq.picklist.clone'],
 120         {   async: true,
 121             params: [openils.User.authtoken, plId, fields.name],
 122
 123             onresponse : function(r) {
 124                 var resp = openils.Util.readResponse(r);
 125                 if(!resp) return;
 126                 progressDialog.update({progress:resp.li});
 127
 128                 if(resp.complete) {
 129                     progressDialog.hide();
 130                     var pl = resp.picklist;
 131                     plCache[pl.id()] = pl;
 132                     pl.owner(openils.User.user);
 133                     pl.entry_count(entryCount);
 134                     plListGrid.store.newItem(fieldmapper.acqpl.toStoreItem(pl));
 135                 }
 136             }
 137         }
 138     );
 139 }
 140
 141 function loadLeadPlSelector() {
 142     var store = new dojo.data.ItemFileWriteStore({data:acqpl.initStoreData()});
 143     dojo.forEach(
 144         plListGrid.getSelectedItems(),
 145         function(item) {
 146             var pl = plCache[plListGrid.store.getValue(item, 'id')];
 147             store.newItem(fieldmapper.acqpl.toStoreItem(pl));
 148         }
 149     );
 150     plMergeLeadSelector.store = store;
 151     plMergeLeadSelector.startup();
 152 }
 153
 154 function mergeSelectedPl(fields) {
 155     if(!fields.lead) return;
 156
 157     var ids = [];
 158     var totalLi = 0;
 159     var leadPl = plCache[fields.lead];
 160     var leadPlItem;
 161
 162     dojo.forEach(
 163         plListGrid.getSelectedItems(),
 164         function(item) {
 165             var id = plListGrid.store.getValue(item, 'id');
 166             if(id == fields.lead) {
 167                 leadPlItem = item;
 168                 return;
 169             }
 170             totalLi +=  new Number(plListGrid.store.getValue(item, 'entry_count'));
 171             ids.push(id);
 172         }
 173     );
 174
 175     progressDialog.show();
 176     progressDialog.update({maximum:totalLi, progress:0});
 177
 178     fieldmapper.standardRequest(
 179         ['open-ils.acq', 'open-ils.acq.picklist.merge'],
 180         {   async: true,
 181             params: [openils.User.authtoken, fields.lead, ids],
 182             onresponse : function(r) {
 183                 var resp = openils.Util.readResponse(r);
 184                 if(!resp) return;
 185                 progressDialog.update({progress:resp.li});
 186
 187                 if(resp.complete) {
 188                     progressDialog.hide();
 189                     leadPl.entry_count( leadPl.entry_count() + totalLi );
 190                     plListGrid.store.setValue(leadPlItem, 'entry_count', leadPl.entry_count());
 191
 192                     // remove the deleted lists from the grid
 193                     dojo.forEach(
 194                         plListGrid.getSelectedItems(),
 195                         function(item) {
 196                             var id = plListGrid.store.getValue(item, 'id');
 197                             if(id != fields.lead)
 198                                 plListGrid.store.deleteItem(item);
 199                         }
 200                     );
 201                 }
 202             }
 203         }
 204     );
 205 }
 206
 207 openils.Util.addOnLoad(loadGrid);
 208
 209