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] = new Array();
  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         });
  93
  94
  95     fieldmapper.vivicateClass = function (cl) {
  96                 dojo.provide( cl );
  97                 dojo.declare( cl , fieldmapper.Fieldmapper, {
  98                         constructor : function () {
  99                                 if (!this.a) this.a = [];
 100                                 this.classname = this.declaredClass;
 101                 this._fields = [];
 102
 103                 if (fieldmapper.IDL && fieldmapper.IDL.loaded) {
 104                     this.Structure = fieldmapper.IDL.fmclasses[this.classname]
 105
 106                     for (var f in fieldmapper.IDL.fmclasses[this.classname].fields) {
 107                         var field = fieldmapper.IDL.fmclasses[this.classname].fields[f];
 108                         var p = field.array_position;
 109                                 this._fields.push( field.name );
 110                                         this[field.name]=new Function('n', 'if(arguments.length==1)this.a['+p+']=n;return this.a['+p+'];');
 111                     }
 112                 } else {
 113                                     this._fields = fmclasses[this.classname];
 114
 115                                 for( var pos = 0; pos <  this._fields.length; pos++ ) {
 116                                         var p = parseInt(pos);
 117                                         var f = this._fields[pos];
 118                                         this[f]=new Function('n', 'if(arguments.length==1)this.a['+p+']=n;return this.a['+p+'];');
 119                                 }
 120                 }
 121
 122                         }
 123                 });
 124
 125                 fieldmapper[cl] = window[cl]; // alias into place
 126
 127         if (fieldmapper.IDL && fieldmapper.IDL.loaded)
 128             fieldmapper[cl].Identifier = fieldmapper.IDL.fmclasses[cl].pkey;
 129
 130         //if (dojo.filter(['aou','aout','pgt'], function(x){return x == cl}).length == 0) {
 131             fieldmapper[cl].prototype.fromStoreItem = _fromStoreItem;
 132             fieldmapper[cl].toStoreData = _toStoreData;
 133             fieldmapper[cl].toStoreItem = _toStoreItem;
 134             fieldmapper[cl].prototype.toStoreItem = function ( args ) { return _toStoreItem(this, args) };
 135             fieldmapper[cl].initStoreData = _initStoreData;
 136             fieldmapper[cl].prototype.toHash = _toHash;
 137             fieldmapper[cl].toHash = _toHash;
 138             fieldmapper[cl].prototype.fromHash = _fromHash;
 139             fieldmapper[cl].fromHash = _fromHash;
 140         //}
 141     };
 142
 143         fieldmapper._request = function ( meth, staff, params ) {
 144                 var ses = OpenSRF.CachedClientSession( meth[0] );
 145                 if (!ses) return null;
 146
 147                 var result = null;
 148                 var args = {};
 149
 150                 if (dojo.isArray(params)) {
 151                         args.params = params;
 152                 } else {
 153
 154                         if (dojo.isObject(params)) {
 155                                 args = params;
 156                         } else {
 157                 args.params = [].splice.call(arguments, 2, arguments.length - 2);
 158                         }
 159
 160                 }
 161
 162         if (!args.async && !args.timeout) args.timeout = 10;
 163
 164         if(!args.onmethoderror) {
 165             args.onmethoderror = function(r, stat, stat_text) {
 166                 throw new Error('Method error: ' + r.stat + ' : ' + stat_text);
 167             }
 168         }
 169
 170         if(!args.ontransporterror) {
 171             args.ontransporterror = function(xreq) {
 172                 throw new Error('Transport error method='+args.method+', status=' + xreq.status);
 173             }
 174         }
 175
 176                 if (!args.onerror) {
 177                         args.onerror = function (r) {
 178                                 throw new Error('Request error encountered! ' + r);
 179                         }
 180                 }
 181
 182                 if (!args.oncomplete) {
 183                         args.oncomplete = function (r) {
 184                                 var x = r.recv();
 185                                 if (x) result = x.content();
 186                         }
 187                 }
 188
 189                 args.method = meth[1];
 190                 if (staff && meth[2]) args.method += '.staff';
 191
 192                 ses.request(args).send();
 193
 194                 return result;
 195         };
 196
 197         fieldmapper.standardRequest = function (meth, params) { return fieldmapper._request(meth, false, params) };
 198         fieldmapper.Fieldmapper.prototype.standardRequest = fieldmapper.standardRequest;
 199
 200         fieldmapper.staffRequest = function (meth, params) { return fieldmapper._request(meth, true, params) };
 201         fieldmapper.Fieldmapper.prototype.staffRequest = fieldmapper.staffRequest;
 202
 203         fieldmapper.OpenSRF = {};
 204
 205         /*      Methods are defined as [ service, method, have_staff ]
 206                 An optional 3rd component is when a method is followed by true, such methods
 207                 have a staff counterpart and should have ".staff" appended to the method
 208                 before the method is called when in XUL mode */
 209         fieldmapper.OpenSRF.methods = {
 210                 FETCH_ORG_BY_SHORTNAME : ['open-ils.actor','open-ils.actor.org_unit.retrieve_by_shortname'],
 211                 FETCH_ORG_SETTING : ['open-ils.actor','open-ils.actor.ou_setting.ancestor_default'],
 212                 FETCH_ORG_SETTING_BATCH : ['open-ils.actor','open-ils.actor.ou_setting.ancestor_default.batch']
 213         };
 214
 215
 216     //** FROM HASH **/
 217         function _fromHash (_hash) {
 218                 for ( var i=0; i < this._fields.length; i++) {
 219                         if (_hash[this._fields[i]] != null)
 220                                 this[this._fields[i]]( _hash[this._fields[i]] );
 221                 }
 222                 return this;
 223         }
 224
 225         function _toHash (includeNulls, virtFields) {
 226                 var _hash = {};
 227                 for ( var i=0; i < this._fields.length; i++) {
 228                         if (includeNulls || this[this._fields[i]]() != null) {
 229                                 if (this[this._fields[i]]() == null)
 230                     _hash[this._fields[i]] = null;
 231                 else
 232                                     _hash[this._fields[i]] = '' + this[this._fields[i]]();
 233             }
 234                 }
 235
 236                 if (virtFields && virtFields.length > 0) {
 237                         for (var i = 0; i < virtFields.length; i++) {
 238                                 if (!_hash[virtFields[i]])
 239                                         _hash[virtFields[i]] = null;
 240                         }
 241                 }
 242
 243                 return _hash;
 244         }
 245     //** FROM HASH **/
 246
 247
 248     /** FROM dojoData **/
 249         function _fromStoreItem (data) {
 250                 this.fromHash(data);
 251
 252                 for (var i = 0; this._ignore_fields && i < this._ignore_fields.length; i++)
 253                         this[this._ignore_fields[i]](null);
 254
 255                 for (var i = 0; this._fields && i < this._fields.length; i++) {
 256                         if (dojo.isArray( this[this._fields[i]]() ))
 257                                 this[this._fields[i]]( this[this._fields[i]]()[0] );
 258                 }
 259                 return this;
 260         }
 261
 262     function _initStoreData(label, params) {
 263                 if (!params) params = {};
 264                 if (!params.identifier) params.identifier = this.Identifier;
 265                 if (!label) label = params.label;
 266                 if (!label) label = params.identifier;
 267                 return { label : label, identifier : params.identifier, items : [] };
 268     }
 269
 270     function _toStoreItem(fmObj, params) {
 271                 if (!params) params = {};
 272         return fmObj.toHash(true, params.virtualFields);
 273     }
 274
 275         function _toStoreData (list, label, params) {
 276                 if (!params) params = {};
 277         var data = this.initStoreData(label, params);
 278
 279                 for (var i = 0; list && i < list.length; i++) data.items.push( list[i].toHash(true, params.virtualFields) );
 280
 281                 if (params.children && params.parent) {
 282                         var _hash_list = data.items;
 283
 284                         var _find_root = {};
 285                         for (var i = 0; _hash_list && i < _hash_list.length; i++) {
 286                                 _find_root[_hash_list[i][params.identifier]] = _hash_list[i];
 287                         }
 288
 289                         var item_data = [];
 290                         for (var i = 0; _hash_list && i < _hash_list.length; i++) {
 291                                 var obj = _hash_list[i]
 292                                 obj[params.children] = [];
 293
 294                                 for (var j = 0; _hash_list && j < _hash_list.length; j++) {
 295                                         var kid = _hash_list[j];
 296                                         if (kid[params.parent] == obj[params.identifier]) {
 297                                                 obj[params.children].push( { _reference : kid[params.identifier] } );
 298                                                 kid._iskid = true;
 299                                                 if (_find_root[kid[params.identifier]]) delete _find_root[kid[params.identifier]];
 300                                         }
 301                                 }
 302
 303                                 item_data.push( obj );
 304                         }
 305
 306                         for (var j in _find_root) {
 307                                 _find_root[j]['_top'] = 'true';
 308                                 if (!_find_root[j][params.parent])
 309                                         _find_root[j]['_trueRoot'] = 'true';
 310                         }
 311
 312                         data.items = item_data;
 313                 }
 314
 315                 return data;
 316         }
 317     /** FROM dojoData **/
 318
 319
 320
 321     /** ! Begin code that executes on page parse */
 322
 323     if (!window.fmclasses) dojo.require("fieldmapper.fmall", true);
 324     for( var cl in fmclasses ) {
 325         fieldmapper.vivicateClass(cl);
 326     }
 327
 328     // if we were NOT called by the IDL loader ...
 329     // XXX This is now deprecated in preference to fieldmapper.AutoIDL
 330     if ( !(fieldmapper.IDL && fieldmapper.IDL.loaded) ) {
 331
 332         fieldmapper.cmsa.Identifier = 'alias';
 333         fieldmapper.cmc.Identifier = 'name';
 334         fieldmapper.i18n_l.Identifier = 'code';
 335         fieldmapper.ccpbt.Identifier = 'code';
 336         fieldmapper.ccnbt.Identifier = 'code';
 337         fieldmapper.cbrebt.Identifier = 'code';
 338         fieldmapper.cubt.Identifier = 'code';
 339         fieldmapper.ccm.Identifier = 'code';
 340         fieldmapper.cvrfm.Identifier = 'code';
 341         fieldmapper.clm.Identifier = 'code';
 342         fieldmapper.cam.Identifier = 'code';
 343         fieldmapper.cifm.Identifier = 'code';
 344         fieldmapper.citm.Identifier = 'code';
 345         fieldmapper.cblvl.Identifier = 'code';
 346         fieldmapper.clfm.Identifier = 'code';
 347         fieldmapper.mous.Identifier = 'usr';
 348         fieldmapper.moucs.Identifier = 'usr';
 349         fieldmapper.mucs.Identifier = 'usr';
 350         fieldmapper.mus.Identifier = 'usr';
 351         fieldmapper.rxbt.Identifier = 'xact';
 352         fieldmapper.rxpt.Identifier = 'xact';
 353         fieldmapper.cxt.Identifier = 'name';
 354         fieldmapper.amtr.Identifier = 'matchpoint';
 355         fieldmapper.coust.Identifier = 'name';
 356
 357     }
 358
 359
 360     /** FROM dojoData **/
 361     /* set up some known class attributes */
 362         if (fieldmapper.aou) fieldmapper.aou.prototype._ignore_fields = ['children'];
 363         if (fieldmapper.aout) fieldmapper.aout.prototype._ignore_fields = ['children'];
 364         if (fieldmapper.pgt) fieldmapper.pgt.prototype._ignore_fields = ['children'];
 365
 366         fieldmapper.aou.toStoreData = function (list, label) {
 367                 if (!label) label = 'shortname';
 368                 return _toStoreData.call(this, list, label, { 'parent' : 'parent_ou', 'children' : 'children' });
 369         }
 370
 371         fieldmapper.aout.toStoreData = function (list, label) {
 372                 if (!label) label = 'name';
 373                 return _toStoreData.call(this, list, label, { 'parent' : 'parent', 'children' : 'children' });
 374         }
 375
 376         fieldmapper.pgt.toStoreData = function (list, label) {
 377                 if (!label) label = 'name';
 378                 return _toStoreData.call(this, list, label, { 'parent' : 'parent', 'children' : 'children' });
 379         }
 380     /** FROM dojoData **/
 381
 382
 383 }
 384
 385
 386