Open-ILS/web/js/dojo/fieldmapper/Fieldmapper.js

   1 /*
   2 # ---------------------------------------------------------------------------
   3 # Copyright (C) 2008  Georgia Public Library Service / Equinox Software, Inc
   4 # Mike Rylander <miker@esilibrary.com>
   5 #
   6 # This program is free software; you can redistribute it and/or
   7 # modify it under the terms of the GNU General Public License
   8 # as published by the Free Software Foundation; either version 2
   9 # of the License, or (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 # ---------------------------------------------------------------------------
  16 */
  17
  18 if(!dojo._hasResource["fieldmapper.Fieldmapper"]){
  19     dojo._hasResource["fieldmapper.Fieldmapper"] = true;
  20
  21     dojo.provide("fieldmapper.Fieldmapper");
  22     dojo.require("DojoSRF");
  23
  24
  25 /* generate fieldmapper javascript classes.  This expects a global variable
  26     called 'fmclasses' to be fleshed with the classes we need to build */
  27
  28     function FMEX(message) { this.message = message; }
  29     FMEX.toString = function() { return "FieldmapperException: " + this.message + "\n"; };
  30
  31     dojo.declare( "fieldmapper.Fieldmapper", null, {
  32
  33         constructor : function (initArray) {
  34             if (initArray) {
  35                 if (dojo.isArray(initArray)) {
  36                     this.a = initArray;
  37                 } else {
  38                     this.a = [];
  39                 }
  40             }
  41         },
  42
  43         _isfieldmapper : true,
  44
  45         clone : function() {
  46             var obj = new this.constructor();
  47
  48             for( var i in this.a ) {
  49                 var thing = this.a[i];
  50                 if(thing === null) continue;
  51
  52                 if( thing._isfieldmapper ) {
  53                     obj.a[i] = thing.clone();
  54                 } else {
  55
  56                     if(dojo.isArray(thing)) {
  57                         obj.a[i] = [];
  58
  59                         for( var j in thing ) {
  60
  61                             if( thing[j]._isfieldmapper )
  62                                 obj.a[i][j] = thing[j].clone();
  63                             else
  64                                 obj.a[i][j] = thing[j];
  65                         }
  66                     } else {
  67                         obj.a[i] = thing;
  68                     }
  69                 }
  70             }
  71             return obj;
  72         },
  73
  74         RequiredField : function (f) {
  75             if (!f) return;
  76             if (fieldmapper.IDL && fieldmapper.IDL.loaded)
  77                 return this.Structure.fields[f].required;
  78             return;
  79         },
  80
  81         ValidateField : function (f) {
  82             if (!f) return;
  83             if (fieldmapper.IDL && fieldmapper.IDL.loaded) {
  84                 if (this.Structure.fields[f] && this.Structure.fields[f].validate) {
  85                     return this.Structure.fields[f].validate.test(this[f]());
  86                 }
  87                 return true;
  88             }
  89             return;
  90         },
  91
  92         toString : function() {
  93             /* ever so slightly aid debugging */
  94             if (this.classname)
  95                 return "[object fieldmapper." + this.classname + "]";
  96             else
  97                 return Object.prototype.toString();
  98         }
  99
 100     });
 101
 102
 103     fieldmapper.vivicateClass = function (cl) {
 104         dojo.provide( cl );
 105         dojo.declare( cl , fieldmapper.Fieldmapper, {
 106             constructor : function () {
 107                 if (!this.a) this.a = [];
 108                 this.classname = this.declaredClass;
 109                 this._fields = [];
 110
 111                 var p, f;
 112                 if (fieldmapper.IDL && fieldmapper.IDL.loaded) {
 113                     this.Structure = fieldmapper.IDL.fmclasses[this.classname];
 114
 115                     var array_pos = 0;
 116                     for (f in fieldmapper.IDL.fmclasses[this.classname].fields) {
 117                         var field = fieldmapper.IDL.fmclasses[this.classname].fields[f];
 118                         p = array_pos++;
 119                         this._fields.push( field.name );
 120                         this[field.name]=new Function('n', 'if(arguments.length==1)this.a['+p+']=n;return this.a['+p+'];');
 121                     }
 122                 } else {
 123                     this._fields = fmclasses[this.classname];
 124
 125                     for( var pos = 0; pos <  this._fields.length; pos++ ) {
 126                         p = parseInt(pos, 10);
 127                         f = this._fields[pos];
 128                         this[f]=new Function('n', 'if(arguments.length==1)this.a['+p+']=n;return this.a['+p+'];');
 129                     }
 130                 }
 131
 132             }
 133         });
 134
 135         fieldmapper[cl] = window[cl]; // alias into place
 136
 137         if (fieldmapper.IDL && fieldmapper.IDL.loaded)
 138             fieldmapper[cl].Identifier = fieldmapper.IDL.fmclasses[cl].pkey;
 139
 140         fieldmapper[cl].prototype.fromStoreItem = _fromStoreItem;
 141         fieldmapper[cl].toStoreData = _toStoreData;
 142         fieldmapper[cl].toStoreItem = _toStoreItem;
 143         fieldmapper[cl].prototype.toStoreItem = function ( args ) { return _toStoreItem(this, args); };
 144         fieldmapper[cl].initStoreData = _initStoreData;
 145         fieldmapper[cl].prototype.toHash = _toHash;
 146         fieldmapper[cl].toHash = _toHash;
 147         fieldmapper[cl].prototype.fromHash = _fromHash;
 148         fieldmapper[cl].fromHash = _fromHash;
 149     };
 150
 151     fieldmapper._request = function ( meth, staff, params ) {
 152         var ses = OpenSRF.CachedClientSession( meth[0] );
 153         if (!ses) return null;
 154
 155         var result = null;
 156         var args = {};
 157
 158         if (dojo.isArray(params)) {
 159             args.params = params;
 160         } else {
 161
 162             if (dojo.isObject(params)) {
 163                 args = params;
 164             } else {
 165                 args.params = [].splice.call(arguments, 2, arguments.length - 2);
 166             }
 167
 168         }
 169
 170         if (!args.async && !args.timeout) args.timeout = 10;
 171
 172         if(!args.onmethoderror) {
 173             args.onmethoderror = function(r, stat, stat_text) {
 174                 throw new Error('Method error: ' + r.stat + ' : ' + stat_text);
 175             };
 176             }
 177
 178         if(!args.ontransporterror) {
 179             args.ontransporterror = function(xreq) {
 180                 throw new Error('Transport error method='+args.method+', status=' + xreq.status);
 181             };
 182             }
 183
 184         if (!args.onerror) {
 185             args.onerror = function (r) {
 186                 throw new Error('Request error encountered! ' + r);
 187             };
 188             }
 189
 190         if (!args.oncomplete) {
 191             args.oncomplete = function (r) {
 192                 var x = r.recv();
 193                 if (x) result = x.content();
 194             };
 195             }
 196
 197         args.method = meth[1];
 198         if (staff && meth[2]) args.method += '.staff';
 199
 200         ses.request(args).send();
 201
 202         return result;
 203     };
 204
 205     fieldmapper.standardRequest = function (meth, params) { return fieldmapper._request(meth, false, params); };
 206     fieldmapper.Fieldmapper.prototype.standardRequest = fieldmapper.standardRequest;
 207
 208     fieldmapper.staffRequest = function (meth, params) { return fieldmapper._request(meth, true, params); };
 209     fieldmapper.Fieldmapper.prototype.staffRequest = fieldmapper.staffRequest;
 210
 211     fieldmapper.OpenSRF = {};
 212
 213     /*    Methods are defined as [ service, method, have_staff ]
 214         An optional 3rd component is when a method is followed by true, such methods
 215         have a staff counterpart and should have ".staff" appended to the method
 216         before the method is called when in XUL mode */
 217     fieldmapper.OpenSRF.methods = {
 218         FETCH_ORG_BY_SHORTNAME : ['open-ils.actor','open-ils.actor.org_unit.retrieve_by_shortname'],
 219         FETCH_ORG_SETTING : ['open-ils.actor','open-ils.actor.ou_setting.ancestor_default'],
 220         FETCH_ORG_SETTING_BATCH : ['open-ils.actor','open-ils.actor.ou_setting.ancestor_default.batch']
 221     };
 222
 223
 224     //** FROM HASH **/
 225     function _fromHash (_hash) {
 226         for ( var i=0; i < this._fields.length; i++) {
 227             if (_hash[this._fields[i]] != null)
 228                 this[this._fields[i]]( _hash[this._fields[i]] );
 229         }
 230         return this;
 231     }
 232
 233     function _toHash (includeNulls, virtFields) {
 234         var _hash = {};
 235         var i;
 236         for (i=0; i < this._fields.length; i++) {
 237             if (includeNulls || this[this._fields[i]]() != null) {
 238                 if (this[this._fields[i]]() == null)
 239                     _hash[this._fields[i]] = null;
 240                 else
 241                     _hash[this._fields[i]] = '' + this[this._fields[i]]();
 242             }
 243         }
 244
 245         if (virtFields && virtFields.length > 0) {
 246             for (i = 0; i < virtFields.length; i++) {
 247                 if (!_hash[virtFields[i]])
 248                     _hash[virtFields[i]] = null;
 249             }
 250         }
 251
 252         return _hash;
 253     }
 254     //** FROM HASH **/
 255
 256
 257     /** FROM dojoData **/
 258     function _fromStoreItem (data) {
 259         this.fromHash(data);
 260
 261         var i;
 262         for (i = 0; this._ignore_fields && i < this._ignore_fields.length; i++)
 263             this[this._ignore_fields[i]](null);
 264
 265         for (i = 0; this._fields && i < this._fields.length; i++) {
 266             if (dojo.isArray( this[this._fields[i]]() ))
 267                 this[this._fields[i]]( this[this._fields[i]]()[0] );
 268         }
 269         return this;
 270     }
 271
 272     function _initStoreData(label, params) {
 273         if (!params) params = {};
 274         if (!params.identifier) params.identifier = this.Identifier;
 275         if (!label) label = params.label;
 276         if (!label) label = params.identifier;
 277         return { label : label, identifier : params.identifier, items : [] };
 278     }
 279
 280     function _toStoreItem(fmObj, params) {
 281         if (!params) params = {};
 282         return fmObj.toHash(true, params.virtualFields);
 283     }
 284
 285     function _toStoreData (list, label, params) {
 286         if (!params) params = {};
 287         var data = this.initStoreData(label, params);
 288
 289         var i, j;
 290         for (i = 0; list && i < list.length; i++) data.items.push( list[i].toHash(true, params.virtualFields) );
 291
 292         if (params.children && params.parent) {
 293             var _hash_list = data.items;
 294
 295             var _find_root = {};
 296             for (i = 0; _hash_list && i < _hash_list.length; i++) {
 297                 _find_root[_hash_list[i][params.identifier]] = _hash_list[i];
 298             }
 299
 300             var item_data = [];
 301             for (i = 0; _hash_list && i < _hash_list.length; i++) {
 302                 var obj = _hash_list[i];
 303                 obj[params.children] = [];
 304
 305                 for (j = 0; _hash_list && j < _hash_list.length; j++) {
 306                     var kid = _hash_list[j];
 307                     if (kid[params.parent] == obj[params.identifier]) {
 308                         obj[params.children].push( { _reference : kid[params.identifier] } );
 309                         kid._iskid = true;
 310                         if (_find_root[kid[params.identifier]]) delete _find_root[kid[params.identifier]];
 311                     }
 312                 }
 313
 314                 item_data.push( obj );
 315             }
 316
 317             for (j in _find_root) {
 318                 _find_root[j]['_top'] = 'true';
 319                 if (!_find_root[j][params.parent])
 320                     _find_root[j]['_trueRoot'] = 'true';
 321             }
 322
 323             data.items = item_data;
 324         }
 325
 326         return data;
 327     }
 328     /** FROM dojoData **/
 329
 330
 331
 332     /** ! Begin code that executes on page load */
 333
 334     if (!window.fmclasses) dojo.require("fieldmapper.fmall", true);
 335     for( var cl in fmclasses ) {
 336         fieldmapper.vivicateClass(cl);
 337     }
 338
 339     // if we were NOT called by the IDL loader ...
 340     // XXX This is now deprecated in preference to fieldmapper.AutoIDL
 341     if ( !(fieldmapper.IDL && fieldmapper.IDL.loaded) ) {
 342
 343         fieldmapper.cmsa.Identifier = 'alias';
 344         fieldmapper.cmc.Identifier = 'name';
 345         fieldmapper.i18n_l.Identifier = 'code';
 346         fieldmapper.ccpbt.Identifier = 'code';
 347         fieldmapper.ccnbt.Identifier = 'code';
 348         fieldmapper.cbrebt.Identifier = 'code';
 349         fieldmapper.cubt.Identifier = 'code';
 350         fieldmapper.ccm.Identifier = 'code';
 351         fieldmapper.cvrfm.Identifier = 'code';
 352         fieldmapper.clm.Identifier = 'code';
 353         fieldmapper.cam.Identifier = 'code';
 354         fieldmapper.cifm.Identifier = 'code';
 355         fieldmapper.citm.Identifier = 'code';
 356         fieldmapper.cblvl.Identifier = 'code';
 357         fieldmapper.clfm.Identifier = 'code';
 358         fieldmapper.mous.Identifier = 'usr';
 359         fieldmapper.moucs.Identifier = 'usr';
 360         fieldmapper.mucs.Identifier = 'usr';
 361         fieldmapper.mus.Identifier = 'usr';
 362         fieldmapper.rxbt.Identifier = 'xact';
 363         fieldmapper.rxpt.Identifier = 'xact';
 364         fieldmapper.cxt.Identifier = 'name';
 365         fieldmapper.amtr.Identifier = 'matchpoint';
 366         fieldmapper.coust.Identifier = 'name';
 367
 368     }
 369
 370
 371     /** FROM dojoData **/
 372     /* set up some known class attributes */
 373     if (fieldmapper.aou) fieldmapper.aou.prototype._ignore_fields = ['children'];
 374     if (fieldmapper.aout) fieldmapper.aout.prototype._ignore_fields = ['children'];
 375     if (fieldmapper.pgt) fieldmapper.pgt.prototype._ignore_fields = ['children'];
 376
 377     fieldmapper.aou.toStoreData = function (list, label) {
 378         if (!label) label = 'shortname';
 379         return _toStoreData.call(this, list, label, { 'parent' : 'parent_ou', 'children' : 'children' });
 380     };
 381
 382     fieldmapper.aout.toStoreData = function (list, label) {
 383         if (!label) label = 'name';
 384         return _toStoreData.call(this, list, label, { 'parent' : 'parent', 'children' : 'children' });
 385     };
 386
 387     fieldmapper.pgt.toStoreData = function (list, label) {
 388         if (!label) label = 'name';
 389         return _toStoreData.call(this, list, label, { 'parent' : 'parent', 'children' : 'children' });
 390     };
 391     /** FROM dojoData **/
 392
 393
 394 }
 395
 396
 397