/// <inheritdoc/>
public override AnalysisValueIntermediateResult ResultWithArgumentRowContextValueContext(JsValue argument, AnalysisProcessingQueryResultRowExecutionContext rowContext, AnalysisProcessingValueExecutionContext valueContext)
{
JavascriptEngine engine = JavascriptEngine.Current;
double maximumValue = 0;
bool first = true;
var arr = JavascriptEngine.ArrayForValue(argument);
if (arr == null)
{
return(new AnalysisValueIntermediateResult(0));
}
foreach (JsValue v in arr)
{
double curVal = JavascriptEngine.DoubleForObject(v);
if (first)
{
maximumValue = curVal;
first = false;
}
else if (curVal > maximumValue)
{
maximumValue = curVal;
}
}
return(new AnalysisValueIntermediateResult(maximumValue));
}
/// <inheritdoc/>
public override AnalysisValueIntermediateResult ResultWithArgumentRowContextValueContext(JsValue argument, AnalysisProcessingQueryResultRowExecutionContext rowContext, AnalysisProcessingValueExecutionContext valueContext)
{
JavascriptEngine engine = JavascriptEngine.Current;
var arr = JavascriptEngine.ArrayForValue(argument);
if (arr == null || arr.Count < 3)
{
return(new AnalysisValueIntermediateResult(0));
}
double curVal = JavascriptEngine.DoubleForObject(arr[0]);
double minVal = JavascriptEngine.DoubleForObject(arr[1]);
double maxVal = JavascriptEngine.DoubleForObject(arr[2]);
if (minVal <= curVal && curVal <= maxVal)
{
if (arr.Count > 3)
{
return(new AnalysisValueIntermediateResult(JavascriptEngine.DoubleForObject(arr[3])));
}
else
{
return(new AnalysisValueIntermediateResult(1));
}
}
else if (arr.Count > 4)
{
return(new AnalysisValueIntermediateResult(JavascriptEngine.DoubleForObject(arr[4])));
}
else
{
return(new AnalysisValueIntermediateResult(0));
}
}
public void DiffKeysWithArrays()
{
using (var engine = new JavascriptEngine()) {
engine.Execute("var a = {};");
var startObj = engine.ExecuteAndReturn("a");
engine.Execute("var a = {};");
engine.Execute("a.users = []");
var endObj = engine.ExecuteAndReturn("a");
// Added
var diff = new ObjectDiff();
diff.Diff(startObj, endObj, "a");
Assert.AreEqual(1, diff.Added.Count);
Assert.AreEqual("a.users", diff.Added.Keys.First(), "It actually equals " + diff.Added.Keys.First());
var val = JsonConvert.SerializeObject(diff.Added.First().Value);
Assert.AreEqual("[]", val);
}
using (var engine = new JavascriptEngine())
{
engine.Execute("var a = {};");
engine.Execute("a.users = []");
var startObj = engine.ExecuteAndReturn("a");
engine.Execute("var a = {};");
engine.Execute("a.users = []");
engine.Execute("a.users[1] = 12");
var endObj = engine.ExecuteAndReturn("a");
// Added
var diff = new ObjectDiff();
diff.Diff(startObj, endObj, "a");
Assert.AreEqual(2, diff.Added.Count);
Assert.True(diff.Added.ContainsKey("a.users[0]"));
Assert.True(diff.Added.ContainsKey("a.users[1]"));
// Deleted
diff = new ObjectDiff();
diff.Diff(endObj, startObj, "a");
Assert.AreEqual(2, diff.Deleted.Count);
Assert.True(diff.Deleted.Contains("a.users[0]"));
Assert.True(diff.Deleted.Contains("a.users[1]"));
// Modified
engine.Execute("var a = {};");
engine.Execute("a.users = []");
engine.Execute("a.users[1] = 14");
var changedObj = engine.ExecuteAndReturn("a");
diff = new ObjectDiff();
diff.Diff(endObj, changedObj, "a");
Assert.AreEqual(1, diff.Modified.Count);
Assert.AreEqual("a.users[1]", diff.Modified.Keys.First(), "It actually equals " + diff.Modified.Keys.First());
}
}
/// <summary>
/// Package typed document asynchronously
/// </summary>
/// <typeparam name="T">Type of document body</typeparam>
/// <param name="request">Request to be packaged</param>
/// <param name="responseTask">Reponse task to be packaged</param>
/// <returns>Packaged document</returns>
protected async Task <IDocument <T> > PackageAndAddDocumentAsync <T>(IRestRequest request, Task <IRestResponse <T> > responseTask)
{
Uri requestUri = _restClient.BaseUrl;
IRestResponse <T> response = await responseTask;
HtmlParser parser = new HtmlParser();
IHtmlDocument htmlDocument = parser.ParseDocument(response.Content);
IDocument <T> document = new Document <T>(request, response, htmlDocument);
Task <int> result = null;
Task <int> styleResult = null;
if (JavascriptScrapingEnabled)
{
result = JavascriptEngine.AddAsync(document);
}
if (StyleScrapingEnabled)
{
styleResult = StyleEngine.AddAsync(document);
}
if (JavascriptScrapingEnabled && result != null)
{
await result;
}
if (StyleScrapingEnabled && styleResult != null)
{
await styleResult;
}
document.RequestUri = requestUri;
Documents.Add(document);
return(document);
}
/// <inheritdoc/>
public override AnalysisValueIntermediateResult ResultWithArgumentRowContextValueContext(JsValue argument, AnalysisProcessingQueryResultRowExecutionContext rowContext, AnalysisProcessingValueExecutionContext valueContext)
{
AnalysisResultCounter resultCounter;
if (!string.IsNullOrEmpty(rowContext.XCategoryKey))
{
resultCounter = valueContext.ContextForYCategoryValueXCategoryValue(rowContext.YCategoryKey, rowContext.XCategoryKey) as AnalysisResultCounter;
}
else
{
resultCounter = valueContext.ContextForYCategoryValue(rowContext.YCategoryKey) as AnalysisResultCounter;
}
if (resultCounter == null)
{
resultCounter = new AnalysisResultCounter();
if (!string.IsNullOrEmpty(rowContext.XCategoryKey))
{
valueContext.SetContextForYCategoryValueXCategoryValue(resultCounter, rowContext.YCategoryKey, rowContext.XCategoryKey);
}
else
{
valueContext.SetContextForYCategoryValue(resultCounter, rowContext.YCategoryKey);
}
}
resultCounter.AddValue(JavascriptEngine.DoubleForValue(argument));
return(new AnalysisValueIntermediateResultDelayed(resultCounter, rowContext));
}
/// <summary>
/// Secondary initializer
/// </summary>
/// <param name="javascriptEngine"></param>
/// <param name="styleEngine"></param>
/// <param name="restClient"></param>
/// <param name="cookieContainer"></param>
/// <param name="historyManager"></param>
/// <param name="styleScrapingEnabled"></param>
/// <param name="javascriptScrapingEnabled"></param>
/// <param name="defaultUriProtocol"></param>
public StandardCore(JavascriptEngine javascriptEngine, StyleEngine styleEngine,
RestClient restClient, CookieContainer cookieContainer,
HistoryManager historyManager, bool styleScrapingEnabled,
bool javascriptScrapingEnabled, string defaultUriProtocol) :
base(javascriptEngine, styleEngine, restClient,
cookieContainer, historyManager, styleScrapingEnabled,
javascriptScrapingEnabled, defaultUriProtocol)
{
}
/// <inheritdoc/>
public override AnalysisValueIntermediateResult ResultWithArgumentRowContextValueContext(JsValue argument, AnalysisProcessingQueryResultRowExecutionContext rowContext, AnalysisProcessingValueExecutionContext valueContext)
{
double argumentValue;
double weight = 0;
bool defaultWeight = true;
JavascriptEngine engine = JavascriptEngine.Current;
if (JavascriptEngine.IsObject(argument))
{
var arr = JavascriptEngine.ArrayForValue(argument);
if (arr.Count > 0)
{
object argobj = arr[0];
argumentValue = argobj.ToDouble();
}
else
{
argumentValue = 0;
}
if (arr.Count > 1)
{
object argobj = arr[1];
weight = argobj.ToDouble();
defaultWeight = false;
}
}
else
{
argumentValue = JavascriptEngine.DoubleForValue(argument);
}
if (defaultWeight)
{
if (rowContext.ProcessingContext.Analysis.WeightField != null)
{
string weightStringValue = rowContext.Row.RawValueAtIndex(rowContext.ProcessingContext.Analysis.WeightField.QueryResultFieldIndex);
if (weightStringValue?.Length > 0)
{
weight = weightStringValue.ToDouble();
}
else
{
weight = 1;
}
}
else
{
weight = 1;
}
}
return(new AnalysisValueIntermediateResult(argumentValue * weight));
}
/// <summary>
/// Default Constructor
/// </summary>
public BrowserCore()
{
_javascriptEngine = new JavascriptEngine();
_styleEngine = new StyleEngine();
_restClient = new RestClient();
_restClient.CookieContainer = new CookieContainer();
_history = new HistoryManager();
_styleScrapingEnabled = true;
_javascriptScrapingEnabled = true;
DefaultUriProtocol = "http";
}
/// <inheritdoc/>
public override AnalysisValueIntermediateResult ResultWithArgumentRowContextValueContext(JsValue argument, AnalysisProcessingQueryResultRowExecutionContext rowContext, AnalysisProcessingValueExecutionContext valueContext)
{
var resultCounter = valueContext.ContextForYCategoryValue("all") as AnalysisResultCounter;
if (resultCounter == null)
{
resultCounter = new AnalysisResultCounter();
valueContext.SetContextForYCategoryValue(resultCounter, "all");
}
resultCounter.AddValue(JavascriptEngine.DoubleForValue(argument));
return(new AnalysisValueIntermediateResultDelayed(resultCounter, rowContext));
}
/// <summary>
/// Browser core secondary constructor
/// </summary>
/// <param name="javascriptEngine"></param>
/// <param name="styleEngine"></param>
/// <param name="restClient"></param>
/// <param name="cookieContainer"></param>
/// <param name="historyManager"></param>
/// <param name="styleScrapingEnabled"></param>
/// <param name="javascriptScrapingEnabled"></param>
/// <param name="defaultUriProtocol"></param>
public BrowserCore(JavascriptEngine javascriptEngine, StyleEngine styleEngine,
RestClient restClient, CookieContainer cookieContainer,
HistoryManager historyManager, bool styleScrapingEnabled,
bool javascriptScrapingEnabled, string defaultUriProtocol)
{
_javascriptEngine = javascriptEngine;
_styleEngine = styleEngine;
_restClient = restClient;
_restClient.CookieContainer = cookieContainer;
_history = historyManager;
_styleScrapingEnabled = styleScrapingEnabled;
_javascriptScrapingEnabled = javascriptScrapingEnabled;
DefaultUriProtocol = defaultUriProtocol;
}
/// <summary>
/// Package typed document
/// </summary>
/// <typeparam name="T">Type of document body</typeparam>
/// <param name="request"></param>
/// <param name="response"></param>
/// <returns></returns>
protected IDocument <T> PackageAndAddDocument <T>(IRestRequest request, IRestResponse <T> response)
{
Uri requestUri = _restClient.BaseUrl;
HtmlParser parser = new HtmlParser();
IHtmlDocument htmlDocument = parser.ParseDocument(response.Content);
IDocument <T> document = new Document <T>(request, response, htmlDocument);
if (JavascriptScrapingEnabled)
{
JavascriptEngine.Add(document);
}
if (StyleScrapingEnabled)
{
StyleEngine.Add(document);
}
document.RequestUri = requestUri;
Documents.Add(document);
return(document);
}
/// <inheritdoc/>
public override AnalysisValueIntermediateResult ResultWithArgumentRowContextValueContext(JsValue argument, AnalysisProcessingQueryResultRowExecutionContext rowContext, AnalysisProcessingValueExecutionContext valueContext)
{
AnalysisResultCounter resultCounter = valueContext.ContextForYCategoryValue(rowContext.YCategoryKey) as AnalysisResultCounter;
if (resultCounter == null)
{
resultCounter = new AnalysisResultCounter();
valueContext.SetContextForYCategoryValue(resultCounter, rowContext.YCategoryKey);
}
string strValue = JavascriptEngine.StringForValue(argument);
if (strValue.Length > 0 && resultCounter.ObjectForKey(strValue) == null)
{
resultCounter.SetObjectForKey(strValue, strValue);
resultCounter.AddValue(1);
}
return(new AnalysisValueIntermediateResultDelayed(resultCounter, rowContext));
}
private void InitializeJS()
{
this.AssertRunningOnThisThread();
Javascript = new JavascriptEngine();
Javascript.Script.console = new
{
log = new Action <object>(ScriptLog)
};
O = new OClass(this);
#pragma warning disable CC0021 // Use nameof
Javascript.AddObject("O", O);
#pragma warning restore CC0021 // Use nameof
O.Init();
if (Resources != null)
{
Javascript.Execute(Resources.ReadEntryPoint());
}
((ManualResetEvent)EngineInitialized).Set();
}
public void IsArray()
{
var js = new JavascriptEngine();
var arrays = new object[] {
js.ExecuteAndReturn("[\"a\"]"),
new string[1] {
"a"
},
};
var notArrays = new object[]
{
js.ExecuteAndReturn("\"a\""),
new ExpandoObject(),
new Dictionary <int, string>()
};
for (var i = 0; i < arrays.Length; i++)
{
try
{
Assert.True(ObjectDiff.IsArray(arrays[i]), "Item {0} is an array", i);
}
catch (Exception e)
{
throw new Exception($"Item {i} in arrays threw an exception", e);
}
}
for (var i = 0; i < notArrays.Length; i++)
{
try
{
Assert.False(ObjectDiff.IsArray(notArrays[i]), "Item {0} is not an array", i);
}
catch (Exception e)
{
throw new Exception($"Item {i} in notArrays threw an exception", e);
}
}
}
public JavascriptEvalutor(ExecutionContext executionContext)
{
engine = new JavascriptEngine();
scope = engine.CreateScope(new ScriptingContext(executionContext));
}
/// <inheritdoc/>
public override AnalysisValueIntermediateResult ResultWithArgumentRowContextValueContext(JsValue argument, AnalysisProcessingQueryResultRowExecutionContext rowContext, AnalysisProcessingValueExecutionContext valueContext)
{
double argumentValue = 0;
int currencyCode = 0;
bool defaultCurrencyField = true;
JavascriptEngine engine = JavascriptEngine.Current;
if (JavascriptEngine.IsObject(argument))
{
var arr = JavascriptEngine.ArrayForValue(argument);
if (arr.Count > 0)
{
object argobj = arr[0];
argumentValue = argobj.ToDouble();
}
else
{
argumentValue = 0;
}
if (arr.Count > 1)
{
object argobj = arr[1];
currencyCode = argobj.ToInt();
defaultCurrencyField = false;
}
}
else
{
argumentValue = JavascriptEngine.DoubleForValue(argument);
}
if (defaultCurrencyField)
{
if (rowContext.ProcessingContext.Analysis.CurrencyField != null)
{
var currencyStringValue = rowContext.Row.RawValueAtIndex(rowContext.ProcessingContext.Analysis.CurrencyField.QueryResultFieldIndex);
if (currencyStringValue?.Length > 0)
{
currencyCode = currencyStringValue.ToInt();
}
else
{
currencyCode = 0;
}
}
else
{
currencyCode = 0;
}
}
int targetCode = rowContext.ProcessingContext.Analysis.CurrentSettings.CurrencyCode;
if (currencyCode == 0 || targetCode == 0 || currencyCode == targetCode)
{
return(new AnalysisValueIntermediateResult(argumentValue));
}
var exchangeRate = rowContext.ProcessingContext.Analysis.CurrencyConversion.ExchangeRateFromCodeToCode(currencyCode, targetCode);
if (exchangeRate != 0)
{
argumentValue /= exchangeRate;
}
return(new AnalysisValueIntermediateResult(argumentValue));
}
/// <inheritdoc/>
public override AnalysisValueIntermediateResult ResultWithArgumentRowContextValueContext(JsValue argument, AnalysisProcessingQueryResultRowExecutionContext rowContext, AnalysisProcessingValueExecutionContext valueContext)
{
double val;
string key;
object valueObject;
JavascriptEngine engine = JavascriptEngine.Current;
var arr = JavascriptEngine.ArrayForValue(argument);
if (arr == null)
{
val = JavascriptEngine.DoubleForObject(argument);
key = null;
}
else
{
if (arr.Count > 1)
{
valueObject = arr[1];
if (valueObject is string)
{
key = (string)valueObject;
}
else
{
key = $"{valueObject}";
}
valueObject = arr[0];
}
else if (arr.Count == 1)
{
valueObject = arr[0];
key = "const";
}
else
{
return(new AnalysisValueIntermediateResult(0));
}
if (valueObject is int || valueObject is string)
{
val = valueObject.ToDouble();
}
else
{
val = 0;
}
}
var resultCounter = valueContext.ContextForYCategoryValue(rowContext.YCategoryKey) as AnalysisResultCounter;
if (resultCounter == null)
{
resultCounter = new AnalysisResultCounter();
valueContext.SetContextForYCategoryValue(resultCounter, rowContext.YCategoryKey);
}
if (key == null)
{
resultCounter.AddValue(val);
}
else
{
var num = resultCounter.ObjectForKey(key);
if (num == null)
{
resultCounter.AddValue(val);
resultCounter.SetObjectForKey(1, key);
}
else
{
resultCounter.SetObjectForKey(num.ToInt() + 1, key);
}
}
return(new AnalysisValueIntermediateResultDelayed(resultCounter, rowContext));
}
public TypescriptEngine()
{
_javascriptEngine = new JavascriptEngine();
}
