Open-ILS/web/js/dojo/openils/acq/Lineitem.js

   1 /* ---------------------------------------------------------------------------
   2  * Copyright (C) 2008  Georgia Public Library Service
   3  * David J. Fiander <david@fiander.info>
   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  */
  16
  17 if(!dojo._hasResource['openils.acq.Lineitem']) {
  18 dojo._hasResource['openils.acq.Lineitem'] = true;
  19 dojo.provide('openils.acq.Lineitem');
  20 dojo.require('dojo.data.ItemFileWriteStore');
  21 dojo.require('fieldmapper.dojoData');
  22 dojo.require('openils.User');
  23 dojo.require('openils.Event');
  24 dojo.require('openils.Util');
  25 dojo.require('dojo.date.stamp');
  26 dojo.require('dojo.date.locale');
  27
  28 dojo.requireLocalization('openils.acq', 'acq');
  29 var localeStrings = dojo.i18n.getLocalization('openils.acq', 'acq');
  30
  31
  32 /** Declare the Lineitem class with dojo */
  33 dojo.declare('openils.acq.Lineitem', null, {
  34     /* add instance methods here if necessary */
  35
  36     constructor: function(args) {
  37         this.lineitem = args.lineitem;
  38     },
  39
  40     findAttr: function(name, type) {
  41         var attrs = this.lineitem.attributes();
  42         if(!attrs) return null;
  43         for(var i = 0; i < attrs.length; i++) {
  44             var attr = attrs[i];
  45             if (attr.attr_type() == type && attr.attr_name() == name)
  46                 return attr.attr_value();
  47         }
  48     },
  49
  50     // returns the actual price if available, otherwise estimated price, otherwise null
  51     // priority is given to local attrs, then provider attrs, then MARC attrs
  52     getPrice: function() {
  53         return this.getActualPrice() || this.getEstimatedPrice();
  54     },
  55
  56     // returns the actual price, null if none
  57     getActualPrice : function() {
  58         return this._getPriceAttr('actual_price');
  59     },
  60
  61     // returns the estimated price, null if none
  62     getEstimatedPrice : function() {
  63         return this._getPriceAttr('estimated_price');
  64     },
  65
  66     _getPriceAttr : function(attr) {
  67         var types = [
  68             'lineitem_local_attr_definition',
  69             'lineitem_provider_attr_definition',
  70             'lineitem_marc_attr_definition'
  71         ];
  72
  73         for(var t in types) {
  74             if(price = this.findAttr(attr, types[t]))
  75                 return {price:price, source_type: attr, source_attr: types[t]};
  76         }
  77
  78         return null;
  79     },
  80
  81     update: function(oncomplete) {
  82         fieldmapper.standardRequest(
  83             ['open-ils.acq', 'open-ils.acq.lineitem.update'],
  84             {   async: true,
  85                 params: [openils.User.authtoken, this.lineitem],
  86                 oncomplete: function(r) {
  87                     oncomplete(openils.Event.parse(r.recv().content()));
  88                 }
  89             }
  90         );
  91     },
  92
  93     approve: function(oncomplete) {
  94         fieldmapper.standardRequest(
  95             ['open-ils.acq', 'open-ils.acq.lineitem.approve'],
  96             {  async: true,
  97                params: [openils.User.authtoken, this.lineitem.id()],
  98                oncomplete: function(r) {
  99                    oncomplete(openils.Event.parse(r.recv().content()));
 100                }
 101             });
 102     },
 103
 104     id: function() {
 105         return this.lineitem.id();
 106     },
 107 });
 108
 109 openils.acq.Lineitem.identDisplayFields = ['isbn', 'upc', 'issn'];
 110 openils.acq.Lineitem.fetchAndRender = function(liId, args, callback) {
 111
 112     // below are the args needed for rendering the basic summary template
 113     args = dojo.mixin(args || {}, {
 114         clear_marc : true,
 115         flesh_attrs : true,
 116         flesh_po : true,
 117         flesh_pl : true,
 118         flesh_order_summary : true
 119     });
 120
 121     fieldmapper.standardRequest(
 122         ['open-ils.acq', 'open-ils.acq.lineitem.retrieve.authoritative'],
 123         {
 124             params : [ openils.User.authtoken, liId, args ],
 125             async : true,
 126             oncomplete : function(r) {
 127                 var lineitem = openils.Util.readResponse(r);
 128                 if(!lineitem) return;
 129
 130                 var wrapper = new openils.acq.Lineitem({lineitem : lineitem});
 131                 var type = 'lineitem_marc_attr_definition';
 132
 133                 var idents = [];
 134                 dojo.forEach(
 135                     openils.acq.Lineitem.identDisplayFields,
 136                     function(ident) {
 137                         if(attr = wrapper.findAttr(ident, type))
 138                             idents.push(attr)
 139                     }
 140                 );
 141
 142                 var po = lineitem.purchase_order();
 143                 var pl = lineitem.picklist();
 144                 var orderDate = '';
 145                 var liLink = '';
 146
 147                 if(pl && pl.name() == '') // special pl
 148                     pl = null;
 149
 150                 if(po) {
 151                     liLink = '/eg2/en-US/staff/acq/po/' + po.id() + '#' + lineitem.id();
 152                     if(po.order_date()) {
 153                         var date = dojo.date.stamp.fromISOString(po.order_date());
 154                         if(date) {
 155                             orderDate = dojo.date.locale.format(date, {selector:'date'});
 156                         }
 157                     }
 158                 }
 159
 160                 var displayString = dojo.string.substitute(
 161                     localeStrings.LINEITEM_SUMMARY, [
 162                         wrapper.findAttr('title', type) || '',
 163                         wrapper.findAttr('author', type) || '',
 164                         idents.join(',') || '',
 165                         lineitem.order_summary().item_count() || '0',
 166                         lineitem.order_summary().recv_count() || '0',
 167                         Number(lineitem.estimated_unit_price()).toFixed(2) | '',
 168                         lineitem.order_summary().estimated_amount() || '0.00',
 169                         lineitem.order_summary().invoice_count() || '0',
 170                         lineitem.order_summary().claim_count() || '0',
 171                         lineitem.order_summary().cancel_count() || '0',
 172                         lineitem.id(),
 173                         oilsBasePath,
 174                         (po) ? po.id() : '',
 175                         (po) ? po.name() : '',
 176                         (pl) ? pl.id() : '',
 177                         (pl) ? pl.name() : '',
 178                         lineitem.order_summary().encumbrance_amount() || '0.00',
 179                         lineitem.order_summary().paid_amount() || '0.00',
 180                         orderDate,
 181                         liLink,
 182                         (po) ? 'foo' : '', // forces class='hiddenfoo' i.e. not hidden
 183                         (pl) ? 'foo' : '', // ditto
 184                         encodeURIComponent(location.pathname + location.search),
 185                         lineitem.order_summary().delay_count() || '0'
 186                     ],
 187                     function(str) {
 188                         // prevent long titles from filling up the page
 189                         var truncSize = 100;
 190                         if(str.length > truncSize)
 191                             str = str.substring(0, truncSize) + '...';
 192                         return str;
 193                     }
 194                 );
 195
 196                 callback(lineitem, displayString);
 197             }
 198         }
 199     );
 200 }
 201
 202 openils.acq.Lineitem.attrDefs = null;
 203
 204 openils.acq.Lineitem.fetchAttrDefs = function(onload) {
 205     if(openils.acq.Lineitem.attrDefs)
 206         return onload(openils.acq.Lineitem.attrDefs);
 207     fieldmapper.standardRequest(
 208         ['open-ils.acq', 'open-ils.acq.lineitem_attr_definition.retrieve.all'],
 209         {   async: true,
 210             params: [openils.User.authtoken],
 211             oncomplete: function(r) {
 212                 openils.acq.Lineitem.attrDefs =
 213                     openils.Util.readResponse(r);
 214                 onload(openils.acq.Lineitem.attrDefs);
 215             }
 216         }
 217     );
 218 }
 219
 220
 221 openils.acq.Lineitem.ModelCache = {};
 222 openils.acq.Lineitem.acqlidCache = {};
 223
 224 openils.acq.Lineitem.createLIDStore = function(li_id, onComplete) {
 225     // Fetches the details of a lineitem and builds a grid
 226
 227     function mkStore(r) {
 228         var msg;
 229         var items = [];
 230         while (msg = r.recv()) {
 231             var data = msg.content();
 232             for (i in data.lineitem_details()) {
 233                 var lid = data.lineitem_details()[i];
 234                 items.push(lid);
 235                 openils.acq.Lineitem.acqlidCache[lid.id()] = lid;
 236             }
 237         }
 238
 239         onComplete(acqlid.toStoreData(items));
 240     }
 241
 242     fieldmapper.standardRequest(
 243         ['open-ils.acq', 'open-ils.acq.lineitem.retrieve'],
 244         { async: true,
 245           params: [openils.User.authtoken, li_id,
 246                    {flesh_attrs:1, flesh_li_details:1}],
 247           oncomplete: mkStore
 248         });
 249 };
 250
 251 openils.acq.Lineitem.alertOnLIDSet = function(griditem, attr, oldVal, newVal) {
 252     var item;
 253     var updateDone = function(r) {
 254         var stat = r.recv().content();
 255         var evt = openils.Event.parse(stat);
 256
 257         if (evt) {
 258             alert("Error: "+evt.desc);
 259             console.dir(evt);
 260             if (attr == "fund") {
 261                 item.fund(oldVal);
 262                 griditem.fund = oldVal;
 263             } else if (attr ==  "owning_lib") {
 264                 item.owning_lib(oldVal);
 265                 griditem.owning_lib = oldVal;
 266             }
 267         }
 268     };
 269
 270     if (oldVal == newVal) {
 271         return;
 272     }
 273
 274     item = openils.acq.Lineitem.acqlidCache[griditem.id];
 275
 276     if (attr == "fund") {
 277         item.fund(newVal);
 278     } else if (attr ==  "owning_lib") {
 279         item.owning_lib(newVal);
 280     } else if (attr ==  "cn_label") {
 281         item.cn_label(newVal);
 282     } else if (attr ==  "barcode") {
 283         item.barcode(newVal);
 284     } else if (attr ==  "location") {
 285         item.location(newVal);
 286     } else {
 287         alert("Unexpected attr in Lineitem.alertOnSet: '"+attr+"'");
 288         return;
 289     }
 290
 291     fieldmapper.standardRequest(
 292         ["open-ils.acq", "open-ils.acq.lineitem_detail.update"],
 293         { params: [openils.User.authtoken, item],
 294           oncomplete: updateDone
 295         });
 296 };
 297
 298 openils.acq.Lineitem.deleteLID = function(id, onComplete) {
 299     fieldmapper.standardRequest(
 300         ['open-ils.acq', 'open-ils.acq.lineitem_detail.delete'],
 301         {   async: true,
 302             params: [openils.User.authtoken, id],
 303             oncomplete: function(r) {
 304                 msg = r.recv()
 305                 stat = msg.content();
 306                 onComplete(openils.Event.parse(stat));
 307             }
 308     });
 309 };
 310
 311 openils.acq.Lineitem.createLID = function(fields, onCreateComplete) {
 312     var lid = new acqlid()
 313     for (var field in fields) {
 314         lid[field](fields[field]);
 315     }
 316
 317     fieldmapper.standardRequest(
 318         ['open-ils.acq', 'open-ils.acq.lineitem_detail.create'],
 319         { async: true,
 320           params: [openils.User.authtoken, lid, {return_obj:1}],
 321           oncomplete: function(r) {
 322               var msg = r.recv();
 323           var obj = msg.content();
 324           openils.Event.parse_and_raise(obj);
 325               if (onCreateComplete) {
 326                     onCreateComplete(obj);
 327               }
 328           }
 329         });
 330 };
 331
 332 openils.acq.Lineitem.loadLIDGrid = function(domNode, id, layout) {
 333     if (!openils.acq.Lineitem.ModelCache[id]) {
 334         openils.acq.Lineitem.createLIDStore(id,
 335                 function(storeData) {
 336                     var store = new dojo.data.ItemFileWriteStore({data:storeData});
 337                     var model = new dojox.grid.data.DojoData(null, store,
 338                         {rowsPerPage: 20, clientSort:true, query:{id:'*'}});
 339
 340                     dojo.connect(store, "onSet",
 341                                  openils.acq.Lineitem.alertOnLIDSet);
 342                     openils.acq.Lineitem.ModelCache[id] = model;
 343
 344                     domNode.setStructure(layout);
 345                     domNode.setModel(model);
 346                     domNode.update();
 347                 });
 348     } else {
 349         domNode.setModel(openils.acq.Lineitem.ModelCache[id]);
 350         domNode.setStructure(layout);
 351         domNode.update();
 352         domNode.refresh();
 353     }
 354 };
 355 }