public async Task <IActionResult> Get([FromServices] INodeServices nodeServices)
{
string filename = @"GeneratePDF.pdf";
//var sb = new StringBuilder();
var html = @"
<html>
<head>
</head>
<body style='padding-left:10px'>
<p>HTML to PDF convert</p>
<br><p>PDF Genetation</p>
</body>
</html>
";
try
{
var htmlContent = html;
var webRoot = _hostingEnvironment.WebRootPath;
var result = await _nodeServices.InvokeAsync <byte[]>(webRoot + "/pdf", htmlContent);
HttpContext.Response.ContentType = "application/pdf";
var filePath = webRoot + "/Downloads" + $@"/{ filename}";
bool fileExists = (System.IO.File.Exists(filePath) ? true : false);
if (fileExists == true)
{
Random random = new Random();
var randomNum = random.Next(99999).ToString();
filename = randomNum + filename;
filePath = webRoot + "/Downloads" + $@"/{ filename}";
}
FileStream fileStream = new FileStream(filename, FileMode.Create, FileAccess.ReadWrite);
fileStream.Write(result, 0, result.Length);
fileStream.Close();
}
catch (Exception e)
{
Console.WriteLine("An error occurred: '{0}'", e);
}
return(Ok(true));
}
public static async Task <JsonResponse> BuildPdf(INodeServices nodeServices, PdfRequest request)
{
try
{
JObject options = JObject.Parse(request.Options);
JsonResponse result = await nodeServices.InvokeAsync <JsonResponse>(request.PdfJsUrl, request.Html, options);
return(result);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <JsonResult> MyAction(string id, [FromServices] INodeServices nodeServices)
{
var queryStrings = Request.Query;
string config = "pg://*****:*****@[email protected]:5432/postgres";
DBConfigModel model = new DBConfigModel()
{
type = "pg",
config = config,
query = string.Format("SELECT * FROM public.apisrepository {0}", (string.IsNullOrEmpty(id))? string.Empty:"where id = " + id)
};
ResponseObj result = await nodeServices.InvokeAsync <ResponseObj>("./NodeApp/db-config-main", "GET", model);
return(Json(result));
}
public async Task <IActionResult> GeneratePdf([FromServices] INodeServices nodeServices, [FromServices] IHostingEnvironment env)
{
var data = GetHtmlTicket(env);
if (data == null)
{
return(NotFound());
}
var options = new { format = "Letter" };
var result = await nodeServices.InvokeAsync <Stream>("generatePdf.js", options, data);
return(File(result, "application/pdf"));
}
public async Task <IActionResult> Chart([FromServices] INodeServices nodeServices)
{
var options = new { width = 400, height = 200 };
var data = new[] {
new { label = "Abulia", count = 10 },
new { label = "Betelgeuse", count = 20 },
new { label = "Cantaloupe", count = 30 },
new { label = "Dijkstra", count = 40 }
};
ViewData["ChartImage"] = await nodeServices.InvokeAsync <string>("NodeChart.js", options, data);
return(View());
}
public async Task <bool> TryTakeScreenshotAsync(string url, string pngFilePath)
{
try
{
var file = await nodeServices.InvokeAsync <string>("nsTakeScreenshot.js", url, pngFilePath);
return(File.Exists(file));
}
catch (Exception ex)
{
Console.WriteLine("Unable to take screenshot: " + ex.Message);
// Console.WriteLine(ex.Dump());
return(false);
}
}
public async Task <string> Render(string template, object data)
{
var scriptPath = HostingEnvironment.MapPath("~/Node/renderNunjucks");
var templateDirectory = HostingEnvironment.MapPath("~/Content/templates");
var result = await _nodeServices.InvokeAsync <string>(
scriptPath,
template,
templateDirectory,
data
);
return(result);
}
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)
});
}
public async Task <IActionResult> About([FromServices] INodeServices nodeServices)
{
HttpClient hc = new HttpClient();
var htmlContent = await hc.GetStringAsync($"http://{Request.Host}/uploads/report.html");
var result = await nodeServices.InvokeAsync <byte[]>("./pdf", htmlContent);
HttpContext.Response.ContentType = "application/pdf";
HttpContext.Response.Headers.Add("x-filename", "report.pdf");
HttpContext.Response.Headers.Add("Access-Control-Expose-Headers", "x-filename");
HttpContext.Response.Body.Write(result, 0, result.Length);
return(View());
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, INodeServices node)
{
loggerFactory.AddConsole();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.Run(async(context) =>
{
var result = node.InvokeAsync <int>("./node/node", 1, 2).Result;
await context.Response.WriteAsync($"Hello World!{result}");
});
}
public async Task Run(INodeServices nodeServices)
{
if (Variables.Step == "1")
{
var data = await nodeServices.InvokeAsync <string>("transform", File.ReadAllText(Variables.SourceJsonPath), File.ReadAllText("./processes.json"), Variables.SourceStateDiagramId, Variables.DestinationStateDiagramId);
File.WriteAllText("Content.json", data);
Variables.Step = "2";
}
if (Variables.Step == "2")
{
Console.WriteLine("Enter destination json path");
Variables.DestinationJsonPath = Console.ReadLine();
dynamic data = JsonConvert.DeserializeObject(await nodeServices.InvokeAsync <string>("process", File.ReadAllText(Variables.DestinationJsonPath), File.ReadAllText("./processes.json")));
File.WriteAllText("NewProcesses.json", JsonConvert.SerializeObject(data.processes, Formatting.Indented));
File.WriteAllText("ProcessNames.json", JsonConvert.SerializeObject(data.processNames, Formatting.Indented));
}
Console.WriteLine("Done");
}
public void INodeServices_Concurrency_Setup()
{
var services = new ServiceCollection();
services.AddNodeServices(options =>
{
options.ProjectPath = _projectPath;
options.WatchFileExtensions = null;
});
_serviceProvider = services.BuildServiceProvider();
_nodeServices = _serviceProvider.GetRequiredService <INodeServices>();
// Warmup. First run starts a Node.js processes.
_nodeServices.InvokeAsync <DummyResult>("dummyLatencyModule.js", 0).GetAwaiter().GetResult();
}
public async Task <IActionResult> Resize(string imagePath, int width,
[FromServices] IHostingEnvironment environment,
[FromServices] INodeServices nodeServices)
{
var fileInfo = environment.WebRootFileProvider.GetFileInfo(imagePath);
if (!fileInfo.Exists)
{
return(NotFound());
}
var result = await nodeServices.InvokeAsync <string>(
"imageresizer.js", fileInfo.PhysicalPath, width);
return(Content(result));
}
private DhtData?ReadSingleResult()
{
Thread.Sleep(1000); // a short delay to avoid issues with sensor called too often
try
{
var data = _nodeServices.InvokeAsync <DhtData>("./DhtReader/readDhtData", _pin).GetAwaiter().GetResult();
return(data);
}
catch (Exception ex)
{
_log.LogError(ex, "Unable to read data from node-dht");
return(null);
}
}
public async Task <IActionResult> Index(int TransportId, [FromServices] INodeServices nodeServices)
{
var hasData = this.mapper.Map <TblTransportData, TransportData2ViewModel>(this.repository.GetTblTransportDataWithKey(TransportId));
HttpClient hc = new HttpClient();
var htmlContent = await hc.GetStringAsync($"http://{Request.Host}/reports/report.html");
//Class to Json
var Json = JsonConvert.SerializeObject(hasData, this.DefaultJsonSettings);
var result = await nodeServices.InvokeAsync <byte[]>("./JS/exportpdf", htmlContent, Json);
return(File(result, "application/pdf", "report.pdf"));
//return new ContentResult();
}
public void INodeServices_Latency_Setup()
{
var services = new ServiceCollection();
services.AddNodeServices(options =>
{
options.ProjectPath = _projectPath;
options.WatchFileExtensions = null;
});
_serviceProvider = services.BuildServiceProvider();
_nodeServices = _serviceProvider.GetRequiredService <INodeServices>();
_counter = 0;
// Warmup. First run starts a Node.js process.
_nodeServices.InvokeAsync <DummyResult>(DUMMY_LATENCY_MODULE_FILE, 0).GetAwaiter().GetResult();
}
public async Task <IActionResult> Index([FromServices] INodeServices nodeServices)
{
try
{
string s = "FE344FEAEA4D8E5169A6D8F25C86681773B8CF69BB920BCC7DF44892F129091C";
var result = await nodeServices.InvokeAsync <dynamic>("wwwroot/Scripts/test.js", s);
ViewBag.result = result.data;
//return Content(result);
}
catch (Exception ex)
{
return(Content(ex.Message));
}
return(View());
}
/// <summary>
/// 通过Google.cn 翻译
/// </summary>
/// <param name="text">需要翻译的文本</param>
/// <param name="fromLang">需要翻译的文本语言。自动:auto</param>
/// <param name="toLang">目标语言。英文:en</param>
/// <param name="nodeServices">nodeServices</param>
/// <returns></returns>
public static async Task <string> Translate(string text, string fromLang, string toLang, INodeServices nodeServices)
{
CookieContainer cc = new CookieContainer();
string GoogleTransBaseUrl = "https://translate.google.cn/";
var BaseResultHtml = GetResultHtml(GoogleTransBaseUrl, cc, "");
Regex re = new Regex(@"(?<=tkk:')(.*?)(?=')");
string tkk = re.Match(BaseResultHtml).ToString();//在返回的HTML中正则匹配TKK的值
string tk = await nodeServices.InvokeAsync <string>("./wwwroot/js/gettk", text, tkk);
string googleTransUrl = "https://translate.google.cn/translate_a/single?client=t&sl=" + fromLang + "&tl=" + toLang + "&hl=en&dt=at&dt=bd&dt=ex&dt=ld&dt=md&dt=qca&dt=rw&dt=rm&dt=ss&dt=t&ie=UTF-8&oe=UTF-8&otf=1&ssel=0&tsel=0&kc=1&tk=" + tk + "&q=" + HttpUtility.UrlEncode(text);
var ResultHtml = GetResultHtml(googleTransUrl, cc, "https://translate.google.cn/");
dynamic TempResult = Newtonsoft.Json.JsonConvert.DeserializeObject(ResultHtml);
string ResultText = Convert.ToString(TempResult[0][0][0]);
return(ResultText);
}
public void INodeServices_RealWorkload_Setup()
{
var services = new ServiceCollection();
services.AddNodeServices(options =>
{
options.ProjectPath = _projectPath;
options.WatchFileExtensions = null;
});
_serviceProvider = services.BuildServiceProvider();
_nodeServices = _serviceProvider.GetRequiredService <INodeServices>();
_counter = 0;
// Warmup. First run starts a Node.js process.
_nodeServices.InvokeAsync <DummyResult>("dummyLatencyModule.js", 0).GetAwaiter().GetResult(); // Doesn't support invoke from string, so this is the simplest/quickest
}
public async Task <IActionResult> Facture([FromServices] INodeServices nodeServices)
{
HttpClient hc = new HttpClient();
var host = Request.Host.ToString() + Request.Path.ToString() + Request.QueryString.ToString();
var b = Request.QueryString;
var htmlContent = await hc.GetStringAsync($"http://{Request.Host}/Factures/Details/2");
var result = await nodeServices.InvokeAsync <byte[]>("./pdf", htmlContent);
HttpContext.Response.ContentType = "application/pdf";
HttpContext.Response.Headers.Add("x-filename", "report.pdf");
HttpContext.Response.Headers.Add("Access-Control-Expose-Headers", "x-filename");
HttpContext.Response.Body.Write(result, 0, result.Length);
return(new ContentResult());
}
public async Task GeneratePDFDocument(string htmlFilePath, ImportStatusLog ipermit, INodeServices nodeServices, string documenttypeCode, string submoduleCode, ImportPermit iipermit)
{
try {
var letterHeading = await _letterHeadingService.GetAsync(1);
var letter = (await _letterService.GetAsync(x => x.ModuleDocument.DocumentType.DocumentTypeCode == documenttypeCode && x.ModuleDocument.Submodule.SubmoduleCode == submoduleCode));
var moduleDocument = await _moduleDocumentService.GetAsync(letter.ModuleDocumentID);
var moduleCode = moduleDocument.Submodule.Module.ModuleCode;
IpermitPDFData data = new IpermitPDFData(iipermit, letterHeading, letter, ipermit.Comment);
var ipemitStatues = (await _statusService.GetIPermitStatus(iipermit.ID));
data.submissionDate = ipemitStatues.FirstOrDefault(s => s.ToImportPermitStatus.ImportPermitStatusCode == "RQST")?.CreatedDate.ToString();
data.approvedDate = ipemitStatues.FirstOrDefault(s => s.ToImportPermitStatus.ImportPermitStatusCode == "APR")?.CreatedDate.ToString();
data.rejectedDate = ipemitStatues.FirstOrDefault(s => s.ToImportPermitStatus.ImportPermitStatusCode == "REJ")?.CreatedDate.ToString();
data.expiryDate = iipermit.ExpiryDate?.ToString();;
data.reason = ipemitStatues.FirstOrDefault(s => s.ToImportPermitStatus.ImportPermitStatusCode == "REJ")?.Comment;
var htmlString = string.Join(" ", System.IO.File.ReadAllLines(htmlFilePath));
htmlString = buildCSS(htmlString);
var pdfPath = $".{Path.DirectorySeparatorChar}external{Path.DirectorySeparatorChar}js{Path.DirectorySeparatorChar}pdf";
var result = await nodeServices.InvokeAsync <byte[]> (pdfPath, htmlString, data);
var relativeDirectory = $"{Path.DirectorySeparatorChar}{moduleCode}{Path.DirectorySeparatorChar}{data.tempFolderName}";
var directory = $"{_rootUrl}{relativeDirectory}";
var filePath = $"{relativeDirectory}{Path.DirectorySeparatorChar}{data.fileName}";
await FileHelper.SaveFileAsync(directory, data.fileName, result);
Domain.Document.Document docEntity = new Domain.Document.Document()
{
ModuleDocumentID = letter.ModuleDocumentID,
FilePath = filePath,
FileType = "application/pdf",
ReferenceID = ipermit.ID,
CreatedBy = ipermit.ChangedBy,
UpdatedBy = ipermit.ChangedBy
};
await _documentService.CreateOrUpdateAsync(docEntity, true, r => r.ModuleDocumentID == docEntity.ModuleDocumentID && r.FilePath == docEntity.FilePath && r.ReferenceID == docEntity.ReferenceID);
} catch (Exception ex) {
_logger.Log(ex);
}
}
private async Task <JSONResponse> BuildReport(INodeServices nodeServices)
{
JSONResponse result = null;
var options = new { format = "letter", orientation = "landscape" };
var opts = new
{
orientation = "landscape",
};
string rawdata = "<!DOCTYPE html><html><head><meta charset='utf-8' /><title></title></head><body><div style='width: 100%; background-color:lightgreen'>Section 1</div><br><div style='page -break-after:always; '></div><div style='width: 100%; background-color:lightgreen'>Section 2</div></body></html>";
// execute the Node.js component
result = await nodeServices.InvokeAsync <JSONResponse>("pdf.js", rawdata, options);
return(result);
}
public async Task <IActionResult> Index(
[FromServices] INodeServices nodeServices)
{
var options = new // pass any html-pdf options here
{
width = "50mm",
height = "90mm"
};
var stream = await nodeServices.InvokeAsync <Stream>(
"./Node/createPdf.js",
HTML,
options
);
return(File(stream, "application/pdf"));
}
public async Task <IActionResult> Chart([FromServices] INodeServices nodeServices)
{
var options = new { width = 400, height = 200, showArea = true, showPoint = true, fullWidth = true };
var data = new
{
labels = new[] { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" },
series = new[] {
new[] { 1, 5, 2, 5, 4, 3 },
new[] { 2, 3, 4, 8, 1, 2 },
new[] { 5, 4, 3, 2, 1, 0 }
}
};
ViewData["ChartMarkup"] = await nodeServices.InvokeAsync <string>("./Node/renderChart", "line", options, data);
return(View());
}
public async Task <ActionResult <string> > GetAsync(string keyword, [FromQuery] DateTime?startTime, [FromQuery] DateTime?endTime,
[FromQuery] string geo, [FromQuery] string hl, [FromQuery] int?timeZone, [FromQuery] int?category, [FromQuery] bool?granularTimeResolution)
{
string result;
try
{
var request = new Request(keyword, startTime, endTime, geo, hl, timeZone, category, granularTimeResolution);
result = await _nodeServices.InvokeAsync <string>("./Node/InterestOverTime", request);
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(BadRequest(e.Message));
}
return(Ok(result));
}
private static async Task RunServiceAsync(CancellationToken cancellationToken = default(CancellationToken))
{
// Start server
INodeServices nodeService = ServiceLocator.Current.GetService <INodeServices>();
if (nodeService == null)
{
nodeService = NodeServicesFactory.CreateNodeServices(new NodeServicesOptions(ServiceLocator.Current));
}
string result = nodeService.InvokeAsync <string>("server.js").Result;
PrintNodeJsOutput(result);
await AwaitCancellation(cancellationToken);
//await nodeService.InvokeAsync<string>("Shutdown").Result;
}
public async Task <IActionResult> MyActionS([FromServices] INodeServices nodeServices, [FromRoute] int id)
{
User user = new User {
Name = "Ivan", Street = "Brace RADIĆ"
};
var result = await nodeServices.InvokeAsync <byte[]>("./pdfSingle", user);
HttpContext.Response.ContentType = "application/pdf";
string filename = @"report.pdf";
HttpContext.Response.Headers.Add("x-filename", filename);
HttpContext.Response.Headers.Add("Access-Control-Expose-Headers", "x-filename");
HttpContext.Response.Body.Write(result, 0, result.Length);
return(new ContentResult());
}
/// <summary>
/// Renders the tree using ELK.js.
/// </summary>
private async Task <string> RenderTree(INodeServices js, TreeLayoutVM tree)
{
var thoroughness = Interpolator.MapValue(
_config.GetDynamicConfig().TreeRenderThoroughness,
new IntervalMap(1, 10, 1, 10),
new IntervalMap(11, 50, 11, 600),
new IntervalMap(51, 100, 301, 15000)
);
var json = JsonConvert.SerializeObject(tree);
var result = await js.InvokeAsync <string>("./External/tree/tree-layout.js", json, thoroughness);
if (string.IsNullOrEmpty(result))
{
throw new Exception("Failed to render tree: output is empty.");
}
return(result);
}
public async Task CreatePdf(string id, [FromServices] INodeServices nodeServices)
{
try
{
var entity = await _service.FindAsync(
id, include => include.User, include => include.Vehicle,
include => include.Vehicle.VehicleBrand,
include => include.Vehicle.VehicleModel,
include => include.Vehicle.VehicleCategory
);
var result = await nodeServices.InvokeAsync <byte[]>(
"./pdf",
SerializeAndDeserializeIgnoringCyclicDependencies(entity.User),
SerializeAndDeserializeIgnoringCyclicDependencies(entity.Vehicle),
SerializeAndDeserializeIgnoringCyclicDependencies(entity)
);
HttpContext.Response.ContentType = "application/pdf";
HttpContext.Response.Headers.Add("x-filename", "Contrato de Locacao.pdf");
HttpContext.Response.Headers.Add("Access-Control-Expose-Headers", "x-filename");
HttpContext.Response.StatusCode = 200;
await HttpContext.Response.Body.WriteAsync(result, 0, result.Length);
}
catch (NotFoundException exception)
{
_logger.Log(LogLevel.Error, exception, exception.Message);
HttpContext.Response.StatusCode = 404;
var obj = JsonConvert.SerializeObject(new { Message = exception.Message });
var objBytes = System.Text.Encoding.UTF8.GetBytes(obj);
await HttpContext.Response.Body.WriteAsync(objBytes, 0, objBytes.Length);
}
catch (Exception exception)
{
_logger.Log(LogLevel.Error, exception, exception.Message);
HttpContext.Response.StatusCode = 500;
var obj = JsonConvert.SerializeObject(new { Message = exception.Message });
var objBytes = System.Text.Encoding.UTF8.GetBytes(obj);
await HttpContext.Response.Body.WriteAsync(objBytes, 0, objBytes.Length);
}
}
public async Task <IActionResult> Index([FromServices] INodeServices nodeServices)
{
var dummyWeatherData = new
{
cityName = "Istanbul",
detail = "Rainy",
highValue = 14,
lowValue = 9
};
var options = new
{
componentName = "WeatherCardTemplate.js",
data = dummyWeatherData
};
ViewData["ResultFromNode"] = await nodeServices.InvokeAsync <string>("wwwroot/js/ComponentRunner.js", options);
return(View());
}
