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

   1 if(!dojo._hasResource["fieldmapper.IDL"]) {
   2     dojo._hasResource['fieldmapper.IDL'] = true;
   3     dojo.require("DojoSRF");
   4     dojo.provide("fieldmapper.IDL");
   5     dojo.declare('fieldmapper.IDL', null, {
   6
   7         _URL_PATH : '/reports/fm_IDL.xml',
   8         NS_REPORTS : 'http://open-ils.org/spec/opensrf/IDL/reporter/v1',
   9         NS_PERSIST : 'http://open-ils.org/spec/opensrf/IDL/persistence/v1',
  10         NS_OBJ : 'http://open-ils.org/spec/opensrf/IDL/objects/v1',
  11
  12         constructor : function(classlist) {
  13
  14             var preload = [];
  15             if (window._preload_fieldmapper_IDL) {
  16                 if (!fieldmapper.IDL.fmclasses) fieldmapper.IDL.fmclasses = {};
  17                 if (!window.fmclasses) window.fmclasses = {};
  18
  19                 for (var c in window._preload_fieldmapper_IDL) {
  20                     preload.push(c);
  21                     fieldmapper.IDL.fmclasses[c] = window._preload_fieldmapper_IDL[c];
  22
  23                     window.fmclasses[c] = [];
  24                     dojo.forEach(fieldmapper.IDL.fmclasses[c].fields, function(obj){ window.fmclasses[c].push(obj.name); });
  25
  26                     if (classlist && classlist.length)
  27                         classlist = dojo.filter(classlist, function(x){return x != c;});
  28                 }
  29
  30                 fieldmapper.IDL.loaded = true;
  31                 window._preload_fieldmapper_IDL = null;
  32             }
  33
  34             if(!fieldmapper.IDL.fmclasses ||
  35                     !Object.keys(fieldmapper.IDL.fmclasses).length ||
  36                     (classlist && classlist.length)) {
  37
  38                 var idl_url = this._URL_PATH;
  39
  40                 if (classlist.length && (classlist.length > 1 || classlist[0] != '*')) {
  41                     idl_url += '?';
  42
  43                     for (var i = 0; i < classlist.length; i++) {
  44                         var trim_class = classlist[i];
  45                         if (!trim_class) continue;
  46                         if (fieldmapper.IDL.fmclasses && fieldmapper.IDL.fmclasses[trim_class]) continue;
  47
  48                         if (i > 0) idl_url += '&';
  49                         idl_url += 'class=' + trim_class;
  50                     }
  51                 }
  52
  53                 if( !idl_url.match(/\?$/) ) { // make sure we have classes that need loading
  54
  55                     var self = this;
  56                     dojo.xhrGet({
  57                         url : idl_url,
  58                         handleAs : 'xml',
  59                         sync : true,
  60                         timeout : 10000,
  61                         headers : {"Accept-Language": OpenSRF.locale},
  62                         load : function (response) {
  63                             self._parse(response);
  64                             fieldmapper.IDL.loaded = true;
  65                         },
  66                         error : function (response) {
  67                             fieldmapper.IDL.loaded = false;
  68                             dojo.require('fieldmapper.fmall', true);
  69                         }
  70                     });
  71                 }
  72             }
  73             dojo.require('fieldmapper.Fieldmapper');
  74
  75             if (preload.length)
  76                 dojo.forEach( classlist, function (c) { fieldmapper.vivicateClass(c); } );
  77
  78             if (classlist && classlist.length)
  79                 dojo.forEach( classlist, function (c) { fieldmapper.vivicateClass(c); } );
  80         },
  81
  82         _parse : function(xmlNode) {
  83             var classes = dojo.query('class',xmlNode);
  84             if (!fieldmapper.IDL || !fieldmapper.IDL.fmclasses)
  85                 fieldmapper.IDL.fmclasses = {};
  86
  87             for(var i = 0; i < classes.length; i++) {
  88                 var node = classes[i];
  89                 var id = node.getAttribute('id');
  90                 var fields = dojo.query('fields',node)[0];
  91                 window.fmclasses[id] = [];
  92
  93                 var fieldData = this._parseFields(node, id);
  94
  95                 var obj = {
  96                     fields  : fieldData.list,
  97                     field_map : fieldData.map,
  98                     name    : node.getAttribute('id'),
  99                     //table   : fieldmapper._getAttributeNS(node,this.NS_PERSIST, 'tablename'),
 100                     //core    : fieldmapper._getAttributeNS(node,this.NS_REPORTS, 'core'),
 101                     label   : fieldmapper._getAttributeNS(node,this.NS_REPORTS, 'label'),
 102                     restrict_primary   : fieldmapper._getAttributeNS(node,this.NS_PERSIST, 'restrict_primary'),
 103                     virtual : (fieldmapper._getAttributeNS(node,this.NS_PERSIST, 'virtual') == 'true'),
 104                     pkey    : fieldmapper._getAttributeNS(fields,this.NS_PERSIST, 'primary'),
 105                     pkey_sequence : fieldmapper._getAttributeNS(fields,this.NS_PERSIST, 'sequence')
 106                 };
 107
 108                 var valid = fieldmapper._getAttributeNS(node,this.NS_OBJ, 'validate');
 109                 if (valid) obj.validate = new RegExp( valid.replace(/\\/g, '\\\\') );
 110
 111                 var permacrud = dojo.query('permacrud',node)[0];
 112                 if(permacrud) {
 113                     var actions = ['create', 'retrieve', 'update', 'delete'];
 114                     obj.permacrud = {};
 115                     for(var idx in actions) {
 116                         var action = actions[idx];
 117                         var pnode = dojo.query(action,permacrud)[0];
 118                         if(pnode) {
 119                             var permString = pnode.getAttribute('permission');
 120                             var permList = null;
 121                             if(permString)
 122                                 permList = (permString.match(/ /)) ? permString.split(' ') : [permString];
 123
 124                             var contextString = pnode.getAttribute('context_field');
 125                             var contextList = null;
 126                             if(contextString)
 127                                 contextList = (contextString.match(/ /)) ? contextString.split(' ') : [contextString];
 128
 129                             obj.permacrud[action] = {
 130                                 perms : permList,
 131                                 localContextFields : contextList // need to add foreign context fields
 132                             }; // add more details as necessary
 133                         }
 134                     }
 135                 }
 136
 137                 obj.core = (obj.core == 'true');
 138                 obj.label = (obj.label) ? obj.label : obj.name;
 139                 fieldmapper.IDL.fmclasses[id] = obj;
 140             }
 141
 142         },
 143
 144         /* parses the links and fields portion of the IDL */
 145         _parseFields : function(node, classname) {
 146             var data = [];
 147             var map = {};
 148
 149             var fields = dojo.query('fields',node)[0];
 150             fields = dojo.query('field',fields);
 151
 152             var links = dojo.query('links',node)[0];
 153             if( links ) links = dojo.query('link',links);
 154             else links = [];
 155
 156
 157             var position = 0;
 158             for(var i = 0; i < fields.length; i++) {
 159                 var field = fields[i];
 160                 var name = field.getAttribute('name');
 161
 162                 if(name == 'isnew' || name == 'ischanged' || name == 'isdeleted')
 163                     continue;
 164
 165                 var obj = {
 166                     field : field,
 167                     name : name,
 168                     label : fieldmapper._getAttributeNS(field,this.NS_REPORTS,'label'),
 169                     datatype : fieldmapper._getAttributeNS(field,this.NS_REPORTS,'datatype'),
 170                     primitive : fieldmapper._getAttributeNS(field,this.NS_PERSIST,'primitive'),
 171                     selector : fieldmapper._getAttributeNS(field,this.NS_REPORTS,'selector'),
 172                     array_position : position++,
 173                     type : 'field',
 174                     virtual : (fieldmapper._getAttributeNS(fields[i],this.NS_PERSIST, 'virtual') == 'true'),
 175                     required : (fieldmapper._getAttributeNS(fields[i],this.NS_OBJ, 'required') == 'true'),
 176                     i18n : (fieldmapper._getAttributeNS(fields[i],this.NS_PERSIST, 'i18n') == 'true')
 177                 };
 178
 179                 obj.label = obj.label || obj.name;
 180                 obj.datatype = obj.datatype || 'text';
 181
 182                 window.fmclasses[classname].push(obj.name);
 183
 184                 var link = null;
 185                 for(var l = 0; l < links.length; l++) {
 186                     if(links[l].getAttribute('field') == name) {
 187                         link = links[l];
 188                         break;
 189                     }
 190                 }
 191
 192                 if(link) {
 193                     obj.type = 'link';
 194                     obj.key = link.getAttribute('key');
 195                     obj['class'] = link.getAttribute('class');
 196                     obj.reltype = link.getAttribute('reltype');
 197                 }
 198
 199                 data.push(obj);
 200                 map[obj.name] = obj;
 201             }
 202
 203             dojo.forEach(['isnew', 'ischanged', 'isdeleted'],
 204                 function(name) {
 205                     var obj = {
 206                         name : name,
 207                         array_position : position++,
 208                         type : 'field',
 209                         virtual : true
 210                     };
 211                     data.push(obj);
 212                     map[obj.name] = obj;
 213                 }
 214             );
 215
 216             return { list : data, map : map };
 217         }
 218
 219     });
 220
 221     fieldmapper._getAttributeNS = function (node,ns,attr) {
 222         if (node.getAttributeNS) return node.getAttributeNS(ns,attr);
 223         return node.getAttribute(attr);
 224     };
 225
 226     window.fmclasses = {};
 227     fieldmapper.IDL.load = function (list) {
 228         if (!list) list = [];
 229         return new fieldmapper.IDL(list);
 230     };
 231     fieldmapper.IDL.loaded = false;
 232
 233     JSON2js.fallbackObjectifier = function (arg, key_name, val_name) {
 234         console.log("Firing IDL loader for " + arg[key_name]);
 235         fieldmapper.IDL.load([arg[key_name]]);
 236         return decodeJS(arg);
 237     };
 238
 239 }
 240