By the way, if you ever have to check, if a string does contain ASCII chars only (0x00 - 0x7F), there is a simple trick:

if $zconvert(string,"O","UTF8")=string { write "7bit only" } else { write "chars with 8 or more bits" }

OK, this is the correct(ed) version:

ClassMethod RemoveNull(obj)
{
   set iter=obj.%GetIterator(),  rem=[]
   while iter.%GetNext(.key,.val) {
      if $isobject(val) { do ..RemoveNull(val) } elseif obj.%GetTypeOf(key)="null" { do rem.%Push({"o":(obj), "k":(key)}) }
   }
   for i=rem.%Size()-1:-1:0 set tmp=rem.%Get(i) do tmp.o.%Remove(tmp.k)
}

Thanks for the hint, I saw the problem right after answering.
Do we have a backwards-%GetNext(), i.e. an %GetPrevious()?

Just create a simple method like this:

ClassMethod RemoveNull(obj)
{
   set iter=obj.%GetIterator()
   while iter.%GetNext(.key,.val) {
   if $isobject(val) { do ..RemoveNull(val) } elseif obj.%GetTypeOf(key)="null" { do obj.%Remove(key) }
}

gives you

set json={"recipients": [{ "name":"Utsavi", "email":"utsavi@gmail.com"},{ "name":"Utsavi 1", "email":"utsavi1@gmail.com"},null, null],"content":[null, {"title":"Test.pdf", "data":"ygwehfbnwfbhew"} ]}

write json.%ToJSON() --> {"recipients":[{"name":"Utsavi","email":"utsavi@gmail.com"},{"name":"Utsavi 1","email":"utsavi1@gmail.com"},null,null],"content":[null,{"title":"Test.pdf","data":"ygwehfbnwfbhew"}]}

write ##class(some.class).RemoveNull(json) --> {"recipients":[{"name":"Utsavi","email":"utsavi@gmail.com"},{"name":"Utsavi 1","email":"utsavi1@gmail.com"},null],"content":[{"title":"Test.pdf","data":"ygwehfbnwfbhew"}]}

Hello Matjaž,

I have a suspicion...

I tested your case with a 16201607 bytes large PNG file (and it worked).

First, to be able to do this, I had to made a change in the User.API class:

//Do model.%JSONExportToString(.json)
//Quit json

Do model.%JSONExportToStream(.str)
Quit str

so you get back a STREAM instead of a string.

As for IRIS and Cache, a string can't have more then 3641144 chars!

And take into account, a base64 encoded string is 33% longer then the orginal (exact: newSize = oldSize  + 2 \ 3 * 4), so you can use stringvariables up to an original picture size of (roughly, not counting the padding(s)): 

3641144 - 19 - $l(identname)  \ 4 * 3  //  19 bytes for {Ident:"","PNG":""}

By the way, can you output the encoded size (i.e. the length) of the JSONString you send and then the size of the same string in C#? Are they the same?

Zdravo Matjaž,

for the first glance, the above methods should work. Although I don't understand why you need the User.Model class? You can achieve the same thing by defining

Class User.Data Extends (%Persistend, %JSONAdapter) { }

and then 

ClassMethod Load(Ident As %String) As %String [ Language = objectscript ]
{
  Set data=##class(User.Data).%OpenId(Ident)
  Quit:data="" "null"

  Do data.%JSONExportToString(.json)
  Quit json
}

By the way, in the User.Data class, you can shorten the index definition to

Index Ident On Ident [ IdKey ];

because an IdKey is ALWAYS unique.

If you say, your C# gets a garbage PNG, then I would check two things:

1) does the PNG property (in User.Data) contain a valid PNG? Issue in a terminal session following commands: 

set data=##class(User.Data).%OpenId("...")
do data.PNG.Rewind() // not necessary straight after an open
zzdump data.PNG.Read(16)

the output should be:
0000: 89 50 4E 47 0D 0A 1A 0A 00 00 00 0D 49 48 44 52         .PNG........IHDR

2) are you sure, C# gets the JSON-string returned by Load() method? Are you sure, no intermediate process (a middleware) changes this string by applying extra encoding or decoding?

Pozdrav z Beča (Dunaja)

Class Test.JD Extends (%Persistent, %JSON.Adaptor) [ Language = objectscript ]
{
Property Name As %String;
Property Type As %String;
Property Image As %Stream.GlobalBinary;
}

set obj=##class(Test.JD).%New()
set obj.Name="Joe"
do obj.Image.Write($system.Encryption.Base64Decode("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAABnRSTlMAAAAAAABupgeRAAAACXBIWXMA"))
do obj.Image.Write($system.Encryption.Base64Decode("AA7EAAAOxAGVKw4bAAAAGElEQVQokWNk+M9AEmAiTfmohlENQ0kDAD8vAR+xLJsiAAAAAElFTkSuQmCC"))

if obj.%JSONExportToString(.string) write string --> 

{"Name":"Joe","Image":"iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAABnRSTlMAA
AAAAABupgeRAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAGElEQVQokWNk+M9AEmAiTfmohlENQ0kDAD8vA
R+xLJsiAAAAAElFTkSuQmCC"}

As you see in the above example, the export works and does Base64Encoding for the appropriate property (in my example this is 16x16 pixel green rectangle). Please show the relevant part (property) of your class (definition).

This is definitely not a JSON.

You are sure, for each and every $P(obx5,"\.br\",i) the equation $L($P(obx5,"\.br\",i))#4=0 holds?

Ach, the linebreaks, good point,  спасибо!

Good Morning Vietnam... ach, I meant Good Morning Julius!

After 1977 (the year I first met Mumps) now is the time to learn M the right way and entirely!

OK, the truth is, I never usd neither the call nor the expression codemode., hence there was no need to check, how parameter passing works...

Nice solution, but just one question, how gets your S routine the parameter <t>?

Is there some trick, I don't know? I would have written this way

ClassMethod ToNato(t) [ CodeMode = call ]
{
^S(t)
}

but then makes 5 chars

Oh, believe me, I can top even myself

include macrodefs
ClassMethod ToNato(t  = "If, you can read?" ) [ CodeMode = expression ]
{
$$$S
}

ClassMethod s(t)
{
// whatever solution you have, put it there.
}

macrodefs.inc
#define S ..s(t)

Are four chars short enough?  

Today, I'm just  and ish

The possibilities to get a corrupted file are:

- you do not read the (Base64) encoded file in chunks of N*4 (where N is an integer)
- your stream wasn't rewinded before starting with reading
- your (incoming) stream is (already) corrupted (but this would in some cases trigger an error in Base64Decode() method). 

Just for a test, try this

str = is your incoming Base64 stream

set filename = "test.tiff"
open filename:"nwu":1
if '$test write "Can't open",! quit

do str.Rewind()
use file
while 'str.AtEnd { write $system.Encryption.Base64Decode(str.Read(32000)) } // 32000 = 4 * 8000
close file

If the incoming stream is not corruoted, the right now created tiff file should be readable

I bet, this one, with 6 chars only, is shorter

ClassMethod ToNato(t  = "If, you can read?" ) [ CodeMode = expression ]
{
..s(t)
}

ClassMethod s(t)
{
// whatever solution you have, put it there.
}