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