@Hansel Rudy Stange Gaete 
Was wondering did you get this problem solved I also have an object with a stream property that I am trying to return in a soap response and is blank but in the trace on the production is populated  any help appreciated 

@Attila Toth  thank you but I managed to crack it and I have sent you the code to update if you like

I am using the supplied FakeXML as below 

ClassMethod FakeXML() [ Internal ]
{
    Write "<fofile" _ 
        $Case(%report.FOFilename, "": "", : " name=""" _ ##class(%File).NormalizeFilename(%report.FOFilename) _ """") _
        $Case(%report.FOStreamString, "": "", : " FOStreamString=""" _ %report.FOStreamString _ """") _
        $Case(%report.CallbackClass, "": "", : " callbackClass=""" _ %report.CallbackClass _ """") _
        $Case(%report.CallbackMethod, "": "", : " callbackMethod=""" _ %report.CallbackMethod _ """") _
        "></fofile>"
}

@Attila Toth  thanks for getting back at me I have tried with log errors and I get a pdf generated which I can not open as if I have a loop running or the file being corrupt your solution works fine with the reading of files and using the call back method with embedded XLFO  is  it possible to supply the call back method with the XLFO stream and use that instead and if possible please could you give us an example if you have one thanks

 @Attila Toth I am using your  FOWrapper to pass a stream of XLFO data in my production to generate a pdf and  nothing is happening I am not getting any errors or anything  would you please advice on where I am going wrong I have altered it a bit to use what I need please advice here is my code thanks in advance

Include Ensemble

IncludeGenerator (%occInclude, EnsUtil)

Class ZEN.Report.XLFOToPDFWrapper Extends %ZEN.Report.reportPage
{

Parameter DEFAULTMODE As STRING = "xml";

/// Default value for the CallbackClass property. This can be set in subclasses!
Parameter DEFAULTCALLBACKCLASS;

/// Default value for the CallbackMethod property. This can be set in subclasses!
Parameter DEFAULTCALLBACKMETHOD;

Parameter ENCODING = "Windows-1252";

Property FOStreamString As %Stream.FileCharacter(ZENURL = "FOSTREAMSTRING");

/// If this and the CallbackMethod are not empty and referring a valid class and method name,
///  then the return value of the corresponding classmethod (which should be a character stream) is used as the XSL-FO file.
Property CallbackClass As %String(ZENURL = "CLASS") [ InitialExpression = {..#DEFAULTCALLBACKCLASS} ];

/// If this and the CallbackClass are not empty and referring a valid class and method name,
///  then the return value of the corresponding classmethod (which should be a character stream) is used as the XSL-FO file.
Property CallbackMethod As %String(ZENURL = "METHOD") [ InitialExpression = {..#DEFAULTCALLBACKMETHOD} ];

/// This callback is invoked after this report is instantiated
/// and before it is run.
Method %OnBeforeReport() As %Status [ Internal ]
{
	Set tSC = $$$OK

	If (..CallbackClass '= "") && (..CallbackMethod '= "") {
		TRY {
			Set tSC = $CLASSMETHOD(..CallbackClass, ..CallbackMethod, .fostream)
		}
		CATCH ex {
			Set tSC = ex.AsStatus()
		}
	}
	Else {
		Set fostream = ##class(%Stream.FileCharacter).%New()
		While '..FOStreamString.AtEnd {
		Set tSC = fostream.Write(..FOStreamString.Read(32000))
	}
		
		 $$$TRACE(fostream)
		 $$$LOGWARNING(fostream)
	}
	
	If $$$ISOK(tSC) {
		// TODO: automatically append XSLT frame around the XSL-FO file.
		Set ..toxslfostream = ..TransformFO2XSL(.fostream)
		Do ..toxslfostream.Rewind()
	}
		
	Quit tSC
}

/// This report has a "fake" XML definition. Basically any XML would do, because the XSL-FO file is created outside of the ZEN Report class.
XData ReportDefinition [ XMLNamespace = "http://www.intersystems.com/zen/report/definition" ]
{



}

/// Method, which generates the "fake" XML content of the report.
/// At the moment this contains a single element (), which reflects the parameters of the report.'
ClassMethod FakeXML() [ Internal ]
{
	Write "">"
}

ClassMethod ProducePDFFile(pOutputFile As %String, pXLFOStream As %String, pDisplayLog As %Boolean = 0, pRenderServer As %String = "") As %Status
{
	Set tSC = $$$OK
	
	Set report = ..%New()
	Set report.FOStreamString = pXLFOStream
	
	Set tSC = report.GenerateReport(pOutputFile, 2, pDisplayLog, pRenderServer)
	Quit tSC
}

/// Appends the XSLT frame around the original XSL-FO stream, to make it usable with this report class.
ClassMethod TransformFO2XSL(ByRef pFOStream As %Stream.Object) As %Stream.Object [ Internal ]
{
	Set tSC = $$$OK
	
	Set xslStream = ##class(%Stream.TmpCharacter).%New()
	
	Do pFOStream.Rewind()
	Set first100 = pFOStream.Read(100)
	If $Extract(first100, 1, 2) = "", 1) _ ">"
		Set first100 = $Piece(first100, ">", 2, *)
	}
	Else {
		Set xmlHeader = "" 
	}
	
	Do xslStream.WriteLine($Select(
		xmlHeader '= "": xmlHeader,
		1: ""))
	Do xslStream.WriteLine("")
	Do xslStream.WriteLine("")
	Do xslStream.WriteLine("")

	Quit xslStream
}

}

and on my operation I call it like so

Class FopPDFRenderingEngineOPRN Extends Ens.BusinessOperation
{

Parameter ADAPTER = "EnsLib.File.OutboundAdapter";

Property Adapter As EnsLib.File.OutboundAdapter;

Parameter INVOCATION = "Queue";

Method Render(pRequest As RenderRequestMREQ, Output pResponse As RenderRequestMRES) As %Status
{

	set tSC = $$$OK
		
	set pResponse = ##class(Ecrion.PublishingEngine.RenderRequestMRES).%New()
	set pResponse.FileName = pRequest.FileName
	set pResponse.Status = 0

	

	#Dim oHttpReq3 AS ZEN.Report.XLFOToPDFWrapper= ##class(ZEN.Report.XLFOToPDFWrapper).%New()

	
	// if the input format is xslfo Base64Encode the stream
	if (pRequest.InputFormat = "xslfo")
	{
	
	
	// write the request object 

		set pResponse.Document = ..getStreamData(pRequest.Source)
		set p=oHttpReq3.ProducePDFFile(..Adapter.FilePath_pRequest.FileName,..getStreamData(pRequest.Source))
		If ($$$ISOK(p))
	    {
		    set pResponse.Message="all good"
		    }else
			{
			set pResponse.Message=$$$ISERR(tSC)
			}
	
      	
      	kill oStream
      	 
	}
	
 
    
    kill oStream
        
    quit tSC
}

Method getStreamData(foo As %Stream.TmpCharacter) As %Stream.TmpCharacter
{
	   set oStream = ##class(%Stream.TmpCharacter).%New()
		
		
		while ('foo.AtEnd) { do oStream.Write(foo.Read(1200)) }
		
		
		do oStream.Rewind()
		quit oStream
}

XData MessageMap
{

	 
		Render
	

}

}

@sjbttt sjbttt  did you final get the solution to this if you did would you kindly share the solution please