private static string GetValueAtLabelBase(FluentQuery response, Direction direction, string[] textTypeOfValue, string[] labelInDocument)
{
response.QueryType = QueryType.SingleCapture;
response.AppendToScript($"Text({string.Join("||", labelInDocument)}) {direction} [{Or(textTypeOfValue)}]");
return(ExecuteSingleCapture(response));
}
private static string[] GetAnyBase(FluentQuery response, string[] textType)
{
response.QueryType = QueryType.Any;
response.AppendToScript($"Any [{Or(textType)}]");
return(response.ExecuteQuery().Select(x => x.Value).ToArray());
}
private static string FindValueForLabelBase(FluentQuery response, string[] textTypeOfValue, int maxSteps, string[] labelInDocument)
{
response.QueryType = QueryType.SingleCapture;
response.AppendToScript($"Text({string.Join("||", labelInDocument)}) RD {maxSteps} [{Or(textTypeOfValue)}]");
return(ExecuteSingleCapture(response));
}
private static string CaptureBase(FluentQuery response, string[] captureTextType)
{
if (response.QueryType == QueryType.None)
{
response.QueryType = QueryType.SingleCapture;
}
return(ExecuteSingleCapture(response.AppendToScript($"[{Or(captureTextType)}]")));
}
private static FluentQuery CaptureNamedBase(FluentQuery response, string[] captureTextType, string propertyName)
{
response.QueryType = QueryType.MultiCapture;
if (string.IsNullOrWhiteSpace(propertyName))
{
throw new FluentQueryException("The specified pattern has multiple captures, a property name must be specified when capturing more than one value.");
}
return(response.AppendToScript((!string.IsNullOrWhiteSpace(propertyName) ? $"'{propertyName}': " : string.Empty) + $"[{Or(captureTextType)}]"));
}
private static Dictionary <string, string> ExecuteQuery(this FluentQuery fluentQuery)
{
if (fluentQuery.QueryType == QueryType.None)
{
throw new FluentQueryException("Query includes no capture tokens. Nothing to query for.");
}
fluentQuery.AppendToScript(";");
var interpretationResultJson = fluentQuery
.Interpreter
.Interpret(fluentQuery.AnalyzedPage, fluentQuery.Script)
.ConvertToJson(fluentQuery.Script);
if (string.IsNullOrWhiteSpace(interpretationResultJson))
{
return(null);
}
var json = JObject.Parse(interpretationResultJson)[FluentQueryConstants.GeneratedScriptQuery];
Dictionary <string, string> deserializedResult = null;
switch (fluentQuery.QueryType)
{
case QueryType.SingleCapture:
deserializedResult = JsonConvert.DeserializeObject <Dictionary <string, string> >(interpretationResultJson);
break;
case QueryType.MultiCapture:
deserializedResult = JsonConvert.DeserializeObject <Dictionary <string, string> >(json.ToString());
break;
case QueryType.Any:
deserializedResult = JsonConvert.DeserializeObject <string[]>(json.ToString())
.Select((x, i) => new KeyValuePair <int, string>(i, x))
.ToDictionary(x => x.Key.ToString(), x => x.Value);
break;
default: throw new FluentQueryException("Query type is invalid");
}
if (deserializedResult == null || deserializedResult.Count == 0)
{
return(null);
}
return(deserializedResult);
}
/// <summary>
/// Following a pattern predicate or a capture, specify to move *Right* from there to look for the next element in the document for the next operation.
/// </summary>
/// <returns>A DocumentLab FluentQuery with a script extension that performs the traversal.</returns>
public static FluentQuery Right(this FluentQuery response) => response.AppendToScript("Right");
/// <summary>
/// Following a pattern predicate or a capture, specify to move *Left* from there to look for the next element in the document for the next operation.
/// </summary>
/// <returns>A DocumentLab FluentQuery with a script extension that performs the traversal.</returns>
public static FluentQuery Left(this FluentQuery response) => response.AppendToScript("Left");
/// <summary>
/// Following a pattern predicate or a capture, specify to move *Down* from there to look for the next element in the document for the next operation.
/// </summary>
/// <returns>A DocumentLab FluentQuery with a script extension that performs the traversal.</returns>
public static FluentQuery Down(this FluentQuery response) => response.AppendToScript("Down");
/// <summary>
/// Following a pattern predicate or a capture, specify to move *Up* from there to look for the next element in the document for the next operation.
/// </summary>
/// <returns>A DocumentLab FluentQuery with a script extension that performs the traversal.</returns>
public static FluentQuery Up(this FluentQuery response) => response.AppendToScript("Up");
/// <summary>
/// Specifies a tablecolumn for the preceding table query initializer
/// </summary>
/// <param name="columnName">The name to assign for the column in the result output</param>
/// <param name="columnTextType">The text type considered valid in the table row's data for this column</param>
/// <param name="labels">Labels that can be evaluated to identify the table on the page</param>
/// <returns>A DocumentLab FluentQuery with a script extension that contains the table column definition</returns>
public static FluentQuery TableColumn(this FluentQuery response, string columnName, string columnTextType, params string[] labels)
=> response.AppendToScript($"'{columnName}': [{columnTextType}({string.Join("||", labels)})]");
private static FluentQuery MatchBase(FluentQuery response, string[] textType, string[] matchText)
{
return(response.AppendToScript(matchText.Count() > 0 ? $"{Or(textType.Select(x => $"{x}({string.Join("||", matchText)})").ToArray())}" : Or(textType)));
}
private static FluentQuery SubsetBase(FluentQuery response, Subset[] subset)
{
return(response.AppendToScript($"Subset({string.Join(", ", subset.ToString())})"));
}
/// <summary>
/// Initiates a table query, a series of TableColumn method calls needs to follow this one.
/// </summary>
/// <returns>A DocumentLab FluentQuery with a script extension that initates the table query</returns>
public static FluentQuery Table(this FluentQuery response) => response.AppendToScript("Table");
/// <summary>
/// Performs a Right-Down search from the previous predcate. A predicate or capture should follow. This is implicitly already used in the FindValueForLabel and GetValueForLabel methods. Use this method if you want to create more detailed patterns using RD.
/// </summary>
/// <param name="maxSteps">The maximum distance in cells between the previous predicate and the next predicate for the pattern to be valid.</param>
/// <returns></returns>
public static FluentQuery RightDownSearch(this FluentQuery response, int maxSteps) => response.AppendToScript($"RD {maxSteps}");
