Ciao Enrico, 

thanks for your response. However, I identified and solved the issue. It was a bit tricky to find because, basically, who developed this REST interface before, returned a response through the following statements:

Set ListaPrenotazioni   = ##class(%Library.ListOfDataTypes).%New()
 
 [... Populate the list of data types ...]
 
Do##class(%ZEN.Auxiliary.jsonProvider).%WriteJSONStreamFromObject(.jsonStream,ListaPrenotazioni,,,,"eu")
Do jsonStream.Rewind()
Do jsonStream.OutputToDevice() 

Since at first I put my statements after this code (before OutputToDevice()), I wasn't able to modify the status or the header. I found it out while reading the comment to the method SetHeader, which says:

All headers must be set before the HTTP headers are written (after OnPreHTTP() completes).

It was a bit unintuitive because I didn't expected that generating the stream will prevent any further header or status modification. Basically, I solved just moving all my statements before the code that creates the variable jsonStream:

Set ListaPrenotazioni   = ##class(%Library.ListOfDataTypes).%New()
 
 [... Populate the list of data types ...]

[ In case of error: ]
Do%response.SetHeader("totalcount",totalcount)
Set%response.Status = ..#HTTP400BADREQUEST
[ ... ]

Do##class(%ZEN.Auxiliary.jsonProvider).%WriteJSONStreamFromObject(.jsonStream,ListaPrenotazioni,,,,"eu")
Do jsonStream.Rewind()
Do jsonStream.OutputToDevice() 

Hi Hannah,

Thank you for your response. As you mentioned, the 'arrayref()' function is not available in IRIS 2023.1, as I suspected.

However, I managed to resolve this issue by developing a custom method to convert a Python dictionary into an ObjectScript dynamic object. I believe it works quite effectively.

I'll share the code here for anyone interested:

/// This classprovidesmethodsforworkingwithembeddedPythoninvariousscenariosClassUtility.PythonExtends %RegisteredObject
{

/// ConvertPyDictToDynamicObjectrecursivelyconvertsaPythondictionarytoanObjectScriptDynamicObject
/// 
/// Input:
/// - PythonDictionary: The Python dictionary to be converted
/// 
/// Output:
/// Returns a DynamicObject with similar structure and content of the parsed Python dictionary
ClassMethod ConvertPyDictToDynamicObject(PythonDictionary) [ Language = python ]
{
    import iris

    # This is a recursive function to parse a Python dictionary and convert it into an ObjectScript %DynamicObject# The method takes two parameters: 'data', which represents the current dictionary being parsed, and 'depth', which keeps track of the nesting level of the current datadefparse_dictionary_to_dynamic_object(data, depth=0):# Create a new ObjectScript DynamicObject through iris module
        dynamic_object = iris.cls('%DynamicObject')._New()

        # If data is a dictionary, iterate through its key-value pairsif isinstance(data, dict):
            for key, value in data.items():
                # Recursively parse the value and set it in the DynamicObject
                parsed_value = parse_dictionary_to_dynamic_object(value, depth + 1)
                dynamic_object._Set(key, parsed_value)
        # If data is a list, create a %DynamicArray and parse each item of the list recursivelyelif isinstance(data, list):
            dynamic_array = iris.cls('%DynamicArray')._New()
            for item in data:
                parsed_item = parse_dictionary_to_dynamic_object(item, depth)
                dynamic_array._Push(parsed_item)
            return dynamic_array
        # If data is neither a dictionary nor a list, return the data itselfelse:
            return data

        return dynamic_object
    
    # Call the recursive parsing function with the input Python dictionary
    dynamic_object = parse_dictionary_to_dynamic_object(PythonDictionary)

    # Return the parsed DynamicObjectreturn dynamic_object
}

}

You can easily test this method with complex dictionaries, like the one in the following example:

ClassMethod StartTestPyDictConverter()
{
    set dynObj = ##class(Python.MessageBuilder).TestPyDictConverter()
    w "dynObj tested",!
}

ClassMethod TestPyDictConverter() [ Language = python ]
{
    import iris

    data = {
        "person": {
            "name": "John Doe",
            "age": 30,
            "address": {
                "street": "123 Main St",
                "city": "Anytown",
                "zipcode": "12345"
            },
            "emails": ["john@example.com", "doe@example.com"],
            "phone_numbers": [
                {
                    "type": "home",
                    "number": "123-456-7890"
                },
                {
                    "type": "work",
                    "number": "987-654-3210"
                }
            ],
            "friends": [
                {
                    "name": "Alice",
                    "age": 28,
                    "address": {
                        "street": "456 Elm St",
                        "city": "Sometown",
                        "zipcode": "54321"
                    },
                    "emails": ["alice@example.com"],
                    "phone_numbers": [
                        {
                            "type": "mobile",
                            "number": "555-555-5555"
                        }
                    ],
                    "pets": [
                        {
                            "name": "Fluffy",
                            "species": "Cat",
                            "age": 5
                        },
                        {
                            "name": "Spot",
                            "species": "Dog",
                            "age": 3
                        }
                    ]
                },
                {
                    "name": "Bob",
                    "age": 35,
                    "address": {
                        "street": "789 Oak St",
                        "city": "Othertown",
                        "zipcode": "67890"
                    },
                    "emails": ["bob@example.com"],
                    "phone_numbers": [
                        {
                            "type": "mobile",
                            "number": "666-666-6666"
                        }
                    ]
                }
            ]
        },
        "company": {
            "name": "Acme Corporation",
            "address": {
                "street": "456 Business Ave",
                "city": "Bigcity",
                "zipcode": "54321"
            },
            "employees": [
                {
                    "name": "Jane Smith",
                    "position": "Manager",
                    "age": 40,
                    "emails": ["jane@example.com"],
                    "phone_numbers": [
                        {
                            "type": "work",
                            "number": "222-222-2222"
                        }
                    ]
                },
                {
                    "name": "Sam Johnson",
                    "position": "Developer",
                    "age": 35,
                    "emails": ["sam@example.com"],
                    "phone_numbers": [
                        {
                            "type": "work",
                            "number": "333-333-3333"
                        }
                    ]
                }
            ]
        }
    }

    dynObj = iris.cls('Utility.Python').ConvertPyDictToDynamicObject(data)

    return dynObj
}

I've tested it even with more complex dictionaries, like FHIR JSON, and it worked fine.

For example, this is a screenshot from my VSC Debugger: