/// <summary> /// Invokes the engine and returns the result of the invocation. /// </summary> /// <param name="engine">The engine.</param> /// <param name="type">The type.</param> /// <param name="path">The path.</param> /// <param name="context">The context.</param> /// <returns></returns> /// <exception cref="System.Exception">Unknown view type.</exception> public Task <ViewInvokeResult> InvokeEngine(IJsEngine engine, ViewType type, string path, ViewContext context) { if (type == ViewType.Full) { if (string.Equals(path, "{auto}", StringComparison.InvariantCultureIgnoreCase)) { path = context.HttpContext.Request.Path; if (context.HttpContext.Request.QueryString.HasValue) { path += context.HttpContext.Request.QueryString.Value; } } var result = engine.CallFunction("RenderView", path, context.ViewData.Model, context.ViewBag); return(Task.FromResult(new ViewInvokeResult { Html = result.html, Status = result.status, Redirect = result.redirect })); } if (type == ViewType.Partial) { return(Task.FromResult(new ViewInvokeResult { Html = (string)engine.CallFunction("RenderPartialView", path, context.ViewData.Model, context.ViewBag) })); } throw new Exception("Unknown view type."); }
public object Invoke(string jsv, params object[] pp) { try { return(engine.CallFunction(jsv, pp)); } catch (JsEngineException e) { Log.Logs.Instance.PushError($"[Script-{Version.id}] An engine-error occurred while running the script.\r\n" + e.Message); } catch (JsCompilationException e) { Log.Logs.Instance.PushError($"[Script-{Version.id}] An compile-error occurred while running the script.\r\n" + e.Message); } catch (JsRuntimeException e) { Log.Logs.Instance.PushError($"[Script-{Version.id}] An runtime-error occurred while running the script.\r\n" + e.Message); } catch (Exception e) { Log.Logs.Instance.PushError($"[Script-{Version.id}] " + e); } return(null); }
/// <summary> /// "Packs" a JS code by using Dean Edwards' Packer /// </summary> /// <param name="content">Text content of JS asset</param> /// <returns>Minified text content of JS asset</returns> public string Pack(string content) { Initialize(); string newContent; try { newContent = _jsEngine.CallFunction <string>(PACKING_FUNCTION_NAME, content, _options.Base62Encode, _options.ShrinkVariables); } catch (JsScriptException e) { string errorDetails = JsErrorHelpers.GenerateErrorDetails(e, true); var stringBuilderPool = StringBuilderPool.Shared; StringBuilder errorMessageBuilder = stringBuilderPool.Rent(); errorMessageBuilder.AppendLine(e.Message); errorMessageBuilder.AppendLine(); errorMessageBuilder.Append(errorDetails); string errorMessage = errorMessageBuilder.ToString(); stringBuilderPool.Return(errorMessageBuilder); throw new JsPackingException(errorMessage); } return(newContent); }
public PDDApi() { jsEngine.ExecuteFile(@"../../jm.js"); _nano_fp = (string)jsEngine.CallFunction("create_nano_fp"); Session.WithHeader("Accept", "application/json, text/plain, */*"); Session.WithHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36 Edg/85.0.564.68"); Session.Cookies.Add( "ua", new Cookie("ua", @"Mozilla%2F5.0%20(Windows%20NT%2010.0%3B%20 Win64%3B%20x64)%20AppleWebKit%2F537.36%20(KH TML%2C%20like%20Gecko)%20Chrome%2F85.0.4183.1 21%20Safari%2F537.36%20Edg%2F85.0.564.68")); Session.Cookies.Add( "_nano_fp", new Cookie("_nano_fp", _nano_fp)); }
private static string EncodeData(string data, string key, int keyId, out string Ctkey) { IJsEngineSwitcher engineSwitcher = JsEngineSwitcher.Current; engineSwitcher.EngineFactories.Add(new JurassicJsEngineFactory()); engineSwitcher.DefaultEngineName = JurassicJsEngine.EngineName; using (IJsEngine engine = JsEngineSwitcher.Current.CreateDefaultEngine()) { engine.Execute(DedeDataJsCode); if (keyId == 1) { engine.Execute("var this_UrlKey1 = 'db0FaVXtwixFUGGQ1Iq9dN7yMrJ9DFHQ';var this_UrlKey2 = 'R8nD2B0DRcT0IoFrA5UqHeHLeFsbrOBvXIVhKmgcXXcDLDrQemyyQLdDpAom9N'"); } var publickey = engine.CallFunction("getCtKey", key); Ctkey = publickey.ToString(); string PostjsonStr = engine.CallFunction("encode", data, publickey).ToString(); return(PostjsonStr); } }
public string Transform(string markdown) { _jsEngine.Evaluate(@"marked.setOptions({ highlight: function (code) { return hljs.highlightAuto(code).value; } });" ); return(_jsEngine.CallFunction <string>("marked", markdown)); }
/// <summary> /// Ensures that React has been correctly loaded into the specified engine. /// </summary> /// <param name="engine">Engine to check</param> private static void EnsureReactLoaded(IJsEngine engine) { var result = engine.CallFunction <bool>("ReactNET_initReact"); if (!result) { throw new ReactNotInitialisedException( "React has not been loaded correctly. Please expose your version of React as global " + "variables named 'React', 'ReactDOM', and 'ReactDOMServer', or enable the " + "'LoadReact' configuration option to use the built-in version of React." ); } }
/// <summary> /// Ensures that React has been correctly loaded into the specified engine. /// </summary> /// <param name="engine">Engine to check</param> private static void EnsureReactLoaded(IJsEngine engine) { var result = engine.CallFunction <string[]>("ReactNET_initReact"); if (result.Length != 0) { throw new ReactNotInitialisedException( $"React has not been loaded correctly: missing ({string.Join(", ", result)})." + "Please expose your version of React as global variables named " + "'React', 'ReactDOM', and 'ReactDOMServer', or enable the 'LoadReact'" + "configuration option to use the built-in version of React." ); } }
private static JObject DecodeData(string data, string key, out int keyId) { keyId = 0; IJsEngineSwitcher engineSwitcher = JsEngineSwitcher.Current; engineSwitcher.EngineFactories.Add(new JurassicJsEngineFactory()); engineSwitcher.DefaultEngineName = JurassicJsEngine.EngineName; using (IJsEngine engine = JsEngineSwitcher.Current.CreateDefaultEngine()) { engine.Execute(DedeDataJsCode); var publickey = engine.CallFunction("getCtKey", key); string PostjsonStr = engine.CallFunction("decode", data, publickey).ToString(); JObject jo; if (PostjsonStr.StartsWith("{")) { jo = JsonStringToJsonObj(PostjsonStr); if (jo != null) { return(jo); } } keyId = 1; engine.Execute("var this_UrlKey1 = 'db0FaVXtwixFUGGQ1Iq9dN7yMrJ9DFHQ';var this_UrlKey2 = 'R8nD2B0DRcT0IoFrA5UqHeHLeFsbrOBvXIVhKmgcXXcDLDrQemyyQLdDpAom9N'"); publickey = engine.CallFunction("getCtKey", key); PostjsonStr = engine.CallFunction("decode", data, publickey).ToString(); if (PostjsonStr.StartsWith("{")) { jo = JsonStringToJsonObj(PostjsonStr); if (jo != null) { return(jo); } } return(null); } }
/// <summary> /// Calls a JavaScript function using the specified engine. If <typeparamref name="T"/> is /// not a scalar type, the function is assumed to return a string of JSON that can be /// parsed as that type. /// </summary> /// <typeparam name="T">Type returned by function</typeparam> /// <param name="engine">Engine to execute function with</param> /// <param name="function">Name of the function to execute</param> /// <param name="args">Arguments to pass to function</param> /// <returns>Value returned by function</returns> public static T CallFunctionReturningJson <T>(this IJsEngine engine, string function, params object[] args) { if (ValidationHelpers.IsSupportedType(typeof(T))) { // Type is supported directly (ie. a scalar type like string/int/bool) // Just execute the function directly. return(engine.CallFunction <T>(function, args)); } // The type is not a scalar type. Assume the function will return its result as // JSON. var resultJson = engine.CallFunction <string>(function, args); try { return(JsonConvert.DeserializeObject <T>(resultJson)); } catch (JsonReaderException ex) { throw new ReactException(string.Format( "{0} did not return valid JSON: {1}.\n\n{2}", function, ex.Message, resultJson )); } }
public void CallFunction(string functionName, params object[] args) { new Thread(() => { try { setMessage("执行开始"); jsEngine.CallFunction(functionName, args); setMessage("执行结束"); } catch (Exception ex) { setMessage(ex.ToString()); } }).Start(); }
/// <summary> /// Ensures that React has been correctly loaded into the specified engine. /// </summary> /// <param name="engine">Engine to check</param> private void EnsureReactLoaded(IJsEngine engine) { var globalsString = engine.CallFunction <string>("ReactNET_initReact"); string[] globals = globalsString.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries); if (globals.Length != 0) { _scriptLoadException = new ReactNotInitialisedException( $"React has not been loaded correctly: missing ({string.Join(", ", globals)})." + "Please expose your version of React as global variables named " + "'React', 'ReactDOM', and 'ReactDOMServer', or enable the 'LoadReact'" + "configuration option to use the built-in version of React." ); } }
/// <summary> /// "Packs" a JS code by using Dean Edwards' Packer /// </summary> /// <param name="content">Text content of JS asset</param> /// <returns>Minified text content of JS asset</returns> public string Pack(string content) { Initialize(); string newContent; try { newContent = _jsEngine.CallFunction <string>(PACKING_FUNCTION_NAME, content, _options.Base62Encode, _options.ShrinkVariables); } catch (JsRuntimeException e) { throw new JsPackingException(JsErrorHelpers.Format(e)); } return(newContent); }
public string ProcessEvent(string serializedEvent) { /* * Avoid high memory usage as described in exploration 2020-02-02: * Use specialized implementation based on `CallFunction` instead of `Evaluate`. * * var eventExpression = AsJavascriptExpression(serializedEvent); * * var expressionJavascript = ProcessFromElm019Code.processEventSyncronousJsFunctionName + "(" + eventExpression + ")"; * * return EvaluateInJsEngineAndReturnResultAsString(expressionJavascript); */ var evalResult = javascriptEngine.CallFunction( ProcessFromElm019Code.processEventSyncronousJsFunctionName, serializedEvent); return(evalResult?.ToString()); }
private T CallJSFunction <T>(string functionName, params object[] args) { try { return(engine.CallFunction <T>(functionName, args)); } catch (JsCompilationException e) { Global.Error("行" + e.LineNumber + "列" + e.ColumnNumber + "编译错误:" + e.Description); throw e; } catch (JsRuntimeException e) { Global.Error("行" + e.LineNumber + "列" + e.ColumnNumber + "运行时错误:" + e.Description); throw e; } catch (Exception e) { Global.Error(e.Message); throw e; } }
public string Transform(string text, bool sanitize = true) { if (text == null) { throw new ArgumentNullException("text"); } string result; lock (_compilationSynchronizer) { Initialize(); _jsEngine.Evaluate(@" marked.setOptions({ gfm: true, tables: true, breaks: true, pedantic: false, sanitize: false, smartLists: true, silent: false, highlight: function (code) { return hljs.highlightAuto(code).value; }, langPrefix: '', smartypants: false, headerPrefix: '', renderer: new marked.Renderer(), xhtml: false });"); result = _jsEngine.CallFunction <string>("marked", text); } return((sanitize) ? HtmlUtility.SanitizeHtml(result) : result); }
public string Transform(string code, BabelConfig config, string fileName = "unknown") { return(_engine.CallFunction <string>("babelTransform", code, config.Serialize(), fileName)); }
public Model.TestTaskForm TemplateTestTaskToForm(string template) { CheckTemplateTestTask(template); Model.TestTaskForm result = new Model.TestTaskForm(); var jsonForm = _engine.CallFunction <string>("translateTemplateTestTaskToForm", new object[1] { template }); dynamic form = Newtonsoft.Json.JsonConvert.DeserializeObject <ExpandoObject>(jsonForm); result.Header = form.header; Int64 type = form.type; switch (type) { case 0: result.Type = "Short Answer"; break; case 1: result.Type = "Single Choose"; break; case 2: result.Type = "Multiply Choose"; break; default: Console.WriteLine("wtf " + (form.type == 0)); break; } result.Grammar = form.grammar; result.TaskText = form.testText; result.FeedbackScript = form.feedbackScript; return(result); }
/// <summary> /// Ensures that React has been correctly loaded into the specified engine. /// </summary> /// <param name="engine">Engine to check</param> private static void EnsureReactLoaded(IJsEngine engine) { var result = engine.CallFunction<bool>("ReactNET_initReact"); if (!result) { throw new ReactNotInitialisedException( "React has not been loaded correctly. Please expose your version of React as a global " + "variable named 'React', or enable the 'LoadReact' configuration option to " + "use the built-in version of React." ); } }
public void CallingOfFunctionWithoutParametersIsCorrect() { // Arrange const string functionCode = @"function hooray() { return 'Hooray!'; }"; const string targetOutput = "Hooray!"; // Act _jsEngine.Execute(functionCode); var output = (string)_jsEngine.CallFunction("hooray"); // Assert Assert.AreEqual(targetOutput, output); }
public object CallFunction(string functionName, params object[] args) { CheckDisposed(); return(_engine.CallFunction(functionName, args)); }
/// <summary> /// Ensures that React has been correctly loaded into the specified engine. /// </summary> /// <param name="engine">Engine to check</param> private static void EnsureReactLoaded(IJsEngine engine) { var result = engine.CallFunction<bool>("ReactNET_initReact"); if (!result) { throw new ReactNotInitialisedException( "React has not been loaded correctly. Please expose your version of React as global " + "variables named 'React', 'ReactDOM' and 'ReactDOMServer', or enable the " + "'LoadReact' configuration option to use the built-in version of React. See " + "http://reactjs.net/guides/byo-react.html for more information." ); } }
public string Transform(string markdown) { return(_jsEngine.CallFunction <string>("marked", markdown)); }