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