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'],
 123         {
 124             params : [ openils.User.authtoken, liId, args ],
 125
 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 li = lineitem.picklist();
 144                 var orderDate = '';
 145                 if(po) {
 146                     var date = dojo.date.stamp.fromISOString(po.order_date());
 147                     if(date) {
 148                         orderDate = dojo.date.locale.format(date, {selector:'date'});
 149                     }
 150                 }
 151
 152                 var displayString = dojo.string.substitute(
 153                     localeStrings.LINEITEM_SUMMARY, [
 154                         wrapper.findAttr('title', type) || '',
 155                         wrapper.findAttr('author', type) || '',
 156                         idents.join(',') || '',
 157                         lineitem.order_summary().item_count() || '0',
 158                         lineitem.order_summary().recv_count() || '0',
 159                         Number(lineitem.estimated_unit_price()).toFixed(2) | '',
 160                         lineitem.order_summary().estimated_amount() || '0.00',
 161                         lineitem.order_summary().invoice_count() || '0',
 162                         lineitem.order_summary().claim_count() || '0',
 163                         lineitem.order_summary().cancel_count() || '0',
 164                         lineitem.id(),
 165                         oilsBasePath,
 166                         (po) ? po.id() : '',
 167                         (po) ? po.name() : '',
 168                         (li) ? li.id() : '',
 169                         (li) ? li.name() : '',
 170                         lineitem.order_summary().encumbrance_amount() || '0.00',
 171                         lineitem.order_summary().paid_amount() || '0.00',
 172                         orderDate
 173                     ]
 174                 );
 175
 176                 callback(lineitem, displayString);
 177             }
 178         }
 179     );
 180 }
 181
 182 openils.acq.Lineitem.attrDefs = null;
 183
 184 openils.acq.Lineitem.fetchAttrDefs = function(onload) {
 185     if(openils.acq.Lineitem.attrDefs)
 186         return onload(openils.acq.Lineitem.attrDefs);
 187     fieldmapper.standardRequest(
 188         ['open-ils.acq', 'open-ils.acq.lineitem_attr_definition.retrieve.all'],
 189         {   async: true,
 190             params: [openils.User.authtoken],
 191             oncomplete: function(r) {
 192                 openils.acq.Lineitem.attrDefs =
 193                     openils.Util.readResponse(r);
 194                 onload(openils.acq.Lineitem.attrDefs);
 195             }
 196         }
 197     );
 198 }
 199
 200
 201 openils.acq.Lineitem.ModelCache = {};
 202 openils.acq.Lineitem.acqlidCache = {};
 203
 204 openils.acq.Lineitem.createLIDStore = function(li_id, onComplete) {
 205     // Fetches the details of a lineitem and builds a grid
 206
 207     function mkStore(r) {
 208         var msg;
 209         var items = [];
 210         while (msg = r.recv()) {
 211             var data = msg.content();
 212             for (i in data.lineitem_details()) {
 213                 var lid = data.lineitem_details()[i];
 214                 items.push(lid);
 215                 openils.acq.Lineitem.acqlidCache[lid.id()] = lid;
 216             }
 217         }
 218
 219         onComplete(acqlid.toStoreData(items));
 220     }
 221
 222     fieldmapper.standardRequest(
 223         ['open-ils.acq', 'open-ils.acq.lineitem.retrieve'],
 224         { async: true,
 225           params: [openils.User.authtoken, li_id,
 226                    {flesh_attrs:1, flesh_li_details:1}],
 227           oncomplete: mkStore
 228         });
 229 };
 230
 231 openils.acq.Lineitem.alertOnLIDSet = function(griditem, attr, oldVal, newVal) {
 232     var item;
 233     var updateDone = function(r) {
 234         var stat = r.recv().content();
 235         var evt = openils.Event.parse(stat);
 236
 237         if (evt) {
 238             alert("Error: "+evt.desc);
 239             console.dir(evt);
 240             if (attr == "fund") {
 241                 item.fund(oldVal);
 242                 griditem.fund = oldVal;
 243             } else if (attr ==  "owning_lib") {
 244                 item.owning_lib(oldVal);
 245                 griditem.owning_lib = oldVal;
 246             }
 247         }
 248     };
 249
 250     if (oldVal == newVal) {
 251         return;
 252     }
 253
 254     item = openils.acq.Lineitem.acqlidCache[griditem.id];
 255
 256     if (attr == "fund") {
 257         item.fund(newVal);
 258     } else if (attr ==  "owning_lib") {
 259         item.owning_lib(newVal);
 260     } else if (attr ==  "cn_label") {
 261         item.cn_label(newVal);
 262     } else if (attr ==  "barcode") {
 263         item.barcode(newVal);
 264     } else if (attr ==  "location") {
 265         item.location(newVal);
 266     } else {
 267         alert("Unexpected attr in Lineitem.alertOnSet: '"+attr+"'");
 268         return;
 269     }
 270
 271     fieldmapper.standardRequest(
 272         ["open-ils.acq", "open-ils.acq.lineitem_detail.update"],
 273         { params: [openils.User.authtoken, item],
 274           oncomplete: updateDone
 275         });
 276 };
 277
 278 openils.acq.Lineitem.deleteLID = function(id, onComplete) {
 279     fieldmapper.standardRequest(
 280         ['open-ils.acq', 'open-ils.acq.lineitem_detail.delete'],
 281         {   async: true,
 282             params: [openils.User.authtoken, id],
 283             oncomplete: function(r) {
 284                 msg = r.recv()
 285                 stat = msg.content();
 286                 onComplete(openils.Event.parse(stat));
 287             }
 288     });
 289 };
 290
 291 openils.acq.Lineitem.createLID = function(fields, onCreateComplete) {
 292     var lid = new acqlid()
 293     for (var field in fields) {
 294         lid[field](fields[field]);
 295     }
 296
 297     fieldmapper.standardRequest(
 298         ['open-ils.acq', 'open-ils.acq.lineitem_detail.create'],
 299         { async: true,
 300           params: [openils.User.authtoken, lid, {return_obj:1}],
 301           oncomplete: function(r) {
 302               var msg = r.recv();
 303           var obj = msg.content();
 304           openils.Event.parse_and_raise(obj);
 305               if (onCreateComplete) {
 306                     onCreateComplete(obj);
 307               }
 308           }
 309         });
 310 };
 311
 312 openils.acq.Lineitem.loadLIDGrid = function(domNode, id, layout) {
 313     if (!openils.acq.Lineitem.ModelCache[id]) {
 314         openils.acq.Lineitem.createLIDStore(id,
 315                 function(storeData) {
 316                     var store = new dojo.data.ItemFileWriteStore({data:storeData});
 317                     var model = new dojox.grid.data.DojoData(null, store,
 318                         {rowsPerPage: 20, clientSort:true, query:{id:'*'}});
 319
 320                     dojo.connect(store, "onSet",
 321                                  openils.acq.Lineitem.alertOnLIDSet);
 322                     openils.acq.Lineitem.ModelCache[id] = model;
 323
 324                     domNode.setStructure(layout);
 325                     domNode.setModel(model);
 326                     domNode.update();
 327                 });
 328     } else {
 329         domNode.setModel(openils.acq.Lineitem.ModelCache[id]);
 330         domNode.setStructure(layout);
 331         domNode.update();
 332         domNode.refresh();
 333     }
 334 };
 335 }