LP1779158 Angular7 and ng-lint updates
[Evergreen.git] / Open-ILS / src / c-apps / oils_idl-core.c
1 #include "openils/oils_idl.h"
2 /*
3  * vim:noet:ts=4:
4  */
5
6 #include <stdlib.h>
7 #include <string.h>
8 #include <libxml/globals.h>
9 #include <libxml/xmlerror.h>
10 #include <libxml/parser.h>
11 #include <libxml/tree.h>
12 #include <libxml/debugXML.h>
13 #include <libxml/xmlmemory.h>
14
15 #define PERSIST_NS "http://open-ils.org/spec/opensrf/IDL/persistence/v1"
16 #define OBJECT_NS "http://open-ils.org/spec/opensrf/IDL/objects/v1"
17 #define BASE_NS "http://opensrf.org/spec/IDL/base/v1"
18 #define REPORTER_NS "http://open-ils.org/spec/opensrf/IDL/reporter/v1"
19 #define PERM_NS "http://open-ils.org/spec/opensrf/IDL/permacrud/v1"
20
21 static xmlDocPtr idlDoc = NULL; // parse and store the IDL here
22
23 /* parse and store the IDL here */
24 static osrfHash* idlHash;
25
26 static void add_std_fld( osrfHash* fields_hash, const char* field_name, unsigned pos );
27 osrfHash* oilsIDL(void) { return idlHash; }
28 osrfHash* oilsIDLInit( const char* idl_filename ) {
29
30         if (idlHash) return idlHash;
31
32         char* prop_str = NULL;
33
34         idlHash = osrfNewHash();
35         osrfHash* class_def_hash = NULL;
36
37         osrfLogInfo(OSRF_LOG_MARK, "Parsing the IDL XML...");
38         idlDoc = xmlReadFile( idl_filename, NULL, XML_PARSE_XINCLUDE );
39         
40         if (!idlDoc) {
41                 osrfLogError(OSRF_LOG_MARK, "Could not load or parse the IDL XML file!");
42                 return NULL;
43         }
44
45         osrfLogDebug(OSRF_LOG_MARK, "Initializing the Fieldmapper IDL...");
46
47         xmlNodePtr docRoot = xmlDocGetRootElement(idlDoc);
48         xmlNodePtr kid = docRoot->children;
49         while (kid) {
50                 if (!strcmp( (char*)kid->name, "class" )) {
51
52                         class_def_hash = osrfNewHash();
53                         char* current_class_name = (char*) xmlGetProp(kid, BAD_CAST "id");
54                         
55                         osrfHashSet( class_def_hash, current_class_name, "classname" );
56                         osrfHashSet( class_def_hash, xmlGetNsProp(kid, BAD_CAST "fieldmapper", BAD_CAST OBJECT_NS), "fieldmapper" );
57                         osrfHashSet( class_def_hash, xmlGetNsProp(kid, BAD_CAST "readonly", BAD_CAST PERSIST_NS), "readonly" );
58
59                         osrfHashSet( idlHash, class_def_hash, current_class_name );
60
61                         if ((prop_str = (char*)xmlGetNsProp(kid, BAD_CAST "tablename", BAD_CAST PERSIST_NS))) {
62                                 osrfLogDebug(OSRF_LOG_MARK, "Using table '%s' for class %s", prop_str, current_class_name );
63                                 osrfHashSet(
64                                         class_def_hash,
65                                         prop_str,
66                                         "tablename"
67                                 );
68                         }
69
70                         if ((prop_str = (char*)xmlGetNsProp(kid, BAD_CAST "restrict_primary", BAD_CAST PERSIST_NS))) {
71                                 osrfLogDebug(OSRF_LOG_MARK, "Delete restriction policy set at '%s' for pkey of class %s", prop_str, current_class_name );
72                                 osrfHashSet(
73                                         class_def_hash,
74                                         prop_str,
75                                         "restrict_primary"
76                                 );
77                         }
78
79                         if ((prop_str = (char*)xmlGetNsProp(kid, BAD_CAST "virtual", BAD_CAST PERSIST_NS))) {
80                                 osrfHashSet(
81                                         class_def_hash,
82                                         prop_str,
83                                         "virtual"
84                                 );
85                         }
86
87                         // Tokenize controller attribute into an osrfStringArray
88                         prop_str = (char*) xmlGetProp(kid, BAD_CAST "controller");
89                         if( prop_str )
90                                 osrfLogDebug(OSRF_LOG_MARK, "Controller list is %s", prop_str );
91                         osrfStringArray* controller = osrfStringArrayTokenize( prop_str, ' ' );
92                         xmlFree( prop_str );
93                         osrfHashSet( class_def_hash, controller, "controller");
94
95                         osrfHash* current_links_hash = osrfNewHash();
96                         osrfHash* current_fields_hash = osrfNewHash();
97
98                         osrfHashSet( class_def_hash, current_fields_hash, "fields" );
99                         osrfHashSet( class_def_hash, current_links_hash, "links" );
100
101                         xmlNodePtr _cur = kid->children;
102
103                         while (_cur) {
104
105                                 if (!strcmp( (char*)_cur->name, "fields" )) {
106
107                                         if( (prop_str = (char*)xmlGetNsProp(_cur, BAD_CAST "primary", BAD_CAST PERSIST_NS)) ) {
108                                                 osrfHashSet(
109                                                         class_def_hash,
110                                                         prop_str,
111                                                         "primarykey"
112                                                 );
113                                         }
114
115                                         if( (prop_str = (char*)xmlGetNsProp(_cur, BAD_CAST "sequence", BAD_CAST PERSIST_NS)) ) {
116                                                 osrfHashSet(
117                                                         class_def_hash,
118                                                         prop_str,
119                                                         "sequence"
120                                                 );
121                                         }
122
123                                         unsigned int array_pos = 0;
124                                         char array_pos_buf[ 7 ];  // For up to 1,000,000 fields per class
125
126                                         xmlNodePtr _f = _cur->children;
127                                         while(_f) {
128                                                 if (strcmp( (char*)_f->name, "field" )) {
129                                                         _f = _f->next;
130                                                         continue;
131                                                 }
132
133                                                 // Get the field name.  If it's one of the three standard
134                                                 // fields that we always generate, ignore it.
135                                                 char* field_name = (char*)xmlGetProp(_f, BAD_CAST "name");
136                                                 if( field_name ) {
137                                                         osrfLogDebug(OSRF_LOG_MARK, 
138                                                                         "Found field %s for class %s", field_name, current_class_name );
139                                                         if(    !strcmp( field_name, "isnew" )
140                                                                 || !strcmp( field_name, "ischanged" )
141                                                                 || !strcmp( field_name, "isdeleted" ) ) {
142                                                                 free( field_name );
143                                                                 _f = _f->next;
144                                                                 continue;
145                                                         }
146                                                 } else {
147                                                         osrfLogDebug(OSRF_LOG_MARK,
148                                                                         "Found field with no name for class %s", current_class_name );
149                                                         _f = _f->next;
150                                                         continue;
151                                                 }
152  
153                                                 osrfHash* field_def_hash = osrfNewHash();
154
155                                                 // Insert array_position
156                                                 snprintf( array_pos_buf, sizeof( array_pos_buf ), "%u", array_pos++ );
157                                                 osrfHashSet( field_def_hash, strdup( array_pos_buf ), "array_position" );
158
159                                                 // Tokenize suppress_controller attribute into an osrfStringArray
160                                                 if( (prop_str = (char*)xmlGetProp(_f, BAD_CAST "suppress_controller")) ) {
161                                                         osrfLogDebug(OSRF_LOG_MARK, "Controller suppression list is %s", prop_str );
162                                                         osrfStringArray* controller = osrfStringArrayTokenize( prop_str, ' ' );
163                                                         osrfHashSet( field_def_hash, controller, "suppress_controller");
164                                                 }
165
166                                                 if( (prop_str = (char*)xmlGetNsProp(_f, BAD_CAST "i18n", BAD_CAST PERSIST_NS)) ) {
167                                                         osrfHashSet(
168                                                                 field_def_hash,
169                                                                 prop_str,
170                                                                 "i18n"
171                                                         );
172                                                 }
173
174                                                 if( (prop_str = (char*)xmlGetNsProp(_f, BAD_CAST "virtual", BAD_CAST PERSIST_NS)) ) {
175                                                         osrfHashSet(
176                                                                 field_def_hash,
177                                                                 prop_str,
178                                                                 "virtual"
179                                                         );
180                                                 } else {   // default to virtual
181                                                         osrfHashSet(
182                                                                 field_def_hash,
183                                                                 "false",
184                                                                 "virtual"
185                                                         );
186                                                 }
187
188                                                 if( (prop_str = (char*)xmlGetNsProp(_f, BAD_CAST "primitive", BAD_CAST PERSIST_NS)) ) {
189                                                         osrfHashSet(
190                                                                 field_def_hash,
191                                                                 prop_str,
192                                                                 "primitive"
193                                                         );
194                                                 }
195
196                                                 osrfHashSet( field_def_hash, field_name, "name" );
197                                                 osrfHashSet(
198                                                         current_fields_hash,
199                                                         field_def_hash,
200                                                         field_name
201                                                 );
202                                                 _f = _f->next;
203                                         }
204
205                                         // Create three standard, stereotyped virtual fields for every class
206                                         add_std_fld( current_fields_hash, "isnew",     array_pos++ );
207                                         add_std_fld( current_fields_hash, "ischanged", array_pos++ );
208                                         add_std_fld( current_fields_hash, "isdeleted", array_pos   );
209
210                                 }
211
212                                 if (!strcmp( (char*)_cur->name, "links" )) {
213                                         xmlNodePtr _l = _cur->children;
214
215                                         while(_l) {
216                                                 if (strcmp( (char*)_l->name, "link" )) {
217                                                         _l = _l->next;
218                                                         continue;
219                                                 }
220
221                                                 osrfHash* link_def_hash = osrfNewHash();
222
223                                                 if( (prop_str = (char*)xmlGetProp(_l, BAD_CAST "reltype")) ) {
224                                                         osrfHashSet(
225                                                                 link_def_hash,
226                                                                 prop_str,
227                                                                 "reltype"
228                                                         );
229                                                         osrfLogDebug(OSRF_LOG_MARK, "Adding link with reltype %s", prop_str );
230                                                 } else
231                                                         osrfLogDebug(OSRF_LOG_MARK, "Adding link with no reltype" );
232
233                                                 if( (prop_str = (char*)xmlGetProp(_l, BAD_CAST "key")) ) {
234                                                         osrfHashSet(
235                                                                 link_def_hash,
236                                                                 prop_str,
237                                                                 "key"
238                                                         );
239                                                         osrfLogDebug(OSRF_LOG_MARK, "Link fkey is %s", prop_str );
240                                                 } else
241                                                         osrfLogDebug(OSRF_LOG_MARK, "Link with no fkey" );
242
243                                                 if( (prop_str = (char*)xmlGetProp(_l, BAD_CAST "class")) ) {
244                                                         osrfHashSet(
245                                                                 link_def_hash,
246                                                                 prop_str,
247                                                                 "class"
248                                                         );
249                                                         osrfLogDebug(OSRF_LOG_MARK, "Link fclass is %s", prop_str );
250                                                 } else
251                                                         osrfLogDebug(OSRF_LOG_MARK, "Link with no fclass" );
252
253                                                 // Tokenize map attribute into an osrfStringArray
254                                                 prop_str = (char*) xmlGetProp(_l, BAD_CAST "map");
255                                                 if( prop_str )
256                                                         osrfLogDebug(OSRF_LOG_MARK, "Link mapping list is %s", prop_str );
257                                                 osrfStringArray* map = osrfStringArrayTokenize( prop_str, ' ' );
258                                                 osrfHashSet( link_def_hash, map, "map");
259                                                 xmlFree( prop_str );
260
261                                                 if( (prop_str = (char*)xmlGetProp(_l, BAD_CAST "field")) ) {
262                                                         osrfHashSet(
263                                                                 link_def_hash,
264                                                                 prop_str,
265                                                                 "field"
266                                                         );
267                                                         osrfLogDebug(OSRF_LOG_MARK, "Link fclass is %s", prop_str );
268                                                 } else
269                                                         osrfLogDebug(OSRF_LOG_MARK, "Link with no fclass" );
270
271                                                 osrfHashSet(
272                                                         current_links_hash,
273                                                         link_def_hash,
274                                                         prop_str
275                                                 );
276
277                                                 _l = _l->next;
278                                         }
279                                 }
280 /**** Structure of permacrud in memory ****
281
282 { create :
283     { permission : [ x, y, z ],
284       global_required : "true", -- anything else, or missing, is false
285       ignore_object_perms : "true", -- anything else, or missing, is false
286       local_context : [ f1, f2 ],
287       foreign_context : { class1 : { fkey : local_class_key, field : class1_field, context : [ a, b, c ] }, ...}
288     },
289   retrieve : null, -- no perm check, or structure similar to the others
290   update : -- like create
291     ...
292   delete : -- like create
293     ...
294 }   
295
296 **** Structure of permacrud in memory ****/
297
298                                 if (!strcmp( (char*)_cur->name, "permacrud" )) {
299                                         osrfHash* pcrud = osrfNewHash();
300                                         osrfHashSet( class_def_hash, pcrud, "permacrud" );
301                                         xmlNodePtr _l = _cur->children;
302                                         char * ignore_object_perms = (char*) xmlGetProp(_cur, BAD_CAST "ignore_object_perms");
303
304                                         while(_l) {
305                                                 if (strcmp( (char*)_l->name, "actions" )) {
306                                                         _l = _l->next;
307                                                         continue;
308                                                 }
309
310                                                 xmlNodePtr _a = _l->children;
311
312                                                 while(_a) {
313                                                         const char* action_name = (const char*) _a->name;
314                                                         if (
315                                                                 strcmp( action_name, "create" ) &&
316                                                                 strcmp( action_name, "retrieve" ) &&
317                                                                 strcmp( action_name, "update" ) &&
318                                                                 strcmp( action_name, "delete" )
319                                                         ) {
320                                                                 _a = _a->next;
321                                                                 continue;
322                                                         }
323
324                                                         osrfLogDebug(OSRF_LOG_MARK, "Found Permacrud action %s for class %s",
325                                                                 action_name, current_class_name );
326
327                                                         osrfHash* action_def_hash = osrfNewHash();
328                                                         osrfHashSet( pcrud, action_def_hash, action_name );
329
330                                                         // Set the class-wide ignore_object_perms flag
331                                                 osrfHashSet( action_def_hash, ignore_object_perms, "ignore_object_perms");
332
333                                                         // Tokenize permission attribute into an osrfStringArray
334                                                         prop_str = (char*) xmlGetProp(_a, BAD_CAST "permission");
335                                                         if( prop_str )
336                                                                 osrfLogDebug(OSRF_LOG_MARK,
337                                                                         "Permacrud permission list is %s", prop_str );
338                                                         osrfStringArray* map = osrfStringArrayTokenize( prop_str, ' ' );
339                                                         osrfHashSet( action_def_hash, map, "permission");
340                                                         xmlFree( prop_str );
341
342                                                 osrfHashSet( action_def_hash,
343                                                                 (char*)xmlGetNoNsProp(_a, BAD_CAST "owning_user"), "owning_user");
344
345                                                 osrfHashSet( action_def_hash,
346                                                                 (char*)xmlGetNoNsProp(_a, BAD_CAST "global_required"), "global_required");
347
348                                                         // Tokenize context_field attribute into an osrfStringArray
349                                                         prop_str = (char*) xmlGetProp(_a, BAD_CAST "context_field");
350                                                         if( prop_str )
351                                                                 osrfLogDebug(OSRF_LOG_MARK,
352                                                                         "Permacrud context_field list is %s", prop_str );
353                                                         map = osrfStringArrayTokenize( prop_str, ' ' );
354                                                         osrfHashSet( action_def_hash, map, "local_context");
355                                                         xmlFree( prop_str );
356
357                                                         osrfHash* foreign_context = osrfNewHash();
358                                                         osrfHashSet( action_def_hash, foreign_context, "foreign_context");
359
360                                                         xmlNodePtr _f = _a->children;
361
362                                                         while(_f) {
363                                                                 if ( strcmp( (char*)_f->name, "context" ) ) {
364                                                                         _f = _f->next;
365                                                                         continue;
366                                                                 }
367
368                                                                 if( (prop_str = (char*)xmlGetNoNsProp(_f, BAD_CAST "link")) ) {
369                                                                         osrfLogDebug(OSRF_LOG_MARK,
370                                                                                 "Permacrud context link definition is %s", prop_str );
371
372                                                                         osrfHash* _tmp_fcontext = osrfNewHash();
373
374                                                                         // Store pointers to elements already stored
375                                                                         // from the <link> aggregate
376                                                                         osrfHash* _flink = osrfHashGet( current_links_hash, prop_str );
377                                                                         osrfHashSet( _tmp_fcontext, osrfHashGet(_flink, "field"), "fkey" );
378                                                                         osrfHashSet( _tmp_fcontext, osrfHashGet(_flink, "key"), "field" );
379                                                                         xmlFree( prop_str );
380
381                                                                     if( (prop_str = (char*)xmlGetNoNsProp(_f, BAD_CAST "jump")) )
382                                                                             osrfHashSet( _tmp_fcontext, osrfStringArrayTokenize( prop_str, '.' ), "jump" );
383                                                                         xmlFree( prop_str );
384
385                                                                         // Tokenize field attribute into an osrfStringArray
386                                                                         char * field_list = (char*) xmlGetProp(_f, BAD_CAST "field");
387                                                                         if( field_list )
388                                                                                 osrfLogDebug(OSRF_LOG_MARK,
389                                                                                         "Permacrud foreign context field list is %s", field_list );
390                                                                         map = osrfStringArrayTokenize( field_list, ' ' );
391                                                                         osrfHashSet( _tmp_fcontext, map, "context");
392                                                                         xmlFree( field_list );
393
394                                                                         // Insert the new hash into a hash attached to the parent node
395                                                                         osrfHashSet( foreign_context, _tmp_fcontext, osrfHashGet( _flink, "class" ) );
396
397                                                                 } else {
398
399                                                                         if( (prop_str = (char*)xmlGetNoNsProp(_f, BAD_CAST "field") )) {
400                                                                                 char* map_list = prop_str;
401                                                                                 osrfLogDebug(OSRF_LOG_MARK,
402                                                                                         "Permacrud local context field list is %s", prop_str );
403                         
404                                                                                 if (strlen( map_list ) > 0) {
405                                                                                         char* st_tmp = NULL;
406                                                                                         char* _map_class = strtok_r(map_list, " ", &st_tmp);
407                                                                                         osrfStringArrayAdd(
408                                                                                                 osrfHashGet( action_def_hash, "local_context"), _map_class);
409                                                                         
410                                                                                         while ((_map_class = strtok_r(NULL, " ", &st_tmp))) {
411                                                                                                 osrfStringArrayAdd(
412                                                                                                         osrfHashGet( action_def_hash, "local_context"), _map_class);
413                                                                                         }
414                                                                                 }
415                                                                                 xmlFree(map_list);
416                                                                         }
417
418                                                                 }
419                                                                 _f = _f->next;
420                                                         }
421                                                         _a = _a->next;
422                                                 }
423                                                 _l = _l->next;
424                                         }
425                                 }
426
427                                 if (!strcmp( (char*)_cur->name, "source_definition" )) {
428                                         char* content_str;
429                                         if( (content_str = (char*)xmlNodeGetContent(_cur)) ) {
430                                                 osrfLogDebug(OSRF_LOG_MARK, "Using source definition '%s' for class %s",
431                                                         content_str, current_class_name );
432                                                 osrfHashSet(
433                                                         class_def_hash,
434                                                         content_str,
435                                                         "source_definition"
436                                                 );
437                                         }
438
439                                 }
440
441                                 _cur = _cur->next;
442                         } // end while
443                 }
444
445                 kid = kid->next;
446         } // end while
447
448         osrfLogInfo(OSRF_LOG_MARK, "...IDL XML parsed");
449
450         return idlHash;
451 }
452
453 // Adds a standard virtual field to a fields hash
454 static void add_std_fld( osrfHash* fields_hash, const char* field_name, unsigned pos ) {
455         char array_pos_buf[ 7 ];
456         osrfHash* std_fld_hash = osrfNewHash();
457
458         snprintf( array_pos_buf, sizeof( array_pos_buf ), "%u", pos );
459         osrfHashSet( std_fld_hash, strdup( array_pos_buf ), "array_position" );
460         osrfHashSet( std_fld_hash, "true", "virtual" );
461         osrfHashSet( std_fld_hash, strdup( field_name ), "name" );
462         osrfHashSet( fields_hash, std_fld_hash, field_name );
463 }
464
465
466 osrfHash* oilsIDLFindPath( const char* path, ... ) {
467         if(!path || strlen(path) < 1) return NULL;
468
469         osrfHash* obj = idlHash;
470
471         VA_LIST_TO_STRING(path);
472         char* buf = VA_BUF;
473
474         char* token = NULL;
475         char* t = buf;
476         char* tt;
477
478         token = strtok_r(t, "/", &tt);
479         if(!token) return NULL;
480
481         do {
482                 obj = osrfHashGet(obj, token);
483         } while( (token = strtok_r(NULL, "/", &tt)) && obj);
484
485         return obj;
486 }
487
488 static osrfHash* findClassDef( const char* classname ) {
489         if( !classname || !idlHash )
490                 return NULL;
491         else
492                 return osrfHashGet( idlHash, classname );
493 }
494
495 osrfHash* oilsIDL_links( const char* classname ) {
496         osrfHash* classdef = findClassDef( classname );
497         if( classdef )
498                 return osrfHashGet( classdef, "links" );
499         else
500                 return NULL;
501 }
502
503 osrfHash* oilsIDL_fields( const char* classname ) {
504         osrfHash* classdef = findClassDef( classname );
505         if( classdef )
506                 return osrfHashGet( classdef, "fields" );
507         else
508                 return NULL;
509 }
510
511 int oilsIDL_classIsFieldmapper ( const char* classname ) {
512         if( findClassDef( classname ) )
513                 return 1;
514         else
515                 return 0;
516 }
517
518 // For a given class: return the array_position associated with a 
519 // specified field. (or -1 if it doesn't exist)
520 int oilsIDL_ntop (const char* classname, const char* fieldname) {
521         osrfHash* fields_hash = oilsIDL_fields( classname );
522         if( !fields_hash )
523                 return -1;     // No such class, or no fields for it
524
525         osrfHash* field_def_hash = osrfHashGet( fields_hash, fieldname );
526         if( !field_def_hash )
527                 return -1;                      // No such field
528
529         const char* pos_attr = osrfHashGet( field_def_hash, "array_position" );
530         if( !pos_attr )
531                 return -1;                      // No array_position attribute
532
533         return atoi( pos_attr );        // Return position as int
534 }
535
536 // For a given class: return a copy of the name of the field 
537 // at a specified array_position (or NULL if there is none)
538 char * oilsIDL_pton (const char* classname, int pos) {
539         osrfHash* fields_hash = oilsIDL_fields( classname );
540         if( !fields_hash )
541                 return NULL;     // No such class, or no fields for it
542
543         char* ret = NULL;
544         osrfHash* field_def_hash = NULL;
545         osrfHashIterator* iter = osrfNewHashIterator( fields_hash );
546
547         while ( ( field_def_hash = osrfHashIteratorNext( iter ) ) ) {
548                 if ( atoi( osrfHashGet( field_def_hash, "array_position" ) ) == pos ) {
549                         ret = strdup( osrfHashIteratorKey( iter ) );
550                         break;
551                 }
552         }
553
554         osrfHashIteratorFree( iter );
555
556         return ret;
557 }
558