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/persistance/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         osrfLogInfo(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, "id"), "classname");
  48                         osrfHashSet( usrData, xmlGetNsProp(kid, "fieldmapper", OBJECT_NS), "fieldmapper");
  49
  50                         osrfHashSet( idlHash, usrData, (char*)osrfHashGet(usrData, "classname") );
  51
  52                         string_tmp = NULL;
  53                         if ((string_tmp = (char*)xmlGetNsProp(kid, "tablename", PERSIST_NS))) {
  54                                 osrfHashSet(
  55                                         usrData,
  56                                         strdup( string_tmp ),
  57                                         "tablename"
  58                                 );
  59                         }
  60
  61                         string_tmp = NULL;
  62                         if ((string_tmp = (char*)xmlGetNsProp(kid, "virtual", PERSIST_NS))) {
  63                                 osrfHashSet(
  64                                         usrData,
  65                                         strdup( string_tmp ),
  66                                         "virtual"
  67                                 );
  68                         }
  69
  70                         osrfHash* _tmp;
  71                         osrfHash* links = osrfNewHash();
  72                         osrfHash* fields = osrfNewHash();
  73
  74                         osrfHashSet( usrData, fields, "fields" );
  75                         osrfHashSet( usrData, links, "links" );
  76
  77                         xmlNodePtr _cur = kid->children;
  78
  79                         while (_cur) {
  80
  81                                 if (!strcmp( (char*)_cur->name, "fields" )) {
  82
  83                                         string_tmp = NULL;
  84                                         if( (string_tmp = (char*)xmlGetNsProp(_cur, "primary", PERSIST_NS)) ) {
  85                                                 osrfHashSet(
  86                                                         usrData,
  87                                                         strdup( string_tmp ),
  88                                                         "primarykey"
  89                                                 );
  90                                         }
  91
  92                                         string_tmp = NULL;
  93                                         if( (string_tmp = (char*)xmlGetNsProp(_cur, "sequence", PERSIST_NS)) ) {
  94                                                 osrfHashSet(
  95                                                         usrData,
  96                                                         strdup( string_tmp ),
  97                                                         "sequence"
  98                                                 );
  99                                         }
 100
 101                                         xmlNodePtr _f = _cur->children;
 102
 103                                         while(_f) {
 104                                                 if (strcmp( (char*)_f->name, "field" )) {
 105                                                         _f = _f->next;
 106                                                         continue;
 107                                                 }
 108
 109                                                 _tmp = osrfNewHash();
 110
 111                                                 string_tmp = NULL;
 112                                                 if( (string_tmp = (char*)xmlGetNsProp(_f, "array_position", OBJECT_NS)) ) {
 113                                                         osrfHashSet(
 114                                                                 _tmp,
 115                                                                 strdup( string_tmp ),
 116                                                                 "array_position"
 117                                                         );
 118                                                 }
 119
 120                                                 string_tmp = NULL;
 121                                                 if( (string_tmp = (char*)xmlGetNsProp(_f, "virtual", PERSIST_NS)) ) {
 122                                                         osrfHashSet(
 123                                                                 _tmp,
 124                                                                 strdup( string_tmp ),
 125                                                                 "virtual"
 126                                                         );
 127                                                 }
 128
 129                                                 string_tmp = NULL;
 130                                                 if( (string_tmp = (char*)xmlGetNsProp(_f, "primitive", PERSIST_NS)) ) {
 131                                                         osrfHashSet(
 132                                                                 _tmp,
 133                                                                 strdup( string_tmp ),
 134                                                                 "primitive"
 135                                                         );
 136                                                 }
 137
 138                                                 string_tmp = NULL;
 139                                                 if( (string_tmp = (char*)xmlGetProp(_f, "name")) ) {
 140                                                         osrfHashSet(
 141                                                                 _tmp,
 142                                                                 strdup( string_tmp ),
 143                                                                 "name"
 144                                                         );
 145                                                 }
 146
 147                                                 osrfLogInfo(OSRF_LOG_MARK, "Found field %s for class %s", string_tmp, osrfHashGet(usrData, "classname") );
 148
 149                                                 osrfHashSet(
 150                                                         fields,
 151                                                         _tmp,
 152                                                         strdup( string_tmp )
 153                                                 );
 154                                                 _f = _f->next;
 155                                         }
 156                                 }
 157
 158                                 if (!strcmp( (char*)_cur->name, "links" )) {
 159                                         xmlNodePtr _l = _cur->children;
 160
 161                                         while(_l) {
 162                                                 if (strcmp( (char*)_l->name, "link" )) {
 163                                                         _l = _l->next;
 164                                                         continue;
 165                                                 }
 166
 167                                                 _tmp = osrfNewHash();
 168
 169                                                 string_tmp = NULL;
 170                                                 if( (string_tmp = (char*)xmlGetProp(_l, "reltype")) ) {
 171                                                         osrfHashSet(
 172                                                                 _tmp,
 173                                                                 strdup( string_tmp ),
 174                                                                 "reltype"
 175                                                         );
 176                                                 }
 177                                                 osrfLogInfo(OSRF_LOG_MARK, "Adding link with reltype %s", string_tmp );
 178
 179                                                 string_tmp = NULL;
 180                                                 if( (string_tmp = (char*)xmlGetProp(_l, "key")) ) {
 181                                                         osrfHashSet(
 182                                                                 _tmp,
 183                                                                 strdup( string_tmp ),
 184                                                                 "key"
 185                                                         );
 186                                                 }
 187                                                 osrfLogInfo(OSRF_LOG_MARK, "Link fkey is %s", string_tmp );
 188
 189                                                 string_tmp = NULL;
 190                                                 if( (string_tmp = (char*)xmlGetProp(_l, "class")) ) {
 191                                                         osrfHashSet(
 192                                                                 _tmp,
 193                                                                 strdup( string_tmp ),
 194                                                                 "class"
 195                                                         );
 196                                                 }
 197                                                 osrfLogInfo(OSRF_LOG_MARK, "Link fclass is %s", string_tmp );
 198
 199                                                 osrfStringArray* map = osrfNewStringArray(0);
 200
 201                                                 string_tmp = NULL;
 202                                                 if( (string_tmp = (char*)xmlGetProp(_l, "map") )) {
 203                                                         char* map_list = strdup( string_tmp );
 204                                                         osrfLogInfo(OSRF_LOG_MARK, "Link mapping list is %s", string_tmp );
 205
 206                                                         if (strlen( map_list ) > 0) {
 207                                                                 char* st_tmp;
 208                                                                 char* _map_class = strtok_r(map_list, " ", &st_tmp);
 209                                                                 osrfStringArrayAdd(map, strdup(_map_class));
 210
 211                                                                 while ((_map_class = strtok_r(NULL, " ", &st_tmp))) {
 212                                                                         osrfStringArrayAdd(map, strdup(_map_class));
 213                                                                 }
 214                                                         }
 215                                                 }
 216                                                 osrfHashSet( _tmp, map, "map");
 217
 218                                                 string_tmp = NULL;
 219                                                 if( (string_tmp = (char*)xmlGetProp(_l, "field")) ) {
 220                                                         osrfHashSet(
 221                                                                 _tmp,
 222                                                                 strdup( string_tmp ),
 223                                                                 "field"
 224                                                         );
 225                                                 }
 226
 227                                                 osrfHashSet(
 228                                                         links,
 229                                                         _tmp,
 230                                                         strdup( string_tmp )
 231                                                 );
 232
 233                                                 osrfLogInfo(OSRF_LOG_MARK, "Found link %s for class %s", string_tmp, osrfHashGet(usrData, "classname") );
 234
 235                                                 _l = _l->next;
 236                                         }
 237                                 }
 238
 239                                 _cur = _cur->next;
 240                         }
 241                 }
 242
 243                 kid = kid->next;
 244         }
 245
 246         osrfLogInfo(OSRF_LOG_MARK, "...IDL XML parsed");
 247
 248         return idlHash;
 249 }
 250
 251 osrfHash* oilsIDLFindPath( char* path, ... ) {
 252         if(!path || strlen(path) < 1) return NULL;
 253
 254         osrfHash* obj = idlHash;
 255
 256         VA_LIST_TO_STRING(path);
 257         char* buf = VA_BUF;
 258
 259         char* token = NULL;
 260         char* t = buf;
 261         char* tt;
 262
 263         token = strtok_r(t, "/", &tt);
 264         if(!token) return NULL;
 265
 266         do {
 267                 obj = osrfHashGet(obj, token);
 268         } while( (token = strtok_r(NULL, "/", &tt)) && obj);
 269
 270         return obj;
 271 }
 272