Open-ILS/src/c-apps/oils_event.c

   1 #include "oils_event.h"
   2 #include <libxml/parser.h>
   3 #include <libxml/tree.h>
   4 #include "opensrf/osrf_settings.h"
   5
   6 osrfHash* __oilsEventEvents = NULL;
   7 osrfHash* __oilsEventDescriptions = NULL;
   8
   9 oilsEvent* oilsNewEvent( char* file, int line, char* event ) {
  10         if(!event) return NULL;
  11         osrfLogInfo(OSRF_LOG_MARK, "Creating new event: %s", event);
  12         if(!__oilsEventEvents) _oilsEventParseEvents();
  13         oilsEvent* evt =  (oilsEvent*) safe_malloc(sizeof(oilsEvent));
  14         evt->event = strdup(event);
  15         evt->permloc = -1;
  16         if(file) evt->file = strdup(file);
  17         evt->line = line;
  18         return evt;
  19 }
  20
  21 oilsEvent* oilsNewEvent2( char* file, int line, char* event, jsonObject* payload ) {
  22         oilsEvent* evt = oilsNewEvent(file, line, event);
  23         oilsEventSetPayload(evt, payload);
  24         return evt;
  25 }
  26
  27 oilsEvent* oilsNewEvent3( char* file, int line, char* event, char* perm, int permloc ) {
  28         oilsEvent* evt = oilsNewEvent(file, line, event);
  29         oilsEventSetPermission( evt, perm, permloc );
  30         return evt;
  31 }
  32
  33 oilsEvent* oilsNewEvent4( char* file, int line,
  34                         char* event, char* perm, int permloc, jsonObject* payload ) {
  35         oilsEvent* evt = oilsNewEvent3( file, line, event, perm, permloc );
  36         if(evt) oilsEventSetPayload( evt, payload );
  37         return evt;
  38 }
  39
  40 void oilsEventSetPermission( oilsEvent* event, char* perm, int permloc ) {
  41         if(!(event && perm)) return;
  42         event->perm = strdup(perm);
  43         event->permloc = permloc;
  44 }
  45
  46 void oilsEventSetPayload( oilsEvent* event, jsonObject* payload ) {
  47         if(!(event && payload)) return;
  48         event->payload = jsonObjectClone(payload);
  49 }
  50
  51
  52 void oilsEventFree( oilsEvent* event ) {
  53         if(!event) return;
  54         free(event->perm);
  55         free(event->file);
  56         if(event->json) jsonObjectFree(event->json);
  57         else jsonObjectFree(event->payload);
  58         free(event);
  59 }
  60
  61
  62 jsonObject* oilsEventToJSON( oilsEvent* event ) {
  63         if(!event) return NULL;
  64         char* code = osrfHashGet( __oilsEventEvents, event->event );
  65
  66         if(!code) {
  67                 osrfLogError(OSRF_LOG_MARK,  "No such event name: %s", event->event );
  68                 return NULL;
  69         }
  70
  71
  72         char* lang = "en-US"; /* assume this for now */
  73         char* desc = NULL;
  74         osrfHash* h = osrfHashGet(__oilsEventDescriptions, lang);
  75         if(h) {
  76                 osrfLogDebug(OSRF_LOG_MARK, "Loaded event lang hash for %s",lang);
  77                 desc = osrfHashGet(h, code);
  78                 osrfLogDebug(OSRF_LOG_MARK, "Found event description %s", desc);
  79         }
  80         if(!desc) desc = "";
  81
  82         jsonObject* json = jsonNewObject(NULL);
  83         jsonObjectSetKey( json, "ilsevent", jsonNewNumberObject(atoi(code)) );
  84         jsonObjectSetKey( json, "textcode", jsonNewObject(event->event) );
  85         jsonObjectSetKey( json, "desc", jsonNewObject(desc) );
  86         jsonObjectSetKey( json, "pid", jsonNewNumberObject(getpid()) );
  87
  88         char buf[256];
  89         memset(buf,0, 256);
  90         snprintf(buf, 256, "%s:%d", event->file, event->line);
  91         jsonObjectSetKey( json, "stacktrace", jsonNewObject(buf) );
  92
  93         if(event->perm) jsonObjectSetKey( json, "ilsperm", jsonNewObject(event->perm) );
  94         if(event->permloc != -1) jsonObjectSetKey( json, "ilspermloc", jsonNewNumberObject(event->permloc) );
  95         if(event->payload) jsonObjectSetKey( json, "payload", event->payload );
  96         event->json = json;
  97         return json;
  98 }
  99
 100
 101 void _oilsEventParseEvents() {
 102
 103         char* xml = osrf_settings_host_value("/ils_events");
 104
 105         if(!xml) {
 106                 osrfLogError(OSRF_LOG_MARK, "Unable to find ILS Events file: %s", xml);
 107                 return;
 108         }
 109
 110         xmlDocPtr doc = xmlParseFile(xml);
 111         free(xml);
 112         int success = 0;
 113         __oilsEventEvents = osrfNewHash();
 114         __oilsEventDescriptions = osrfNewHash();
 115
 116         if( doc ) {
 117                 xmlNodePtr root = xmlDocGetRootElement(doc);
 118                 if( root ) {
 119                         xmlNodePtr child = root->children;
 120                         while( child ) {
 121                                 if( !strcmp((char*) child->name, "event") ) {
 122                                         xmlChar* code = xmlGetProp( child, BAD_CAST "code");
 123                                         xmlChar* textcode = xmlGetProp( child, BAD_CAST "textcode");
 124                                         if( code && textcode ) {
 125                                                 osrfHashSet( __oilsEventEvents, code, textcode );
 126                                                 success = 1;
 127                                         }
 128
 129                                         /* here we collect all of the <desc> nodes on the event
 130                                          * element and store them based on the xml:lang attribute
 131                                          */
 132                                         xmlNodePtr desc = child->children;
 133                                         while(desc) {
 134                                                 if( !strcmp((char*) desc->name, "desc") ) {
 135                                                         xmlChar* lang = xmlGetProp( desc, BAD_CAST "lang");
 136                                                         if(lang) {
 137                                                                 osrfLogDebug(OSRF_LOG_MARK, "Loaded event lang: %s", (char*) lang);
 138                                                                 osrfHash* langHash = osrfHashGet(
 139                                                                         __oilsEventDescriptions, lang);
 140                                                                 if(!langHash) {
 141                                                                         langHash = osrfNewHash();
 142                                                                         osrfHashSet(__oilsEventDescriptions, langHash, lang);
 143                                                                 }
 144                                                                 char* content;
 145                                                                 if( desc->children && (content = desc->children->content) ) {
 146                                                                         osrfLogDebug(OSRF_LOG_MARK, "Loaded event desc: %s", (char*) content);
 147                                                                         osrfHashSet( langHash, content, code );
 148                                                                 }
 149                                                         }
 150                                                 }
 151                                                 desc = desc->next;
 152                                         }
 153                                 }
 154                                 child = child->next;
 155                         }
 156                 }
 157         }
 158
 159         if(!success) osrfLogError(OSRF_LOG_MARK,  " ! Unable to parse events file: %s", xml );
 160 }
 161
 162