Example #1
0
        public override void Run(string[] args)
        {
            base.Run(args);
            Validate();
            hParser.Run(args);

            if (merge == true)
            {
                Console.WriteLine($"Читаю псевдонимы из {aOutput}");
                Dictionary <string, object> dict = JSONWebParser.Load(aOutput) as Dictionary <string, object>;
                foreach (var it in dict)
                {
                    AddValue(mapper, it.Key, (int)it.Value);
                }

                Console.WriteLine($"Закончил чтение псевдонимов из файла");
            }

            foreach (var it in hParser.HeroResult)
            {
                AddValue(mapper, it.Name, it.Id);
            }


            object[] aliases = (object[])ReadData();
            foreach (var obj in aliases)
            {
                var  pair  = ParseData(obj);
                bool parse = mapper.TryGetValue(pair.Key, out int id);
                if (parse == false)
                {
                    Console.WriteLine("Неизвестный герой {0}", pair.Key);
                    continue;
                }

                foreach (string alias in pair.Value)
                {
                    AddValue(mapper, alias, id);
                }
            }

            System.IO.File.WriteAllText(aOutput, JSonParser.Save(mapper, mapper.GetType()));
        }
        private static void Parse()
        {
            int part = count / perpage;

            Bar = new ConsoleProgressBar(part);
            var ci = CultureInfo.CreateSpecificCulture("ru-RU");
            Func <string, string> tr      = WebUtility.HtmlDecode;
            List <FilmEntity>     dataset = new List <FilmEntity>();

            for (int i = 0; i < part; i++)
            {
                //Если ресурс не найден, получаем исключение
                //переходим на сл. итерацию
                try
                {
                    CQ  cq      = CQ.CreateFromUrl(url + "/page/" + i);
                    var reviews = cq.Find(".response");

                    foreach (var it in reviews)
                    {
                        var    response = it.Cq();
                        string author   = tr(response.Find(Selectors.Author)[0].InnerHTML);
                        string name     = tr(response.Find(Selectors.Film)[0].InnerHTML);
                        string dateRepr = tr(response.Find(Selectors.Date)[0].InnerHTML);
                        var    date     = DateTime.ParseExact(dateRepr, "d MMMM yyyy | HH:mm", ci);
                        var    title    = tr(response.Find(Selectors.Title)[0].InnerHTML);
                        var    text     = tr(response.Find(Selectors.Text)[0].ChildNodes[1].ChildNodes[0].InnerText);

                        var entity = new FilmEntity(name, author, date, title, text, status);
                        dataset.Add(entity);
                    }
                }
                catch
                {
                }

                Bar.Update(i);
            }

            File.WriteAllText(name, JSonParser.Save(dataset, dataset.GetType()));
        }
Example #3
0
 protected override void Save(string name, object obj, Type t)
 {
     File.WriteAllText(name, JSonParser.Save(obj, t));
 }
Example #4
0
        public override void Run(string[] args)
        {
            base.Run(args);
            Validate();
            rParser.Run(args);

            Statistic[] stat = new Statistic[rParser.MapCount + 1];

            HeroStatisticItemAvg[] avgStat = new HeroStatisticItemAvg[1000];
            HeroStatisticItemMin[] minStat = new HeroStatisticItemMin[1000];
            HeroStatisticItemMax[] maxStat = new HeroStatisticItemMax[1000];

            InitializeHeroStat(avgStat, minStat, maxStat);

            OpenSource(inputFolder);

            object data;
            int    i = 0;
            List <Tuple <int, int, HeroStatisticItem> > temps = new List <Tuple <int, int, HeroStatisticItem> >();
            Dictionary <Match, double> result = new Dictionary <Match, double>();

            Console.WriteLine("Парсинг матчей");
            int heroCount   = 0;
            int lastMatchId = -1;

            while ((data = ReadData()) != null)
            {
                var r = ParseData(data);
                if (r.Item1 == -1)
                {
                    continue;
                }

                if (lastMatchId == r.Item1)
                {
                    continue;
                }

                temps.Add(r);
                i++;

                r.Item3.sec = rParser.ReplayResult[temps[0].Item1].Item2;

                UpdateHeroStat(avgStat, minStat, maxStat, r);

                //собираем части воедино
                if (i == 10)
                {
                    i = 0;
                    bool flag = false;
                    for (int j = 0; j < 9; j++)
                    {
                        if (temps[j].Item1 != temps[j + 1].Item1)
                        {
                            flag = true;
                            break;
                        }
                    }
                    if (flag == true)
                    {
                        temps.Clear();
                        continue;
                    }

                    Match m = new Match();
                    m.Map = rParser.ReplayResult[temps[0].Item1].Item1;
                    m.ProbabilityToWin = 1;
                    int first_i = 0, second_i = 0;
                    for (int j = 0; j < temps.Count; j++)
                    {
                        if (temps[j].Item3.winrate == 1)
                        {
                            m.YourTeam[first_i++] = temps[j].Item2;
                        }
                        else
                        {
                            m.EnemyTeam[second_i++] = temps[j].Item2;
                        }
                        if (temps[j].Item2 > heroCount)
                        {
                            heroCount = temps[j].Item2;
                        }
                    }
                    //обратное
                    Match temp_m = new Match()
                    {
                        YourTeam  = m.EnemyTeam,
                        EnemyTeam = m.YourTeam,
                        Map       = m.Map
                    };
                    //пробуем добавить
                    //если запись уже есть
                    if (result.ContainsKey(m))
                    {
                        //усредняем вероятность
                        double used  = result[m];
                        double newer = m.ProbabilityToWin;
                        double rez   = (used + newer) / 2;
                        result[m] = rez;
                        Console.WriteLine(m.ToString() + " Уже существует");
                    }
                    //если есть противоречие
                    else if (result.ContainsKey(temp_m))
                    {
                        //усредняем вероятность
                        double used  = result[m];
                        double newer = 1 - m.ProbabilityToWin;
                        double rez   = (used + newer) / 2;
                        result[m] = rez;
                    }
                    else
                    {
                        result.Add(m, m.ProbabilityToWin);
                        if (result.Count % 100000 == 0)
                        {
                            Console.WriteLine("Уже обработано " + result.Count);
                        }
                    }
                    lastMatchId = temps.Last().Item1;
                    temps.Clear();
                }
            }

            ClearEmptyStat(ref avgStat, ref minStat, ref maxStat);
            ComputeAverage(avgStat);

            Tuple <HeroStatisticItemAvg[], HeroStatisticItemMin[], HeroStatisticItemMax[]> heroStat =
                new Tuple <HeroStatisticItemAvg[], HeroStatisticItemMin[], HeroStatisticItemMax[]>(avgStat, minStat, maxStat);

            Save(output, result, typeof(Dictionary <Match, double>));

            File.WriteAllText(statisticHeroOutput, JSonParser.Save(heroStat, typeof(Tuple <HeroStatisticItemAvg[], HeroStatisticItemMin[], HeroStatisticItemMax[]>)), Encoding.Default);

            Array.Resize(ref avgStat, 0);
            Array.Resize(ref minStat, 0);
            Array.Resize(ref maxStat, 0);

            for (int j = 0; j < stat.Length; j++)
            {
                stat[j] = new Statistic()
                {
                    Statictic = new StatisticItem()
                    {
                        Matches = new int[heroCount + 1],
                        Wins    = new int[heroCount + 1]
                    }
                };
            }

            Console.WriteLine("Расчет статистики матчей");
            ///считаем сколько матчей на каждой карте
            foreach (var it in rParser.ReplayResult)
            {
                stat[it.Value.Item1].Statictic.Ammount++;
            }

            //данные собраны,считаем статистику
            Console.WriteLine("Расчет статистики героев");

            foreach (var it in result)
            {
                Match cur = it.Key;
                for (int j = 0; j < 5; j++)
                {
                    stat[cur.Map].Statictic.Matches[cur.YourTeam[j]]++;
                    stat[cur.Map].Statictic.Wins[cur.YourTeam[j]]++;
                }
                for (int j = 0; j < 5; j++)
                {
                    stat[cur.Map].Statictic.Matches[cur.EnemyTeam[j]]++;
                }
            }

            File.WriteAllText(statisticOutput, JSonParser.Save(stat, typeof(Statistic[])), Encoding.Default);

            Console.WriteLine("Успешно спарсено " + result.Count + " записей");
        }
Example #5
0
        static void Main(string[] args)
        {
            ServicePointManager.SecurityProtocol =
                SecurityProtocolType.Ssl3 |
                SecurityProtocolType.Tls |
                SecurityProtocolType.Tls11 |
                SecurityProtocolType.Tls12;

            string HTML = "";

            if (!Directory.Exists("Cache"))
            {
                Directory.CreateDirectory("Cache");
            }
            if (!Directory.Exists("./Source/Images"))
            {
                Directory.CreateDirectory("./Source/Images");
            }
            if (!Directory.Exists("./Source/Icons"))
            {
                Directory.CreateDirectory("./Source/Icons");
            }
            if (!Directory.Exists("./Source/Hero"))
            {
                Directory.CreateDirectory("./Source/Hero");
            }
            if (!Directory.Exists("./Source/Portrait"))
            {
                Directory.CreateDirectory("./Source/Portrait");
            }

            log("debug", "WEB Парсер запущен");
            if (!File.Exists("./Source/Hero/Hero.json"))
            {
                log("error", "Не найден исходный файл схемы героев по пути ./Source/Hero/Hero.json");
            }
            Heroes.Load("./Source/Hero/Hero.json");
            if (USE_HERO_DETAILS)
            {
                Details      = new HeroDetails[Heroes.Count()];
                WebExtension = new HeroWebExtension[Heroes.Count()];

                log("succes", "Схема героев успешно загружена");
                log("debug", "Парсинг деталей героев");

                for (int i = 0; i < Heroes.Count(); i++)
                {
                    temp = i;
                    var Hero = Heroes.Find(i);
                    var path = HeroTemplateURL + Hero.Name;

                    Caching(HeroTemplateURL + Hero.Name, $"./Cache/{Hero.Name}.html");

                    log("debug", "Чтение Data:" + Hero.Name);

                    HTML = File.ReadAllText($"./Cache/{Hero.Name}.html", Encoding.Default);

                    log("succes", "Считан Data:" + Hero.Name);

                    log("debug", "Парсинг " + Hero.Name + " начат");
                    Details[i] = ParseDetails(HTML);

                    WebExtension[i]            = new HeroWebExtension(i);
                    WebExtension[i].DetailsUrl = path;

                    log("info", Details[i].ToString());
                    log("succes", "Парсинг " + Hero.Name + " завершен");
                }
            }

            if (USE_HERO_ICONS)
            {
                Caching(IconsURL, "./Cache/Icons.html");

                log("debug", "Чтение Icons");
                HTML = File.ReadAllText($"./Cache/Icons.html");
                log("succes", "Считан Icons");

                log("debug", "Парсинг Icons начат");
                ParseIcons(HTML);
                log("succes", "Парсинг Icons завершен");
            }

            log("debug", "Парсинг изображений");

            for (int i = 0; i < Heroes.Count(); i++)
            {
                var Hero = Heroes.Find(i);


                Caching(ImageTemplateURL + Hero.Name, $"./Cache/{Hero.Name}_Large.html");

                log("debug", $"Чтение {Hero.Name}_Large");
                HTML = File.ReadAllText($"./Cache/{Hero.Name}_Large.html", Encoding.Default);
                log("succes", $"Считан {Hero.Name}_Large");

                log("debug", $"Парсинг {Hero.Name}_Large");
                ParseImages(HTML, Hero.Name);
                ParseModel(HTML, Hero.Name);
                log("succes", $"Парсинг {Hero.Name}_Large завершен");
            }

            log("succes", "Парсинг изображений завершен");

            log("succes", "Парсинг деталей героев завершен");

            var outputDetails    = JSonParser.Save(Details, typeof(HeroDetails[]));
            var outputExtensions = JSonParser.Save(WebExtension, typeof(HeroWebExtension[]));

            File.WriteAllText("./Source/Hero/HeroDetails.json", outputDetails);
            File.WriteAllText("./Source/Hero/HeroWebExtension.json", outputExtensions);
        }