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()); }