public bool SetParseResult(string res)
{
UiDispatcher?.Invoke(() => { ParseResult.Add(res); }); return(true);
}
public override ParseResult <TResult> Parse()
{
var result = new ParseResult <TResult>();
var regexes = regexList.Cast <KeyValuePair <string, DeviceModel> >();
if (!regexes.Any())
{
return(result);
}
KeyValuePair <string, DeviceModel> localDevice = new KeyValuePair <string, DeviceModel>(null, null);
string[] localMatches = null;
foreach (var regex in regexes)
{
var matches = MatchUserAgent(regex.Value.Regex);
if (matches.Length > 0)
{
localDevice = regex;
localMatches = matches;
break;
}
}
if (localMatches == null)
{
return(result);
}
if (!localDevice.Key.Equals(UnknownBrand))
{
var localBrand = DeviceBrands.SingleOrDefault(x => x.Value == localDevice.Key).Key;
if (string.IsNullOrEmpty(localBrand))
{
// This Exception should never be thrown. If so a defined brand name is missing in DeviceBrands
throw new Exception("The brand with name '" + localDevice.Key + "' should be listed in the deviceBrands array.");
}
brand = localBrand;
}
if (localDevice.Value.Device != null && DeviceTypes.ContainsKey(localDevice.Value.Device))
{
DeviceTypes.TryGetValue(localDevice.Value.Device, out var localDeviceType);
deviceType = localDeviceType;
}
model = "";
if (!string.IsNullOrEmpty(localDevice.Value.Name))
{
model = BuildModel(localDevice.Value.Name, localMatches);
}
if (localDevice.Value.Models != null)
{
Model localModel = null;
string[] localModelMatches = null;
foreach (var localmodel in localDevice.Value.Models)
{
var modelMatches = MatchUserAgent(localmodel.Regex);
if (modelMatches.Length > 0)
{
localModel = localmodel;
localModelMatches = modelMatches;
break;
}
}
if (localModelMatches == null)
{
result.Add(new TResult {
Name = model, Brand = brand, Type = deviceType
});
return(result);
}
model = BuildModel(localModel.Name, localModelMatches)?.Trim();
if (localModel.Brand != null)
{
var localBrand = DeviceBrands.SingleOrDefault(x => x.Value == localModel.Brand).Key;
if (!string.IsNullOrEmpty(brand))
{
brand = localBrand;
}
}
if (localModel.Device != null && DeviceTypes.ContainsKey(localModel.Device))
{
DeviceTypes.TryGetValue(localModel.Device, out var localDeviceType);
deviceType = localDeviceType;
}
}
result.Add(new TResult {
Name = model, Brand = brand, Type = deviceType
});
return(result);
}
protected override Task <DataFlowResult> Parse(DataFlowContext context)
{
var selectable = context.Selectable;
var results = new ParseResult <T>();
if (selectable.Properties == null)
{
selectable.Properties = new Dictionary <string, object>();
}
var environments = new Dictionary <string, string>();
foreach (var property in context.Response.Request.Properties)
{
environments.Add(property.Key, property.Value);
}
if (Model.GlobalValueSelectors != null)
{
foreach (var selector in Model.GlobalValueSelectors)
{
string name = selector.Name;
if (string.IsNullOrWhiteSpace(name))
{
continue;
}
var value = selectable.Select(selector.ToSelector()).GetValue();
if (!environments.ContainsKey(name))
{
environments.Add(name, value);
}
else
{
environments[name] = value;
}
}
}
bool singleExtractor = Model.Selector == null;
if (!singleExtractor)
{
var selector = Model.Selector.ToSelector();
var list = selectable.SelectList(selector).Nodes()?.ToList();
if (list != null)
{
if (Model.Take > 0 && list.Count > Model.Take)
{
list = Model.TakeFromHead
? list.Take(Model.Take).ToList()
: list.Skip(list.Count - Model.Take).ToList();
}
for (var i = 0; i < list.Count; ++i)
{
var item = list.ElementAt(i);
var obj = ParseObject(context, environments, item, i);
if (obj != null)
{
results.Add(obj);
}
else
{
Logger?.LogWarning($"解析到空数据，类型: {Model.TypeName}");
}
}
}
}
else
{
var obj = ParseObject(context, environments, selectable, 0);
if (obj != null)
{
results.Add(obj);
}
else
{
Logger?.LogWarning($"解析到空数据，类型: {Model.TypeName}");
}
}
AddParseResult(context, results);
return(base.Parse(context));
}
public ParseResult Parse(string[] args, IEnumerable <ArgumentRaw> argumentsRaw, IEnumerable <CommandMap> commandsMap, bool enableMultiAction)
{
var parseResult = new ParseResult();
parseResult.Args = args;
parseResult.Maps = commandsMap;
parseResult.EnableMultiAction = enableMultiAction;
IEnumerable <ArgumentRaw> initialExtraArguments;
var allPropertiesMap = commandsMap.GetProperties();
var allMethodsMaps = commandsMap.GetMethods();
var hasPropertyMap = allPropertiesMap.Any();
var methodsParsed = this.actionParser.Parse(argumentsRaw, enableMultiAction, allMethodsMaps, out initialExtraArguments).ToList();
var hasMethodsParsed = methodsParsed.Count > 0;
// *******
// Step1: Parse properties if has initial extras
// *******
if (initialExtraArguments.Any())
{
var levelInitial = this.GetLevelWithProperties(commandsMap, initialExtraArguments);
if (!this.IsEmptyLevel(levelInitial))
{
parseResult.Add(levelInitial);
}
}
if (hasMethodsParsed)
{
// Separate per level
var levelsGroups = methodsParsed.GroupBy(f => f.Level).OrderBy(f => f.Key);
foreach (var levelGroup in levelsGroups)
{
// Separate per Command
var commandsGroups = levelGroup.GroupBy(f => f.ActionMap.Target);
// Step2 & Step 3: Create level only with methods and separate valids and invalids methods
var levelOfMethods = this.GetLevelWithMethods(hasPropertyMap, commandsGroups);
if (levelOfMethods == null)
{
continue;
}
var bestValidMethodInLevel = this.GetBestValidMethodInLevel(levelOfMethods);
if (bestValidMethodInLevel != null)
{
// Step2: Add or not the method
var canAddMethodLevel = true;
if (this.IsMethodImplicitAndNoArguments(bestValidMethodInLevel))
{
// Step2.1: If has args, this default implicit method can't be added.
// because it is invoked only if no has input.
// eg:
// method: void defaultMethodWithoutArgs()
// input : $ --some-args value
// result: can't executed because is invalid.
if (args.Length > 0)
{
canAddMethodLevel = false;
}
}
if (canAddMethodLevel)
{
// Step2.2: Remove imcompatible valid methods
this.RemoveIncompatibleValidMethods(levelOfMethods, bestValidMethodInLevel);
if (!this.IsEmptyLevel(levelOfMethods))
{
parseResult.Add(levelOfMethods);
}
}
// Step3: Get extras of the best method and use as properties input to create a new level.
var levelOfProperties = this.GetLevelWithPropertiesUsingMethodExtras(commandsMap, bestValidMethodInLevel);
if (levelOfProperties != null && !this.IsEmptyLevel(levelOfProperties))
{
parseResult.Add(levelOfProperties);
}
}
else
{
// Step4 & Step5: When not exists valid methods
var allRemoved = this.RemoveInvalidImplicitDefaultMethodsIfExists(args, levelOfMethods, hasPropertyMap);
if (allRemoved)
{
// Step4: All defaults and invalid methods have been ignored to maintain the fluency
// and the process of following with properties.
// select all raw before 'level 1'
IEnumerable <ArgumentRaw> raws;
var methodLevel1 = methodsParsed.FirstOrDefault(f => f.Level == 1);
if (methodLevel1 != null)
{
var rawsAux = new List <ArgumentRaw>();
foreach (var raw in argumentsRaw)
{
if (raw != methodLevel1.ArgumentRawOfAction)
{
rawsAux.Add(raw);
}
else
{
break;
}
}
raws = rawsAux;
}
else
{
raws = argumentsRaw;
}
var levelOfProperties = this.GetLevelWithProperties(commandsMap, raws);
if (levelOfProperties != null && !this.IsEmptyLevel(levelOfProperties))
{
parseResult.Add(levelOfProperties);
}
}
else
{
// Step5: There are some default method that has a real problem.
parseResult.Add(levelOfMethods);
}
}
}
}
// *******
// Step5: Create properties with default values if not exists
// Create required properties if not exists (to show errors)
// *******
var levelDefaultOrRequired = this.GetLevelWithPropertiesDefaultOrRequired(parseResult.Levels, commandsMap);
if (levelDefaultOrRequired != null && !this.IsEmptyLevel(levelDefaultOrRequired))
{
parseResult.Add(levelDefaultOrRequired);
}
// *******
// Step6: Organize level number
// *******
this.OrganizeLevelsSequence(parseResult);
return(parseResult);
}