In InterSystems IRIS, the construction and manipulation of dynamic objects like JSON objects can be achieved in various ways using the %DynamicObject class.

Issue with Direct JSON Syntax Incorporating Variables

When attempting return {"value1":val1, "value2":val2}, you are utilizing JSON literal syntax directly with variables. This won't work because ObjectScript does not dynamically interpret variables within such JSON literals. Instead, it requires an explicit declaration or assignment for each field.

Correct Dynamic Object Construction

For initializing dynamic objects with variables, you need to use step-by-step assignment. Below is an example:

ClassMethod Planets() As %DynamicObject
{
    Set val1 = "Jupiter"
    Set val2 = "Mars"
    Set result = {}
    Set result.value1 = val1
    Set result.value2 = val2
    Return result
}

This approach builds the dynamic object incrementally and ensures compatibility.

Alternative Using %DynamicObject Methods

The %DynamicObject class provides built-in methods like Set to explicitly set fields in the object. This method allows specifying both the key and value dynamically:

Set json = {}
Do json.%Set("value1", val1)
Do json.%Set("value2", val2)
Return json

Both approaches work because the dynamic object understands individual assignments and ensures proper serialization to JSON format. This clarifies that within ObjectScript, variables must be individually assigned to object properties rather than being interpreted directly in literal JSON syntax [1].

Sources:

To handle the JSON response and extract specific values into a Data Class structure and display them in the Trace Viewer, consider the following:

1. Populating JSON into a Defined Class Structure: You need to map the JSON response to an object-based structure by using %JSON.Adaptor in classes. To do so, make sure all fields in your JSON are represented in the class structure. Create proper mapping with class schema that extends %JSON.Adaptor.

2. Transforming Data Using DTL:

   • Build your Data Transformation Logic (DTL) by associating the source JSON structure to the target structure.
   • The JSON schema can be imported into targeted classes using tools like JSON2Persistent, or you can manually define the structure.

   Example of integrating DTL transformation:

   set reader=##class(%XML.Reader).%New()
   set status=reader.OpenString(rsXML)
   do reader.Correlate("ReportMsg","package.source.ReportMsg")
   do reader.Next(.sourceObject,.status)
   
   set targetClassObject=##class(package.target.ReportMsg).%New()
   set result=##class(DTL.transformation).Transform(sourceObject,.targetClassObject)
   

3. Use Trace in DTL: To make the extracted data visible in Trace Viewer, you can use the <trace> element within your DTL transformation. Example:

   <trace value='"Extracted ID: " & sourceObject.id' />
   <trace value='"Extracted Name: " & sourceObject.name' />
   

   This will print the values of id or name into Trace Viewer during execution [1][2][3].

4. Dynamic Object Parsing using ObjectScript:
   If you want to parse certain JSON fields dynamically:

   set jsonObj = {}.%FromJSON(yourJsonData)
   write jsonObj.data.entities.%Get(0).id  ; This extracts the first entity's `id`
   write jsonObj.data.entities.%Get(0).overallRating.name  ; Extract `overallRating.name`
   

By defining a proper structure, mapping it correctly, and using the trace tag in DTL transformations, you can ensure both visibility in Trace Viewer and efficient data handling.

Sources:

To split a stream containing multiple HL7 messages into individual HL7 messages, you can follow these summarized steps that are extracted from different documented approaches:

1. Identify Starting Points of HL7 Messages: Use the MSH| segment as a delimiter to identify individual HL7 messages. This can be accomplished by scanning the stream for each occurrence of MSH| and ensuring each message starts from there.

2. Stream Handling:

   • First, read the entire input stream containing the series of HL7 messages.
   • Loop through the content, splitting it at every occurrence of the MSH| delimiter.
   • For this, you might store each message as an individual string or an EnsLib.HL7.Message object in a collection (such as a list or array) for further processing.

3. Create HL7 Messages:

   • After extracting segments based on delimiters, instantiate new HL7 message objects using the raw content you have extracted.
   • Set the properties and ensure the framing is correct for each message object.

4. Use Business Processes or ObjectScript Logic:

   • You can write ObjectScript logic to loop through the stream, parse out each HL7 message, and process or route it. Ensure that the formatting remains compliant with HL7 standards before routing.

5. Save or Forward Messages:

   • Process these individual messages as required within the production (e.g., store in EnsLib.Message or forward them to other components in your InterSystems setup).

For implementing the splitting process more programmatically, you can use InterSystems ObjectScript or related tools such as DTLs for message transformation or splitting logic.

Consider efficiently using InterSystems features for handling streams and HL7 messages, and ensure to test with various configurations to verify the messages stay HL7-compliant after splitting [1][2][3].

Sources: