Open-ILS/src/c-apps/oils_idl-core.c

   1 #include "oils_idl.h"
   2
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <libxml/globals.h>
   6 #include <libxml/xmlerror.h>
   7 #include <libxml/parser.h>
   8 #include <libxml/tree.h>
   9 #include <libxml/debugXML.h>
  10 #include <libxml/xmlmemory.h>
  11
  12 #define PERSIST_NS "http://open-ils.org/spec/opensrf/IDL/persistence/v1"
  13 #define OBJECT_NS "http://open-ils.org/spec/opensrf/IDL/objects/v1"
  14 #define BASE_NS "http://opensrf.org/spec/IDL/base/v1"
  15
  16 xmlDocPtr idlDoc = NULL; // parse and store the IDL here
  17
  18 /* parse and store the IDL here */
  19 osrfHash* idlHash;
  20
  21 osrfHash* oilsIDL() { return idlHash; }
  22 osrfHash* oilsIDLInit( char* idl_filename ) {
  23
  24         if (idlHash) return idlHash;
  25
  26         char* string_tmp = NULL;
  27
  28         idlHash = osrfNewHash();
  29         osrfHash* usrData = NULL;
  30
  31         osrfLogInfo(OSRF_LOG_MARK, "Parsing the IDL XML...");
  32         idlDoc = xmlReadFile( idl_filename, NULL, XML_PARSE_XINCLUDE );
  33
  34         if (!idlDoc) {
  35                 osrfLogError(OSRF_LOG_MARK, "Could not load or parse the IDL XML file!");
  36                 return NULL;
  37         }
  38
  39         osrfLogDebug(OSRF_LOG_MARK, "Initializing the Fieldmapper IDL...");
  40
  41         xmlNodePtr docRoot = xmlDocGetRootElement(idlDoc);
  42         xmlNodePtr kid = docRoot->children;
  43         while (kid) {
  44                 if (!strcmp( (char*)kid->name, "class" )) {
  45
  46                         usrData = osrfNewHash();
  47                         osrfHashSet( usrData, xmlGetProp(kid, BAD_CAST "id"), "classname");
  48                         osrfHashSet( usrData, xmlGetNsProp(kid, BAD_CAST "fieldmapper", BAD_CAST OBJECT_NS), "fieldmapper");
  49                         osrfHashSet( usrData, xmlGetNsProp(kid, BAD_CAST "readonly", BAD_CAST PERSIST_NS), "readonly");
  50
  51                         osrfHashSet( idlHash, usrData, (char*)osrfHashGet(usrData, "classname") );
  52
  53                         string_tmp = NULL;
  54                         if ((string_tmp = (char*)xmlGetNsProp(kid, BAD_CAST "tablename", BAD_CAST PERSIST_NS))) {
  55                                 osrfLogDebug(OSRF_LOG_MARK, "Using table '%s' for class %s", string_tmp, osrfHashGet(usrData, "classname") );
  56                                 osrfHashSet(
  57                                         usrData,
  58                                         strdup( string_tmp ),
  59                                         "tablename"
  60                                 );
  61                         }
  62
  63                         string_tmp = NULL;
  64                         if ((string_tmp = (char*)xmlGetNsProp(kid, BAD_CAST "virtual", BAD_CAST PERSIST_NS))) {
  65                                 osrfHashSet(
  66                                         usrData,
  67                                         strdup( string_tmp ),
  68                                         "virtual"
  69                                 );
  70                         }
  71
  72                         osrfStringArray* controller = osrfNewStringArray(0);
  73                         string_tmp = NULL;
  74                         if( (string_tmp = (char*)xmlGetProp(kid, BAD_CAST "controller") )) {
  75                                 char* controller_list = strdup( string_tmp );
  76                                 osrfLogDebug(OSRF_LOG_MARK, "Controller list is %s", string_tmp );
  77
  78                                 if (strlen( controller_list ) > 0) {
  79                                         char* st_tmp;
  80                                         char* _controller_class = strtok_r(controller_list, " ", &st_tmp);
  81                                         osrfStringArrayAdd(controller, strdup(_controller_class));
  82
  83                                         while ((_controller_class = strtok_r(NULL, " ", &st_tmp))) {
  84                                                 osrfStringArrayAdd(controller, strdup(_controller_class));
  85                                         }
  86                                 }
  87                         }
  88                         osrfHashSet( usrData, controller, "controller");
  89
  90
  91                         osrfHash* _tmp;
  92                         osrfHash* links = osrfNewHash();
  93                         osrfHash* fields = osrfNewHash();
  94
  95                         osrfHashSet( usrData, fields, "fields" );
  96                         osrfHashSet( usrData, links, "links" );
  97
  98                         xmlNodePtr _cur = kid->children;
  99
 100                         while (_cur) {
 101
 102                                 if (!strcmp( (char*)_cur->name, "fields" )) {
 103
 104                                         string_tmp = NULL;
 105                                         if( (string_tmp = (char*)xmlGetNsProp(_cur, BAD_CAST "primary", BAD_CAST PERSIST_NS)) ) {
 106                                                 osrfHashSet(
 107                                                         usrData,
 108                                                         strdup( string_tmp ),
 109                                                         "primarykey"
 110                                                 );
 111                                         }
 112
 113                                         string_tmp = NULL;
 114                                         if( (string_tmp = (char*)xmlGetNsProp(_cur, BAD_CAST "sequence", BAD_CAST PERSIST_NS)) ) {
 115                                                 osrfHashSet(
 116                                                         usrData,
 117                                                         strdup( string_tmp ),
 118                                                         "sequence"
 119                                                 );
 120                                         }
 121
 122                                         xmlNodePtr _f = _cur->children;
 123
 124                                         while(_f) {
 125                                                 if (strcmp( (char*)_f->name, "field" )) {
 126                                                         _f = _f->next;
 127                                                         continue;
 128                                                 }
 129
 130                                                 _tmp = osrfNewHash();
 131
 132                                                 string_tmp = NULL;
 133                                                 if( (string_tmp = (char*)xmlGetNsProp(_f, BAD_CAST "array_position", BAD_CAST OBJECT_NS)) ) {
 134                                                         osrfHashSet(
 135                                                                 _tmp,
 136                                                                 strdup( string_tmp ),
 137                                                                 "array_position"
 138                                                         );
 139                                                 }
 140
 141                                                 string_tmp = NULL;
 142                                                 if( (string_tmp = (char*)xmlGetNsProp(_f, BAD_CAST "virtual", BAD_CAST PERSIST_NS)) ) {
 143                                                         osrfHashSet(
 144                                                                 _tmp,
 145                                                                 strdup( string_tmp ),
 146                                                                 "virtual"
 147                                                         );
 148                                                 }
 149
 150                                                 string_tmp = NULL;
 151                                                 if( (string_tmp = (char*)xmlGetNsProp(_f, BAD_CAST "primitive", BAD_CAST PERSIST_NS)) ) {
 152                                                         osrfHashSet(
 153                                                                 _tmp,
 154                                                                 strdup( string_tmp ),
 155                                                                 "primitive"
 156                                                         );
 157                                                 }
 158
 159                                                 string_tmp = NULL;
 160                                                 if( (string_tmp = (char*)xmlGetProp(_f, BAD_CAST "name")) ) {
 161                                                         osrfHashSet(
 162                                                                 _tmp,
 163                                                                 strdup( string_tmp ),
 164                                                                 "name"
 165                                                         );
 166                                                 }
 167
 168                                                 osrfLogDebug(OSRF_LOG_MARK, "Found field %s for class %s", string_tmp, osrfHashGet(usrData, "classname") );
 169
 170                                                 osrfHashSet(
 171                                                         fields,
 172                                                         _tmp,
 173                                                         strdup( string_tmp )
 174                                                 );
 175                                                 _f = _f->next;
 176                                         }
 177                                 }
 178
 179                                 if (!strcmp( (char*)_cur->name, "links" )) {
 180                                         xmlNodePtr _l = _cur->children;
 181
 182                                         while(_l) {
 183                                                 if (strcmp( (char*)_l->name, "link" )) {
 184                                                         _l = _l->next;
 185                                                         continue;
 186                                                 }
 187
 188                                                 _tmp = osrfNewHash();
 189
 190                                                 string_tmp = NULL;
 191                                                 if( (string_tmp = (char*)xmlGetProp(_l, BAD_CAST "reltype")) ) {
 192                                                         osrfHashSet(
 193                                                                 _tmp,
 194                                                                 strdup( string_tmp ),
 195                                                                 "reltype"
 196                                                         );
 197                                                 }
 198                                                 osrfLogDebug(OSRF_LOG_MARK, "Adding link with reltype %s", string_tmp );
 199
 200                                                 string_tmp = NULL;
 201                                                 if( (string_tmp = (char*)xmlGetProp(_l, BAD_CAST "key")) ) {
 202                                                         osrfHashSet(
 203                                                                 _tmp,
 204                                                                 strdup( string_tmp ),
 205                                                                 "key"
 206                                                         );
 207                                                 }
 208                                                 osrfLogDebug(OSRF_LOG_MARK, "Link fkey is %s", string_tmp );
 209
 210                                                 string_tmp = NULL;
 211                                                 if( (string_tmp = (char*)xmlGetProp(_l, BAD_CAST "class")) ) {
 212                                                         osrfHashSet(
 213                                                                 _tmp,
 214                                                                 strdup( string_tmp ),
 215                                                                 "class"
 216                                                         );
 217                                                 }
 218                                                 osrfLogDebug(OSRF_LOG_MARK, "Link fclass is %s", string_tmp );
 219
 220                                                 osrfStringArray* map = osrfNewStringArray(0);
 221
 222                                                 string_tmp = NULL;
 223                                                 if( (string_tmp = (char*)xmlGetProp(_l, BAD_CAST "map") )) {
 224                                                         char* map_list = strdup( string_tmp );
 225                                                         osrfLogDebug(OSRF_LOG_MARK, "Link mapping list is %s", string_tmp );
 226
 227                                                         if (strlen( map_list ) > 0) {
 228                                                                 char* st_tmp;
 229                                                                 char* _map_class = strtok_r(map_list, " ", &st_tmp);
 230                                                                 osrfStringArrayAdd(map, strdup(_map_class));
 231
 232                                                                 while ((_map_class = strtok_r(NULL, " ", &st_tmp))) {
 233                                                                         osrfStringArrayAdd(map, strdup(_map_class));
 234                                                                 }
 235                                                         }
 236                                                 }
 237                                                 osrfHashSet( _tmp, map, "map");
 238
 239                                                 string_tmp = NULL;
 240                                                 if( (string_tmp = (char*)xmlGetProp(_l, BAD_CAST "field")) ) {
 241                                                         osrfHashSet(
 242                                                                 _tmp,
 243                                                                 strdup( string_tmp ),
 244                                                                 "field"
 245                                                         );
 246                                                 }
 247
 248                                                 osrfHashSet(
 249                                                         links,
 250                                                         _tmp,
 251                                                         strdup( string_tmp )
 252                                                 );
 253
 254                                                 osrfLogDebug(OSRF_LOG_MARK, "Found link %s for class %s", string_tmp, osrfHashGet(usrData, "classname") );
 255
 256                                                 _l = _l->next;
 257                                         }
 258                                 }
 259
 260                                 if (!strcmp( (char*)_cur->name, "source_definition" )) {
 261                                         string_tmp = NULL;
 262                                         if( (string_tmp = (char*)xmlNodeGetContent(_cur)) ) {
 263                                                 osrfLogDebug(OSRF_LOG_MARK, "Using source definion '%s' for class %s", string_tmp, osrfHashGet(usrData, "classname") );
 264                                                 osrfHashSet(
 265                                                         usrData,
 266                                                         strdup( string_tmp ),
 267                                                         "source_definition"
 268                                                 );
 269                                         }
 270
 271                                 }
 272
 273                                 _cur = _cur->next;
 274                         }
 275                 }
 276
 277                 kid = kid->next;
 278         }
 279
 280         osrfLogInfo(OSRF_LOG_MARK, "...IDL XML parsed");
 281
 282         return idlHash;
 283 }
 284
 285 osrfHash* oilsIDLFindPath( char* path, ... ) {
 286         if(!path || strlen(path) < 1) return NULL;
 287
 288         osrfHash* obj = idlHash;
 289
 290         VA_LIST_TO_STRING(path);
 291         char* buf = VA_BUF;
 292
 293         char* token = NULL;
 294         char* t = buf;
 295         char* tt;
 296
 297         token = strtok_r(t, "/", &tt);
 298         if(!token) return NULL;
 299
 300         do {
 301                 obj = osrfHashGet(obj, token);
 302         } while( (token = strtok_r(NULL, "/", &tt)) && obj);
 303
 304         return obj;
 305 }
 306
 307 int oilsIDL_classIsFieldmapper ( char* classname ) {
 308         if (!classname) return 0;
 309         if(oilsIDLFindPath( "/%s", classname )) return 1;
 310         return 0;
 311 }
 312
 313 int oilsIDL_ntop (char* classname, char* fieldname) {
 314         osrfHash* _pos = NULL;
 315
 316         if (!oilsIDL_classIsFieldmapper(classname)) return -1;
 317         _pos = oilsIDLFindPath( "/%s/fields/%s", classname, fieldname );
 318         if (_pos) return atoi( osrfHashGet(_pos, "array_position") );
 319         return -1;
 320 }
 321
 322 char * oilsIDL_pton (char* classname, int pos) {
 323         char* ret = NULL;
 324         osrfHash* f = NULL;
 325         osrfHash* fields = NULL;
 326         osrfHashIterator* itr = NULL;
 327
 328         if (!oilsIDL_classIsFieldmapper(classname)) return NULL;
 329
 330         fields = oilsIDLFindPath( "/%s/fields", classname );
 331         itr = osrfNewHashIterator( fields );
 332
 333         while ( (f = osrfHashIteratorNext( itr )) ) {
 334                 if ( atoi(osrfHashGet(f, "array_position")) == pos ) {
 335                         ret = strdup(itr->current);
 336                         break;
 337                 }
 338         }
 339
 340         osrfHashIteratorFree( itr );
 341
 342         return ret;
 343 }
 344