public Task <RenderResponse> RenderAsync(string executionId, RenderRequest request)
{
using (var context = this.SetMessageHeaders(executionId))
{
return(this.RenderAsync(request));
}
}
public static void GifNotification(DisplayWindow window, int displayTime, string imagineFile, string soundFile, int textheight, string content)
{
int oWidth = window.Width;
int oHeight = window.Height;
ImagineRequest imagineRender = new ImagineRequest()
{
x = 0,
y = 0,
width = oWidth,
height = oHeight - (textheight * 2),
};
imagineRender.SetFromFile(imagineFile);
TextRequest textRender = new TextRequest()
{
x = 5,
y = oHeight - (textheight * 2),
width = oWidth - 5,
height = textheight,
autoResize = true,
text = content,
};
SoundRequest soundRequest = new SoundRequest()
{
file = soundFile
};
RenderRequest request = new RenderRequest(displayTime, soundRequest, imagineRender, textRender);
window.EnqueueRenders(request);
}
public async Task <Report> RenderViewAsync(HttpContext context, RenderRequest renderRequest, RouteData routeData, string viewName, object model)
{
var str = await RenderViewToStringAsync(context, routeData, viewName, model);
renderRequest.Template.Content = str;
return(await _renderService.RenderAsync(renderRequest));
}
/// <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 <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);
}
public async Task <RenderResult> Post([FromBody] RenderRequest renderRequest)
{
try
{
var layoutServiceResult = renderRequest.Args.LayoutServiceResult;
_layoutServiceResultProvider.Result = layoutServiceResult;
var appType = _blazorAppConfiguration.AppComponentType;
var appDomElementSelector = _blazorAppConfiguration.AppDomElementSelector;
var pageEditing = layoutServiceResult.Sitecore.Context.PageEditing;
var appHtml = await _preRenderer.RenderAppAsync(appType, appDomElementSelector, ControllerContext, ViewData, TempData, pageEditing);
var resultModel = new RenderResult
{
Html = appHtml,
Status = (int)HttpStatusCode.OK
};
return(resultModel);
}
catch (Exception ex)
{
return(new RenderResult
{
Html = $"<html><body><h1>An error occurred during server-side rendering.</h1><div>{ex.Message}</div></body></html>",
Status = (int)HttpStatusCode.InternalServerError
});
}
}
private void getImage(string displayName, RenderRequest renderRequest)
{
if (UseCache)
{
if (!string.IsNullOrEmpty(renderRequest.Context))
{
if (avatarImageCacher.TryGetCachedImage(renderRequest.Handle, out var icon, renderRequest.Context))
{
pendingRenderRequests.Remove(displayName);
dispatchImageReady(renderRequest.Handle, icon);
return;
}
}
else
{
Log.LogErrorFormatted(this, "Could not find a context string to check the cache with for display name: {0}", displayName);
}
}
if (isRenderingActive)
{
renderImage(renderRequest);
}
else
{
pausedRenderRequests.Add(displayName);
}
}
public async Task <IActionResult> TestTemplate()
{
try
{
// *************************************************************
// Create output using json and mustache template
// *************************************************************
RenderRequest request = new RenderRequest()
{
JsonString = "{\"title\": \"Sample Template\", \"name\": \"McTesty\"}",
RenderJsUrl = _configuration.GetSection("Constants").GetSection("RenderJsUrl").Value,
Template = _configuration.GetSection("Constants").GetSection("SampleTemplate").Value
};
string result = await TemplateHelper.RenderDocument(_nodeServices, request);
// *************************************************************
// Convert results to Pdf
// *************************************************************
PdfRequest pdfRequest = new PdfRequest()
{
Html = "<h1>" + result + "<h1>",
PdfFileName = "TestTemplate"
};
byte[] pdfResponse = PdfDocument.BuildPdf(_configuration, pdfRequest);
return(File(pdfResponse, "application/pdf"));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public static string SerializeRenderRequest(RenderRequest rr, IContractResolver dataContractResolver = null)
{
// a hack to avoid camel casing the data prop values
var data = rr.Data;
rr.Data = null;
var js = new JsonSerializer()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
NullValueHandling = NullValueHandling.Ignore,
ReferenceLoopHandling = ReferenceLoopHandling.Serialize,
PreserveReferencesHandling = PreserveReferencesHandling.Objects
};
var jo = JObject.FromObject(rr, js);
if (data != null)
{
js.ContractResolver = dataContractResolver ?? new DefaultContractResolver();
jo["data"] = JObject.FromObject(data, js);
}
jo["overwrites"]?["template"]?.Values().ToList()
.ForEach((val => jo["template"][val.Path.Replace("overwrites.template.", "")] = val));
jo["overwrites"]?["options"]?.Values().ToList()
.ForEach((val => jo["options"][val.Path.Replace("overwrites.options.", "")] = val));
jo.Children().FirstOrDefault(c => c.Path.Contains("overwrites"))?.Remove();
return(jo.ToString());
}
public byte[] Render(string xml, string template, OutputFormat outputFormat)
{
try
{
var request = new RenderRequest
{
Input = new XmlDataSource
{
Content = xml,
Format = InputFormat.XML
},
Parameters = new RenderingParameters
{
OutputFormat = outputFormat,
PDFOutputSettings = new PDFOutputSettings {
ImageCompression = PDFImageCompression.FLAT
},
Template = new ServerDocumentTemplate {
ID = template
}
}
};
return(_ecrionServiceClient.Render(request).RenderResult);
}
catch (Exception ex)
{
throw ex;
}
}
public JsReportFeature(HttpContext context)
{
RenderRequest = new RenderRequest();
RenderRequest.Template.Engine = Types.Engine.None;
Context = context;
RenderRequest.Options.Base = $"{Context.Request.Scheme}://{Context.Request.Host}";
Enabled = true;
}
public JsReportFeature(HttpContextBase context)
{
RenderRequest = new RenderRequest();
RenderRequest.Template.Engine = Types.Engine.None;
Context = context;
RenderRequest.Options.Base = GetBaseUrl(context.Request);
Enabled = true;
}
private void UnqueueRender()
{
if (displayQueue.Count > 0 && !isRendering)
{
RenderRequest request = displayQueue.Dequeue();
request.Render(this);
isRendering = true;
}
}
public static RenderTicket CreateSuccess(RenderRequest request, int position)
{
return(new RenderTicket
{
IsEnqueued = true,
Worldname = request.Worldname,
Position = position
});
}
public static RenderTicket CreateDuplicate(RenderRequest request, int position)
{
return(new RenderTicket
{
IsEnqueued = false,
Worldname = request.Worldname,
Position = position,
Message = $"The job is already enqueued on position {position}."
});
}
private void Update()
{
RenderRequest r = requests[0];
r.lookDir = lookDir;
requests[0] = r;
exposureRenderer.RenderSize = new int2(renderSize.x, renderSize.y);
exposureRenderer.Render(requests, float4x4.identity);
}
private void onAvatarDetailsInitialized(AvatarDetailsData avatarDetailsData)
{
avatarDetailsData.OnInitialized -= onAvatarDetailsInitialized;
DataEntityHandle entityByComponent = dataEntityCollection.GetEntityByComponent(avatarDetailsData);
string displayName = dataEntityCollection.GetComponent <DisplayNameData>(entityByComponent).DisplayName;
if (pendingRenderRequests.ContainsKey(displayName))
{
RenderRequest renderRequest = pendingRenderRequests[displayName];
renderRequest.AvatarDetailsData = avatarDetailsData;
getImage(displayName, renderRequest);
}
}
public override void GetJobInfo(TaskListener <IList <JobInfo> > listener, IList <IRenderRequest> renderRequests)
{
IList <JobInfo> jobs = new List <JobInfo>();
for (int i = 0; i < renderRequests?.Count; ++i)
{
RenderRequest request = (RenderRequest)renderRequests[i];
string renderer = request.Browser.Name.GetAttribute <System.Runtime.Serialization.EnumMemberAttribute>().Value;
jobs.Add(new JobInfo()
{
EyesEnvironment = "MockEnvironment", Renderer = renderer
});
}
listener.OnComplete(jobs);
}
public async Task <Report> RenderAsync(RenderRequest request, CancellationToken ct = default)
{
var response = await _nodeServices.InvokeAsync <byte[]>("./wwwroot/create-pdf", request.Template.Content);
var stream = new MemoryStream();
stream.Write(response, 0, response.Length);
stream.Position = 0;
var meta = new Dictionary <string, string>();
return(new Report {
Content = stream,
Meta = SerializerHelper.ParseReportMeta(meta)
});
}
private void resumeRender(string displayName)
{
if (pendingRenderRequests.ContainsKey(displayName))
{
RenderRequest renderRequest = pendingRenderRequests[displayName];
if (renderRequest.AvatarDetailsData != null || dataEntityCollection.TryGetComponent <AvatarDetailsData>(renderRequest.Handle, out renderRequest.AvatarDetailsData))
{
getImage(displayName, renderRequest);
}
else
{
otherPlayerDetailsRequestBatcher.RequestOtherPlayerDetails(renderRequest.Handle);
}
}
}
protected override BitmapSource RenderDataFrame(DataRect data, Rect output, RenderRequest renderRequest)
{
var points = GetLastPointsInDataRect(data);
if (points == null)
{
return(EmptyBitmap);
}
else
{
_groupedMarkers.Transform = Plotter2D.Transform;
_groupedMarkers.LastSelection = LastSelectionArgs;
return(_groupedMarkers.DrawImage((int)output.Width, (int)output.Height, points, renderRequest));
}
}
private static async Task DebugExampleSingleTemplateAsync()
{
var model = new ExampleSingleTemplateModel
{
PlainText = "Test single template"
};
var request = new RenderRequest
{
ModelJson = JsonConvert.SerializeObject(model),
TemplateType = TemplateType.ExampleSingleTemplate,
Culture = "es-ES"
};
var result = await new RazorRendererFunction().Handler(request);
Console.Write(result);
}
public async Task <IActionResult> GetOwnerVerificationPdf([FromBody] string ownersJson, [FromRoute] string name)
{
try
{
string fileName = name + ".pdf";
_logger.LogInformation("GetOwnerVerificationPdf [FileName: {0}]", fileName);
// *************************************************************
// Create output using json and mustache template
// *************************************************************
RenderRequest request = new RenderRequest()
{
JsonString = ownersJson,
RenderJsUrl = _configuration.GetSection("Constants").GetSection("RenderJsUrl").Value,
Template = _configuration.GetSection("Constants").GetSection("OwnerVerificationTemplate").Value
};
_logger.LogInformation("GetOwnerVerificationPdf [FileName: {0}] - Render Html", fileName);
string result = await TemplateHelper.RenderDocument(_nodeServices, request);
_logger.LogInformation("GetOwnerVerificationPdf [FileName: {0}] - Html Length: {1}", fileName, result.Length);
// *************************************************************
// Convert results to Pdf
// *************************************************************
PdfRequest pdfRequest = new PdfRequest()
{
Html = result,
PdfFileName = fileName
};
_logger.LogInformation("GetOwnerVerificationPdf [FileName: {0}] - Gen Pdf", fileName);
byte[] pdfResponseBytes = PdfDocument.BuildPdf(_configuration, pdfRequest);
// convert to string and log
string pdfResponse = System.Text.Encoding.Default.GetString(pdfResponseBytes);
_logger.LogInformation("GetOwnerVerificationPdf [FileName: {0}] - Pdf Length: {1}", fileName, pdfResponse.Length);
_logger.LogInformation("GetOwnerVerificationPdf [FileName: {0}] - Done", fileName);
return(File(pdfResponseBytes, "application/pdf", fileName));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
private static async Task DebugExampleMultipleTemplatesAsync()
{
var model = new ExampleMultipleTemplatesModel
{
PlainText = "Test multiple template",
HtmlContent = "<hi>Html content for multiple template</h1>"
};
var request = new RenderRequest
{
ModelJson = JsonConvert.SerializeObject(model),
TemplateType = TemplateType.ExampleMultipleTemplates,
Culture = "es-ES"
};
var result = await new RazorRendererFunction().Handler(request);
Console.Write(result);
}
public void Evaluate(int SpreadMax)
{
FOut.Stream.IsChanged = false;
var valid = _input != null;
if (valid)
{
valid = _input.Spread.SliceCount > 0;
}
if (valid)
{
valid = _input[0] != null;
}
if (valid)
{
RenderRequest?.Invoke(this, FPluginHost);
if (!_input.Spread.IsChanged && !_typeChanged && !FFlagChanged[0])
{
return;
}
FOut.ResizeAndDismiss(_input.Spread.SliceCount, i => null);
for (int i = 0; i < _input.Spread.SliceCount; i++)
{
if (FOut[i] == null)
{
FOut[i] = new VAuxObject {
Object = _input[i]
}
}
;
var vaux = (VAuxObject)FOut[i];
vaux.Object = _input[i];
}
_typeChanged = false;
FOut.Stream.IsChanged = FFlagChanged[0];
}
else
{
FOut.Stream.IsChanged = _prevvalid;
FOut.SliceCount = 0;
}
_prevvalid = valid;
}
public async Task<ActionResult> Index()
{
var gitHubApi = RestService.For<IGitHubApi>("https://api.github.com");
var request = new RenderRequest
{
Text = "Hello **world**, this is sample markdown [with a URL](http://www.somewhere.com)",
Mode = "markdown"
};
var response = await gitHubApi.RenderAsMarkdown(request);
ViewBag.Markdown = request.Text;
ViewBag.Html = response;
return View();
}
/// <summary>
/// Spawn a prefab without any Components except visuals. Also prevents calling Awake methods of the prefab.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private static RenderObject SpawnSafe(RenderRequest request)
{
GameObject prefab = request.Target;
// map prefab GameObjects to the instantiated GameObjects
Dictionary <GameObject, GameObject> realToClone = new Dictionary <GameObject, GameObject>();
GameObject spawn = SpawnOnlyTransformsClone(prefab, null, realToClone);
foreach (var pair in realToClone)
{
CopyVisualComponents(pair.Key, pair.Value, realToClone);
}
spawn.transform.position = Vector3.zero;
spawn.transform.rotation = request.Rotation;
spawn.name = prefab.name;
// calculate visual center
Vector3 min = new Vector3(1000f, 1000f, 1000f);
Vector3 max = new Vector3(-1000f, -1000f, -1000f);
foreach (Renderer meshRenderer in spawn.GetComponentsInChildren <Renderer>())
{
min = Vector3.Min(min, meshRenderer.bounds.min);
max = Vector3.Max(max, meshRenderer.bounds.max);
}
// center the prefab
spawn.transform.position = SpawnPoint - (min + max) / 2f;
Vector3 size = new Vector3(
Mathf.Abs(min.x) + Mathf.Abs(max.x),
Mathf.Abs(min.y) + Mathf.Abs(max.y),
Mathf.Abs(min.z) + Mathf.Abs(max.z));
// just in case it doesn't gets deleted properly later
TimedDestruction timedDestruction = spawn.AddComponent <TimedDestruction>();
timedDestruction.Trigger(1f);
return(new RenderObject(spawn, size)
{
Request = request
});
}
/// <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));
}
public static string SerializeRenderRequest(RenderRequest rr)
{
var js = new JsonSerializer()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
NullValueHandling = NullValueHandling.Ignore,
ReferenceLoopHandling = ReferenceLoopHandling.Serialize,
PreserveReferencesHandling = PreserveReferencesHandling.Objects
};
var jo = JObject.FromObject(rr, js);
jo["overwrites"]?["template"]?.Values().ToList()
.ForEach((val => jo["template"][val.Path.Replace("overwrites.template.", "")] = val));
jo["overwrites"]?["options"]?.Values().ToList()
.ForEach((val => jo["options"][val.Path.Replace("overwrites.options.", "")] = val));
jo.Children().FirstOrDefault(c => c.Path.Contains("overwrites"))?.Remove();
return(jo.ToString());
}
public bool EnqueueRender(RenderRequest renderRequest, Action <Sprite> callback)
{
if (!renderRequest.Target)
{
throw new ArgumentException("Target is required");
}
if (callback == null)
{
throw new ArgumentException("Callback is required");
}
if (!renderRequest.Target.GetComponentsInChildren <Component>(false).Any(IsVisualComponent))
{
callback.Invoke(null);
return(false);
}
renderRequest.Callback = callback;
callback?.Invoke(Render(renderRequest));
return(true);
}
public async Task <Stream> GeneratePdf(
string bodyTemplate,
string headerTemplate = null,
string footerTemplate = null,
object templateData = null,
PageMargins margins = null,
PageFormat format = PageFormat.A4,
PageOrientation orientation = PageOrientation.Portrait,
CancellationToken cancellationToken = default(CancellationToken))
{
var renderRequest = new RenderRequest
{
Template = new Template
{
Engine = Engine.Handlebars,
Recipe = Recipe.ChromePdf,
Content = bodyTemplate,
Helpers = _handlebarsHelpers,
Chrome = new Chrome
{
Landscape = orientation == PageOrientation.Landscape,
Format = format.ToString(),
DisplayHeaderFooter = true,
HeaderTemplate = headerTemplate ?? " ",
FooterTemplate = footerTemplate ?? " ",
MarginTop = margins?.TopInPx != null ? $"{margins.TopInPx}px" : null,
MarginRight = margins?.RightInPx != null ? $"{margins.RightInPx}px" : null,
MarginBottom = margins?.BottomInPx != null ? $"{margins.BottomInPx}px" : null,
MarginLeft = margins?.LeftInPx != null ? $"{margins.LeftInPx}px" : null,
MediaType = MediaType.Print
}
},
Data = templateData
};
Report report = await _renderService.RenderAsync(renderRequest, cancellationToken);
return(report.Content);
}
public bool Lock(RenderRequest renderRequest)
{
IImageProvider provider = null;
if (pipelineEnd == null || !pipelineEnd.TryGetTarget(out provider))
return false;
else
return provider.Lock(renderRequest);
}
public bool Lock(RenderRequest renderRequest)
{
IImageProvider provider = null;
if (pipelineEnd == null || !pipelineEnd.TryGetTarget(out provider))
throw new InvalidOperationException("No image provider in the pipeline.");
else
return provider.Lock(renderRequest);
}
public bool Lock(RenderRequest renderRequest)
{
return m_imageProvider.Lock(renderRequest);
}
bool IImageProvider.Lock(RenderRequest renderRequest)
{
return true;
}
