public async Task Render()
{
await Prepare();
RenderNode node = manager.GetNodeByName(THIS_NAME);
long lastFileChange = new FileInfo(BLEND_FILE).LastWriteTime.Ticks;
SyncResponse respSync = null;
using (FileStream stream = new FileStream(BLEND_FILE, FileMode.Open))
respSync = await node.SyncFile(SESSION, lastFileChange, stream, Compression.Raw);
Assert.IsTrue(respSync.Success);
RenderResponse respRender = await node.Render(new RenderRequest()
{
FileID = lastFileChange,
SessionID = SESSION,
TaskID = "Whatever",
Version = BLEND_VERSION,
Settings = new Shared.RenderPacketModel()
{
Width = 640,
Height = 360,
Samples = 8
}
});
Assert.IsTrue(respRender.Success);
File.WriteAllBytes($"{RESULTS_DIRECTORY}/Test.Render.png", respRender.Data);
Assert.IsTrue(respRender.Data != null && respRender.Data.Length > 0);
//Check equality
}
/// <summary>
/// Render a single RenderSettings
/// </summary>
public async Task <RenderResponse> Render(RenderRequest req)
{
if (Client == null)
{
throw new InvalidOperationException("Client not connected");
}
RenderResponse resp = null;
_taskCancelToken = new CancellationTokenSource();
try
{
CurrentTask = req.TaskID;
UpdateActivity("Render Loading..");
if (Client != null)
{
resp = await Client.Send <RenderResponse>(req, _taskCancelToken.Token);
}
}
finally
{
UpdateActivity("");
CurrentTask = null;
_taskCancelToken = null;
}
return(resp);
}
public async Task <byte[]> RenderReport(string report, ParameterValue[] parameters, string exportFormat = "PDF")
{
var binding = new BasicHttpBinding(BasicHttpSecurityMode.TransportCredentialOnly);
binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Ntlm;
binding.MaxReceivedMessageSize = 100485760;
var rsExec = new ReportExecutionServiceSoapClient(binding, new EndpointAddress(url));
var clientCredentials = new NetworkCredential(userName, password);
rsExec.ClientCredentials.Windows.AllowedImpersonationLevel = System.Security.Principal.TokenImpersonationLevel.Impersonation;
rsExec.ClientCredentials.Windows.ClientCredential = clientCredentials;
TrustedUserHeader trustedUserHeader = new TrustedUserHeader();
LoadReportResponse taskLoadReport = null;
string historyID = null;
taskLoadReport = await rsExec.LoadReportAsync(trustedUserHeader, report, historyID);
ExecutionHeader executionHeader = new ExecutionHeader
{
ExecutionID = taskLoadReport.executionInfo.ExecutionID
};
await rsExec.SetExecutionParametersAsync(executionHeader, trustedUserHeader, parameters, null);
const string deviceInfo = @"<DeviceInfo><Toolbar>False</Toolbar><SimplePageHeaders>True</SimplePageHeaders></DeviceInfo>";
RenderResponse response = await rsExec.RenderAsync(new RenderRequest(executionHeader, trustedUserHeader, exportFormat ?? "PDF", deviceInfo));
return(response.Result);
}
public async Task <RenderResponse> Handler(RenderRequest request)
{
var response = new RenderResponse();
try
{
var serviceCollection = new ServiceCollection();
ConfigureServices(serviceCollection);
var serviceProvider = serviceCollection.BuildServiceProvider();
var templateStrategyProvider = new TemplateStrategyProvider(serviceProvider);
var strategy = templateStrategyProvider.GetStrategy(request.TemplateType);
CultureInfo.CurrentUICulture = new CultureInfo(request.Culture, true);
var htmlSource = await strategy.HandleAsync(request.ModelJson);
var premailerResult = PreMailer.Net.PreMailer.MoveCssInline(htmlSource, true);
response.HtmlResult = premailerResult.Html;
}
catch (Exception e)
{
response.Exception = e;
}
return(response);
}
private async Task Render(HttpRequest req, HttpResponse res, RouteData rd)
{
dynamic expando = new ExpandoObject();
expando.url = rd.Values["url"];
RenderResponse response = await this.nodeServices.InvokeAsync <RenderResponse>(@"aspnetshim.js", expando).ConfigureAwait(false);
res.StatusCode = response.code;
res.ContentType = "text/html";
await res.WriteAsync(response.response ?? "");
}
/// <summary>
/// Async executes a subtask on node
/// </summary>
private async Task <SubTaskResult> ExecuteSubTaskAsync(RenderNode node, RenderSubTask task)
{
RenderRequest req = task.GetRenderRequest();
Image bitmap = null;
Stopwatch time = new Stopwatch();
time.Start();
try
{
req.Settings.RenderType = node.RenderType;
RenderResponse resp = await node.Render(req);
if (resp == null)
{
return(new SubTaskResult(new Exception("Render fail: (null)")));
}
if (resp.Success == false)
{
return(new SubTaskResult(new Exception("Render fail: " + resp.Message)));
}
//Update Performance
node.UpdatePerformance((int)((req.Settings.Height * (req.Settings.Y2 - req.Settings.Y)) * (req.Settings.Width * (req.Settings.X2 - req.Settings.X))),
(int)time.ElapsedMilliseconds);
using (MemoryStream str = new MemoryStream(resp.Data))
bitmap = Bitmap.FromStream(str);
resp = null;
}
finally
{
time.Stop();
}
return(new SubTaskResult(bitmap));
}
// https://docs.microsoft.com/en-us/dotnet/api/reportexecution2005.reportexecutionservice.render?view=sqlserver-2016
// https://docs.microsoft.com/en-us/sql/reporting-services/customize-rendering-extension-parameters-in-rsreportserver-config?view=sql-server-ver15
// https://medium.com/@yates.programmer/generating-an-ssrs-report-using-wcf-from-net-core-application-730e22886da3
public async Task <byte[]> Render(string reportPath, string reportType = "PDF", string deviceInfo = null)
{
if (string.IsNullOrEmpty(reportPath))
{
throw new Exception("Missing required reportPath parameter");
}
reportType = reportType.ToUpper().Trim();
switch (reportType)
{
case "PDF":
case "EXCEL":
case "WORD":
case "XML":
case "CSV":
case "IMAGE":
case "HTML4.0":
case "MHTML":
break;
default:
throw new Exception("Invalid reportType: " + reportType);
}
TrustedUserHeader trustedHeader = new TrustedUserHeader();
LoadReportResponse loadReponse = await LoadReport(RSExecutionClient, trustedHeader, reportPath);
if (ReportParameters.Count > 0)
{
await RSExecutionClient.SetExecutionParametersAsync(
loadReponse.ExecutionHeader,
trustedHeader,
ReportParameters.ToArray(),
"en-US"
);
}
var renderRequest = new RenderRequest(loadReponse.ExecutionHeader, trustedHeader, reportType, deviceInfo);
RenderResponse response = await RSExecutionClient.RenderAsync(renderRequest);
if (response.Warnings != null)
{
foreach (ReportExecution.Warning warning in response.Warnings)
{
Warnings.Add(
new KeyValuePair <string, string>(
warning.Code,
String.Format(
"Severity: {0} Object: {1} Message: {2}",
warning.Severity,
warning.ObjectName,
warning.Message
)
)
);
}
}
Extension = response.Extension;
MimeType = response.MimeType;
Encoding = response.Encoding;
StreamIds = response.StreamIds;
return(response.Result);
}
