LP1779158 Angular7 and ng-lint updates
[Evergreen.git] / Open-ILS / src / c-apps / oils_utils.c
1 #include <ctype.h>
2 #include <limits.h>
3 #include "openils/oils_utils.h"
4 #include "openils/oils_idl.h"
5
6 osrfHash* oilsInitIDL(const char* idl_filename) {
7
8         char* freeable_filename = NULL;
9         const char* filename;
10
11         if(idl_filename)
12                 filename = idl_filename;
13         else {
14                 freeable_filename = osrf_settings_host_value("/IDL");
15                 filename = freeable_filename;
16         }
17
18         if (!filename) {
19                 osrfLogError(OSRF_LOG_MARK, "No settings config for '/IDL'");
20                 return NULL;
21         }
22
23         osrfLogInfo(OSRF_LOG_MARK, "Parsing IDL %s", filename);
24
25         if (!oilsIDLInit( filename )) {
26                 osrfLogError(OSRF_LOG_MARK, "Problem loading IDL file [%s]!", filename);
27                 if(freeable_filename)
28                         free(freeable_filename);
29                 return NULL;
30         }
31
32         if(freeable_filename)
33                 free(freeable_filename);
34         return oilsIDL();
35 }
36
37 /**
38         @brief Return a const string with the value of a specified column in a row object.
39         @param object Pointer to the row object.
40         @param field Name of the column.
41         @return Pointer to a const string representing the value of the specified column,
42                 or NULL in case of error.
43
44         The row object must be a JSON_ARRAY with a classname.  The column value must be a
45         JSON_STRING or a JSON_NUMBER.  Any other object type results in a return of NULL.
46
47         The return value points into the internal contents of the row object, which
48         retains ownership.
49 */
50 const char* oilsFMGetStringConst( const jsonObject* object, const char* field ) {
51         return jsonObjectGetString(oilsFMGetObject( object, field ));
52 }
53
54 /**
55         @brief Return a string with the value of a specified column in a row object.
56         @param object Pointer to the row object.
57         @param field Name of the column.
58         @return Pointer to a newly allocated string representing the value of the specified column,
59                 or NULL in case of error.
60
61         The row object must be a JSON_ARRAY with a classname.  The column value must be a
62         JSON_STRING or a JSON_NUMBER.  Any other object type results in a return of NULL.
63
64         The calling code is responsible for freeing the returned string by calling free().
65  */
66 char* oilsFMGetString( const jsonObject* object, const char* field ) {
67         return jsonObjectToSimpleString(oilsFMGetObject( object, field ));
68 }
69
70 /**
71         @brief Return a pointer to the value of a specified column in a row object.
72         @param object Pointer to the row object.
73         @param field Name of the column.
74         @return Pointer to the jsonObject representing the value of the specified column, or NULL
75                 in case of error.
76
77         The row object must be a JSON_ARRAY with a classname.
78
79         The return value may point to a JSON_NULL, JSON_STRING, JSON_NUMBER, or JSON_ARRAY.  It
80         points into the internal contents of the row object, which retains ownership.
81 */
82 const jsonObject* oilsFMGetObject( const jsonObject* object, const char* field ) {
83         if(!(object && field)) return NULL;
84         if( object->type != JSON_ARRAY || !object->classname ) return NULL;
85         int pos = fm_ntop(object->classname, field);
86         if( pos > -1 )
87                 return jsonObjectGetIndex( object, pos );
88         return NULL;
89 }
90
91
92 int oilsFMSetString( jsonObject* object, const char* field, const char* string ) {
93         if(!(object && field && string)) return -1;
94         osrfLogInternal(OSRF_LOG_MARK, "oilsFMSetString(): Collecing position for field %s", field);
95         int pos = fm_ntop(object->classname, field);
96         if( pos > -1 ) {
97                 osrfLogInternal(OSRF_LOG_MARK, "oilsFMSetString(): Setting string "
98                                 "%s at field %s [position %d]", string, field, pos );
99                 jsonObjectSetIndex( object, pos, jsonNewObject(string) );
100                 return 0;
101         }
102         return -1;
103 }
104
105
106 int oilsUtilsIsDBTrue( const char* val ) {
107         if( val && strcasecmp(val, "f") && strcmp(val, "0") ) return 1;
108         return 0;
109 }
110
111
112 long oilsFMGetObjectId( const jsonObject* obj ) {
113         long id = -1;
114         if(!obj) return id;
115         char* ids = oilsFMGetString( obj, "id" );
116         if(ids) {
117                 id = atol(ids);
118                 free(ids);
119         }
120         return id;
121 }
122
123 int oilsUtilsTrackUserActivity(osrfMethodContext* ctx, long usr, const char* ewho, const char* ewhat, const char* ehow) {
124     if (!usr && !(ewho || ewhat || ehow)) return 0;
125     int rowcount = 0;
126
127     jsonObject* params = jsonParseFmt(
128         "{\"from\":[\"actor.insert_usr_activity\", %ld, \"%s\", \"%s\", \"%s\"]}",
129         usr, 
130         (NULL == ewho)  ? "" : ewho, 
131         (NULL == ewhat) ? "" : ewhat, 
132         (NULL == ehow)  ? "" : ehow
133     );
134
135         osrfAppSession* session = osrfAppSessionClientInit("open-ils.cstore");
136     osrfAppSessionConnect(session);
137     int reqid = osrfAppSessionSendRequest(session, NULL, "open-ils.cstore.transaction.begin", 1);
138         osrfMessage* omsg = osrfAppSessionRequestRecv(session, reqid, 60);
139
140     if(omsg) {
141         osrfMessageFree(omsg);
142         reqid = osrfAppSessionSendRequest(session, params, "open-ils.cstore.json_query", 1);
143             omsg = osrfAppSessionRequestRecv(session, reqid, 60);
144
145         if(omsg) {
146             const jsonObject* rows = osrfMessageGetResult(omsg);
147             if (rows) rowcount = rows->size;
148             osrfMessageFree(omsg); // frees rows
149             if (rowcount) {
150                 reqid = osrfAppSessionSendRequest(session, NULL, "open-ils.cstore.transaction.commit", 1);
151                     omsg = osrfAppSessionRequestRecv(session, reqid, 60);
152                 osrfMessageFree(omsg);
153             } else {
154                 reqid = osrfAppSessionSendRequest(session, NULL, "open-ils.cstore.transaction.rollback", 1);
155                     omsg = osrfAppSessionRequestRecv(session, reqid, 60);
156                 osrfMessageFree(omsg);
157             }
158         }
159     }
160
161     osrfAppSessionFree(session); // calls disconnect internally
162     jsonObjectFree(params);
163     return rowcount;
164 }
165
166
167 static int rootOrgId = 0; // cache the ID of the root org unit.
168 int oilsUtilsGetRootOrgId() {
169
170     // return the cached value if we have it.
171     if (rootOrgId > 0) return rootOrgId;
172
173     jsonObject* where_clause = jsonParse("{\"parent_ou\":null}");
174     jsonObject* org = oilsUtilsQuickReq(
175         "open-ils.cstore",
176         "open-ils.cstore.direct.actor.org_unit.search",
177         where_clause
178     );
179
180     rootOrgId = (int) 
181         jsonObjectGetNumber(oilsFMGetObject(org, "id"));
182
183     jsonObjectFree(where_clause);
184     jsonObjectFree(org);
185
186     return rootOrgId;
187 }
188
189 oilsEvent* oilsUtilsCheckPerms( int userid, int orgid, char* permissions[], int size ) {
190     if (!permissions) return NULL;
191     int i;
192
193     // Check perms against the root org unit if no org unit is provided.
194     if (orgid == -1)
195         orgid = oilsUtilsGetRootOrgId();
196
197     for( i = 0; i < size && permissions[i]; i++ ) {
198         oilsEvent* evt = NULL;
199         char* perm = permissions[i];
200
201         jsonObject* params = jsonParseFmt(
202             "{\"from\":[\"permission.usr_has_perm\",\"%d\",\"%s\",\"%d\"]}",
203             userid, perm, orgid
204         );
205
206         // Execute the query
207         jsonObject* result = oilsUtilsCStoreReq(
208             "open-ils.cstore.json_query", params);
209
210         const jsonObject* hasPermStr = 
211             jsonObjectGetKeyConst(result, "permission.usr_has_perm");
212
213         if (!oilsUtilsIsDBTrue(jsonObjectGetString(hasPermStr))) {
214             evt = oilsNewEvent3(
215                 OSRF_LOG_MARK, OILS_EVENT_PERM_FAILURE, perm, orgid);
216         }
217
218         jsonObjectFree(params);
219         jsonObjectFree(result);
220
221         // return first failed permission check.
222         if (evt) return evt;
223     }
224
225     return NULL; // all perm checks succeeded
226 }
227
228 /**
229         @brief Perform a remote procedure call.
230         @param service The name of the service to invoke.
231         @param method The name of the method to call.
232         @param params The parameters to be passed to the method, if any.
233         @return A copy of whatever the method returns as a result, or a JSON_NULL if the method
234         doesn't return anything.
235
236         If the @a params parameter points to a JSON_ARRAY, pass each element of the array
237         as a separate parameter.  If it points to any other kind of jsonObject, pass it as a
238         single parameter.  If it is NULL, pass no parameters.
239
240         The calling code is responsible for freeing the returned object by calling jsonObjectFree().
241 */
242 jsonObject* oilsUtilsQuickReq( const char* service, const char* method,
243                 const jsonObject* params ) {
244         if(!(service && method)) return NULL;
245
246         osrfLogDebug(OSRF_LOG_MARK, "oilsUtilsQuickReq(): %s - %s", service, method );
247
248         // Open an application session with the service, and send the request
249         osrfAppSession* session = osrfAppSessionClientInit( service );
250         int reqid = osrfAppSessionSendRequest( session, params, method, 1 );
251
252         // Get the response
253         osrfMessage* omsg = osrfAppSessionRequestRecv( session, reqid, 60 );
254         jsonObject* result = jsonObjectClone( osrfMessageGetResult(omsg) );
255
256         // Clean up
257         osrfMessageFree(omsg);
258         osrfAppSessionFree(session);
259         return result;
260 }
261
262 /**
263         @brief Perform a remote procedure call, propagating session
264         locale and timezone
265         @param service The name of the service to invoke.
266         @param method The name of the method to call.
267         @param params The parameters to be passed to the method, if any.
268         @return A copy of whatever the method returns as a result, or a JSON_NULL if the method
269         doesn't return anything.
270
271         If the @a params parameter points to a JSON_ARRAY, pass each element of the array
272         as a separate parameter.  If it points to any other kind of jsonObject, pass it as a
273         single parameter.  If it is NULL, pass no parameters.
274
275         The calling code is responsible for freeing the returned object by calling jsonObjectFree().
276 */
277 jsonObject* oilsUtilsQuickReqCtx( osrfMethodContext* ctx, const char* service,
278                 const char* method, const jsonObject* params ) {
279         if(!(service && method && ctx)) return NULL;
280
281         osrfLogDebug(OSRF_LOG_MARK, "oilsUtilsQuickReqCtx(): %s - %s (%s)", service, method, ctx->session->session_tz );
282
283         // Open an application session with the service, and send the request
284         osrfAppSession* session = osrfAppSessionClientInit( service );
285         osrf_app_session_set_tz(session, ctx->session->session_tz);
286         int reqid = osrfAppSessionSendRequest( session, params, method, 1 );
287
288         // Get the response
289         osrfMessage* omsg = osrfAppSessionRequestRecv( session, reqid, 60 );
290         jsonObject* result = jsonObjectClone( osrfMessageGetResult(omsg) );
291
292         // Clean up
293         osrfMessageFree(omsg);
294         osrfAppSessionFree(session);
295         return result;
296 }
297
298 /**
299         @brief Call a method of the open-ils.storage service.
300         @param method Name of the method.
301         @param params Parameters to be passed to the method, if any.
302         @return A copy of whatever the method returns as a result, or a JSON_NULL if the method
303         doesn't return anything.
304
305         If the @a params parameter points to a JSON_ARRAY, pass each element of the array
306         as a separate parameter.  If it points to any other kind of jsonObject, pass it as a
307         single parameter.  If it is NULL, pass no parameters.
308
309         The calling code is responsible for freeing the returned object by calling jsonObjectFree().
310 */
311 jsonObject* oilsUtilsStorageReq( const char* method, const jsonObject* params ) {
312         return oilsUtilsQuickReq( "open-ils.storage", method, params );
313 }
314
315 /**
316         @brief Call a method of the open-ils.cstore service.
317         @param method Name of the method.
318         @param params Parameters to be passed to the method, if any.
319         @return A copy of whatever the method returns as a result, or a JSON_NULL if the method
320         doesn't return anything.
321
322         If the @a params parameter points to a JSON_ARRAY, pass each element of the array
323         as a separate parameter.  If it points to any other kind of jsonObject, pass it as a
324         single parameter.  If it is NULL, pass no parameters.
325
326         The calling code is responsible for freeing the returned object by calling jsonObjectFree().
327 */
328 jsonObject* oilsUtilsCStoreReq( const char* method, const jsonObject* params ) {
329         return oilsUtilsQuickReq("open-ils.cstore", method, params);
330 }
331
332 /**
333         @brief Call a method of the open-ils.cstore service, context aware.
334         @param ctx Method context object.
335         @param method Name of the method.
336         @param params Parameters to be passed to the method, if any.
337         @return A copy of whatever the method returns as a result, or a JSON_NULL if the method
338         doesn't return anything.
339
340         If the @a params parameter points to a JSON_ARRAY, pass each element of the array
341         as a separate parameter.  If it points to any other kind of jsonObject, pass it as a
342         single parameter.  If it is NULL, pass no parameters.
343
344         The calling code is responsible for freeing the returned object by calling jsonObjectFree().
345 */
346 jsonObject* oilsUtilsCStoreReqCtx( osrfMethodContext* ctx, const char* method, const jsonObject* params ) {
347         return oilsUtilsQuickReqCtx(ctx, "open-ils.cstore", method, params);
348 }
349
350
351
352 /**
353         @brief Given a username, fetch the corresponding row from the actor.usr table, if any.
354         @param name The username for which to search.
355         @return A Fieldmapper object for the relevant row in the actor.usr table, if it exists;
356         or a JSON_NULL if it doesn't.
357
358         The calling code is responsible for freeing the returned object by calling jsonObjectFree().
359 */
360 jsonObject* oilsUtilsFetchUserByUsername( osrfMethodContext* ctx, const char* name ) {
361         if(!name) return NULL;
362         jsonObject* params = jsonParseFmt("{\"usrname\":\"%s\"}", name);
363         jsonObject* user = oilsUtilsQuickReqCtx(
364                 ctx, "open-ils.cstore", "open-ils.cstore.direct.actor.user.search", params );
365
366         jsonObjectFree(params);
367         long id = oilsFMGetObjectId(user);
368         osrfLogDebug(OSRF_LOG_MARK, "Fetched user %s:%ld", name, id);
369         return user;
370 }
371
372 /**
373         @brief Given a barcode, fetch the corresponding row from the actor.usr table, if any.
374         @param name The barcode for which to search.
375         @return A Fieldmapper object for the relevant row in the actor.usr table, if it exists;
376         or a JSON_NULL if it doesn't.
377
378         Look up the barcode in actor.card.  Follow a foreign key from there to get a row in
379         actor.usr.
380
381         The calling code is responsible for freeing the returned object by calling jsonObjectFree().
382 */
383 jsonObject* oilsUtilsFetchUserByBarcode(osrfMethodContext* ctx, const char* barcode) {
384         if(!barcode) return NULL;
385
386         osrfLogInfo(OSRF_LOG_MARK, "Fetching user by barcode %s", barcode);
387
388         jsonObject* params = jsonParseFmt("{\"barcode\":\"%s\"}", barcode);
389         jsonObject* card = oilsUtilsQuickReqCtx(
390                 ctx, "open-ils.cstore", "open-ils.cstore.direct.actor.card.search", params );
391         jsonObjectFree(params);
392
393         if(!card)
394                 return NULL;   // No such card
395
396         // Get the user's id as a long
397         char* usr = oilsFMGetString(card, "usr");
398         jsonObjectFree(card);
399         if(!usr)
400                 return NULL;   // No user id (shouldn't happen)
401         long iusr = strtol(usr, NULL, 10);
402         free(usr);
403
404         // Look up the user in actor.usr
405         params = jsonParseFmt("[%d]", iusr);
406         jsonObject* user = oilsUtilsQuickReqCtx(
407                 ctx, "open-ils.cstore", "open-ils.cstore.direct.actor.user.retrieve", params);
408
409         jsonObjectFree(params);
410         return user;
411 }
412
413 char* oilsUtilsFetchOrgSetting( int orgid, const char* setting ) {
414         if(!setting) return NULL;
415
416         jsonObject* params = jsonParseFmt("[%d, \"%s\"]", orgid, setting );
417
418         jsonObject* set = oilsUtilsQuickReq(
419                 "open-ils.actor",
420                 "open-ils.actor.ou_setting.ancestor_default", params);
421
422         char* value = jsonObjectToSimpleString( jsonObjectGetKeyConst( set, "value" ));
423         jsonObjectFree(params);
424         jsonObjectFree(set);
425         osrfLogDebug(OSRF_LOG_MARK, "Fetched org [%d] setting: %s => %s", orgid, setting, value);
426         return value;
427 }
428
429
430
431 char* oilsUtilsLogin( const char* uname, const char* passwd, const char* type, int orgId ) {
432         if(!(uname && passwd)) return NULL;
433
434         osrfLogDebug(OSRF_LOG_MARK, "Logging in with username %s", uname );
435         char* token = NULL;
436
437         jsonObject* params = jsonParseFmt("[\"%s\"]", uname);
438
439         jsonObject* o = oilsUtilsQuickReq(
440                 "open-ils.auth", "open-ils.auth.authenticate.init", params );
441
442         const char* seed = jsonObjectGetString(o);
443         char* passhash = md5sum(passwd);
444         char buf[256];
445         snprintf(buf, sizeof(buf), "%s%s", seed, passhash);
446         char* fullhash = md5sum(buf);
447
448         jsonObjectFree(o);
449         jsonObjectFree(params);
450         free(passhash);
451
452         params = jsonParseFmt( "[\"%s\", \"%s\", \"%s\", \"%d\"]", uname, fullhash, type, orgId );
453         o = oilsUtilsQuickReq( "open-ils.auth",
454                 "open-ils.auth.authenticate.complete", params );
455
456         if(o) {
457                 const char* tok = jsonObjectGetString(
458                         jsonObjectGetKeyConst( jsonObjectGetKey( o,"payload" ), "authtoken" ));
459                 if( tok )
460                         token = strdup( tok );
461         }
462
463         free(fullhash);
464         jsonObjectFree(params);
465         jsonObjectFree(o);
466
467         return token;
468 }
469
470
471 jsonObject* oilsUtilsFetchWorkstation( long id ) {
472         jsonObject* p = jsonParseFmt("[%ld]", id);
473         jsonObject* r = oilsUtilsQuickReq(
474                 "open-ils.storage",
475                 "open-ils.storage.direct.actor.workstation.retrieve", p );
476         jsonObjectFree(p);
477         return r;
478 }
479
480 jsonObject* oilsUtilsFetchWorkstationByName( const char* name ) {
481         jsonObject* p = jsonParseFmt("{\"name\":\"%s\"}", name);
482         jsonObject* r = oilsUtilsCStoreReq(
483                 "open-ils.cstore.direct.actor.workstation.search", p);
484         jsonObjectFree(p);
485         return r;
486 }
487
488 /**
489         @brief Convert a string to a number representing a time interval in seconds.
490         @param interval Pointer to string, e.g. "420" or "2 weeks".
491         @return If successful, the number of seconds that the string represents; otherwise -1.
492
493         If the string is all digits (apart from any leading or trailing white space), convert
494         it directly.  Otherwise pass it to PostgreSQL for translation.
495
496         The result is the same as if we were to pass every string to PostgreSQL, except that,
497         depending on the value of LONG_MAX, we return values for some strings that represent
498         intervals too long for PostgreSQL to represent (i.e. more than 2147483647 seconds).
499
500         WARNING: a valid interval of -1 second will be indistinguishable from an error.  If
501         such an interval is a plausible possibility, don't use this function.
502 */
503 long oilsUtilsIntervalToSeconds( const char* s ) {
504
505         if( !s ) {
506                 osrfLogWarning( OSRF_LOG_MARK, "String to be converted is NULL" );
507                 return -1;
508         }
509
510         // Skip leading white space
511         while( isspace( (unsigned char) *s ))
512                 ++s;
513
514         if( '\0' == *s ) {
515                 osrfLogWarning( OSRF_LOG_MARK, "String to be converted is empty or all white space" );
516                 return -1;
517         }
518
519         // See if the string is a raw number, i.e. all digits
520         // (apart from any leading or trailing white space)
521
522         const char* p = s;   // For traversing and examining the remaining string
523         if( isdigit( (unsigned char) *p )) {
524                 // Looks like a number so far...skip over the digits
525                 do {
526                         ++p;
527                 } while( isdigit( (unsigned char) *p ));
528                 // Skip over any following white space
529                 while( isspace( (unsigned char) *p ))
530                         ++p;
531                 if( '\0' == *p ) {
532                         // This string is a raw number.  Convert it directly.
533                         long n = strtol( s, NULL, 10 );
534                         if( LONG_MAX == n ) {
535                                 // numeric overflow
536                                 osrfLogWarning( OSRF_LOG_MARK,
537                                         "String \"%s\"represents a number too big for a long", s );
538                                 return -1;
539                         } else
540                                 return n;
541                 }
542         }
543
544         // If we get to this point, the string is not all digits.  Pass it to PostgreSQL.
545
546         // Build the query
547         jsonObject* query_obj = jsonParseFmt(
548                 "{\"from\":[\"config.interval_to_seconds\",\"%s\"]}", s );
549
550         // Execute the query
551         jsonObject* result = oilsUtilsCStoreReq(
552                 "open-ils.cstore.json_query", query_obj );
553         jsonObjectFree( query_obj );
554
555         // Get the results
556         const jsonObject* seconds_obj = jsonObjectGetKeyConst( result, "config.interval_to_seconds" );
557         long seconds = -1;
558         if( seconds_obj && JSON_NUMBER == seconds_obj->type )
559                 seconds = (long) jsonObjectGetNumber( seconds_obj );
560         else
561                 osrfLogError( OSRF_LOG_MARK,
562                         "Error calling json_query to convert \"%s\" to seconds", s );
563
564         jsonObjectFree( result );
565         return seconds;
566 }