Open-ILS/web/js/dojo/openils/widget/AutoFieldWidget.js

   1 if(!dojo._hasResource['openils.widget.AutoFieldWidget']) {
   2     dojo.provide('openils.widget.AutoFieldWidget');
   3     dojo.require('openils.Util');
   4     dojo.require('openils.User');
   5     dojo.require('fieldmapper.IDL');
   6
   7     dojo.declare('openils.widget.AutoFieldWidget', null, {
   8
   9         async : false,
  10
  11         /**
  12          * args:
  13          *  idlField -- Field description object from fieldmapper.IDL.fmclasses
  14          *  fmObject -- If available, the object being edited.  This will be used
  15          *      to set the value of the widget.
  16          *  fmClass -- Class name (not required if idlField or fmObject is set)
  17          *  fmField -- Field name (not required if idlField)
  18          *  parentNode -- If defined, the widget will be appended to this DOM node
  19          *  dijitArgs -- Optional parameters object, passed directly to the dojo widget
  20          *  orgLimitPerms -- If this field defines a set of org units and an orgLimitPerms
  21          *      is defined, the code will limit the org units in the set to those
  22          *      allowed by the permission
  23          */
  24         constructor : function(args) {
  25             for(var k in args)
  26                 this[k] = args[k];
  27
  28             // find the field description in the IDL if not provided
  29             if(this.fmObject)
  30                 this.fmClass = this.fmObject.classname;
  31             this.fmIDL = fieldmapper.IDL.fmclasses[this.fmClass];
  32
  33             if(!this.idlField) {
  34                 this.fmIDL = fieldmapper.IDL.fmclasses[this.fmClass];
  35                 var fields = this.fmIDL.fields;
  36                 for(var f in fields)
  37                     if(fields[f].name == this.fmField)
  38                         this.idlField = fields[f];
  39             }
  40         },
  41
  42         /**
  43          * Turn the widget-stored value into a value oils understands
  44          */
  45         getFormattedValue : function() {
  46             var value = this.baseWidgetValue();
  47
  48             /* text widgets default to "" when no data is entered */
  49             if(value == '') return null;
  50
  51             switch(this.idlField.datatype) {
  52                 case 'bool':
  53                     return (value) ? 't' : 'f'
  54                 case 'timestamp':
  55                     return dojo.date.stamp.toISOString(value);
  56                 default:
  57                     return value;
  58             }
  59         },
  60
  61         baseWidgetValue : function(value) {
  62             var attr = (this.readOnly) ? 'content' : 'value';
  63             if(arguments.length) this.widget.attr(attr, value);
  64             return this.widget.attr(attr);
  65         },
  66
  67         /**
  68          * Turn the widget-stored value into something visually suitable
  69          */
  70         getDisplayString : function() {
  71             var value = this.widgetValue;
  72             switch(this.idlField.datatype) {
  73                 case 'bool':
  74                     return (value) ? 'True' : 'False'; // XXX i18n!
  75                 case 'timestamp':
  76                     dojo.require('dojo.date.locale');
  77                     dojo.require('dojo.date.stamp');
  78                     var date = dojo.date.stamp.fromISOString(value);
  79                     return dojo.date.locale.format(date, {formatLength:'short'});
  80                 case 'org_unit':
  81                     return fieldmapper.aou.findOrgUnit(value).shortname();
  82                 default:
  83                     return value+'';
  84             }
  85         },
  86
  87         build : function(onload) {
  88             this.onload = onload;
  89             if(this.widgetValue == null)
  90                 this.widgetValue = (this.fmObject) ? this.fmObject[this.idlField.name]() : null;
  91
  92             if(this.readOnly) {
  93                 dojo.require('dijit.layout.ContentPane');
  94                 this.widget = new dijit.layout.ContentPane(this.dijitArgs, this.parentNode);
  95
  96             } else {
  97
  98                 switch(this.idlField.datatype) {
  99
 100                     case 'id':
 101                         dojo.require('dijit.form.TextBox');
 102                         this.widget = new dijit.form.TextBox(this.dijitArgs, this.parentNode);
 103                         this.widget.attr('disabled', true); // never allow editing of IDs
 104                         break;
 105
 106                     case 'org_unit':
 107                         this._buildOrgSelector();
 108                         break;
 109
 110                     case 'money':
 111                         dojo.require('dijit.form.CurrencyTextBox');
 112                         this.widget = new dijit.form.CurrencyTextBox(this.dijitArgs, this.parentNode);
 113                         break;
 114
 115                     case 'timestamp':
 116                         dojo.require('dijit.form.DateTextBox');
 117                         dojo.require('dojo.date.stamp');
 118                         this.widget = new dijit.form.DateTextBox(this.dijitArgs, this.parentNode);
 119                         if(this.widgetValue != null)
 120                             this.widgetValue = dojo.date.stamp.fromISOString(this.widgetValue);
 121                         break;
 122
 123                     case 'bool':
 124                         dojo.require('dijit.form.CheckBox');
 125                         this.widget = new dijit.form.CheckBox(this.dijitArgs, this.parentNode);
 126                         this.widgetValue = openils.Util.isTrue(this.widgetValue);
 127                         break;
 128
 129                     case 'link':
 130                         if(this._buildLinkSelector()) break;
 131
 132                     default:
 133                         dojo.require('dijit.form.TextBox');
 134                         this.widget = new dijit.form.TextBox(this.dijitArgs, this.parentNode);
 135                 }
 136             }
 137
 138             if(!this.async) this._widgetLoaded();
 139             return this.widget;
 140         },
 141
 142         _buildLinkSelector : function() {
 143
 144             /* verify we can and should grab the related class */
 145             var linkClass = this.idlField['class'];
 146             if(this.idlField.reltype != 'has_a')  return false;
 147             if(!fieldmapper.IDL.fmclasses[linkClass].permacrud) return false;
 148             if(!fieldmapper.IDL.fmclasses[linkClass].permacrud.retrieve) return false;
 149
 150             dojo.require('openils.PermaCrud');
 151             dojo.require('dojo.data.ItemFileReadStore');
 152             dojo.require('dijit.form.FilteringSelect');
 153
 154             var self = this;
 155             this.async = true;
 156             this.widget = new dijit.form.FilteringSelect(this.dijitArgs, this.parentNode);
 157             var rclassIdl = fieldmapper.IDL.fmclasses[linkClass];
 158             var vfield;
 159
 160             for(var f in rclassIdl.fields) {
 161                 if(self.idlField.key == rclassIdl.fields[f].name) {
 162                     vfield = rclassIdl.fields[f];
 163                     break;
 164                 }
 165             }
 166
 167             this.widget.searchAttr = this.widget.labelAttr = vfield.selector || vfield.name;
 168             this.widget.valueAttr = vfield.name;
 169
 170             new openils.PermaCrud().retrieveAll(linkClass, {
 171                 async : true,
 172                 oncomplete : function(r) {
 173                     var list = openils.Util.readResponse(r, false, true);
 174                     if(list) {
 175                         self.widget.store =
 176                             new dojo.data.ItemFileReadStore({data:fieldmapper[linkClass].toStoreData(list)});
 177                     }
 178                     self.widget.startup();
 179                     self._widgetLoaded();
 180                 }
 181             });
 182
 183             return true;
 184         },
 185
 186         /**
 187          * For widgets that run asynchronously, provide a callback for finishing up
 188          */
 189         _widgetLoaded : function(value) {
 190             if(this.readOnly) {
 191                 this.baseWidgetValue(this.getDisplayString());
 192             } else {
 193                 this.baseWidgetValue(this.widgetValue);
 194                 if(this.idlField.name == this.fmIDL.pkey && this.fmIDL.pkey_sequence)
 195                     this.widget.attr('disabled', true);
 196             }
 197             if(this.onload)
 198                 this.onload(this.widget, self);
 199         },
 200
 201         _buildOrgSelector : function() {
 202             dojo.require('fieldmapper.OrgUtils');
 203             dojo.require('openils.widget.FilteringTreeSelect');
 204             this.widget = new openils.widget.FilteringTreeSelect(this.dijitArgs, this.parentNode);
 205             this.widget.searchAttr = 'shortname';
 206             this.widget.labelAttr = 'shortname';
 207             this.widget.parentField = 'parent_ou';
 208
 209             // if we have a limit perm, find the relevent orgs (async)
 210             if(this.orgLimitPerms && this.orgLimitPerms.length > 0) {
 211                 this.async = true;
 212                 var user = new openils.User();
 213                 var self = this;
 214                 user.getPermOrgList(this.orgLimitPerms,
 215                     function(orgList) {
 216                         self.widget.tree = orgList;
 217                         self.widget.startup();
 218                         self._widgetLoaded();
 219                     }
 220                 );
 221
 222             } else {
 223                 this.widget.tree = fieldmapper.aou.globalOrgTree;
 224                 this.widget.startup();
 225             }
 226         }
 227     });
 228 }
 229