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