public MainViewModel()
{
_set = Settings.Load();
StarListenerCommand = new RealyCommand(StarListener);
StartParsingCommand = new RealyCommand(StartParsing);
StopParsingCommand = new RealyCommand(StopParsing);
UpdateBaseCommand = new RealyCommand(UpdateBase);
List <Bookmaker> bookmakers = new List <Bookmaker>
{
new Bookmaker()
{
Name = "Olimp", Site = _set.OlimpUrl
},
new Bookmaker()
{
Name = "Fonbet", Site = _set.FonbetUrl
},
new Bookmaker()
{
Name = "Marafon", Site = _set.MarafonUrl
},
new Bookmaker()
{
Name = "Zenit", Site = _set.ZenitUrl
},
new Bookmaker()
{
Name = "Parimatch", Site = _set.PariMatchUrl
}
};
Bookmakers = new ObservableCollection <Bookmaker>(bookmakers);
_manager = new ParserManager(_set.OlimpUrl, _set.FonbetUrl, _set.MarafonUrl, _set.ZenitUrl, _set.PariMatchUrl, _set.UsingProxy);
_forkFinder = new ForkFinder(_manager);
_server = new ServerManager(_forkFinder);
//Проверяем был ли сервер запущен после обновления
string[] args = Environment.GetCommandLineArgs();
bool isUpdate = false;
foreach (string arg in args)
{
if (arg != "update")
{
continue;
}
isUpdate = true;
break;
}
if (isUpdate)
{
StarListenerCommand.Execute(null);
#if !DEBUG
StartParsingCommand.Execute(null);
#endif
}
}
public void Should_invoke_default_parser()
{
var defaultParser = new List <IDefaultParser>()
{
new DefaultParser()
};
var genericParser = new List <IGenericParser>()
{
new GenericParser()
};
var gameParser = new List <IGameParser>()
{
new GameParser()
};
var manager = new ParserManager(gameParser, genericParser, defaultParser);
var result = manager.Parse(new ParserManagerArgs()
{
File = "fake",
GameType = "game"
});
result.First().File.Should().Be("default_parser");
result.First().UsedParser.Should().Be("DefaultParser");
}
private void StartParsing()
{
if (!Start)
{
if (_manager == null)
{
_manager = new ParserManager(_set.OlimpUrl, _set.FonbetUrl, _set.MarafonUrl, _set.ZenitUrl, _set.PariMatchUrl, _set.UsingProxy);
}
_manager.Start();
if (_forkFinder == null)
{
_forkFinder = new ForkFinder(_manager);
}
_forkFinder.Start();
foreach (var key in Bookmakers)
{
key.Status = WorkStatus.Work;
}
Logger.Write("Сбор данных успешно запущен!");
Start = true;
}
else
{
MessageBox.Show("Парсинг уже запущен!");
}
}
public static Project ParseProject(IEnumerable <string> sourceFiles, bool runInSerial)
{
var files = runInSerial ? sourceFiles : sourceFiles.AsParallel();
var languageList = new List <ILanguageParser>();
var parsedFiles = files.Select(path =>
{
Report.Message("Parsing", path);
// Parse source files.
ILanguageParser language;
try
{
language = ParserManager.GetParserByExtension(Path.GetExtension(path));
}
catch (NotSupportedException e)
{
Report.Error(p => p.DescriptionReasonLocation(ReportGenre.FileRead, e.Message, path), e);
return(null);
}
languageList.AddIf(p => languageList.Select(p2 => p2.Identifier).All(i => i != p.Identifier), language);
var source = OtherUtils.ReadAllText(path);
return(language.Parse(path, source));
})
.ToList();
var project = new Project(parsedFiles);
new Traverser("Global post processing", languageList.SelectMany(p => p.GlobalTraverserActions).ToArray()).Go(project);
return(project);
}
private void button8_Click(object sender, EventArgs e)
{
ParserManager pm = new ParserManager();
textBox1.Text = pm.supportedFileTypies + "\n";
textBox1.Text = textBox1.Text + pm.GetSupportedFilesCount();
}
private void button3_Click(object sender, EventArgs e)
{
ParserManager pm = new ParserManager();
Action a = new Action(pm.ParseAll);
Task t = new Task(a);
t.Start();
}
public static Parser GetParser()
{
var settings = new ParserSettings
{
Algorithm = Parser.Algorithm.LL,
NestingType = Parser.NestingType.Stack,
Unit = Parser.Unit.Character,
};
Parser parser = new ParserManager(GetGrammar(), settings);
return(parser);
}
// GET: api/GooglePlay?id=com.rockstargames.gtavc
public object Get(string id)
{
if (id == null)
{
return new
{
error = "Название пакета не может быть пустым!"
}
}
;
if (!Applications.ContainsKey(id))
{
HtmlDocument doc = null;
try
{
doc = ParserManager.GetPageDocument(id);
}
catch (Exception ex)
{
return(new
{
error = $"Такого приложения на Google Play не существует."
});
}
try
{
ApplicationModel app = ParserManager.GetApplicationData(doc, id);
if (!app.Verify())
{
return new
{
error = $"Объект собран не полностью."
}
}
;
Applications[app.PackageName] = app;
return(app);
}
catch (Exception ex)
{
return(new
{
error = ex.Message
});
}
}
return(Applications[id]);
}
internal static SearchExpression ExpandParser(SearchExpressionParserArgs args)
{
var outerText = args.text;
var text = ParserUtils.SimplifyExpression(outerText);
if (!text.StartsWith("...", System.StringComparison.Ordinal))
{
return(null);
}
var expression = ParserManager.Parse(args.With(text.Substring(3)));
return(new SearchExpression(expression, expression.types | SearchExpressionType.Expandable, outerText, expression.innerText));
}
private ParserInfo GetParserInfo()
{
string parserName = this.cboParser.Text;
ParserInfo info = ParserManager.GetParserInfoByName(parserName);
if (info == null)
{
MessageBox.Show($"Can't get ParserInfo for parser \"{parserName}\".");
return(null);
}
return(info);
}
public DataSet Execute(string sql)
{
var parserManager = new ParserManager(Configuration);
var parseStatementsResult = parserManager.ParseStatements(sql);
if (parseStatementsResult.Errors.Any())
{
var sb = new StringBuilder();
foreach (var error in parseStatementsResult.Errors)
{
sb.AppendLine($"{error.Message}");
}
throw new Exception(sb.ToString());
}
var statements = parseStatementsResult.Value;
var dataSet = new DataSet();
using (var service = OrganizationService.Create(Credential))
{
foreach (var statement in statements)
{
if (statement is SelectStatement)
{
var crmInstance = new CRMInstance(service);
var selectEngine = new SelectEngine(crmInstance, Configuration);
var selectStatement = (SelectStatement)statement;
var dt = selectEngine.Execute(selectStatement);
dataSet.Tables.Add(dt);
}
else if (statement is UpdateStatement)
{
throw new NotSupportedException($"'Update' statement is currently not supported.");
}
else if (statement is DeleteStatement)
{
throw new NotSupportedException($"'Delete' statement is currently not supported.");
}
}
}
return(dataSet);
}
public IActionResult Index()
{
var sessions = JArray.Parse(System.IO.File.ReadAllText(@"D:\User\Desktop\response_1589728162482.json"));
var results = ParserManager.ParseTestResults(sessions);
HierarchicalClustering.ComputeMultiple(0.5f, results.Clusters);
Log.Information("Tests count: {tcount}, clusters count {ccount}, cluster depth: {depth}",
results.Clusters.Count, HierarchicalClustering.Output.Count, HierarchicalClustering.Output.Max(c => c.Depth));
ViewBag.Width = HierarchicalClustering.Output.Max(c => c.Depth) * 150 + 460;
ViewBag.Height = results.Clusters.Count * 30;
ViewBag.Cluster = ClusterSerializer.Serialize(HierarchicalClustering.Output);
return(View());
}
private static async void StartTimer(object obj)
{
Console.WriteLine("Парсинг и обновление по таймеру начато");
await ParserManager.Run();
ParserManager.Push();
await ParserManager.Update();
ArticleStateSolver.Solve();
Console.WriteLine("Парсинг и обновление по таймеру окончено");
}
protected override void OnStart(string[] args)
{
var parser = new ParserManager();
parser.MakeParsed(args[0]);
sourceDirectoryPath = parser.SourcePath;
targetDirectoryPath = parser.TargetPath;
if (sourceDirectoryPath == null || targetDirectoryPath == null)
{
throw new NullReferenceException("Wrong path!");
}
mods = parser.Mods;
logger = new Logger(sourceDirectoryPath, targetDirectoryPath, mods);
Thread loggerThread = new Thread(new ThreadStart(logger.Start));
loggerThread.Start();
}
private static void Main()
{
try
{
var manager = new ParserManager();
using (manager.ParserManagerInformation.Subscribe(Console.WriteLine))
{
manager.Start();
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
Console.WriteLine("Finished. Press any key to exit...");
Console.ReadKey(true);
}
static async Task Main(string[] args)
{
string inputCommand;
int timerStep = 7200000;
TimerCallback tm = new TimerCallback(StartTimer);
while (true)
{
Console.Write(">");
inputCommand = Console.ReadLine();
switch (inputCommand)
{
case "s":
await ParserManager.Run();
ParserManager.Push();
Console.WriteLine("Парсинг окончен");
break;
case "u":
await ParserManager.Update();
ArticleStateSolver.Solve();
break;
case "s t":
Timer timer = new Timer(tm, null, 0, timerStep);
break;
case "q":
return;
default:
Console.WriteLine("Команда не найдена");
break;
}
}
}
public object Post([FromBody] PackageModel model)
{
ApplicationModel app = null;
HtmlDocument doc = null;
try
{
doc = ParserManager.GetPageDocument(model.GetPackageName());
}
catch (Exception ex)
{
return(new
{
error = $"Такого приложения на Google Play не существует."
});
}
try
{
app = ParserManager.GetApplicationData(doc, model.GetPackageName());
if (!app.Verify())
{
return new
{
error = $"Объект собран не полностью."
}
}
;
Applications[app.PackageName] = app;
}
catch (Exception ex)
{
return(new
{
error = $"Серверная ошибка. [DEBUG DATA (not for production)]: {ex.Message}."
});
}
return(app);
}
private void button1_Click(object sender, EventArgs e)
{
var input = this.textBox1.Text.Trim();
if (string.IsNullOrEmpty(input))
{
return;
}
foreach (var item in ParserManager.GetLinks(input))
{
var parser = ParserManager.GetNewsParser(item);
if (parser == null)
{
continue;
}
this.newList.Add(new NewsModel()
{
Author = parser.Author,
Content = parser.Content,
ContentSourceUrl = parser.Url,
Url = string.Empty,
CreatedBy = string.Empty,
CreatedOn = DateTime.UtcNow,
UpdatedBy = string.Empty,
UpdatedOn = DateTime.UtcNow,
Digest = parser.Digest,
Id = Guid.NewGuid().ToString("N"),
IsReleased = false,
LastUpdateTime = DateTime.UtcNow,
MaterialID = string.Empty,
MediaId = string.Empty,
OfficialAccount = string.Empty,
ShowCoverPicture = false,
SortBy = 0,
ThumbMediaId = parser.ThumbMedia,
Title = parser.Title
});
}
}
static void Parse(string language)
{
CodeParserTest codeParserTest = ParserHelper.GetParserTest(language);
if (codeParserTest != null)
{
ParserInfo info = ParserManager.GetParserInfoByLanguage(language);
if (info != null)
{
codeParserTest.Parse(info);
}
else
{
Console.WriteLine($"Can't get ParserInfo for language \"{language}\".");
}
}
else
{
Console.WriteLine($"There's no parser test class for language \"{language}\".");
}
}
public void OnClickSave()
{
float[] value = new float[_Edits.Length];
for (int i = 0; i < _Edits.Length; ++i)
{
UIInput input = _Edits[i].transform.Find("Input").GetComponent <UIInput>();
if (input.value == "")
{
value[i] = -1000f;
}
else
{
value[i] = float.Parse(input.value);
}
//LogManager.Log(_Edits[i].name + " : " + value[i]);
}
ParserManager.DeveloperSetting(value);
SceneChangeManager.Change_Scene("Proto");
}
public PythonSiteImpl(IPythonRuntime runtime)
{
string name = runtime.GetType().Name;
string configPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
string dbPath = PathCombine(configPath, "MonoDevelop", "PyBinding", "Sites", name, "completion.db");
m_pathsPath = PathCombine(configPath, "MonoDevelop", "PyBinding", "Sites", name, "paths");
if (File.Exists(m_pathsPath))
{
foreach (var line in File.ReadAllLines(m_pathsPath))
{
string trimmed = line.Trim();
if (!String.IsNullOrEmpty(line))
{
m_Paths.Add(trimmed);
}
}
}
m_Database = new ParserDatabase(dbPath);
m_Database.Open();
m_parser = ParserManager.GetParser(runtime);
}
private void ParseHTML(CommandLineLogger logger, ParserVersionEnum version, string caseName, ref bool hasPreservation)
{
Stopwatch stopWatch = new Stopwatch();
logger.LogInfo("Begin parsing files.");
stopWatch.Start();
foreach (ExtractFileInfo htmlx in _htmlToParse)
{
ParserManager parser = new ParserManager(logger)
{
CaseNumber = caseName,
HtmlToLoad = htmlx.File_Path,
HtmlToRecord = htmlx.IsTemporary ? htmlx.ParentFile_Path : htmlx.File_Path,
IsPreservation = false,
DatabasePreservationNoPrefix = string.Empty,
Version = version,
DefaultDirectory = _defaultDirectory
};
logger.LogInfo("Processing " + htmlx.File_Path);
try
{
if (htmlx.File_Path.ToLower().Contains("preservation"))
{
hasPreservation = true;
/*Preservation-1, Preservation-2, Preservation-3 */
parser.IsPreservation = true;
DirectoryInfo di = new DirectoryInfo(htmlx.File_Path);
string p = di.Parent.Name; //goes up to parent directory, preservation
if (!p.ToLower().Contains("preservation"))
{
p = di.Parent.Parent.Name; //goes up to parent directory, preservation\folderX\index.html
}
parser.DatabasePreservationNoPrefix = p.Replace("-", "_"); //sqllite doesn't like sql queries ref tables with a '-', change to '_'
}
if (!htmlx.File_Name.ToUpper().Contains("PRESERVATION"))
{
switch (htmlx.File_Name.ToUpper().Trim())
{
case "ABOUT_ME.HTML":
parser.AboutMeParse(htmlx);
break;
case "ACCOUNT_STATUS_HISTORY.HTML":
parser.AccountStatusHistoryParse(htmlx);
break;
case "COMMENTS.HTML":
parser.CommentsParse(htmlx);
break;
case "DEVICES.HTML":
parser.DevicesParse(htmlx);
break;
case "DIRECT_SHARES.HTML":
parser.DirectSharesParse(htmlx);
break;
case "DIRECT_STORIES.HTML":
parser.DirectStoriesParse(htmlx);
break;
case "FOLLOWERS.HTML":
parser.FollowersParse(htmlx);
break;
case "FOLLOWING.HTML":
parser.FollowingParse(htmlx);
break;
case "GENDER.HTML":
parser.GenderParse(htmlx);
break;
case "INCOMING_FOLLOW_REQUESTS.HTML":
parser.IncomingFollowRequestsParse(htmlx);
break;
case "INDEX.HTML":
parser.IndexParse(htmlx);
break;
case "LIKES.HTML":
parser.LikesParse(htmlx);
break;
case "LINKED_ACCOUNTS.HTML":
parser.LinkedAccountsParse(htmlx);
break;
case "LIVE_VIDEOS.HTML":
parser.LiveVideosParse(htmlx);
break;
case "UNIFIED_MESSAGES.HTML":
parser.UnifiedMessagesParse(htmlx);
break;
case "NAME_CHANGES.HTML":
parser.NameChangesParse(htmlx);
break;
case "NCMEC_REPORTS.HTML":
parser.NcmecReportsParse(htmlx);
break;
case "PHOTOS.HTML":
parser.PhotosParse(htmlx);
break;
case "POPULAR_BLOCK.HTML":
parser.PopularBlockParse(htmlx);
break;
case "PRIVACY_SETTINGS.HTML":
parser.PrivacySettingsParse(htmlx);
break;
case "PROFILE_PICTURE.HTML":
parser.ProfilePictureParse(htmlx);
break;
case "VANITY_CHANGES.HTML":
parser.VanityChangesParse(htmlx);
break;
case "VIDEOS.HTML":
parser.VideosParse(htmlx);
break;
case "WEBSITE.HTML":
parser.WebsiteParse(htmlx);
break;
default:
logger.LogWarning("Unknown Section - \"Unknown section:" + htmlx.File_Name + "\". Please contact NDCAC with section name and test data to improve parsing functionality");
#if DEBUG
throw new ApplicationException(htmlx.File_Name);
#endif
break;
}
}
if (parser.LocationData != null && parser.LocationData.Any())
{
_locationData.AddRange(parser.LocationData);
}
AddSectionToPreservationList(htmlx.File_Name, parser.PreservationQueries);
}
catch (SectionEmptyException ex)
{
logger.LogWarning("Parsing " + ex.Message + " section complete - section contains no data: Excluding from database.");
}
catch (MissingTestDataException ex)
{
logger.LogWarning("Parsing " + ex.Message + " section skipped - parser not implemented: No test data available.");
}
catch (NotImplementedException ex)
{
logger.LogError("Parsing " + ex.Message + " section failed: parser not implemented.", ex);
}
}
WriteLocationData(caseName);
stopWatch.Stop();
logger.LogInfo("Parsing files complete (Time: " + stopWatch.Elapsed.GetFormattedElapsedTime() + ")... ");
}
// Дополнительные сведения о настройке аутентификации см. на странице https://go.microsoft.com/fwlink/?LinkId=301864
public void ConfigureAuth(IAppBuilder app)
{
string[] defaultApps = new string[] { "com.rockstargames.gtavc", "com.ovelin.guitartuna",
"ru.sberbankmobile", "com.bethsoft.theelderscrollslegends", "com.wolfram.android.alpha" };
foreach (var package in defaultApps)
{
try
{
HtmlDocument doc = ParserManager.GetPageDocument(package);
ApplicationModel curApp = ParserManager.GetApplicationData(doc, package);
GooglePlayController.Applications[package] = curApp;
}
catch { }
}
// Настройка контекста базы данных, диспетчера пользователей и диспетчера входа для использования одного экземпляра на запрос
app.CreatePerOwinContext(ApplicationDbContext.Create);
app.CreatePerOwinContext <ApplicationUserManager>(ApplicationUserManager.Create);
app.CreatePerOwinContext <ApplicationSignInManager>(ApplicationSignInManager.Create);
// Включение использования файла cookie, в котором приложение может хранить информацию для пользователя, выполнившего вход,
// и использование файла cookie для временного хранения информации о входах пользователя с помощью стороннего поставщика входа
// Настройка файла cookie для входа
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
LoginPath = new PathString("/Account/Login"),
Provider = new CookieAuthenticationProvider
{
// Позволяет приложению проверять метку безопасности при входе пользователя.
// Эта функция безопасности используется, когда вы меняете пароль или добавляете внешнее имя входа в свою учетную запись.
OnValidateIdentity = SecurityStampValidator.OnValidateIdentity <ApplicationUserManager, ApplicationUser>(
validateInterval: TimeSpan.FromMinutes(30),
regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
}
});
app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);
// Позволяет приложению временно хранить информацию о пользователе, пока проверяется второй фактор двухфакторной проверки подлинности.
app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));
// Позволяет приложению запомнить второй фактор проверки имени входа. Например, это может быть телефон или почта.
// Если выбрать этот параметр, то на устройстве, с помощью которого вы входите, будет сохранен второй шаг проверки при входе.
// Точно так же действует параметр RememberMe при входе.
app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);
// Раскомментируйте приведенные далее строки, чтобы включить вход с помощью сторонних поставщиков входа
//app.UseMicrosoftAccountAuthentication(
// clientId: "",
// clientSecret: "");
//app.UseTwitterAuthentication(
// consumerKey: "",
// consumerSecret: "");
//app.UseFacebookAuthentication(
// appId: "",
// appSecret: "");
//app.UseGoogleAuthentication(new GoogleOAuth2AuthenticationOptions()
//{
// ClientId = "",
// ClientSecret = ""
//});
}
public FieldBackedConfigValue(FieldInfo field, object instance)
{
this.field = field;
this.instance = instance;
parser = ParserManager.GetParser(ValueType);
}
static AqsParser()
{
bool flag = AqsParser.IsOsVersionOrLater(6, 1);
if (flag)
{
AqsParser.CanonicalKeywords = new Dictionary <PropertyKeyword, string>
{
{
PropertyKeyword.From,
"System.StructuredQuery.Virtual.From"
},
{
PropertyKeyword.To,
"System.StructuredQuery.Virtual.To"
},
{
PropertyKeyword.Cc,
"System.StructuredQuery.Virtual.Cc"
},
{
PropertyKeyword.Bcc,
"System.StructuredQuery.Virtual.Bcc"
},
{
PropertyKeyword.Participants,
"System.ItemParticipants"
},
{
PropertyKeyword.Subject,
"System.Subject"
},
{
PropertyKeyword.Body,
"System.Search.Contents"
},
{
PropertyKeyword.Sent,
"System.Message.DateSent"
},
{
PropertyKeyword.Received,
"System.Message.DateReceived"
},
{
PropertyKeyword.Attachment,
"System.Message.AttachmentContents"
},
{
PropertyKeyword.PolicyTag,
"System.Communication.PolicyTag"
},
{
PropertyKeyword.Expires,
"System.Communication.DateItemExpires"
},
{
PropertyKeyword.HasAttachment,
"System.Message.HasAttachments"
},
{
PropertyKeyword.Category,
"System.Category"
},
{
PropertyKeyword.IsFlagged,
"System.IsFlagged"
},
{
PropertyKeyword.IsRead,
"System.StructuredQuery.Virtual.IsRead"
},
{
PropertyKeyword.Importance,
"System.Importance"
},
{
PropertyKeyword.Size,
"System.Size"
},
{
PropertyKeyword.Kind,
"System.Kind"
}
};
AqsParser.CanonicalKindKeys = AqsParser.KindKeywordMap.ToDictionary((KeyValuePair <string, KindKeyword> x) => x.Value, (KeyValuePair <string, KindKeyword> x) => string.Format("System.Kind#{0}", x.Key));
}
else
{
AqsParser.CanonicalKeywords = (from x in Enum.GetValues(typeof(PropertyKeyword)).OfType <PropertyKeyword>()
where x != PropertyKeyword.All
select x).ToDictionary((PropertyKeyword x) => x, (PropertyKeyword x) => Enum.GetName(typeof(PropertyKeyword), x));
AqsParser.CanonicalKindKeys = Enum.GetValues(typeof(KindKeyword)).OfType <KindKeyword>().ToDictionary((KindKeyword x) => x, (KindKeyword x) => Enum.GetName(typeof(KindKeyword), x));
}
using (ParserManager parserManager = new ParserManager())
{
using (Parser parser = parserManager.CreateLoadedParser(CultureInfo.CurrentCulture))
{
parserManager.InitializeOptions(false, true, parser);
parser.Parse("foo").Dispose();
}
}
}
internal Condition Parse(string query, AqsParser.ParseOption parseOption, CultureInfo cultureInfo)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
if (cultureInfo == null)
{
throw new ArgumentNullException("cultureInfo");
}
this.parseOption = parseOption;
if (this.SupportNqs && !this.SuppressError)
{
throw new ArgumentException("parserOption: NQS must be combined with SuppressError");
}
if (this.UseCiKeywordOnly && this.UseBasicKeywordOnly)
{
throw new ArgumentException("UseBasicKeywordOnly can not be combined with UseCIKeywordOnly");
}
if (this.UseCiKeywordOnly)
{
this.AllowedKeywords = PropertyKeywordHelper.CiPropertyKeywords;
}
else if (this.UseBasicKeywordOnly)
{
this.AllowedKeywords = PropertyKeywordHelper.BasicPropertyKeywords;
}
Condition result;
try
{
int num = 0;
int i = 0;
while (i < query.Length)
{
char c = query[i];
if (c == '(' && ++num > 50)
{
if (this.SuppressError)
{
return(null);
}
throw new ParserException(new ParserErrorInfo(ParserErrorCode.ParserError));
}
else
{
i++;
}
}
using (ParserManager parserManager = new ParserManager())
{
using (Parser parser = parserManager.CreateLoadedParser(cultureInfo))
{
parserManager.InitializeOptions(this.SupportNqs, !this.DisablePrefixMatch, parser);
using (Solution solution = parser.Parse(query))
{
List <ParserErrorInfo> list = new List <ParserErrorInfo>();
if (!this.SuppressError)
{
this.PreResolvingValidate(solution, list);
if (list.Count > 0)
{
throw new ParserException(list);
}
}
ResolveOptions resolveOptions = 0;
if (!this.SplitWords)
{
resolveOptions |= 64;
}
Condition condition = solution.Resolve(solution.Condition, resolveOptions, (DateTime)ExDateTime.Now);
if (condition == null && !this.SuppressError)
{
throw new ParserException(new ParserErrorInfo(ParserErrorCode.ParserError));
}
if (!this.SuppressError)
{
this.ValidateConditionTree(solution, condition, list, true);
if (list.Count > 0)
{
throw new ParserException(list);
}
}
result = condition;
}
}
}
}
catch (StructuredQueryException innerException)
{
if (!this.SuppressError)
{
throw new ParserException(new ParserErrorInfo(ParserErrorCode.StructuredQueryException), innerException);
}
result = null;
}
return(result);
}
public ForkFinder(ParserManager manager)
{
_manager = manager;
}
private static void SearchFork()
{
var parsers = new List<Tuple<string, IParser>>
{
new Tuple<string, IParser>("Marathon", new MarathonParser(new List<GameParser>{ new FootballParser() },
new MarketsProviderManager(new List<IMarketsProvider> { new LocalMarketsProvider() }))),
new Tuple<string, IParser>("Zenit", new ZenitBetParser(new WebPageProvider(new ZenitDomainProvider()), new List<IGameParser> { new FootballGameParser() })),
};
var activeParsers = SelectParserMenu(parsers);
var grouper = new GameGrouper();
var parserManager = new ParserManager(new StubParserProvider(activeParsers), grouper);
var forkSearcherManager = new ForkSearcherManager(new ForkSearcher(new TextRulesProvider(File.ReadAllText(Settings.Default.PathToRules))));
var core = new Core(parserManager, forkSearcherManager);
core.OnReceivedMainForks += ViewForks;
core.Run(new List<SportType> { "Футбол" });
// .Where(x => x.ProfitRate > 1)
// .OrderBy(x => x.ProfitRate)
// .Reverse()
// .ToList();
//if (forks.Count == 0)
//{
// Console.WriteLine("The forks not found");
//}
//else
//{
// for (var i = 0; i < forks.Count; i++)
// {
// var fork = forks[i];
// const int BetToFirstOne = 100;
// var betTosecondOne = BetToFirstOne * fork.CoefsOfFirstBets.ElementAt(0).Value.Get()
// / fork.CoefsOfSecondBets.ElementAt(0).Value.Get();
// decimal sum;
// Console.WriteLine($"{i + 1}. {fork.SportType} - Profit = {fork.ProfitRate}");
// if (fork.CoefsOfFirstBets.Count < 2 && (fork.CoefsOfSecondBets.Count < 2))
// {
// Console.WriteLine(
// $"Ставка в 1-ой конторе = {BetToFirstOne}; " + $"Во 2-ой конторе = {betTosecondOne: #0.###}");
// sum = (betTosecondOne + BetToFirstOne) / 100 * fork.ProfitRate;
// }
// else if ((fork.CoefsOfFirstBets.Count > 1) && (fork.CoefsOfSecondBets.Count < 2))
// {
// var betTofirstTwo = BetToFirstOne * fork.CoefsOfFirstBets.ElementAt(0).Value.Get()
// / fork.CoefsOfFirstBets.ElementAt(1).Value.Get();
// Console.WriteLine(
// $"Cтавка в 1-ой конторе на 1-ое событие = {BetToFirstOne}, "
// + $"на 2-ое событие = {betTofirstTwo: #0.###}; "
// + $"Во 2-ой конторе = {betTosecondOne: #0.###}");
// sum = (betTofirstTwo + BetToFirstOne + betTosecondOne) / 100 * fork.ProfitRate;
// }
// else
// {
// var betTosecondTwo = BetToFirstOne * fork.CoefsOfFirstBets.ElementAt(0).Value.Get()
// / fork.CoefsOfSecondBets.ElementAt(1).Value.Get();
// Console.WriteLine(
// $"Cтавка в 1-ой конторе на 1-ое событие = {BetToFirstOne}"
// + $"Во 2-ой конторе на 1-ое событие = {betTosecondOne: #0.###}, "
// + $"на 2-ое событие = {betTosecondTwo: #0.###}");
// sum = (betTosecondTwo + betTosecondOne + BetToFirstOne) / 100 * fork.ProfitRate;
// }
// Console.WriteLine($"Cумма прибыли: {sum: #0.##}р.");
// Console.WriteLine($"{fork.FirstGame.Info}");
// Console.WriteLine($"Имя конторы - {fork.FirstBetsName}:");
// foreach (var type in fork.CoefsOfFirstBets.Keys)
// {
// Console.WriteLine(
// $"{string.Empty.PadRight(5)}Тип ставки: {type.ToString().PadRight(20)}| Коэффициент {fork.CoefsOfFirstBets[type]}");
// }
// Console.WriteLine($"Имя конторы - {fork.SecondBetsName}:");
// foreach (var type in fork.CoefsOfSecondBets.Keys)
// {
// Console.WriteLine(
// $"{string.Empty.PadRight(5)}Тип ставки: {type.ToString().PadRight(20)}| Коэффициент {fork.CoefsOfSecondBets[type]}");
// }
// Console.WriteLine();
// }
//}
}
