Pavan Kumar Pyneni,

The last output shown is correct JSON and the expected output not. JSON is a nested data structure and each member like "RequestBody" can have a single value like a string, or number etc, but also a List (something between [ ] ) or even an Structure (or Dict) with members between { }.

It you like to add to a JSON member a string, you need to escape each inner " with \ and might replace each newline with \n.

So this is also OK (I left out the new lines):

"RequestBody": "{\"Test\": null,\"Value\": 9878,\"Date\": null}"

To get the last value in RequestBody your have to escape each " in the result of lr_eval_string("{response}") before assigning it to parameter tmp.

I think also that you need quotes around the {tmp} in:

               "Value=\"{tmp}\"",

or make a json-stringify function that does all the work. E.g.

 // evaluate and stringify a json_param and puts it
 // as a string constant in param.
 void my_json_stringify(char *json_param, char *param)
 {
     char *p, *q;
     char *buf = (char*)malloc(strlen(json_param)+10);
     sprintf(buf,"Buffer={%s}", json_param);
     lr_eval_json(buf, "JsonObject=MY_MJO",LAST);
     free(buf);
     lr_json_stringify("JsonObject=MY_MJO","Format=compact", "OutputParam=my_json_stringify_param",LAST);
     p = lr_eval_string("{my_json_stringify_param}");
     buf = q = (char*)malloc(strlen(p)*2+2);
     *q++ = '"';                       // Start quote
     while(*p) {
         if( *p == '"' ) *q++ = '\\';  // Escape "
         *q++ = *p++;                  // Copy character
     }
     *q++ = '"';                       // End quote
     *q   = '\0';                      // End of String
     lr_save_string(buf, param);
     free(buf);
 }


// Example:
  lr_save_string("{\"Test\": null,\n\"Value\": 9878,\n\"Date\": null\n}", "ResponseBody");
  my_json_stringify("ResponseBody", "response2");
  lr_log_message(lr_eval_string("{response2}"));
// Log: "{\"Test\":null,\"Value\":9878,\"Date\":null}"

JHF Remmelzwaal said:

constant

Thank you for the idea. I used the below code to replace " with /".

char *string_replace(char *input_string,
    char *substring_to_be_replaced,
    char *substitution_string)

 {

// strstr function declaration
 char *strstr(const char *s1, const char *s2); 

// newstring variable the new string to be returned
// increase the buffer size if needed. Default is 200

char newstring[200]=""; 

// str is a temporary pointer to aid in creation of newstring;
// it points at the beginning of each substring that
// needs to be included in the new string.

char *str; 

// ptr is a pointer to hold strstr result.

char *ptr; 

str = input_string;

// search for substring_to_be_replaced and
// replace with substitution_string

 while((ptr = strstr(input_string, substring_to_be_replaced))!=NULL)
 {
 input_string = &ptr[strlen(substring_to_be_replaced)];
 ptr[0] = '\0';
 strcat(newstring, str);
 strcat(newstring, substitution_string);
 str = input_string;
 }

// concatenate the rest of the string

strcat(newstring, input_string);

return newstring;

 }

You can use a more generic function, but

you declare

char newstring[200]="";

in your function that means that the allocation space is likely be on the call stack. You return the pointer of this variable. The variable is out of scope when you return from your function (i.e. not valid / not trustworthy). This is a source for random errors. Also the size is fixed, but you might one day run out of space, but you did not protect against this.

That is why I use strlen() and malloc()/free() and prefer in the context of LR to use LR parameters to communicate. This protects against memory leaking (that on of the reasons why LR uses in many cases parameters for all kind of APIs).

Dit you test your function with string_replace("LR", "", "for ever") ?